From 689829548e3aa4a7005d72a68b5fb6d58298c9d3 Mon Sep 17 00:00:00 2001 From: chaokunyang Date: Sat, 9 May 2026 12:49:54 +0800 Subject: [PATCH 01/12] docs: rewrite README --- .asf.yaml | 2 +- README.md | 967 +++++++++++++++++++++++++++--------------------------- 2 files changed, 478 insertions(+), 491 deletions(-) diff --git a/.asf.yaml b/.asf.yaml index 38b3e48d28..4dece2dacb 100644 --- a/.asf.yaml +++ b/.asf.yaml @@ -19,7 +19,7 @@ github: description: >- - A blazingly fast multi-language serialization framework powered by JIT and zero-copy. + A multi-language serialization framework for idiomatic domain objects, schema IDL, fast object serialization, cross-language data exchange, and row-format random access. homepage: https://fory.apache.org labels: - javascript diff --git a/README.md b/README.md index 5e8b708c6a..67bd4a46f3 100644 --- a/README.md +++ b/README.md @@ -12,155 +12,147 @@ [![NuGet](https://img.shields.io/nuget/v/Apache.Fory?logo=nuget&style=for-the-badge)](https://www.nuget.org/packages/Apache.Fory) [![pub.dev](https://img.shields.io/pub/v/fory?logo=dart&style=for-the-badge)](https://pub.dev/packages/fory) -**Apache Fory™** is a blazingly-fast multi-language serialization framework powered by **JIT compilation**, **zero-copy** techniques, and **advanced code generation**, achieving up to **170x performance improvement** while maintaining simplicity and ease of use. +**Apache Fory™** is a multi-language serialization framework for idiomatic +domain objects, schema IDL, fast object serialization, cross-language data +exchange, and row-format random access. > [!IMPORTANT] -> **Apache Fory™ was previously named as Apache Fury. For versions before 0.11, please use "fury" instead of "fory" in package names, imports, and dependencies, see [Fury Docs](https://fory.apache.org/docs/0.10/docs/introduction/) for how to use Fury in older versions**. - -## Key Features - -### High-Performance Serialization - -Apache Fory™ delivers excellent performance through advanced optimization techniques: - -- **JIT Compilation**: Runtime code generation for Java eliminates virtual method calls and inlines hot paths -- **Static Code Generation**: Compile-time code generation for Rust, C++, and Go delivers peak performance without runtime overhead -- **Meta Packing & Sharing**: Class metadata packing and sharing reduces redundant type information across objects on one stream - -### Cross-Language Serialization - -The **[xlang serialization format](docs/specification/xlang_serialization_spec.md)** enables seamless data exchange across programming languages: - -- **Reference Preservation**: Shared and circular references work correctly across languages -- **Polymorphism**: Objects serialize/deserialize with their actual runtime types -- **Schema Evolution**: Optional forward/backward compatibility for evolving schemas -- **Automatic Serialization**: Serialize domain objects automatically, no IDL or schema definitions required - -### Row Format - -A cache-friendly **[row format](docs/specification/row_format_spec.md)** optimized for analytics workloads: - -- **Zero-Copy Random Access**: Read individual fields without deserializing entire objects -- **Partial Operations**: Selective field serialization and deserialization for efficiency -- **Apache Arrow Integration**: Seamless conversion to columnar format for analytics pipelines -- **Multi-Language**: Available in Java, Python, Rust and C++ - -### Security & Production-Readiness - -Built for production environments with secure defaults and explicit control: - -- **Class Registration**: Whitelist-based deserialization control is enabled by default to block untrusted classes. -- **Depth Limiting**: Configurable object graph depth limits mitigate recursive and stack exhaustion attacks. -- **Configurable Policies**: Custom class checkers and deserialization policies let teams enforce internal security rules. -- **Platform Support**: Runs on Java 8 through 25, supports GraalVM native image, and works across major operating systems. - -## Protocols - -Apache Fory™ provides three protocol families optimized for different scenarios: - -| Protocol Family | Use Case | Key Features | -| ------------------------------------------------------------------------- | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| **[Xlang Serialization](docs/specification/xlang_serialization_spec.md)** | Cross-language object exchange | Automatic serialization, reference preservation, polymorphism | -| **[Row Format](docs/specification/row_format_spec.md)** | Analytics and data processing | Zero-copy random access, partial operations, Apache Arrow compatibility | -| **Native Serialization** | Language-specific optimization | Native protocol implementations per language, including **[Java Serialization](docs/specification/java_serialization_spec.md)** and Python Native. Python Native extends Xlang with more type support and better performance. | - -All protocol families share the same optimized codebase, allowing improvements in one family to benefit others. - -## Benchmarks - -### Java Serialization Performance - -Charts labeled **"compatible"** show schema evolution mode with forward/backward compatibility enabled, while others show schema consistent mode where class schemas must match. - -**Serialization Throughput**: +> Apache Fory™ was previously named Apache Fury. For versions before 0.11, use +> `fury` instead of `fory` in package names, imports, and dependencies. See the +> [Fury docs](https://fory.apache.org/docs/0.10/docs/introduction/) for older +> releases. + +## Why Fory + +- **Domain-object first**: Serialize Java classes, Python dataclasses, Go + structs, Rust/C++ structs, and generated or annotated model types directly. + You do not need an IDL file to start. +- **Schema IDL with native domain objects**: For shared schemas, define numbers, + strings, lists, maps, arrays, enums, structs, and unions once, then generate + domain objects that use each language's native types. +- **Fast paths in one codebase**: Native serialization, xlang serialization, + and row format all benefit from Fory's optimized runtime work, including Java + JIT serializers and generated/static serializers in other runtimes. +- **Xlang wire format**: Exchange payloads across supported languages with + compact binary encoding, metadata packing, cross-language type mapping, and + polymorphic runtime types. +- **Shared and circular references**: Preserve object identity for graphs that + need it. +- **Schema evolution**: Add or delete fields while services deploy + independently, with compatible mode handling forward and backward reads. +- **Row format**: Use zero-copy random access, partial reads/deserialization, + and Arrow integration when jobs need fields instead of whole objects. +- **Broad runtime support**: Java, Python, C++, Go, Rust, + JavaScript/TypeScript, C#, Swift, Dart, Scala, and Kotlin, including GraalVM + native image, Dart VM/Flutter/web, and Node.js/browser JavaScript. + +## Performance + +Charts labeled "compatible" use schema evolution mode. Other Java charts use +schema-consistent mode, where writer and reader class schemas are expected to +match. + +### Java serialization + +In Java serialization benchmarks, Fory reaches up to **170x** the throughput of +JDK serialization on selected workloads. + +**Serialization throughput**

-Java Serialization Throughput +Java serialization throughput

-**Deserialization Throughput**: +**Deserialization throughput**

-Java Deserialization Throughput +Java deserialization throughput

-**Xlang Throughput**: +**Xlang throughput**

- +Java xlang throughput

-See [Java Benchmarks](docs/benchmarks/java) for more details. +See [Java benchmarks](docs/benchmarks/java) for the full methodology and data. + +### Other runtime benchmarks -### Rust Serialization Performance +### Rust

- +Rust serialization throughput

-For more detailed benchmarks and methodology, see [Rust Benchmarks](benchmarks/rust). +See [Rust benchmarks](benchmarks/rust). -### C++ Serialization Performance +### C++

- +C++ serialization throughput

-For more detailed benchmarks and methodology, see [C++ Benchmarks](benchmarks/cpp). +See [C++ benchmarks](benchmarks/cpp). -### Go Serialization Performance +### Go

- +Go serialization throughput

-For more detailed benchmarks and methodology, see [Go Benchmark](benchmarks/go). +See [Go benchmarks](benchmarks/go). -### Python Serialization Performance +### Python

- +Python serialization throughput

-For more detailed benchmarks and methodology, see [Python Benchmarks](benchmarks/python). +See [Python benchmarks](benchmarks/python). -### JavaScript/NodeJS Serialization Performance +### JavaScript/TypeScript

- +JavaScript serialization throughput

-For more detailed benchmarks and methodology, see [JavaScript Benchmarks](docs/benchmarks/javascript). +See [JavaScript benchmarks](docs/benchmarks/javascript). -### C# Serialization Performance +### C#

- +C# serialization throughput

-For more detailed benchmarks and methodology, see [C# Benchmarks](docs/benchmarks/csharp). +See [C# benchmarks](docs/benchmarks/csharp). -### Swift Serialization Performance +### Swift

- +Swift serialization throughput

-For more detailed benchmarks and methodology, see [Swift Benchmarks](docs/benchmarks/swift). +See [Swift benchmarks](docs/benchmarks/swift). -### Dart Serialization Performance +### Dart

- +Dart serialization throughput

-For more detailed benchmarks and methodology, see [Dart Benchmarks](docs/benchmarks/dart). +See [Dart benchmarks](docs/benchmarks/dart). ## Installation -**Java**: +Pick the runtime you use and run the package-manager command, or paste the +dependency block into your build file. + +### Java + +Maven: ```xml @@ -170,19 +162,29 @@ For more detailed benchmarks and methodology, see [Dart Benchmarks](docs/benchma ``` -Snapshots are available from `https://repository.apache.org/snapshots/` (version `0.17.0-SNAPSHOT`). +Gradle: + +```gradle +implementation "org.apache.fory:fory-core:0.17.0" +``` -**Scala**: +### Scala -```sbt -// Scala 2.13 -libraryDependencies += "org.apache.fory" % "fory-scala_2.13" % "0.17.0" +sbt: -// Scala 3 -libraryDependencies += "org.apache.fory" % "fory-scala_3" % "0.17.0" +```scala +libraryDependencies += "org.apache.fory" %% "fory-scala" % "0.17.0" ``` -**Kotlin**: +### Kotlin + +Gradle: + +```kotlin +implementation("org.apache.fory:fory-kotlin:0.17.0") +``` + +Maven: ```xml @@ -192,113 +194,179 @@ libraryDependencies += "org.apache.fory" % "fory-scala_3" % "0.17.0" ``` -**Python**: +### Python ```bash pip install pyfory +``` -# With row format support -pip install pyfory[format] +For row-format support: + +```bash +pip install "pyfory[format]" ``` -**Rust**: +### Rust + +`Cargo.toml`: ```toml [dependencies] -fory = "0.16" +fory = "0.17" +``` + +### C++ + +CMake: + +```cmake +include(FetchContent) +FetchContent_Declare( + fory + GIT_REPOSITORY https://github.com/apache/fory.git + GIT_TAG v0.17.0 + SOURCE_SUBDIR cpp +) +FetchContent_MakeAvailable(fory) +target_link_libraries(my_app PRIVATE fory::serialization) ``` -**C++**: +Bazel `MODULE.bazel`: -Fory C++ supports both CMake and Bazel build systems. See [C++ Installation Guide](https://fory.apache.org/docs/guide/cpp/#installation) for detailed instructions. +```bazel +bazel_dep(name = "fory", version = "0.17.0") +git_override(module_name = "fory", remote = "https://github.com/apache/fory.git", commit = "v0.17.0") +``` -**Golang**: +Bazel `BUILD`: + +```bazel +deps = ["@fory//cpp/fory/serialization:fory_serialization"] +``` + +See the [C++ installation guide](https://fory.apache.org/docs/guide/cpp/#installation) +for complete CMake, Bazel, and source-build details. + +### Go ```bash go get github.com/apache/fory/go/fory ``` -**NodeJS/JavaScript**: +### JavaScript/TypeScript ```bash npm install @apache-fory/core ``` -Optional Node.js string fast-path support: +For the Node.js string fast path: ```bash npm install @apache-fory/core @apache-fory/hps ``` -**C#**: +### C# -```xml - - - +```bash +dotnet add package Apache.Fory --version 0.17.0 ``` -**Dart**: +### Dart -```yaml -dependencies: - fory: ^0.17.0 +```bash +dart pub add fory:^0.17.0 +dart pub add dev:build_runner +``` + +### Swift + +Add Fory to `Package.swift`: -dev_dependencies: - build_runner: ^2.4.0 +```swift +dependencies: [ + .package(url: "https://github.com/apache/fory.git", exact: "0.17.0") +], +targets: [ + .target( + name: "YourTarget", + dependencies: [.product(name: "Fory", package: "fory")] + ) +] ``` -## Quick Start +See the [Swift guide](https://fory.apache.org/docs/guide/swift/) for generated +serializer setup. + +### Development from source + +See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md). -This section provides quick examples for getting started with Apache Fory™. For comprehensive guides, see the [Documentation](#documentation). +Snapshots for Java, Scala, and Kotlin are available from +`https://repository.apache.org/snapshots/` with the matching `-SNAPSHOT` version. -### Native Serialization +## Choose a mode -**Always use native mode when working with a single language.** Native mode delivers optimal performance by avoiding the type metadata overhead required for cross-language compatibility. Xlang mode introduces additional metadata encoding costs and restricts serialization to types that are common across all supported languages. Language-specific types will be rejected during serialization in xlang-mode. +| Mode | Use it when | Start here | +| -------------------- | ------------------------------------------------------------- | -------------------------------------------------------- | +| Xlang serialization | Data crosses language boundaries | [Cross-language guide](docs/guide/xlang) | +| Native serialization | Producer and consumer are in the same language | Language guide for your runtime | +| Row format | You need random field access or analytics-style partial reads | [Row format spec](docs/specification/row_format_spec.md) | -#### Java Serialization +Use native mode for same-language traffic. It avoids xlang's cross-language +type mapping and metadata constraints, so it can serialize broader +language-specific object graphs and is the fastest path for same-language +payloads. -When you don't need cross-language support, use Java mode for optimal performance. +Compatible mode is Fory's schema-evolution mode. It writes the metadata readers +and writers need to tolerate schema differences. Xlang mode enables compatible +mode by default to better handle differences between language type systems. +Native mode keeps it off by default for smaller payloads and higher throughput. + +Use compatible mode when services deploy independently or when fields may be +added or deleted over time. Use schema-consistent mode when writer and reader +schemas deploy together and you want the smallest payloads. + +For xlang, all peers must agree on type identity. Name-based registration is +easier to read in examples. Numeric IDs are smaller and faster, but they require +coordination across every reader and writer. + +## Quick start: xlang serialization + +Xlang mode writes the cross-language Fory wire format. Bytes produced by one +runtime can be read by another when the runtimes use the same type identity, +compatible mode setting, and field schema. + +### Java ```java -import org.apache.fory.*; -import org.apache.fory.config.*; +import org.apache.fory.Fory; public class Example { public static class Person { - String name; - int age; + public String name; + public int age; } public static void main(String[] args) { - // Create Fory instance - should be reused across serializations - BaseFory fory = Fory.builder() - .withXlang(false) - .requireClassRegistration(true) - // replace `build` with `buildThreadSafeFory` for Thread-Safe Usage - .build(); - // Register your classes (required when class registration is enabled) - // Registration order must be consistent if id is not specified - fory.register(Person.class); - // Serialize + Fory fory = Fory.builder().withXlang(true).withCompatible(true).build(); + fory.register(Person.class, "example.Person"); + Person person = new Person(); - person.name = "chaokunyang"; - person.age = 28; + person.name = "Alice"; + person.age = 30; + byte[] bytes = fory.serialize(person); - Person result = (Person) fory.deserialize(bytes); - System.out.println(result.name + " " + result.age); // Output: chaokunyang 28 + Person decoded = (Person) fory.deserialize(bytes); + System.out.println(decoded.name); } } ``` -For detailed Java usage including compatibility modes, compression, and advanced features, see [Java Serialization Guide](docs/guide/java) and [java/README.md](java/README.md). - -#### Python Serialization - -Python native mode provides a high-performance drop-in replacement for pickle/cloudpickle with better speed and compatibility. +### Python ```python from dataclasses import dataclass + import pyfory @dataclass @@ -306,28 +374,49 @@ class Person: name: str age: pyfory.Int32 -# Create Fory instance - should be reused across serializations -fory = pyfory.Fory() -# Register your classes (required when class registration is enabled) -fory.register_type(Person) -person = Person(name="chaokunyang", age=28) -data = fory.serialize(person) -result = fory.deserialize(data) -print(result.name, result.age) # Output: chaokunyang 28 +fory = pyfory.Fory(xlang=True, compatible=True) +fory.register_type(Person, typename="example.Person") + +data = fory.serialize(Person("Alice", 30)) +person = fory.deserialize(data) +print(person.name) ``` -Python schema aliases also apply inside declared containers, such as -`Dict[pyfory.FixedInt32, List[pyfory.TaggedInt64]]`, so nested keys and values use the requested -wire encoding in both pure Python and Cython modes. +### Go + +```go +package main -For detailed Python usage including type hints, compatibility modes, and advanced features, see [Python Guide](docs/guide/python). +import ( + "fmt" -#### Rust Serialization + "github.com/apache/fory/go/fory" +) -Rust native mode provides compile-time code generation via derive macros for high-performance serialization without runtime overhead. +type Person struct { + Name string + Age int32 +} + +func main() { + f := fory.New(fory.WithXlang(true), fory.WithCompatible(true)) + if err := f.RegisterNamedStruct(Person{}, "example.Person"); err != nil { + panic(err) + } + + data, _ := f.Serialize(&Person{Name: "Alice", Age: 30}) + var person Person + if err := f.Deserialize(data, &person); err != nil { + panic(err) + } + fmt.Println(person.Name) +} +``` + +### Rust ```rust -use fory::{Fory, ForyStruct}; +use fory::{Error, Fory, ForyStruct}; #[derive(ForyStruct, Debug, PartialEq)] struct Person { @@ -335,111 +424,93 @@ struct Person { age: i32, } -fn main() -> Result<(), fory::Error> { - // Create Fory instance - should be reused across serializations - let mut fory = Fory::default(); - // Register your structs (required when class registration is enabled) - fory.register::(1); - let person = Person { - name: "chaokunyang".to_string(), - age: 28, - }; - let bytes = fory.serialize(&person); - let result: Person = fory.deserialize(&bytes)?; - println!("{} {}", result.name, result.age); // Output: chaokunyang 28 +fn main() -> Result<(), Error> { + let mut fory = Fory::builder().xlang(true).compatible(true).build(); + fory.register_by_name::("example", "Person")?; + + let bytes = fory.serialize(&Person { + name: "Alice".to_string(), + age: 30, + })?; + let person: Person = fory.deserialize(&bytes)?; + println!("{}", person.name); Ok(()) } ``` -For detailed Rust usage including collections, references, and custom serializers, see [Rust Guide](docs/guide/rust). - -#### C++ Serialization - -C++ native mode provides compile-time reflection via the `FORY_STRUCT` macro for efficient serialization with zero runtime overhead. +### C++ ```cpp #include "fory/serialization/fory.h" +#include +#include +#include using namespace fory::serialization; struct Person { - std::string name; - int32_t age; + std::string name; + int32_t age; }; FORY_STRUCT(Person, name, age); int main() { - // Create Fory instance - should be reused across serializations - auto fory = Fory::builder().build(); - // Register your structs (required when class registration is enabled) - fory.register_struct(1); - Person person{"chaokunyang", 28}; - auto bytes = fory.serialize(person).value(); - auto result = fory.deserialize(bytes).value(); - std::cout << result.name << " " << result.age << std::endl; // Output: chaokunyang 28 + auto fory = Fory::builder().xlang(true).compatible(true).build(); + fory.register_struct("example.Person"); + + auto bytes = fory.serialize(Person{"Alice", 30}).value(); + Person person = fory.deserialize(bytes).value(); + std::cout << person.name << std::endl; } ``` -For detailed C++ usage including collections, smart pointers, and error handling, see [C++ Guide](docs/guide/cpp). - -#### NodeJS/JavaScript Serialization - -JavaScript native mode uses registered schemas to generate fast serializers for repeated use in browser or Node.js applications. +### JavaScript/TypeScript ```ts import Fory, { Type } from "@apache-fory/core"; -const personType = Type.struct("example.person", { - name: Type.string(), - age: Type.int32(), -}); +const personType = Type.struct( + { typeName: "example.Person" }, + { + name: Type.string(), + age: Type.int32(), + }, +); -const fory = new Fory(); +const fory = new Fory({ compatible: true }); const { serialize, deserialize } = fory.register(personType); -const bytes = serialize({ - name: "chaokunyang", - age: 28, -}); +const bytes = serialize({ name: "Alice", age: 30 }); const person = deserialize(bytes); -console.log(person.name, person.age); // Output: chaokunyang 28 +console.log(person.name); ``` -For detailed JavaScript usage including schema registration, references, and cross-language support, see [JavaScript Guide](docs/guide/javascript). - -#### C# Serialization - -C# native mode provides source-generator-backed serialization for registered .NET types. +### C# ```csharp using Apache.Fory; -[ForyStruct] +[ForyObject] public sealed class Person { - public long Id { get; set; } public string Name { get; set; } = string.Empty; + public int Age { get; set; } } -Fory fory = Fory.Builder().Build(); -fory.Register(1); - -Person person = new() -{ - Id = 1, - Name = "chaokunyang", -}; +Fory fory = Fory.Builder() + .Compatible(true) + .Build(); +fory.Register("example", "Person"); -byte[] bytes = fory.Serialize(person); -Person result = fory.Deserialize(bytes); -Console.WriteLine($"{result.Name} {result.Id}"); // Output: chaokunyang 1 +byte[] bytes = fory.Serialize(new Person { Name = "Alice", Age = 30 }); +Person person = fory.Deserialize(bytes); +Console.WriteLine(person.Name); ``` -For detailed C# usage including configuration, custom serializers, and thread-safe runtime options, see [C# Guide](docs/guide/csharp). +C# always writes the xlang frame header, so there is no separate xlang builder +flag. -#### Dart Serialization - -Dart native mode uses generated serializers for fast serialization without runtime reflection. +### Dart ```dart import 'package:fory/fory.dart'; @@ -457,7 +528,7 @@ class Person { } void main() { - final fory = Fory(); + final fory = Fory(compatible: true); PersonFory.register( fory, Person, @@ -465,27 +536,41 @@ void main() { typeName: 'Person', ); - final person = Person() - ..name = 'chaokunyang' - ..age = 28; - - final bytes = fory.serialize(person); - final result = fory.deserialize(bytes); - print('${result.name} ${result.age}'); + final bytes = fory.serialize(Person() + ..name = 'Alice' + ..age = 30); + final person = fory.deserialize(bytes); + print(person.name); } ``` -Generate the companion file before running the program: +Dart uses the xlang wire format directly. Generate the companion file before +running: ```bash dart run build_runner build --delete-conflicting-outputs ``` -For detailed Dart usage including code generation, field configuration, and cross-language guidance, see [Dart Guide](docs/guide/dart). +### Swift + +```swift +import Fory -#### Scala Serialization +@ForyStruct +struct Person { + var name: String = "" + var age: Int32 = 0 +} -Scala native mode provides optimized serialization for Scala-specific types including case classes, collections, and Option types. +let fory = Fory(xlang: true, compatible: true) +try fory.register(Person.self, namespace: "example", name: "Person") + +let bytes = try fory.serialize(Person(name: "Alice", age: 30)) +let person: Person = try fory.deserialize(bytes) +print(person.name) +``` + +### Scala ```scala import org.apache.fory.Fory @@ -493,29 +578,19 @@ import org.apache.fory.serializer.scala.ScalaSerializers case class Person(name: String, age: Int) -object Example { - def main(args: Array[String]): Unit = { - // Create Fory instance - should be reused across serializations - val fory = Fory.builder() - .withXlang(false) - .requireClassRegistration(true) - .build() - // Register Scala serializers for Scala-specific types - ScalaSerializers.registerSerializers(fory) - // Register your case classes - fory.register(classOf[Person]) - val bytes = fory.serialize(Person("chaokunyang", 28)) - val result = fory.deserialize(bytes).asInstanceOf[Person] - println(s"${result.name} ${result.age}") // Output: chaokunyang 28 - } -} -``` - -For detailed Scala usage including collection serialization and integration patterns, see [Scala Guide](docs/guide/scala). +val fory = Fory.builder() + .withXlang(true) + .withCompatible(true) + .build() +ScalaSerializers.registerSerializers(fory) +fory.register(classOf[Person], "example.Person") -#### Kotlin Serialization +val bytes = fory.serialize(Person("Alice", 30)) +val person = fory.deserialize(bytes).asInstanceOf[Person] +println(person.name) +``` -Kotlin native mode provides optimized serialization for Kotlin-specific types including data classes, nullable types, and Kotlin collections. +### Kotlin ```kotlin import org.apache.fory.Fory @@ -524,285 +599,197 @@ import org.apache.fory.serializer.kotlin.KotlinSerializers data class Person(val name: String, val age: Int) fun main() { - // Create Fory instance - should be reused across serializations val fory = Fory.builder() - .withXlang(false) - .requireClassRegistration(true) + .withXlang(true) + .withCompatible(true) .build() - // Register Kotlin serializers for Kotlin-specific types KotlinSerializers.registerSerializers(fory) - // Register your data classes - fory.register(Person::class.java) - val bytes = fory.serialize(Person("chaokunyang", 28)) - val result = fory.deserialize(bytes) as Person - println("${result.name} ${result.age}") // Output: chaokunyang 28 + fory.register(Person::class.java, "example.Person") + + val bytes = fory.serialize(Person("Alice", 30)) + val person = fory.deserialize(bytes) as Person + println(person.name) } ``` -For detailed Kotlin usage including null safety and default value support, see [kotlin/README.md](kotlin/README.md). +For shared/circular references, polymorphism, numeric IDs versus names, and +type-mapping rules, see the [cross-language guide](docs/guide/xlang) and +[type mapping specification](docs/specification/xlang_type_mapping.md). -### Cross-Language Serialization +## Native mode: same-language serialization -**Only use xlang mode when you need cross-language data exchange.** Xlang mode adds type metadata overhead for cross-language compatibility and only supports types that can be mapped across all languages. For single-language use cases, always prefer native mode for better performance. +Use native mode when the writer and reader are in the same language. Java and +Python can serialize broader language-specific object graphs this way. The +languages below expose an explicit `xlang=false` or native-mode setting; runtimes +without that switch stay on their documented default path. -The following examples demonstrate serializing a `Person` object across Java and Rust. For other languages (Python, Go, JavaScript, etc.), simply set the xlang mode to `true` and follow the same pattern. +Keep class/type registration enabled for untrusted input. See the language guides +for runtime-specific security and compatibility settings. **Java** ```java -import org.apache.fory.*; -import org.apache.fory.config.*; - -public class XlangExample { - public record Person(String name, int age) {} - - public static void main(String[] args) { - // Create Fory instance with XLANG mode. Compatible mode is the xlang default. - Fory fory = Fory.builder().withXlang(true).withCompatible(true).build(); - // Register with cross-language type id/name - fory.register(Person.class, 1); - // fory.register(Person.class, "example.Person"); - Person person = new Person("chaokunyang", 28); - byte[] bytes = fory.serialize(person); - // bytes can be deserialized by Rust, Python, Go, or other languages - Person result = (Person) fory.deserialize(bytes); - System.out.println(result.name + " " + result.age); // Output: chaokunyang 28 - } -} +Fory fory = Fory.builder() + .withXlang(false) + .requireClassRegistration(true) + .build(); +// Register, serialize, and deserialize as in the xlang example above. ``` -**Rust** - -```rust -use fory::{Fory, ForyStruct}; +**Python** -#[derive(ForyStruct, Debug)] -struct Person { - name: String, - age: i32, -} - -fn main() -> Result<(), Error> { - let mut fory = Fory::builder().xlang(true).compatible(true).build(); - fory.register::(1)?; - // fory.register_by_name::("example.Person")?; - let person = Person { - name: "chaokunyang".to_string(), - age: 28, - }; - let bytes = fory.serialize(&person); - // bytes can be deserialized by Java, Python, Go, or other languages - let result: Person = fory.deserialize(&bytes)?; - println!("{} {}", result.name, result.age); // Output: chaokunyang 28 -} +```python +fory = pyfory.Fory(xlang=False, ref=True) +# Register, serialize, and deserialize as in the xlang example above. ``` -**Key Points for Cross-Language Serialization**: - -- Enable xlang mode in all languages, for example `withXlang(true)` in Java -- Compatible mode defaults to `true` when xlang mode is enabled and is recommended for - cross-language services because schemas can diverge more easily across languages. -- Register types with **consistent IDs or names** across all languages: - - **By ID** (`fory.register(Person.class, 1)`): Faster serialization, more compact encoding, but requires coordination to avoid ID conflicts - - **By name** (`fory.register(Person.class, "example.Person")`): More flexible, less prone to conflicts, easier to manage across teams, but slightly larger encoding -- Type IDs/names must match across all languages for successful deserialization -- Only use types that have cross-language mappings (see [Type Mapping](docs/specification/xlang_type_mapping.md)) - -For examples with **circular references**, **shared references**, and **polymorphism** across languages, see: - -- [Cross-Language Serialization Guide](docs/guide/xlang) -- [Java Serialization Guide - Cross Language](docs/guide/java) -- [Python Guide - Cross Language](docs/guide/python) +**Go** -### Row Format Encoding +```go +f := fory.New(fory.WithXlang(false)) +// Register, serialize, and deserialize as in the xlang example above. +``` -Row format provides zero-copy random access to serialized data, making it ideal for analytics workloads and data processing pipelines. +**Rust** -#### Java +```rust +let mut fory = Fory::builder().xlang(false).build(); +// Register, serialize, and deserialize as in the xlang example above. +``` -```java -import org.apache.fory.format.*; -import java.util.*; -import java.util.stream.*; +**C++** -public class Bar { - String f1; - List f2; -} +```cpp +auto fory = Fory::builder().xlang(false).build(); +// Register, serialize, and deserialize as in the xlang example above. +``` -public class Foo { - int f1; - List f2; - Map f3; - List f4; -} +**Scala** -RowEncoder encoder = Encoders.bean(Foo.class); -Foo foo = new Foo(); -foo.f1 = 10; -foo.f2 = IntStream.range(0, 1000000).boxed().collect(Collectors.toList()); -foo.f3 = IntStream.range(0, 1000000).boxed().collect(Collectors.toMap(i -> "k"+i, i -> i)); - -List bars = new ArrayList<>(1000000); -for (int i = 0; i < 1000000; i++) { - Bar bar = new Bar(); - bar.f1 = "s" + i; - bar.f2 = LongStream.range(0, 10).boxed().collect(Collectors.toList()); - bars.add(bar); -} -foo.f4 = bars; +```scala +val fory = Fory.builder() + .withXlang(false) + .requireClassRegistration(true) + .build() +ScalaSerializers.registerSerializers(fory) +// Register, serialize, and deserialize as in the xlang example above. +``` -// Serialize to row format (can be zero-copy read by Python) -BinaryRow binaryRow = encoder.toRow(foo); +**Kotlin** -// Deserialize entire object -Foo newFoo = encoder.fromRow(binaryRow); +```kotlin +val fory = Fory.builder() + .withXlang(false) + .requireClassRegistration(true) + .build() +KotlinSerializers.registerSerializers(fory) +// Register, serialize, and deserialize as in the xlang example above. +``` -// Zero-copy access to nested fields without full deserialization -BinaryArray binaryArray2 = binaryRow.getArray(1); // Access f2 field -BinaryArray binaryArray4 = binaryRow.getArray(3); // Access f4 field -BinaryRow barStruct = binaryArray4.getStruct(10); // Access 11th Bar element -long value = barStruct.getArray(1).getInt64(5); // Access nested value +## Row format -// Partial deserialization -RowEncoder barEncoder = Encoders.bean(Bar.class); -Bar newBar = barEncoder.fromRow(barStruct); -Bar newBar2 = barEncoder.fromRow(binaryArray4.getStruct(20)); -``` +Row format is for random access and partial reads. These examples encode an +object with an integer array field, then read one array element from the binary +row without rebuilding the object. -#### Python +### Python ```python from dataclasses import dataclass -from typing import List, Dict -import pyarrow as pa -import pyfory +from typing import List -@dataclass -class Bar: - f1: str - f2: List[pa.int64] +import pyfory @dataclass -class Foo: - f1: pa.int32 - f2: List[pa.int32] - f3: Dict[str, pa.int32] - f4: List[Bar] - -encoder = pyfory.encoder(Foo) -foo = Foo( - f1=10, - f2=list(range(1000_000)), - f3={f"k{i}": i for i in range(1000_000)}, - f4=[Bar(f1=f"s{i}", f2=list(range(10))) for i in range(1000_000)] -) +class User: + id: pyfory.Int32 + name: str + scores: List[pyfory.Int32] -# Serialize to row format -binary: bytes = encoder.to_row(foo).to_bytes() +encoder = pyfory.encoder(User) +binary = encoder.to_row(User(1, "Alice", [98, 100, 95])).to_bytes() -# Zero-copy random access without full deserialization -foo_row = pyfory.RowData(encoder.schema, binary) -print(foo_row.f2[100000]) # Access element directly -print(foo_row.f4[100000].f1) # Access nested field -print(foo_row.f4[200000].f2[5]) # Access deeply nested field +row = pyfory.RowData(encoder.schema, binary) +print(row.name) +print(row.scores[1]) ``` -For more details on row format, see [Row Format Specification](docs/specification/row_format_spec.md). - -## Documentation - -### User Guides - -| Guide | Description | Source | Website | -| -------------------------------- | ------------------------------------------ | -------------------------------------------------------- | ------------------------------------------------------------------ | -| **Java Serialization** | Comprehensive guide for Java serialization | [java](docs/guide/java) | [📖 View](https://fory.apache.org/docs/guide/java/) | -| **Python** | Python-specific features and usage | [python](docs/guide/python) | [📖 View](https://fory.apache.org/docs/guide/python/) | -| **Rust** | Rust implementation and patterns | [rust](docs/guide/rust) | [📖 View](https://fory.apache.org/docs/guide/rust/) | -| **C++** | C++ implementation and patterns | [cpp](docs/guide/cpp) | [📖 View](https://fory.apache.org/docs/guide/cpp/) | -| **Go** | Go serialization and runtime usage | [go](docs/guide/go) | [📖 View](https://fory.apache.org/docs/guide/go/) | -| **JavaScript/NodeJS** | JavaScript and Node.js serialization guide | [javascript](docs/guide/javascript) | [📖 View](https://fory.apache.org/docs/guide/javascript/) | -| **C#** | C# serialization and .NET usage | [csharp](docs/guide/csharp) | [📖 View](https://fory.apache.org/docs/guide/csharp/) | -| **Swift** | Swift implementation and patterns | [swift](docs/guide/swift) | [📖 View](https://fory.apache.org/docs/guide/swift/) | -| **Dart** | Dart serialization and codegen usage | [dart](docs/guide/dart) | [📖 View](https://fory.apache.org/docs/guide/dart/) | -| **Scala** | Scala integration and best practices | [scala](docs/guide/scala) | [📖 View](https://fory.apache.org/docs/guide/scala/) | -| **Kotlin** | Kotlin integration and type support | [kotlin](docs/guide/kotlin) | [📖 View](https://fory.apache.org/docs/guide/kotlin/) | -| **Cross-Language Serialization** | Multi-language object exchange | [xlang](docs/guide/xlang) | [📖 View](https://fory.apache.org/docs/guide/xlang/) | -| **GraalVM** | Native image support and AOT compilation | [graalvm-support.md](docs/guide/java/graalvm-support.md) | [📖 View](https://fory.apache.org/docs/guide/java/graalvm_support) | -| **Development** | Building and contributing to Fory | [DEVELOPMENT.md](docs/DEVELOPMENT.md) | [📖 View](docs/DEVELOPMENT.md) | - -### Protocol Specifications - -| Specification | Description | Source | Website | -| ----------------------- | ------------------------------ | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | -| **Xlang Serialization** | Cross-language binary protocol | [xlang_serialization_spec.md](docs/specification/xlang_serialization_spec.md) | [📖 View](https://fory.apache.org/docs/specification/fory_xlang_serialization_spec) | -| **Java Serialization** | Java-optimized protocol | [java_serialization_spec.md](docs/specification/java_serialization_spec.md) | [📖 View](https://fory.apache.org/docs/specification/fory_java_serialization_spec) | -| **Row Format** | Row-based binary format | [row_format_spec.md](docs/specification/row_format_spec.md) | [📖 View](https://fory.apache.org/docs/specification/fory_row_format_spec) | -| **Type Mapping** | Cross-language type conversion | [xlang_type_mapping.md](docs/specification/xlang_type_mapping.md) | [📖 View](https://fory.apache.org/docs/specification/fory_xlang_serialization_spec) | +### Java -## Compatibility - -### Schema Compatibility - -Apache Fory™ supports class schema forward/backward compatibility across languages, enabling seamless schema evolution in production systems without requiring coordinated upgrades across all services. Fory provides two schema compatibility modes: - -1. **Compatible Mode (xlang default)**: Supports independent schema evolution with forward and backward compatibility. This mode enables field addition/deletion, limited type evolution, and graceful handling of schema mismatches. It is recommended for `xlang=true` because different languages can diverge on schemas more easily. Enable explicitly using `withCompatible(true)` in Java, `compatible=True` in Python, `compatible(true)` in Rust, `WithCompatible(true)` in Go, or the equivalent runtime option. - -2. **Schema Consistent Mode**: Assumes identical class schemas between serialization and deserialization peers. This mode offers minimal serialization overhead, smallest data size, and fastest performance. Use it only when schemas do not change, or when all services deploy schema changes at the same time. Disable compatible mode explicitly, for example `withCompatible(false)` in Java. - -### Binary Compatibility - -**Current Status**: Binary compatibility is **not guaranteed** between Fory major releases as the protocol continues to evolve. Compatibility **is guaranteed** between minor versions (for example, 0.13.x). - -**Recommendations**: - -- Version your serialized data by Fory major version -- Plan migration strategies when upgrading major versions -- See [upgrade guide](docs/guide/java) for details - -Major-version compatibility is the boundary for stable serialized data. - -## Security - -### Overview - -Serialization security varies by protocol: - -- **Row Format**: Secure with predefined schemas -- **Object Graph Serialization** (Java/Python native): More flexible but requires careful security configuration - -Dynamic serialization can deserialize arbitrary types, which may introduce risks. For example, the deserialization may invoke `init` constructor or `equals/hashCode` method; If the method body contains malicious code, the system will be at risk. - -Fory enables class registration **by default** for dynamic protocols, allowing only trusted registered types. -**Do not disable class registration unless you can ensure your environment is secure**. - -If this option is disabled, you are responsible for serialization security. You should implement and configure a customized `TypeChecker` or `DeserializationPolicy` for fine-grained security control. - -To report security vulnerabilities in Apache Fory™, please follow the [ASF vulnerability reporting process](https://apache.org/security/#reporting-a-vulnerability). +```java +public class User { + public int id; + public String name; + public int[] scores; +} -## Community and Support +RowEncoder encoder = Encoders.bean(User.class); -### Getting Help +User user = new User(); +user.id = 1; +user.name = "Alice"; +user.scores = new int[] {98, 100, 95}; -- **Slack**: Join our [Slack workspace](https://join.slack.com/t/fory-project/shared_invite/zt-36g0qouzm-kcQSvV_dtfbtBKHRwT5gsw) for community discussions -- **Twitter/X**: Follow [@ApacheFory](https://x.com/ApacheFory) for updates and announcements -- **GitHub Issues**: Report bugs and request features at [apache/fory](https://github.com/apache/fory/issues) -- **Mailing Lists**: Subscribe to Apache Fory mailing lists for development discussions +BinaryRow row = encoder.toRow(user); -### Contributing +Schema schema = encoder.schema(); +Schema.StringField nameField = schema.stringField("name"); +Schema.ArrayField scoresField = schema.arrayField("scores"); -We welcome contributions! Please read our [Contributing Guide](CONTRIBUTING.md) to get started. +String name = nameField.get(row); +ArrayData scores = scoresField.get(row); +int secondScore = scores.getInt32(1); +``` -**Ways to Contribute**: +For Java imports, nested structs, arrays/maps, Arrow integration, and partial +deserialization, see the +[Java row-format guide](https://fory.apache.org/docs/guide/java/row_format), the +[Python row-format guide](docs/guide/python/row-format.md), and the +[row-format specification](docs/specification/row_format_spec.md). -- 🐛 Report bugs and issues -- 💡 Propose new features -- 📝 Improve documentation -- 🔧 Submit pull requests -- 🧪 Add test cases -- 📊 Share benchmarks +## Documentation -See [Development Guide](docs/DEVELOPMENT.md) for build instructions and development workflow. +### User guides + +| Guide | Source | Website | +| --------------------- | ------------------------------------------------------------------------ | --------------------------------------------------------------- | +| Java | [docs/guide/java](docs/guide/java) | [View](https://fory.apache.org/docs/guide/java/) | +| Python | [docs/guide/python](docs/guide/python) | [View](https://fory.apache.org/docs/guide/python/) | +| Rust | [docs/guide/rust](docs/guide/rust) | [View](https://fory.apache.org/docs/guide/rust/) | +| C++ | [docs/guide/cpp](docs/guide/cpp) | [View](https://fory.apache.org/docs/guide/cpp/) | +| Go | [docs/guide/go](docs/guide/go) | [View](https://fory.apache.org/docs/guide/go/) | +| JavaScript/TypeScript | [docs/guide/javascript](docs/guide/javascript) | [View](https://fory.apache.org/docs/guide/javascript/) | +| C# | [docs/guide/csharp](docs/guide/csharp) | [View](https://fory.apache.org/docs/guide/csharp/) | +| Swift | [docs/guide/swift](docs/guide/swift) | [View](https://fory.apache.org/docs/guide/swift/) | +| Dart | [docs/guide/dart](docs/guide/dart) | [View](https://fory.apache.org/docs/guide/dart/) | +| Scala | [docs/guide/scala](docs/guide/scala) | [View](https://fory.apache.org/docs/guide/scala/) | +| Kotlin | [docs/guide/kotlin](docs/guide/kotlin) | [View](https://fory.apache.org/docs/guide/kotlin/) | +| Cross-language xlang | [docs/guide/xlang](docs/guide/xlang) | [View](https://fory.apache.org/docs/guide/xlang/) | +| Schema IDL/compiler | [docs/compiler](docs/compiler) | [View](https://fory.apache.org/docs/compiler/) | +| GraalVM native image | [docs/guide/java/graalvm-support.md](docs/guide/java/graalvm-support.md) | [View](https://fory.apache.org/docs/guide/java/graalvm_support) | +| Development | [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) | [View](docs/DEVELOPMENT.md) | + +### Specifications + +| Specification | Source | Website | +| ---------------------- | ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | +| Xlang serialization | [xlang_serialization_spec.md](docs/specification/xlang_serialization_spec.md) | [View](https://fory.apache.org/docs/specification/fory_xlang_serialization_spec) | +| Java serialization | [java_serialization_spec.md](docs/specification/java_serialization_spec.md) | [View](https://fory.apache.org/docs/specification/fory_java_serialization_spec) | +| Row format | [row_format_spec.md](docs/specification/row_format_spec.md) | [View](https://fory.apache.org/docs/specification/fory_row_format_spec) | +| Cross-language mapping | [xlang_type_mapping.md](docs/specification/xlang_type_mapping.md) | [View](https://fory.apache.org/docs/specification/fory_xlang_serialization_spec) | + +## Community and support + +- [Slack workspace](https://join.slack.com/t/fory-project/shared_invite/zt-36g0qouzm-kcQSvV_dtfbtBKHRwT5gsw) +- [@ApacheFory on X](https://x.com/ApacheFory) +- [GitHub issues](https://github.com/apache/fory/issues) +- Apache Fory mailing lists for development discussion + +## Contributing + +Read [CONTRIBUTING.md](CONTRIBUTING.md) and +[docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) before sending pull requests. Bug +reports, docs fixes, tests, benchmarks, and runtime improvements are welcome. ## License From 1b0cc55ab35d3b68625ba5c7bf8640d828d67049 Mon Sep 17 00:00:00 2001 From: chaokunyang Date: Sat, 9 May 2026 12:52:30 +0800 Subject: [PATCH 02/12] refactor(rust): rename registration APIs --- compiler/README.md | 6 +- compiler/extension/fory_options.proto | 2 +- compiler/fory_compiler/generators/rust.py | 12 +- .../fory_compiler/tests/test_nested_types.py | 8 +- docs/compiler/generated-code.md | 30 ++-- docs/compiler/index.md | 2 +- docs/compiler/schema-idl.md | 2 +- docs/guide/go/type-registration.md | 2 +- docs/guide/python/cross-language.md | 2 +- docs/guide/rust/basic-serialization.md | 6 +- docs/guide/rust/cross-language.md | 14 +- docs/guide/rust/custom-serializers.md | 2 +- docs/guide/rust/index.md | 6 +- docs/guide/rust/polymorphism.md | 12 +- docs/guide/rust/references.md | 4 +- docs/guide/rust/schema-evolution.md | 6 +- docs/guide/rust/troubleshooting.md | 4 +- docs/guide/rust/type-registration.md | 26 +-- docs/guide/xlang/getting-started.md | 2 +- docs/guide/xlang/serialization.md | 4 +- rust/README.md | 28 +-- rust/fory-core/src/fory.rs | 94 ++-------- rust/fory-core/src/lib.rs | 8 +- rust/fory-core/src/resolver/type_resolver.rs | 69 +++++-- rust/fory-core/src/serializer/trait_object.rs | 4 +- rust/fory-derive/src/lib.rs | 2 +- rust/fory/src/lib.rs | 54 +++--- rust/tests/tests/compatible/test_container.rs | 20 +-- rust/tests/tests/compatible/test_struct.rs | 86 ++++----- .../tests/compatible/test_struct_enum.rs | 64 +++---- rust/tests/tests/test_any.rs | 17 +- rust/tests/tests/test_array.rs | 16 +- rust/tests/tests/test_associated_types.rs | 8 +- rust/tests/tests/test_box.rs | 4 +- rust/tests/tests/test_collection.rs | 4 +- rust/tests/tests/test_complex_struct.rs | 18 +- rust/tests/tests/test_cross_language.rs | 168 ++++++++++-------- rust/tests/tests/test_debug.rs | 4 +- rust/tests/tests/test_enum.rs | 21 +-- rust/tests/tests/test_enum_compatible.rs | 40 ++--- rust/tests/tests/test_ext.rs | 2 +- rust/tests/tests/test_field_meta.rs | 63 ++++--- rust/tests/tests/test_fory.rs | 12 +- rust/tests/tests/test_generate_default.rs | 12 +- rust/tests/tests/test_lifecycle_guard.rs | 106 ++++++----- rust/tests/tests/test_list.rs | 2 +- rust/tests/tests/test_map.rs | 2 +- rust/tests/tests/test_marker.rs | 9 +- rust/tests/tests/test_max_dyn_depth.rs | 8 +- rust/tests/tests/test_multi_thread.rs | 4 +- rust/tests/tests/test_one_struct.rs | 4 +- rust/tests/tests/test_rc_arc.rs | 2 +- rust/tests/tests/test_rc_arc_trait_object.rs | 34 ++-- rust/tests/tests/test_refcell.rs | 6 +- rust/tests/tests/test_simple_struct.rs | 32 ++-- rust/tests/tests/test_skip_fields.rs | 32 ++-- rust/tests/tests/test_trait_object.rs | 50 +++--- rust/tests/tests/test_tuple.rs | 6 +- rust/tests/tests/test_tuple_compatible.rs | 32 ++-- rust/tests/tests/test_tuple_struct.rs | 54 +++--- rust/tests/tests/test_unsigned.rs | 22 +-- rust/tests/tests/test_weak.rs | 6 +- 62 files changed, 702 insertions(+), 679 deletions(-) diff --git a/compiler/README.md b/compiler/README.md index 0205707eea..1f4a6b8d2f 100644 --- a/compiler/README.md +++ b/compiler/README.md @@ -177,7 +177,7 @@ message User [id=101] { ... } // Registered with type ID 101 message User [id=101, deprecated=true] { ... } // Multiple options ``` -Types without `[id=...]` use namespace-based registration: +Types without `[id=...]` use name-based registration: ```fdl message Config { ... } // Registered as "package.Config" @@ -238,7 +238,7 @@ option polymorphism = true; option enable_auto_type_id = true; ``` -`enable_auto_type_id` defaults to `true`. Set it to `false` to keep namespace-based registration +`enable_auto_type_id` defaults to `true`. Set it to `false` to keep name-based registration for types that omit explicit IDs. **Message/Enum options:** @@ -372,7 +372,7 @@ Generates structs with: - `#[derive(ForyStruct)]`, `#[derive(ForyEnum)]`, and `#[derive(ForyUnion)]` macros - `#[fory(...)]` field attributes -- a registration helper for namespace-based registration +- a registration helper for name-based registration ```rust #[derive(ForyStruct, Debug, Clone, PartialEq, Default)] diff --git a/compiler/extension/fory_options.proto b/compiler/extension/fory_options.proto index 9dc89abcc3..1fbf72e26d 100644 --- a/compiler/extension/fory_options.proto +++ b/compiler/extension/fory_options.proto @@ -108,7 +108,7 @@ message ForyMessageOptions { // Unique type ID for cross-language registration. // Used for efficient type lookup during deserialization. // Must be a positive integer unique within the schema. - // If not specified, namespace-based registration is used. + // If not specified, name-based registration is used. optional int32 id = 1; // Enable schema evolution for this message. diff --git a/compiler/fory_compiler/generators/rust.py b/compiler/fory_compiler/generators/rust.py index 376d3c02b2..dc028ba4e0 100644 --- a/compiler/fory_compiler/generators/rust.py +++ b/compiler/fory_compiler/generators/rust.py @@ -1005,11 +1005,11 @@ def generate_enum_registration( reg_name = self.get_registration_type_name(enum.name, parent_stack) if self.should_register_by_id(enum): - lines.append(f" fory.register::<{type_name}>({enum.type_id})?;") + lines.append(f" fory.register_by_id::<{type_name}>({enum.type_id})?;") else: ns = self.package or "default" lines.append( - f' fory.register_by_namespace::<{type_name}>("{ns}", "{reg_name}")?;' + f' fory.register_by_name::<{type_name}>("{ns}", "{reg_name}")?;' ) def generate_message_registration( @@ -1041,11 +1041,11 @@ def generate_message_registration( # Register this message if self.should_register_by_id(message): - lines.append(f" fory.register::<{type_name}>({message.type_id})?;") + lines.append(f" fory.register_by_id::<{type_name}>({message.type_id})?;") else: ns = self.package or "default" lines.append( - f' fory.register_by_namespace::<{type_name}>("{ns}", "{reg_name}")?;' + f' fory.register_by_name::<{type_name}>("{ns}", "{reg_name}")?;' ) def generate_union_registration( @@ -1059,9 +1059,9 @@ def generate_union_registration( reg_name = self.get_registration_type_name(union.name, parent_stack) if self.should_register_by_id(union): - lines.append(f" fory.register_union::<{type_name}>({union.type_id})?;") + lines.append(f" fory.register_union_by_id::<{type_name}>({union.type_id})?;") else: ns = self.package or "default" lines.append( - f' fory.register_union_by_namespace::<{type_name}>("{ns}", "{reg_name}")?;' + f' fory.register_union_by_name::<{type_name}>("{ns}", "{reg_name}")?;' ) diff --git a/compiler/fory_compiler/tests/test_nested_types.py b/compiler/fory_compiler/tests/test_nested_types.py index 4dafcb5b72..55d06515be 100644 --- a/compiler/fory_compiler/tests/test_nested_types.py +++ b/compiler/fory_compiler/tests/test_nested_types.py @@ -415,7 +415,7 @@ def test_nested_message_field_type_qualified(self): assert "pub bar: foo::Bar," in content def test_nested_message_registration_uses_pascal_struct(self): - """register_by_namespace must reference the PascalCase struct name.""" + """register_by_name must reference the PascalCase struct name.""" source = dedent(""" message foo { message Bar { @@ -425,9 +425,9 @@ def test_nested_message_registration_uses_pascal_struct(self): } """) content = self._generate_rust(source) - assert "register_by_namespace::" in content - assert 'register_by_namespace::("default", "foo")' in content - assert "register_by_namespace::" in content + assert "register_by_name::" in content + assert 'register_by_name::("default", "foo")' in content + assert "register_by_name::" in content def test_pascal_case_names_unchanged(self): """Messages already in PascalCase must not be renamed.""" diff --git a/docs/compiler/generated-code.md b/docs/compiler/generated-code.md index 6fcdc5f373..480980d9b1 100644 --- a/docs/compiler/generated-code.md +++ b/docs/compiler/generated-code.md @@ -388,13 +388,13 @@ Generated registration function: ```rust pub fn register_types(fory: &mut Fory) -> Result<(), fory::Error> { - fory.register_union::(106)?; - fory.register::(101)?; - fory.register::(102)?; - fory.register::(100)?; - fory.register::(104)?; - fory.register::(105)?; - fory.register::(103)?; + fory.register_union_by_id::(106)?; + fory.register_by_id::(101)?; + fory.register_by_id::(102)?; + fory.register_by_id::(100)?; + fory.register_by_id::(104)?; + fory.register_by_id::(105)?; + fory.register_by_id::(103)?; Ok(()) } ``` @@ -402,18 +402,18 @@ pub fn register_types(fory: &mut Fory) -> Result<(), fory::Error> { For schemas without explicit `[id=...]`, generated registration uses computed numeric IDs: ```rust -fory.register::(1124725126)?; -fory.register_union::(1471345060)?; -fory.register::(3022445236)?; -fory.register_union::(1609214087)?; -fory.register::(2862577837)?; +fory.register_by_id::(1124725126)?; +fory.register_union_by_id::(1471345060)?; +fory.register_by_id::(3022445236)?; +fory.register_union_by_id::(1609214087)?; +fory.register_by_id::(2862577837)?; ``` If `option enable_auto_type_id = false;` is set: ```rust -fory.register_by_namespace::("myapp.models", "Config")?; -fory.register_union_by_namespace::("myapp.models", "Holder")?; +fory.register_by_name::("myapp.models", "Config")?; +fory.register_union_by_name::("myapp.models", "Holder")?; ``` ### Usage @@ -1046,7 +1046,7 @@ void main() { - Explicit `[id=...]` values are used directly in generated registration. - When type IDs are omitted, generated code uses computed numeric IDs (see `auto_id.*` outputs). -- If `option enable_auto_type_id = false;` is set, generated registration uses namespace/type-name APIs instead of numeric IDs. +- If `option enable_auto_type_id = false;` is set, generated registration uses name-based APIs instead of numeric IDs. ### Nested Type Shape diff --git a/docs/compiler/index.md b/docs/compiler/index.md index 707a679fcb..286de0b5cc 100644 --- a/docs/compiler/index.md +++ b/docs/compiler/index.md @@ -88,7 +88,7 @@ Unlike generic IDLs, Fory IDL is designed specifically for Fory serialization: - **Reference Tracking**: First-class support for shared and circular references via `ref` - **Nullable Fields**: Explicit `optional` modifier for nullable types -- **Type Registration**: Built-in support for both numeric IDs and namespace-based registration +- **Type Registration**: Built-in support for both numeric IDs and name-based registration - **Native Code Generation**: Generates idiomatic code with Fory annotations/macros ### Low Integration Overhead diff --git a/docs/compiler/schema-idl.md b/docs/compiler/schema-idl.md index 85249596d0..a008f7740a 100644 --- a/docs/compiler/schema-idl.md +++ b/docs/compiler/schema-idl.md @@ -88,7 +88,7 @@ package com.example.models alias models_v1; - Optional but recommended - Must appear before any type definitions - Only one package declaration per file -- Used for namespace-based type registration +- Used for name-based type registration - Package alias is used for auto-ID hashing **Language Mapping:** diff --git a/docs/guide/go/type-registration.md b/docs/guide/go/type-registration.md index 51425ec30d..97435a6398 100644 --- a/docs/guide/go/type-registration.md +++ b/docs/guide/go/type-registration.md @@ -223,7 +223,7 @@ struct User { } let mut fory = Fory::default(); -fory.register_by_name::("example.User")?; +fory.register_by_name::("example", "User")?; ``` ## Best Practices diff --git a/docs/guide/python/cross-language.md b/docs/guide/python/cross-language.md index 0022958245..ab8f5cab61 100644 --- a/docs/guide/python/cross-language.md +++ b/docs/guide/python/cross-language.md @@ -89,7 +89,7 @@ let mut fory = Fory::builder() .compatible(true) .xlang(true).build(); -fory.register_by_namespace::("example", "Person"); +fory.register_by_name::("example", "Person"); let person: Person = fory.deserialize(&binary_data)?; ``` diff --git a/docs/guide/rust/basic-serialization.md b/docs/guide/rust/basic-serialization.md index 2d2386f5a6..83bd590b51 100644 --- a/docs/guide/rust/basic-serialization.md +++ b/docs/guide/rust/basic-serialization.md @@ -55,8 +55,8 @@ struct Address { } let mut fory = Fory::default(); -fory.register::
(100); -fory.register::(200); +fory.register_by_id::
(100); +fory.register_by_id::(200); let person = Person { name: "John Doe".to_string(), @@ -137,7 +137,7 @@ assert_eq!(person, decoded); use fory::{Fory, Reader}; let mut fory = Fory::default(); -fory.register::(1)?; +fory.register_by_id::(1)?; let obj = MyStruct { /* ... */ }; diff --git a/docs/guide/rust/cross-language.md b/docs/guide/rust/cross-language.md index b95e1741bf..83065d2137 100644 --- a/docs/guide/rust/cross-language.md +++ b/docs/guide/rust/cross-language.md @@ -32,10 +32,10 @@ let mut fory = Fory::builder() .xlang(true).build(); // Register types with consistent IDs across languages -fory.register::(100); +fory.register_by_id::(100); -// Or use namespace-based registration -fory.register_by_namespace::("com.example", "MyStruct"); +// Or use name-based registration +fory.register_by_name::("com.example", "MyStruct"); ``` ## Type Registration for Cross-Language @@ -49,15 +49,15 @@ let mut fory = Fory::builder() .compatible(true) .xlang(true).build(); -fory.register::(100); // Same ID in Java, Python, etc. +fory.register_by_id::(100); // Same ID in Java, Python, etc. ``` -### Register by Namespace +### Register by Name For more flexible type naming: ```rust -fory.register_by_namespace::("com.example", "User"); +fory.register_by_name::("com.example", "User"); ``` ## Cross-Language Example @@ -78,7 +78,7 @@ let mut fory = Fory::builder() .compatible(true) .xlang(true).build(); -fory.register::(100); +fory.register_by_id::(100); let person = Person { name: "Alice".to_string(), diff --git a/docs/guide/rust/custom-serializers.md b/docs/guide/rust/custom-serializers.md index 508e37e570..06e2b962bb 100644 --- a/docs/guide/rust/custom-serializers.md +++ b/docs/guide/rust/custom-serializers.md @@ -80,7 +80,7 @@ impl ForyDefault for CustomType { ```rust let mut fory = Fory::default(); -fory.register_serializer::(100); +fory.register_serializer_by_id::(100); let custom = CustomType { value: 42, diff --git a/docs/guide/rust/index.md b/docs/guide/rust/index.md index 3b32eac6dd..bf54dce2e4 100644 --- a/docs/guide/rust/index.md +++ b/docs/guide/rust/index.md @@ -65,7 +65,7 @@ struct User { fn main() -> Result<(), Error> { let mut fory = Fory::default(); - fory.register::(1)?; + fory.register_by_id::(1)?; let user = User { name: "Alice".to_string(), @@ -107,7 +107,7 @@ struct Item { fn main() -> Result<(), Error> { let mut fory = Fory::default(); - fory.register::(1000)?; + fory.register_by_id::(1000)?; let fory = Arc::new(fory); let handles: Vec<_> = (0..8) @@ -130,7 +130,7 @@ fn main() -> Result<(), Error> { } ``` -**Tip:** Perform registrations (such as `fory.register::(id)`) before spawning threads so every worker sees the same metadata. Once configured, wrapping the instance in `Arc` is enough to fan out serialization and deserialization tasks safely. +**Tip:** Perform registrations (such as `fory.register_by_id::(id)`) before spawning threads so every worker sees the same metadata. Once configured, wrapping the instance in `Arc` is enough to fan out serialization and deserialization tasks safely. ## Architecture diff --git a/docs/guide/rust/polymorphism.md b/docs/guide/rust/polymorphism.md index f3b7bbbb1b..e40f5b1017 100644 --- a/docs/guide/rust/polymorphism.md +++ b/docs/guide/rust/polymorphism.md @@ -65,9 +65,9 @@ struct Zoo { } let mut fory = Fory::builder().compatible(true).build(); -fory.register::(100); -fory.register::(101); -fory.register::(102); +fory.register_by_id::(100); +fory.register_by_id::(101); +fory.register_by_id::(102); let zoo = Zoo { star_animal: Box::new(Dog { @@ -154,9 +154,9 @@ struct AnimalShelter { } let mut fory = Fory::builder().compatible(true).build(); -fory.register::(100); -fory.register::(101); -fory.register::(102); +fory.register_by_id::(100); +fory.register_by_id::(101); +fory.register_by_id::(102); let shelter = AnimalShelter { animals_rc: vec![ diff --git a/docs/guide/rust/references.md b/docs/guide/rust/references.md index f18d11cd17..667ac5d6c2 100644 --- a/docs/guide/rust/references.md +++ b/docs/guide/rust/references.md @@ -103,7 +103,7 @@ struct Node { } let mut fory = Fory::default(); -fory.register::(2000); +fory.register_by_id::(2000); // Build a parent-child tree let parent = Rc::new(RefCell::new(Node { @@ -155,7 +155,7 @@ struct Node { } let mut fory = Fory::default(); -fory.register::(6000); +fory.register_by_id::(6000); let parent = Arc::new(Mutex::new(Node { val: 10, diff --git a/docs/guide/rust/schema-evolution.md b/docs/guide/rust/schema-evolution.md index e6dbfced1d..5fad31f30f 100644 --- a/docs/guide/rust/schema-evolution.md +++ b/docs/guide/rust/schema-evolution.md @@ -48,10 +48,10 @@ struct PersonV2 { } let mut fory1 = Fory::builder().compatible(true).build(); -fory1.register::(1); +fory1.register_by_id::(1); let mut fory2 = Fory::builder().compatible(true).build(); -fory2.register::(1); +fory2.register_by_id::(1); let person_v1 = PersonV1 { name: "Alice".to_string(), @@ -121,7 +121,7 @@ enum Value { } let mut fory = Fory::default(); -fory.register::(1)?; +fory.register_by_id::(1)?; let value = Value::Object { name: "score".to_string(), value: 100 }; let bytes = fory.serialize(&value)?; diff --git a/docs/guide/rust/troubleshooting.md b/docs/guide/rust/troubleshooting.md index 90afa1369c..c12d828d79 100644 --- a/docs/guide/rust/troubleshooting.md +++ b/docs/guide/rust/troubleshooting.md @@ -33,12 +33,12 @@ This page covers common issues and debugging techniques for Apache Fory™ Rust. ```rust let mut fory = Fory::default(); -fory.register::(100)?; // Register before use +fory.register_by_id::(100)?; // Register before use ``` Confirm that: -- Every serializable struct or trait implementation calls `fory.register::(type_id)` +- Every serializable struct or trait implementation calls `fory.register_by_id::(type_id)` - The same IDs are reused on the deserialize side ### Type Mismatch Errors diff --git a/docs/guide/rust/type-registration.md b/docs/guide/rust/type-registration.md index d2849ac881..ddf1690e4c 100644 --- a/docs/guide/rust/type-registration.md +++ b/docs/guide/rust/type-registration.md @@ -36,7 +36,7 @@ struct User { } let mut fory = Fory::default(); -fory.register::(1)?; +fory.register_by_id::(1)?; let user = User { name: "Alice".to_string(), @@ -47,7 +47,7 @@ let bytes = fory.serialize(&user)?; let decoded: User = fory.deserialize(&bytes)?; ``` -## Register by Namespace +## Register by Name For cross-language compatibility, register with namespace and type name: @@ -56,8 +56,8 @@ let mut fory = Fory::builder() .compatible(true) .xlang(true).build(); -// Register with namespace-based naming -fory.register_by_namespace::("com.example", "MyStruct")?; +// Register with symbolic type identity +fory.register_by_name::("com.example", "MyStruct")?; ``` ## Register Custom Serializer @@ -66,7 +66,7 @@ For types that need custom serialization logic: ```rust let mut fory = Fory::default(); -fory.register_serializer::(100)?; +fory.register_serializer_by_id::(100)?; ``` ## Registration Consistency @@ -76,15 +76,15 @@ Rust registration APIs use explicit IDs or explicit namespace/type names. Keep t ```rust // Serializer side let mut fory = Fory::default(); -fory.register::(1)?; -fory.register::(2)?; -fory.register::(3)?; +fory.register_by_id::(1)?; +fory.register_by_id::(2)?; +fory.register_by_id::(3)?; // Deserializer side - MUST use the same ID mapping let mut fory = Fory::default(); -fory.register::(1)?; -fory.register::(2)?; -fory.register::(3)?; +fory.register_by_id::(1)?; +fory.register_by_id::(2)?; +fory.register_by_id::(3)?; ``` ## Thread-Safe Registration @@ -96,8 +96,8 @@ use std::sync::Arc; use std::thread; let mut fory = Fory::default(); -fory.register::(1)?; -fory.register::(2)?; +fory.register_by_id::(1)?; +fory.register_by_id::(2)?; // Now share across threads let fory = Arc::new(fory); diff --git a/docs/guide/xlang/getting-started.md b/docs/guide/xlang/getting-started.md index 7d091e3912..f5a81c209d 100644 --- a/docs/guide/xlang/getting-started.md +++ b/docs/guide/xlang/getting-started.md @@ -177,7 +177,7 @@ struct Person { let mut fory = Fory::builder().xlang(true).compatible(true).build(); fory - .register_by_namespace::("example", "Person") + .register_by_name::("example", "Person") .expect("register Person"); ``` diff --git a/docs/guide/xlang/serialization.md b/docs/guide/xlang/serialization.md index aca6d3c250..4f37a1a1dc 100644 --- a/docs/guide/xlang/serialization.md +++ b/docs/guide/xlang/serialization.md @@ -410,10 +410,10 @@ fn complex_struct() { let mut fory = Fory::builder().xlang(true).compatible(true).build(); fory - .register_by_namespace::("example", "foo2") + .register_by_name::("example", "foo2") .expect("register Animal"); fory - .register_by_namespace::("example", "foo") + .register_by_name::("example", "foo") .expect("register Person"); let bin = fory.serialize(&person).expect("serialize success"); let obj: Person = fory.deserialize(&bin).expect("deserialize success"); diff --git a/rust/README.md b/rust/README.md index 6fd35dc004..8223db45bf 100644 --- a/rust/README.md +++ b/rust/README.md @@ -51,7 +51,7 @@ struct User { fn main() -> Result<(), Error> { let mut fory = Fory::default(); - fory.register::(1)?; + fory.register_by_id::(1)?; let user = User { name: "Alice".to_string(), @@ -112,8 +112,8 @@ struct Address { } let mut fory = Fory::default(); -fory.register::
(100); -fory.register::(200); +fory.register_by_id::
(100); +fory.register_by_id::(200); let person = Person { name: "John Doe".to_string(), @@ -197,7 +197,7 @@ struct Node { } let mut fory = Fory::default(); -fory.register::(2000); +fory.register_by_id::(2000); // Build a parent-child tree let parent = Rc::new(RefCell::new(Node { @@ -282,9 +282,9 @@ struct Zoo { } let mut fory = Fory::builder().compatible(true).build(); -fory.register::(100); -fory.register::(101); -fory.register::(102); +fory.register_by_id::(100); +fory.register_by_id::(101); +fory.register_by_id::(102); let zoo = Zoo { star_animal: Box::new(Dog { @@ -341,10 +341,10 @@ struct PersonV2 { } let mut fory1 = Fory::builder().compatible(true).build(); -fory1.register::(1); +fory1.register_by_id::(1); let mut fory2 = Fory::builder().compatible(true).build(); -fory2.register::(1); +fory2.register_by_id::(1); let person_v1 = PersonV1 { name: "Alice".to_string(), @@ -393,7 +393,7 @@ enum Value { } let mut fory = Fory::default(); -fory.register::(1)?; +fory.register_by_id::(1)?; let value = Value::Object { name: "score".to_string(), value: 100 }; let bytes = fory.serialize(&value)?; @@ -496,7 +496,7 @@ impl ForyDefault for CustomType { } let mut fory = Fory::default(); -fory.register_serializer::(100); +fory.register_serializer_by_id::(100); let custom = CustomType { value: 42, @@ -607,10 +607,10 @@ let mut fory = Fory::builder() .xlang(true).build(); // Register types with consistent IDs across languages -fory.register::(100); +fory.register_by_id::(100); -// Or use namespace-based registration -fory.register_by_namespace::("com.example", "MyStruct"); +// Or use name-based registration +fory.register_by_name::("com.example", "MyStruct"); ``` See [xlang_type_mapping.md](https://fory.apache.org/docs/specification/xlang_type_mapping) for type mapping across languages. diff --git a/rust/fory-core/src/fory.rs b/rust/fory-core/src/fory.rs index 89c9d1c083..2f6f952104 100644 --- a/rust/fory-core/src/fory.rs +++ b/rust/fory-core/src/fory.rs @@ -806,9 +806,9 @@ impl Fory { /// struct User { name: String, age: u32 } /// /// let mut fory = Fory::default(); - /// fory.register::(100); + /// fory.register_by_id::(100); /// ``` - pub fn register( + pub fn register_by_id( &mut self, id: u32, ) -> Result<(), Error> { @@ -819,7 +819,7 @@ impl Fory { /// Register a union type with a numeric type ID. /// /// This is intended for union-compatible enums generated by the compiler. - pub fn register_union( + pub fn register_union_by_id( &mut self, id: u32, ) -> Result<(), Error> { @@ -855,72 +855,29 @@ impl Fory { /// struct User { name: String, age: u32 } /// /// let mut fory = Fory::default(); - /// fory.register_by_namespace::("com.example", "User"); + /// fory.register_by_name::("com.example", "User"); /// ``` - pub fn register_by_namespace( + pub fn register_by_name( &mut self, namespace: &str, type_name: &str, ) -> Result<(), Error> { self.check_registration_allowed()?; self.type_resolver - .register_by_namespace::(namespace, type_name) + .register_by_name::(namespace, type_name) } /// Register a union type with namespace and type name. /// /// This is intended for union-compatible enums generated by the compiler. - pub fn register_union_by_namespace( + pub fn register_union_by_name( &mut self, namespace: &str, type_name: &str, ) -> Result<(), Error> { self.check_registration_allowed()?; self.type_resolver - .register_union_by_namespace::(namespace, type_name) - } - - /// Registers a struct type with a type name (using the default namespace). - /// - /// # Type Parameters - /// - /// * `T` - The struct type to register. Must implement `StructSerializer`, `Serializer`, and `ForyDefault`. - /// - /// # Arguments - /// - /// * `type_name` - The name of the type (e.g., "User"). - /// - /// # Notes - /// - /// This is a convenience method that calls `register_by_namespace` with an empty namespace string. - /// - /// # Examples - /// - /// ```rust, ignore - /// use fory::Fory; - /// use fory::{ForyEnum, ForyStruct, ForyUnion}; - /// - /// #[derive(ForyStruct)] - /// struct User { name: String, age: u32 } - /// - /// let mut fory = Fory::default(); - /// fory.register_by_name::("User"); - /// ``` - pub fn register_by_name( - &mut self, - type_name: &str, - ) -> Result<(), Error> { - self.check_registration_allowed()?; - self.register_by_namespace::("", type_name) - } - - /// Register a union type with type name only (no namespace). - pub fn register_union_by_name( - &mut self, - type_name: &str, - ) -> Result<(), Error> { - self.check_registration_allowed()?; - self.register_union_by_namespace::("", type_name) + .register_union_by_name::(namespace, type_name) } /// Registers a custom serializer type with a numeric type ID. @@ -928,7 +885,7 @@ impl Fory { /// # Type Parameters /// /// * `T` - The type to register. Must implement `Serializer` and `ForyDefault`. - /// Unlike `register()`, this does not require `StructSerializer`, making it suitable + /// Unlike `register_by_id()`, this does not require `StructSerializer`, making it suitable /// for non-struct types or types with custom serialization logic. /// /// # Arguments @@ -948,9 +905,9 @@ impl Fory { /// use fory_core::Fory; /// /// let mut fory = Fory::default(); - /// fory.register_serializer::(200); + /// fory.register_serializer_by_id::(200); /// ``` - pub fn register_serializer( + pub fn register_serializer_by_id( &mut self, id: u32, ) -> Result<(), Error> { @@ -971,43 +928,22 @@ impl Fory { /// /// # Notes /// - /// This is the namespace-based equivalent of `register_serializer()`, preferred for + /// This is the named equivalent of `register_serializer_by_id()`, preferred for /// cross-language serialization scenarios. /// - pub fn register_serializer_by_namespace( + pub fn register_serializer_by_name( &mut self, namespace: &str, type_name: &str, ) -> Result<(), Error> { self.check_registration_allowed()?; self.type_resolver - .register_serializer_by_namespace::(namespace, type_name) - } - - /// Registers a custom serializer type with a type name (using the default namespace). - /// - /// # Type Parameters - /// - /// * `T` - The type to register. Must implement `Serializer` and `ForyDefault`. - /// - /// # Arguments - /// - /// * `type_name` - The name of the type. - /// - /// # Notes - /// - /// This is a convenience method that calls `register_serializer_by_namespace` with an empty namespace. - pub fn register_serializer_by_name( - &mut self, - type_name: &str, - ) -> Result<(), Error> { - self.check_registration_allowed()?; - self.register_serializer_by_namespace::("", type_name) + .register_serializer_by_name::(namespace, type_name) } /// Registers a generic trait object type for serialization. /// This method should be used to register collection types such as `Vec`, `HashMap`, etc. - /// Don't register concrete struct types with this method. Use `register()` instead. + /// Don't register concrete struct types with this method. Use `register_by_id()` instead. pub fn register_generic_trait( &mut self, ) -> Result<(), Error> { diff --git a/rust/fory-core/src/lib.rs b/rust/fory-core/src/lib.rs index 4d1ac219b5..bac59ebb25 100644 --- a/rust/fory-core/src/lib.rs +++ b/rust/fory-core/src/lib.rs @@ -102,9 +102,9 @@ //! //! # fn main() { //! let mut fory = Fory::builder().compatible(true).build(); -//! fory.register::(100); -//! fory.register::(101); -//! fory.register::(102); +//! fory.register_by_id::(100); +//! fory.register_by_id::(101); +//! fory.register_by_id::(102); //! //! let zoo = Zoo { //! star_animal: Box::new(Dog { name: "Buddy".to_string() }), @@ -171,7 +171,7 @@ //! let deserialized_map: HashMap = fory.deserialize(&serialized_map).unwrap(); //! assert_eq!(map, deserialized_map); //! // Register types for object serialization -//! // fory.register::(type_id); +//! // fory.register_by_id::(type_id); //! //! // Use row-based serialization for zero-copy operations //! // let row_data = to_row(&my_data); diff --git a/rust/fory-core/src/resolver/type_resolver.rs b/rust/fory-core/src/resolver/type_resolver.rs index 1a0e3fbaa7..73ab88fe7b 100644 --- a/rust/fory-core/src/resolver/type_resolver.rs +++ b/rust/fory-core/src/resolver/type_resolver.rs @@ -69,6 +69,16 @@ const INTERNAL_TYPE_ID_LIMIT: usize = 256; const MAX_USER_TYPE_ID: u32 = 0xfffffffe; pub(crate) const NO_USER_TYPE_ID: u32 = u32::MAX; +fn validate_named_registration(type_name: &str, api: &str) -> Result<(), Error> { + if type_name.is_empty() { + return Err(Error::not_allowed(format!( + "type_name must be non-empty for {}", + api + ))); + } + Ok(()) +} + #[derive(Clone, Debug)] pub struct Harness { write_fn: WriteFn, @@ -803,7 +813,7 @@ impl TypeResolver { &mut self, id: u32, ) -> Result<(), Error> { - self.register::(id, &EMPTY_STRING, &EMPTY_STRING, true) + self.register_struct_type::(id, &EMPTY_STRING, &EMPTY_STRING, true) } pub fn register_union_by_id( @@ -815,31 +825,33 @@ impl TypeResolver { "register_union_by_id requires a union-compatible enum type", )); } - self.register::(id, &EMPTY_STRING, &EMPTY_STRING, true) + self.register_struct_type::(id, &EMPTY_STRING, &EMPTY_STRING, true) } - pub fn register_by_namespace( + pub fn register_by_name( &mut self, namespace: &str, type_name: &str, ) -> Result<(), Error> { - self.register::(0, namespace, type_name, true) + validate_named_registration(type_name, "register_by_name")?; + self.register_struct_type::(0, namespace, type_name, true) } - pub fn register_union_by_namespace( + pub fn register_union_by_name( &mut self, namespace: &str, type_name: &str, ) -> Result<(), Error> { + validate_named_registration(type_name, "register_union_by_name")?; if T::fory_static_type_id() != TypeId::UNION { return Err(Error::not_allowed( - "register_union_by_namespace requires a union-compatible enum type", + "register_union_by_name requires a union-compatible enum type", )); } - self.register::(0, namespace, type_name, true) + self.register_struct_type::(0, namespace, type_name, true) } - fn register( + fn register_struct_type( &mut self, id: u32, namespace: &str, @@ -847,6 +859,18 @@ impl TypeResolver { _lazy: bool, ) -> Result<(), Error> { let register_by_name = !type_name.is_empty(); + if register_by_name + && self.partial_type_infos.values().any(|info| { + info.register_by_name + && info.namespace.original == namespace + && info.type_name.original == type_name + }) + { + return Err(Error::type_error(format!( + "Type name {}::{} conflicts with already registered type", + namespace, type_name + ))); + } if !register_by_name && id > MAX_USER_TYPE_ID { return Err(Error::not_allowed(format!( "type id must be in range [0, 0xfffffffe], got {}", @@ -1022,14 +1046,15 @@ impl TypeResolver { "register_serializer can only be used for ext and named_ext types", )); } - self.register_serializer::(id, actual_type_id, &EMPTY_STRING, &EMPTY_STRING) + self.register_serializer_type::(id, actual_type_id, &EMPTY_STRING, &EMPTY_STRING) } - pub fn register_serializer_by_namespace( + pub fn register_serializer_by_name( &mut self, namespace: &str, type_name: &str, ) -> Result<(), Error> { + validate_named_registration(type_name, "register_serializer_by_name")?; let actual_type_id = get_ext_actual_type_id(0, true); let static_type_id = T::fory_static_type_id(); if static_type_id != TypeId::EXT && static_type_id != TypeId::NAMED_EXT { @@ -1037,7 +1062,7 @@ impl TypeResolver { "register_serializer can only be used for ext and named_ext types", )); } - self.register_serializer::(0, actual_type_id, namespace, type_name) + self.register_serializer_type::(0, actual_type_id, namespace, type_name) } fn register_internal_serializer( @@ -1051,10 +1076,10 @@ impl TypeResolver { raw_id ))); } - self.register_serializer::(raw_id, raw_id, &EMPTY_STRING, &EMPTY_STRING) + self.register_serializer_type::(raw_id, raw_id, &EMPTY_STRING, &EMPTY_STRING) } - fn register_serializer( + fn register_serializer_type( &mut self, id: u32, actual_type_id: u32, @@ -1062,6 +1087,18 @@ impl TypeResolver { type_name: &str, ) -> Result<(), Error> { let register_by_name = !type_name.is_empty(); + if register_by_name + && self.partial_type_infos.values().any(|info| { + info.register_by_name + && info.namespace.original == namespace + && info.type_name.original == type_name + }) + { + return Err(Error::type_error(format!( + "Type name {}::{} conflicts with already registered type", + namespace, type_name + ))); + } if !register_by_name && id > MAX_USER_TYPE_ID { return Err(Error::not_allowed(format!( "type id must be in range [0, 0xfffffffe], got {}", @@ -1298,6 +1335,12 @@ impl TypeResolver { let namespace = &type_info.namespace; let type_name = &type_info.type_name; let ms_key = (namespace.clone(), type_name.clone()); + if type_info_map_by_meta_string_name.contains_key(&ms_key) { + return Err(Error::type_error(format!( + "Type name {}::{} conflicts with already registered type", + namespace.original, type_name.original + ))); + } type_info_map_by_meta_string_name.insert(ms_key, Rc::new(type_info.clone())); let string_key = (namespace.original.clone(), type_name.original.clone()); type_info_map_by_name.insert(string_key, Rc::new(type_info.clone())); diff --git a/rust/fory-core/src/serializer/trait_object.rs b/rust/fory-core/src/serializer/trait_object.rs index bcba476752..1757217761 100644 --- a/rust/fory-core/src/serializer/trait_object.rs +++ b/rust/fory-core/src/serializer/trait_object.rs @@ -91,8 +91,8 @@ macro_rules! downcast_and_serialize { /// /// # fn main() { /// let mut fory = Fory::builder().compatible(true).build(); -/// fory.register::(100); -/// fory.register::(101); +/// fory.register_by_id::(100); +/// fory.register_by_id::(101); /// /// let dog: Box = Box::new(Dog { name: "Rex".to_string() }); /// let bytes = fory.serialize(&dog); diff --git a/rust/fory-derive/src/lib.rs b/rust/fory-derive/src/lib.rs index f8a726ef19..f7db564177 100644 --- a/rust/fory-derive/src/lib.rs +++ b/rust/fory-derive/src/lib.rs @@ -156,7 +156,7 @@ //! //! fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register::(100); +//! fory.register_by_id::(100); //! //! let data = MyData { //! value: 42, diff --git a/rust/fory/src/lib.rs b/rust/fory/src/lib.rs index c96e46baf9..1afad5a1d4 100644 --- a/rust/fory/src/lib.rs +++ b/rust/fory/src/lib.rs @@ -68,7 +68,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register::(1)?; +//! fory.register_by_id::(1)?; //! //! let user = User { //! name: "Alice".to_string(), @@ -140,8 +140,8 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register::
(100); -//! fory.register::(200); +//! fory.register_by_id::
(100); +//! fory.register_by_id::(200); //! //! let person = Person { //! name: "John Doe".to_string(), @@ -252,7 +252,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::builder().track_ref(true).build(); -//! fory.register::(2000); +//! fory.register_by_id::(2000); //! //! let parent = Rc::new(RefCell::new(Node { //! value: 1, @@ -294,7 +294,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::builder().track_ref(true).build(); -//! fory.register::(6000); +//! fory.register_by_id::(6000); //! //! let parent = Arc::new(Mutex::new(Node { //! val: 10, @@ -375,9 +375,9 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::builder().compatible(true).build(); -//! fory.register::(100); -//! fory.register::(101); -//! fory.register::(102); +//! fory.register_by_id::(100); +//! fory.register_by_id::(101); +//! fory.register_by_id::(102); //! //! let zoo = Zoo { //! star_animal: Box::new(Dog { @@ -421,7 +421,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register::(100); +//! fory.register_by_id::(100); //! //! let dog: Rc = Rc::new(Dog { //! name: "Rex".to_string() @@ -450,7 +450,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register::(101); +//! fory.register_by_id::(101); //! //! let cat: Arc = Arc::new(Cat { //! name: "Whiskers".to_string() @@ -502,9 +502,9 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::builder().compatible(true).build(); -//! fory.register::(100); -//! fory.register::(101); -//! fory.register::(102); +//! fory.register_by_id::(100); +//! fory.register_by_id::(101); +//! fory.register_by_id::(102); //! //! let shelter = AnimalShelter { //! animals_rc: vec![ @@ -556,7 +556,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::builder().compatible(true).build(); -//! fory.register::(100); +//! fory.register_by_id::(100); //! //! // For Rc //! let dog_rc: Rc = Rc::new(Dog { name: "Rex".to_string() }); @@ -631,10 +631,10 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory1 = Fory::builder().compatible(true).build(); -//! fory1.register::(1); +//! fory1.register_by_id::(1); //! //! let mut fory2 = Fory::builder().compatible(true).build(); -//! fory2.register::(1); +//! fory2.register_by_id::(1); //! //! let person_v1 = PersonV1 { //! name: "Alice".to_string(), @@ -695,7 +695,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register::(1)?; +//! fory.register_by_id::(1)?; //! //! let value = Value::Object { name: "score".to_string(), value: 100 }; //! let bytes = fory.serialize(&value)?; @@ -728,10 +728,10 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory_old = Fory::builder().compatible(true).build(); -//! fory_old.register::(5)?; +//! fory_old.register_by_id::(5)?; //! //! let mut fory_new = Fory::builder().compatible(true).build(); -//! fory_new.register::(5)?; +//! fory_new.register_by_id::(5)?; //! //! // Serialize with old schema (2 fields) //! let old_bytes = fory_old.serialize(&OldEvent::Click { x: 100, y: 200 })?; @@ -856,7 +856,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register_serializer::(100); +//! fory.register_serializer_by_id::(100); //! //! let custom = CustomType { //! value: 42, @@ -1061,13 +1061,13 @@ //! field2: String, //! } //! -//! fory.register_by_namespace::("com.example", "MyStruct"); +//! fory.register_by_name::("com.example", "MyStruct"); //! ``` //! //! **Type registration strategies:** //! -//! - **ID-based registration**: `fory.register::(id)` - Fastest, requires coordination -//! - **Namespace-based registration**: `fory.register_by_namespace::(namespace, name)` - Automatic cross-language mapping +//! - **ID-based registration**: `fory.register_by_id::(id)` - Fastest, requires coordination +//! - **Name-based registration**: `fory.register_by_name::(namespace, name)` - Automatic cross-language mapping //! //! ## Performance Characteristics //! @@ -1109,7 +1109,7 @@ //! //! fn process_data(bytes: &[u8]) -> Result { //! let mut fory = Fory::default(); -//! fory.register::(100); +//! fory.register_by_id::(100); //! //! let data: Data = fory.deserialize(bytes)?; //! Ok(data) @@ -1135,7 +1135,7 @@ //! } //! //! let mut fory = Fory::default(); -//! fory.register::(1000).unwrap(); +//! fory.register_by_id::(1000).unwrap(); //! let fory = Arc::new(fory); //! let handles: Vec<_> = (0..8) //! .map(|i| { @@ -1154,7 +1154,7 @@ //! } //! ``` //! -//! **Best practice:** Perform type registration (e.g., `fory.register::(id)`) before +//! **Best practice:** Perform type registration (e.g., `fory.register_by_id::(id)`) before //! spawning worker threads so metadata is ready, then share the configured instance. //! //! ## Examples @@ -1170,7 +1170,7 @@ //! //! - **Type registry errors**: Errors such as `TypeId ... not found in type_info registry` mean //! the type was never registered with the active `Fory` instance. Ensure every serializable -//! struct, enum, or trait implementation calls `register::(type_id)` before use, and reuse +//! struct, enum, or trait implementation calls `register_by_id::(type_id)` before use, and reuse //! the same IDs when deserializing. //! - **Quick error lookup**: Always prefer the static constructors on //! [`fory_core::error::Error`]—for example `Error::type_mismatch`, `Error::invalid_data`, or diff --git a/rust/tests/tests/compatible/test_container.rs b/rust/tests/tests/compatible/test_container.rs index 5abebea86c..d2470da2f0 100644 --- a/rust/tests/tests/compatible/test_container.rs +++ b/rust/tests/tests/compatible/test_container.rs @@ -286,9 +286,9 @@ fn container_outer_auto_conv() { #[test] fn collection_inner() { let mut fory1 = Fory::builder().compatible(true).build(); - fory1.register::(101).unwrap(); + fory1.register_by_id::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).build(); - fory2.register_by_name::("item").unwrap(); + fory2.register_by_name::("", "item").unwrap(); for fory in [fory1, fory2] { // serialize let mut bins = vec![ @@ -349,9 +349,9 @@ fn collection_inner() { #[test] fn collection_inner_auto_conv() { let mut fory1 = Fory::builder().compatible(true).build(); - fory1.register::(101).unwrap(); + fory1.register_by_id::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).build(); - fory2.register_by_name::("item").unwrap(); + fory2.register_by_name::("", "item").unwrap(); for fory in [fory1, fory2] { // serialize_non_null let mut bins = vec![ @@ -417,9 +417,9 @@ fn collection_inner_auto_conv() { #[test] fn map_inner() { let mut fory1 = Fory::builder().compatible(true).build(); - fory1.register::(101).unwrap(); + fory1.register_by_id::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).build(); - fory2.register_by_name::("item").unwrap(); + fory2.register_by_name::("", "item").unwrap(); for fory in [fory1, fory2] { // serialize let bytes = fory.serialize(&basic_map()).unwrap(); @@ -454,9 +454,9 @@ fn map_inner() { #[test] fn map_inner_auto_conv() { let mut fory1 = Fory::builder().compatible(true).build(); - fory1.register::(101).unwrap(); + fory1.register_by_id::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).build(); - fory2.register_by_name::("item").unwrap(); + fory2.register_by_name::("", "item").unwrap(); for fory in [fory1, fory2] { // serialize_non_null let bytes = fory.serialize(&basic_map()).unwrap(); @@ -494,9 +494,9 @@ fn map_inner_auto_conv() { #[test] fn complex() { let mut fory1 = Fory::builder().compatible(true).build(); - fory1.register::(101).unwrap(); + fory1.register_by_id::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).build(); - fory2.register_by_name::("item").unwrap(); + fory2.register_by_name::("", "item").unwrap(); for fory in [fory1, fory2] { let mut bins = vec![ fory.serialize(&nested_collection()).unwrap(), diff --git a/rust/tests/tests/compatible/test_struct.rs b/rust/tests/tests/compatible/test_struct.rs index 1b5e94dec4..ade9df5116 100644 --- a/rust/tests/tests/compatible/test_struct.rs +++ b/rust/tests/tests/compatible/test_struct.rs @@ -47,8 +47,8 @@ fn simple() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(999).unwrap(); - fory2.register::(999).unwrap(); + fory1.register_by_id::(999).unwrap(); + fory2.register_by_id::(999).unwrap(); let animal: Animal1 = Animal1 { f1: HashMap::from([(1, vec![2])]), f2: String::from("hello"), @@ -101,8 +101,8 @@ fn compatible_list_array_field_pairs() { let mut writer = Fory::builder().compatible(true).build(); let mut reader = Fory::builder().compatible(true).build(); - writer.register::(991).unwrap(); - reader.register::(991).unwrap(); + writer.register_by_id::(991).unwrap(); + reader.register_by_id::(991).unwrap(); let bytes = writer .serialize(&ListPayload { payload: vec![1, 2, 3], @@ -113,8 +113,8 @@ fn compatible_list_array_field_pairs() { let mut writer = Fory::builder().compatible(true).build(); let mut reader = Fory::builder().compatible(true).build(); - writer.register::(992).unwrap(); - reader.register::(992).unwrap(); + writer.register_by_id::(992).unwrap(); + reader.register_by_id::(992).unwrap(); let bytes = writer .serialize(&ArrayPayload { payload: vec![1, 2, 3], @@ -125,8 +125,8 @@ fn compatible_list_array_field_pairs() { let mut writer = Fory::builder().compatible(true).build(); let mut reader = Fory::builder().compatible(true).build(); - writer.register::(993).unwrap(); - reader.register::(993).unwrap(); + writer.register_by_id::(993).unwrap(); + reader.register_by_id::(993).unwrap(); let bytes = writer .serialize(&NullableListPayload { payload: vec![Some(1), Some(2), Some(3)], @@ -151,8 +151,8 @@ fn compatible_list_array_field_pairs() { let mut writer = Fory::builder().compatible(true).build(); let mut reader = Fory::builder().compatible(true).build(); - writer.register::(994).unwrap(); - reader.register::(994).unwrap(); + writer.register_by_id::(994).unwrap(); + reader.register_by_id::(994).unwrap(); let bytes = writer .serialize(&NestedListPayload { payload: vec![vec![1, 2], vec![3]], @@ -179,8 +179,8 @@ fn skip_option() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(999).unwrap(); - fory2.register::(999).unwrap(); + fory1.register_by_id::(999).unwrap(); + fory2.register_by_id::(999).unwrap(); let item1 = Item1 { f1: None, f2: Some(String::from("f2")), @@ -218,10 +218,10 @@ fn nonexistent_struct() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(899).unwrap(); - fory1.register::(999).unwrap(); - fory2.register::(799).unwrap(); - fory2.register::(999).unwrap(); + fory1.register_by_id::(899).unwrap(); + fory1.register_by_id::(999).unwrap(); + fory2.register_by_id::(799).unwrap(); + fory2.register_by_id::(999).unwrap(); let person = Person1 { f2: Item1 { f1: 42 }, f3: 24, @@ -249,7 +249,7 @@ fn option() { last: i64, } let mut fory = Fory::builder().compatible(true).build(); - fory.register::(999).unwrap(); + fory.register_by_id::(999).unwrap(); let animal: Animal = Animal { f1: Some(String::from("f1")), f2: None, @@ -294,8 +294,8 @@ fn nullable() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(999).unwrap(); - fory2.register::(999).unwrap(); + fory1.register_by_id::(999).unwrap(); + fory2.register_by_id::(999).unwrap(); let item1 = Item1 { f2: 43, @@ -348,8 +348,8 @@ fn nullable_container() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(999).unwrap(); - fory2.register::(999).unwrap(); + fory1.register_by_id::(999).unwrap(); + fory2.register_by_id::(999).unwrap(); let item1 = Item1 { f1: vec![44, 45], @@ -400,8 +400,8 @@ fn inner_nullable() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(999).unwrap(); - fory2.register::(999).unwrap(); + fory1.register_by_id::(999).unwrap(); + fory2.register_by_id::(999).unwrap(); let item1 = Item1 { f1: vec![None, Some("hello".to_string())], @@ -447,10 +447,10 @@ fn nullable_struct() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(199).unwrap(); - fory1.register::(200).unwrap(); - fory2.register::(199).unwrap(); - fory2.register::(200).unwrap(); + fory1.register_by_id::(199).unwrap(); + fory1.register_by_id::(200).unwrap(); + fory2.register_by_id::(199).unwrap(); + fory2.register_by_id::(200).unwrap(); let person1 = Person1 { f1: Item { @@ -523,13 +523,13 @@ fn enum_without_payload() { } let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); - fory1.register::(101).unwrap(); - fory1.register::(102).unwrap(); - fory1.register::(103).unwrap(); + fory1.register_by_id::(101).unwrap(); + fory1.register_by_id::(102).unwrap(); + fory1.register_by_id::(103).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); - fory2.register::(101).unwrap(); - fory2.register::(102).unwrap(); - fory2.register::(103).unwrap(); + fory2.register_by_id::(101).unwrap(); + fory2.register_by_id::(102).unwrap(); + fory2.register_by_id::(103).unwrap(); let person1 = Person1 { f1: Color1::Blue, @@ -589,11 +589,11 @@ fn named_enum() { last: i8, } let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); - fory1.register_by_name::("a").unwrap(); - fory1.register::(101).unwrap(); + fory1.register_by_name::("", "a").unwrap(); + fory1.register_by_id::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); - fory2.register_by_name::("a").unwrap(); - fory2.register::(101).unwrap(); + fory2.register_by_name::("", "a").unwrap(); + fory2.register_by_id::(101).unwrap(); let item1 = Item1 { f1: Color::Red, f2: Color::Blue, @@ -645,9 +645,9 @@ fn boxed() { } let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); - fory1.register::(101).unwrap(); + fory1.register_by_id::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); - fory2.register::(101).unwrap(); + fory2.register_by_id::(101).unwrap(); let f1 = 1; let f2 = 2; @@ -765,10 +765,10 @@ fn test_struct_with_generic() { let mut fory3 = Fory::builder().xlang(true).compatible(false).build(); fn inner_test(fory: &mut Fory) -> Result<(), Error> { - fory.register::(1)?; - fory.register::(2)?; - fory.register_serializer::>(3)?; - fory.register_serializer::>(4)?; + fory.register_by_id::(1)?; + fory.register_by_id::(2)?; + fory.register_serializer_by_id::>(3)?; + fory.register_serializer_by_id::>(4)?; let w1 = Wrapper:: { value: "Value1".into(), diff --git a/rust/tests/tests/compatible/test_struct_enum.rs b/rust/tests/tests/compatible/test_struct_enum.rs index 0ff6a6b884..60dc4611d7 100644 --- a/rust/tests/tests/compatible/test_struct_enum.rs +++ b/rust/tests/tests/compatible/test_struct_enum.rs @@ -46,8 +46,8 @@ fn simple() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(999).unwrap(); - fory2.register::(999).unwrap(); + fory1.register_by_id::(999).unwrap(); + fory2.register_by_id::(999).unwrap(); let animal: Animal1 = Animal1 { f1: HashMap::from([(1, vec![2])]), f2: String::from("hello"), @@ -82,7 +82,7 @@ fn simple_write_continuous() { } let mut fory = Fory::builder().compatible(true).build(); - fory.register::(999).unwrap(); + fory.register_by_id::(999).unwrap(); let animal: Animal1 = Animal1 { f1: HashMap::from([(1, vec![2])]), f2: String::from("hello"), @@ -130,8 +130,8 @@ fn skip_option() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(999).unwrap(); - fory2.register::(999).unwrap(); + fory1.register_by_id::(999).unwrap(); + fory2.register_by_id::(999).unwrap(); let item1 = Item1 { f1: None, f2: Some(String::from("f2")), @@ -169,10 +169,10 @@ fn nonexistent_struct() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(899).unwrap(); - fory1.register::(999).unwrap(); - fory2.register::(799).unwrap(); - fory2.register::(999).unwrap(); + fory1.register_by_id::(899).unwrap(); + fory1.register_by_id::(999).unwrap(); + fory2.register_by_id::(799).unwrap(); + fory2.register_by_id::(999).unwrap(); let person = Person1 { f2: Item1 { f1: 42 }, f3: 24, @@ -200,7 +200,7 @@ fn option() { last: i64, } let mut fory = Fory::builder().compatible(true).build(); - fory.register::(999).unwrap(); + fory.register_by_id::(999).unwrap(); let animal: Animal = Animal { f1: Some(String::from("f1")), f2: None, @@ -245,8 +245,8 @@ fn nullable() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(999).unwrap(); - fory2.register::(999).unwrap(); + fory1.register_by_id::(999).unwrap(); + fory2.register_by_id::(999).unwrap(); let item1 = Item1 { f2: 43, @@ -299,8 +299,8 @@ fn nullable_container() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(999).unwrap(); - fory2.register::(999).unwrap(); + fory1.register_by_id::(999).unwrap(); + fory2.register_by_id::(999).unwrap(); let item1 = Item1 { f1: vec![44, 45], @@ -351,8 +351,8 @@ fn inner_nullable() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(999).unwrap(); - fory2.register::(999).unwrap(); + fory1.register_by_id::(999).unwrap(); + fory2.register_by_id::(999).unwrap(); let item1 = Item1 { f1: vec![None, Some("hello".to_string())], @@ -398,10 +398,10 @@ fn nullable_struct() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(199).unwrap(); - fory1.register::(200).unwrap(); - fory2.register::(199).unwrap(); - fory2.register::(200).unwrap(); + fory1.register_by_id::(199).unwrap(); + fory1.register_by_id::(200).unwrap(); + fory2.register_by_id::(199).unwrap(); + fory2.register_by_id::(200).unwrap(); let person1 = Person1 { f1: Item { @@ -474,13 +474,13 @@ fn enum_without_payload() { } let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); - fory1.register::(101).unwrap(); - fory1.register::(102).unwrap(); - fory1.register::(103).unwrap(); + fory1.register_by_id::(101).unwrap(); + fory1.register_by_id::(102).unwrap(); + fory1.register_by_id::(103).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); - fory2.register::(101).unwrap(); - fory2.register::(102).unwrap(); - fory2.register::(103).unwrap(); + fory2.register_by_id::(101).unwrap(); + fory2.register_by_id::(102).unwrap(); + fory2.register_by_id::(103).unwrap(); let person1 = Person1 { f1: Color1::Blue, @@ -540,11 +540,11 @@ fn named_enum() { last: i8, } let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); - fory1.register_by_name::("a").unwrap(); - fory1.register::(101).unwrap(); + fory1.register_by_name::("", "a").unwrap(); + fory1.register_by_id::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); - fory2.register_by_name::("a").unwrap(); - fory2.register::(101).unwrap(); + fory2.register_by_name::("", "a").unwrap(); + fory2.register_by_id::(101).unwrap(); let item1 = Item1 { f1: Color::Red, f2: Color::Blue, @@ -596,9 +596,9 @@ fn boxed() { } let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); - fory1.register::(101).unwrap(); + fory1.register_by_id::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); - fory2.register::(101).unwrap(); + fory2.register_by_id::(101).unwrap(); let f1 = 1; let f2 = 2; diff --git a/rust/tests/tests/test_any.rs b/rust/tests/tests/test_any.rs index 9c13e00b18..9f984a851a 100644 --- a/rust/tests/tests/test_any.rs +++ b/rust/tests/tests/test_any.rs @@ -147,8 +147,7 @@ fn test_any_registered_by_name() { } let mut fory = Fory::default(); - fory.register_by_namespace::("test", "Person") - .unwrap(); + fory.register_by_name::("test", "Person").unwrap(); let person = Person { name: "Alice".to_string(), @@ -175,7 +174,7 @@ fn test_mixed_any_types() { } let mut fory = Fory::default(); - fory.register_by_name::("Item").unwrap(); + fory.register_by_name::("", "Item").unwrap(); let item = Item { id: 123, @@ -223,10 +222,10 @@ struct AnyMapFixedKey { #[test] fn test_hashmap_fixed_key_rc_any_field_compatible() { let mut writer = Fory::builder().compatible(true).build(); - writer.register::(700).unwrap(); + writer.register_by_id::(700).unwrap(); let mut reader = Fory::builder().compatible(true).build(); - reader.register::(700).unwrap(); + reader.register_by_id::(700).unwrap(); let original = AnyMapFixedKey { values: HashMap::from([ @@ -251,7 +250,7 @@ fn test_hashmap_fixed_key_rc_any_field_compatible() { #[test] fn test_arc_by_name() { let mut fory = Fory::default(); - fory.register_by_name::("Container").unwrap(); + fory.register_by_name::("", "Container").unwrap(); let container = Container { id: 999, @@ -282,7 +281,7 @@ fn test_arc_by_name() { #[test] fn test_rc_by_name() { let mut fory = Fory::default(); - fory.register_by_name::("Container").unwrap(); + fory.register_by_name::("", "Container").unwrap(); let container = Container { id: 555, @@ -333,9 +332,9 @@ struct StructB { fn test_vec_of_different_struct_types_in_box_any_returns_error() { let mut fory = Fory::default(); // Register both struct types - fory.register_by_name::("StructA").unwrap(); + fory.register_by_name::("", "StructA").unwrap(); fory.register_generic_trait::>().unwrap(); - fory.register_by_name::("StructB").unwrap(); + fory.register_by_name::("", "StructB").unwrap(); fory.register_generic_trait::>().unwrap(); // Create Box wrappers for Vec and Vec diff --git a/rust/tests/tests/test_array.rs b/rust/tests/tests/test_array.rs index b21e8d72e4..5e89765840 100644 --- a/rust/tests/tests/test_array.rs +++ b/rust/tests/tests/test_array.rs @@ -129,7 +129,7 @@ struct Point { #[test] fn test_array_struct() { let mut fory = Fory::default(); - fory.register_by_name::("Point").unwrap(); + fory.register_by_name::("", "Point").unwrap(); let arr = [ Point { x: 1, y: 2 }, @@ -151,7 +151,8 @@ struct ArrayStruct { #[test] fn test_struct_with_arrays() { let mut fory = Fory::default(); - fory.register_by_name::("ArrayStruct").unwrap(); + fory.register_by_name::("", "ArrayStruct") + .unwrap(); let data = ArrayStruct { int_array: [1, 2, 3, 4, 5], @@ -256,8 +257,8 @@ register_trait_type!(Shape, Circle, Rectangle); #[test] fn test_array_box_trait_objects() { let mut fory = Fory::builder().compatible(true).build(); - fory.register::(9001).unwrap(); - fory.register::(9002).unwrap(); + fory.register_by_id::(9001).unwrap(); + fory.register_by_id::(9002).unwrap(); // Create an array of Box let shapes: [Box; 3] = [ @@ -315,7 +316,8 @@ fn test_struct_with_vec_of_arrays() { } let mut fory = Fory::default(); - fory.register_by_name::("PointCloud").unwrap(); + fory.register_by_name::("", "PointCloud") + .unwrap(); let data = PointCloud { index: 42, @@ -334,8 +336,8 @@ fn test_struct_with_vec_of_arrays() { #[test] fn test_array_rc_trait_objects() { let mut fory = Fory::builder().compatible(true).build(); - fory.register::(9001).unwrap(); - fory.register::(9002).unwrap(); + fory.register_by_id::(9001).unwrap(); + fory.register_by_id::(9002).unwrap(); // Create Rc instances and convert to wrappers let circle1: Rc = Rc::new(Circle { radius: 2.0 }); diff --git a/rust/tests/tests/test_associated_types.rs b/rust/tests/tests/test_associated_types.rs index ef787baece..1aea0b3a8c 100644 --- a/rust/tests/tests/test_associated_types.rs +++ b/rust/tests/tests/test_associated_types.rs @@ -68,7 +68,7 @@ where #[test] fn test_leader_id_with_associated_types() { let mut fory = Fory::default(); - fory.register::>(100).unwrap(); + fory.register_by_id::>(100).unwrap(); let leader_id: LeaderId = LeaderId { term: 1, @@ -84,7 +84,7 @@ fn test_leader_id_with_associated_types() { #[test] fn test_leader_id_default_values() { let mut fory = Fory::default(); - fory.register::>(100).unwrap(); + fory.register_by_id::>(100).unwrap(); let leader_id: LeaderId = LeaderId { term: 0, @@ -100,7 +100,7 @@ fn test_leader_id_default_values() { #[test] fn test_vec_of_leader_ids() { let mut fory = Fory::default(); - fory.register::>(100).unwrap(); + fory.register_by_id::>(100).unwrap(); let leader_ids: Vec> = vec![ LeaderId { @@ -126,7 +126,7 @@ fn test_vec_of_leader_ids() { #[test] fn test_option_leader_id() { let mut fory = Fory::default(); - fory.register::>(100).unwrap(); + fory.register_by_id::>(100).unwrap(); // Test with Some value let some_leader: Option> = Some(LeaderId { diff --git a/rust/tests/tests/test_box.rs b/rust/tests/tests/test_box.rs index 66dba99db0..76a3314001 100644 --- a/rust/tests/tests/test_box.rs +++ b/rust/tests/tests/test_box.rs @@ -53,7 +53,7 @@ fn test_box_struct() { } let mut fory = Fory::default(); - fory.register::(999).unwrap(); + fory.register_by_id::(999).unwrap(); let person = Person { name: "John Doe".to_string(), @@ -76,7 +76,7 @@ fn test_box_struct_separate() { } let mut fory = Fory::default(); - fory.register::(999).unwrap(); + fory.register_by_id::(999).unwrap(); // Test serializing the Box directly, not as a field let person = Person { diff --git a/rust/tests/tests/test_collection.rs b/rust/tests/tests/test_collection.rs index b883d9202c..6f6fbdac50 100644 --- a/rust/tests/tests/test_collection.rs +++ b/rust/tests/tests/test_collection.rs @@ -65,7 +65,7 @@ struct SetContainer { #[test] fn test_set_container() { let mut fory: Fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let mut btree = BTreeSet::new(); btree.insert("apple".to_string()); @@ -104,7 +104,7 @@ struct HeapContainer { #[test] fn test_heap_container() { let mut fory: Fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let mut binary_heap = BinaryHeap::new(); binary_heap.push(3); diff --git a/rust/tests/tests/test_complex_struct.rs b/rust/tests/tests/test_complex_struct.rs index 933a32ff35..2d943ab92e 100644 --- a/rust/tests/tests/test_complex_struct.rs +++ b/rust/tests/tests/test_complex_struct.rs @@ -41,8 +41,8 @@ use std::collections::HashMap; // }; // // let mut fory = Fory::default(); -// fory.register::(999); -// fory.register::(1000); +// fory.register_by_id::(999); +// fory.register_by_id::(1000); // let bin = fory.serialize(&person); // let obj: Person = fory.deserialize(&bin).expect(""); // assert!(obj.f1.is::()) @@ -58,7 +58,7 @@ fn enum_without_payload() { Blue, } let mut fory = Fory::default(); - fory.register::(999).unwrap(); + fory.register_by_id::(999).unwrap(); let color = Color::Red; let bin = fory.serialize(&color).unwrap(); let color2: Color = fory.deserialize(&bin).expect(""); @@ -109,14 +109,14 @@ fn complex_struct() { c6: 4.0, }; let mut fory = Fory::default(); - fory.register::(899).unwrap(); - fory.register::(999).unwrap(); + fory.register_by_id::(899).unwrap(); + fory.register_by_id::(999).unwrap(); let bin: Vec = fory.serialize(&person).unwrap(); let obj: Person = fory.deserialize(&bin).expect("should success"); assert_eq!(person, obj); let mut fory = Fory::default(); - fory.register_by_name::("animal").unwrap(); - fory.register_by_name::("person").unwrap(); + fory.register_by_name::("", "animal").unwrap(); + fory.register_by_name::("", "person").unwrap(); let bin: Vec = fory.serialize(&person).unwrap(); let obj: Person = fory.deserialize(&bin).expect("should success"); assert_eq!(person, obj); @@ -142,8 +142,8 @@ fn encode_to_obin() { f10: HashMap, } let mut fory = Fory::default(); - fory.register::(999).unwrap(); - fory.register::(899).unwrap(); + fory.register_by_id::(999).unwrap(); + fory.register_by_id::(899).unwrap(); let bin: Vec = fory .serialize(&Person { f1: "Hello".to_string(), diff --git a/rust/tests/tests/test_cross_language.rs b/rust/tests/tests/test_cross_language.rs index 8660ad493e..b26932b71f 100644 --- a/rust/tests/tests/test_cross_language.rs +++ b/rust/tests/tests/test_cross_language.rs @@ -346,7 +346,7 @@ fn test_cross_language_serializer() { let bytes = fs::read(&data_file_path).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(101).unwrap(); + fory.register_by_id::(101).unwrap(); assert_de!(fory, reader, bool, true); assert_de!(fory, reader, bool, false); assert_de!(fory, reader, i32, -1); @@ -413,9 +413,9 @@ fn test_simple_struct() { let data_file_path = get_data_file(); let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(101).unwrap(); - fory.register::(102).unwrap(); - fory.register::(103).unwrap(); + fory.register_by_id::(101).unwrap(); + fory.register_by_id::(102).unwrap(); + fory.register_by_id::(103).unwrap(); let local_obj = SimpleStruct { f1: HashMap::from([(1, 1.0f64), (2, 2.0f64)]), @@ -444,10 +444,9 @@ fn test_named_simple_struct() { let data_file_path = get_data_file(); let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_namespace::("demo", "color") - .unwrap(); - fory.register_by_namespace::("demo", "item").unwrap(); - fory.register_by_namespace::("demo", "simple_struct") + fory.register_by_name::("demo", "color").unwrap(); + fory.register_by_name::("demo", "item").unwrap(); + fory.register_by_name::("demo", "simple_struct") .unwrap(); let local_obj = SimpleStruct { @@ -477,9 +476,9 @@ fn test_struct_evolving_override() { let data_file_path = get_data_file(); let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_namespace::("test", "evolving_yes") + fory.register_by_name::("test", "evolving_yes") .unwrap(); - fory.register_by_namespace::("test", "evolving_off") + fory.register_by_name::("test", "evolving_off") .unwrap(); let mut reader = Reader::new(bytes.as_slice()); @@ -511,7 +510,7 @@ fn test_list() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(102).unwrap(); + fory.register_by_id::(102).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let str_list = vec![Some("a".to_string()), Some("b".to_string())]; @@ -553,7 +552,7 @@ fn test_map() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(102).unwrap(); + fory.register_by_id::(102).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let str_map = HashMap::from([ @@ -626,7 +625,7 @@ fn test_integer() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(101).unwrap(); + fory.register_by_id::(101).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let f1 = 1; let f2 = 2; @@ -774,13 +773,13 @@ fn _test_skip_custom(fory1: &Fory, fory2: &Fory) { #[ignore] fn test_skip_id_custom() { let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); - fory1.register_serializer::(103).unwrap(); - fory1.register::(104).unwrap(); + fory1.register_serializer_by_id::(103).unwrap(); + fory1.register_by_id::(104).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); - fory2.register::(101).unwrap(); - fory2.register::(102).unwrap(); - fory2.register_serializer::(103).unwrap(); - fory2.register::(104).unwrap(); + fory2.register_by_id::(101).unwrap(); + fory2.register_by_id::(102).unwrap(); + fory2.register_serializer_by_id::(103).unwrap(); + fory2.register_by_id::(104).unwrap(); _test_skip_custom(&fory1, &fory2); } @@ -789,16 +788,18 @@ fn test_skip_id_custom() { fn test_skip_name_custom() { let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); fory1 - .register_serializer_by_name::("my_ext") + .register_serializer_by_name::("", "my_ext") .unwrap(); - fory1.register_by_name::("my_wrapper").unwrap(); + fory1.register_by_name::("", "my_wrapper").unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); - fory2.register_by_name::("color").unwrap(); - fory2.register_by_name::("my_struct").unwrap(); + fory2.register_by_name::("", "color").unwrap(); + fory2.register_by_name::("", "my_struct").unwrap(); + fory2 + .register_serializer_by_name::("", "my_ext") + .unwrap(); fory2 - .register_serializer_by_name::("my_ext") + .register_by_name::("", "my_wrapper") .unwrap(); - fory2.register_by_name::("my_wrapper").unwrap(); _test_skip_custom(&fory1, &fory2); } @@ -806,9 +807,10 @@ fn test_skip_name_custom() { #[ignore] fn test_consistent_named() { let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register_by_name::("color").unwrap(); - fory.register_by_name::("my_struct").unwrap(); - fory.register_serializer_by_name::("my_ext").unwrap(); + fory.register_by_name::("", "color").unwrap(); + fory.register_by_name::("", "my_struct").unwrap(); + fory.register_serializer_by_name::("", "my_ext") + .unwrap(); let color = Color::White; let my_struct = MyStruct { id: 42 }; @@ -945,7 +947,7 @@ fn test_struct_version_check() { .xlang(true) .check_struct_version(true) .build(); - fory.register::(201).unwrap(); + fory.register_by_id::(201).unwrap(); let local_obj = VersionCheckStruct { f1: 10, @@ -967,7 +969,7 @@ fn test_item() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(102).unwrap(); + fory.register_by_id::(102).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let item1 = Item { @@ -1002,7 +1004,7 @@ fn test_color() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(101).unwrap(); + fory.register_by_id::(101).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let remote_green: Color = fory.deserialize_from(&mut reader).unwrap(); @@ -1029,7 +1031,7 @@ fn test_struct_with_list() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(201).unwrap(); + fory.register_by_id::(201).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let struct1 = StructWithList { @@ -1061,7 +1063,7 @@ fn test_struct_with_map() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(202).unwrap(); + fory.register_by_id::(202).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let struct1 = StructWithMap { @@ -1095,7 +1097,7 @@ fn test_nested_annotated_container_schema_consistent() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register::(801) + fory.register_by_id::(801) .unwrap(); let local_obj = NestedAnnotatedContainerSchemaConsistent { @@ -1122,7 +1124,7 @@ fn test_nested_annotated_container_compatible() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(802) + fory.register_by_id::(802) .unwrap(); let local_obj = NestedAnnotatedContainerCompatible { @@ -1178,9 +1180,9 @@ fn test_polymorphic_list() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(302).unwrap(); - fory.register::(303).unwrap(); - fory.register::(304).unwrap(); + fory.register_by_id::(302).unwrap(); + fory.register_by_id::(303).unwrap(); + fory.register_by_id::(304).unwrap(); let mut reader = Reader::new(bytes.as_slice()); // Part 1: Read List with polymorphic elements (Dog, Cat) @@ -1229,9 +1231,9 @@ fn test_polymorphic_map() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(302).unwrap(); - fory.register::(303).unwrap(); - fory.register::(305).unwrap(); + fory.register_by_id::(302).unwrap(); + fory.register_by_id::(303).unwrap(); + fory.register_by_id::(305).unwrap(); let mut reader = Reader::new(bytes.as_slice()); // Part 1: Read Map with polymorphic values @@ -1292,7 +1294,7 @@ fn test_one_string_field_schema() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register::(200).unwrap(); + fory.register_by_id::(200).unwrap(); let value: OneStringFieldStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.f1, Some("hello".to_string())); @@ -1308,7 +1310,7 @@ fn test_one_string_field_compatible() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(200).unwrap(); + fory.register_by_id::(200).unwrap(); let value: OneStringFieldStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.f1, Some("hello".to_string())); @@ -1324,7 +1326,7 @@ fn test_two_string_field_compatible() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(201).unwrap(); + fory.register_by_id::(201).unwrap(); let value: TwoStringFieldStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.f1, "first".to_string()); @@ -1342,7 +1344,7 @@ fn test_schema_evolution_compatible() { // Read TwoStringFieldStruct data as EmptyStructEvolution let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(200).unwrap(); + fory.register_by_id::(200).unwrap(); let value: EmptyStructEvolution = fory.deserialize(&bytes).unwrap(); @@ -1359,7 +1361,7 @@ fn test_schema_evolution_compatible_reverse() { // Read OneStringFieldStruct data as TwoStringFieldStruct (missing f2) let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(200).unwrap(); + fory.register_by_id::(200).unwrap(); let value: TwoStringFieldStruct = fory.deserialize(&bytes).unwrap(); @@ -1379,7 +1381,8 @@ fn test_reduced_precision_float_struct() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register::(213).unwrap(); + fory.register_by_id::(213) + .unwrap(); let value: ReducedPrecisionFloatStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.float16_value.to_bits(), 0x3E00); @@ -1412,7 +1415,7 @@ fn test_reduced_precision_float_struct_compatible_skip() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(213).unwrap(); + fory.register_by_id::(213).unwrap(); let value: EmptyStructEvolution = fory.deserialize(&bytes).unwrap(); @@ -1427,7 +1430,8 @@ fn test_list_array_compatible_list_to_array() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(901).unwrap(); + fory.register_by_id::(901) + .unwrap(); let value: CompatibleInt32ArrayField = fory.deserialize(&bytes).unwrap(); let new_bytes = fory.serialize(&value).unwrap(); fs::write(&data_file_path, new_bytes).unwrap(); @@ -1440,7 +1444,8 @@ fn test_list_array_compatible_array_to_list() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(901).unwrap(); + fory.register_by_id::(901) + .unwrap(); let value: CompatibleInt32ListField = fory.deserialize(&bytes).unwrap(); let new_bytes = fory.serialize(&value).unwrap(); fs::write(&data_file_path, new_bytes).unwrap(); @@ -1453,7 +1458,8 @@ fn test_list_array_compatible_nullable_list_to_array_error() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(901).unwrap(); + fory.register_by_id::(901) + .unwrap(); let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { fory.deserialize::(&bytes) })); @@ -1475,8 +1481,8 @@ fn test_one_enum_field_schema() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register::(210).unwrap(); - fory.register::(211).unwrap(); + fory.register_by_id::(210).unwrap(); + fory.register_by_id::(211).unwrap(); let value: OneEnumFieldStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.f1, TestEnum::VALUE_B); @@ -1492,8 +1498,8 @@ fn test_one_enum_field_compatible() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(210).unwrap(); - fory.register::(211).unwrap(); + fory.register_by_id::(210).unwrap(); + fory.register_by_id::(211).unwrap(); let value: OneEnumFieldStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.f1, TestEnum::VALUE_A); @@ -1509,8 +1515,8 @@ fn test_two_enum_field_compatible() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(210).unwrap(); - fory.register::(212).unwrap(); + fory.register_by_id::(210).unwrap(); + fory.register_by_id::(212).unwrap(); let value: TwoEnumFieldStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.f1, TestEnum::VALUE_A); @@ -1528,8 +1534,8 @@ fn test_enum_schema_evolution_compatible() { // Read TwoEnumFieldStruct data as EmptyStructEvolution let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(210).unwrap(); - fory.register::(211).unwrap(); + fory.register_by_id::(210).unwrap(); + fory.register_by_id::(211).unwrap(); let value: EmptyStructEvolution = fory.deserialize(&bytes).unwrap(); @@ -1546,8 +1552,8 @@ fn test_enum_schema_evolution_compatible_reverse() { // Read OneEnumFieldStruct data as TwoEnumFieldStruct (missing f2) let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(210).unwrap(); - fory.register::(211).unwrap(); + fory.register_by_id::(210).unwrap(); + fory.register_by_id::(211).unwrap(); let value: TwoEnumFieldStruct = fory.deserialize(&bytes).unwrap(); @@ -1681,7 +1687,7 @@ fn test_nullable_field_schema_consistent_not_null() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register::(401) + fory.register_by_id::(401) .unwrap(); let local_obj = NullableComprehensiveSchemaConsistent { @@ -1731,7 +1737,7 @@ fn test_nullable_field_schema_consistent_null() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register::(401) + fory.register_by_id::(401) .unwrap(); let local_obj = NullableComprehensiveSchemaConsistent { @@ -1784,7 +1790,7 @@ fn test_nullable_field_compatible_not_null() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(402) + fory.register_by_id::(402) .unwrap(); let local_obj = NullableComprehensiveCompatible { @@ -1844,7 +1850,7 @@ fn test_nullable_field_compatible_null() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(402) + fory.register_by_id::(402) .unwrap(); let local_obj = NullableComprehensiveCompatible { @@ -1929,8 +1935,8 @@ fn test_union_xlang() { let mut fory = Fory::builder().compatible(true).xlang(true).build(); // Register both the enum and the struct that contains it - fory.register::(300).unwrap(); - fory.register::(301).unwrap(); + fory.register_by_id::(300).unwrap(); + fory.register_by_id::(301).unwrap(); // Read struct1 with String value (index 0) let mut reader = Reader::new(bytes.as_slice()); @@ -2027,8 +2033,10 @@ fn test_ref_schema_consistent() { .xlang(true) .track_ref(true) .build(); - fory.register::(501).unwrap(); - fory.register::(502).unwrap(); + fory.register_by_id::(501) + .unwrap(); + fory.register_by_id::(502) + .unwrap(); let outer: RefOuterSchemaConsistent = fory.deserialize(&bytes).unwrap(); @@ -2075,8 +2083,8 @@ fn test_ref_compatible() { .xlang(true) .track_ref(true) .build(); - fory.register::(503).unwrap(); - fory.register::(504).unwrap(); + fory.register_by_id::(503).unwrap(); + fory.register_by_id::(504).unwrap(); let outer: RefOuterCompatible = fory.deserialize(&bytes).unwrap(); @@ -2119,8 +2127,8 @@ fn test_collection_element_ref_override() { .xlang(true) .track_ref(true) .build(); - fory.register::(701).unwrap(); - fory.register::(702).unwrap(); + fory.register_by_id::(701).unwrap(); + fory.register_by_id::(702).unwrap(); let outer: RefOverrideContainer = fory.deserialize(&bytes).unwrap(); assert!( @@ -2177,8 +2185,8 @@ fn test_collection_element_ref_remote_tracking() { .xlang(true) .track_ref(true) .build(); - fory.register::(701).unwrap(); - fory.register::(702).unwrap(); + fory.register_by_id::(701).unwrap(); + fory.register_by_id::(702).unwrap(); let shared = Rc::new(RefOverrideElement { id: 7, @@ -2236,7 +2244,7 @@ fn test_circular_ref_schema_consistent() { .xlang(true) .track_ref(true) .build(); - fory.register::(601).unwrap(); + fory.register_by_id::(601).unwrap(); // Deserialize as Rc since the whole struct needs ref tracking let obj: Rc = fory.deserialize(&bytes).unwrap(); @@ -2281,7 +2289,7 @@ fn test_circular_ref_compatible() { .xlang(true) .track_ref(true) .build(); - fory.register::(602).unwrap(); + fory.register_by_id::(602).unwrap(); // Deserialize as Rc since the whole struct needs ref tracking let obj: Rc = fory.deserialize(&bytes).unwrap(); @@ -2396,7 +2404,8 @@ fn test_unsigned_schema_consistent() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register::(501).unwrap(); + fory.register_by_id::(501) + .unwrap(); let local_obj = UnsignedSchemaConsistent { // Primitive unsigned fields @@ -2433,7 +2442,8 @@ fn test_unsigned_schema_compatible() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register::(502).unwrap(); + fory.register_by_id::(502) + .unwrap(); let local_obj = UnsignedSchemaCompatible { // Group 1: Option fields (values from Java's non-nullable fields) diff --git a/rust/tests/tests/test_debug.rs b/rust/tests/tests/test_debug.rs index 2908d0769b..b1556126af 100644 --- a/rust/tests/tests/test_debug.rs +++ b/rust/tests/tests/test_debug.rs @@ -108,7 +108,7 @@ fn debug_hooks_trigger_for_struct() { set_after_read_field_func(after_read); let mut fory = Fory::default(); - fory.register::(4001).unwrap(); + fory.register_by_id::(4001).unwrap(); let sample = DebugSample { a: 7, b: "debug".to_string(), @@ -151,7 +151,7 @@ fn debug_hooks_trigger_for_struct() { event_log().lock().unwrap().clear(); let mut fory_compat = Fory::builder().compatible(true).build(); - fory_compat.register::(4001).unwrap(); + fory_compat.register_by_id::(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 b5ae1385c3..6798bc5286 100644 --- a/rust/tests/tests/test_enum.rs +++ b/rust/tests/tests/test_enum.rs @@ -35,7 +35,7 @@ fn basic() { } let mut fory = Fory::builder().xlang(false).build(); - fory.register::(1000).unwrap(); + fory.register_by_id::(1000).unwrap(); let mut map = HashMap::new(); map.insert("one".to_string(), Token::Number(1)); @@ -76,10 +76,10 @@ fn named_enum() { } let mut fory1 = Fory::builder().xlang(false).build(); - fory1.register::(1000).unwrap(); + fory1.register_by_id::(1000).unwrap(); let mut fory2 = Fory::builder().xlang(false).build(); - fory2.register::(1000).unwrap(); + fory2.register_by_id::(1000).unwrap(); let token = Token1::Assign { target: "bar".to_string(), @@ -133,8 +133,8 @@ fn struct_with_enum_field() { ); let mut fory = Fory::builder().xlang(true).compatible(false).build(); - fory.register::(100).unwrap(); - fory.register::(101).unwrap(); + fory.register_by_id::(100).unwrap(); + fory.register_by_id::(101).unwrap(); let obj = StructWithEnum { name: "test".to_string(), @@ -177,8 +177,8 @@ fn union_compatible_enum_xlang_format() { // Test xlang mode serialization let mut fory = Fory::builder().xlang(true).compatible(false).build(); - fory.register::(300).unwrap(); - fory.register::(301).unwrap(); + fory.register_by_id::(300).unwrap(); + fory.register_by_id::(301).unwrap(); // Test with String variant (index 0) let obj1 = StructWithUnion { @@ -211,7 +211,7 @@ fn union_payload_nested_codec_annotations_roundtrip() { } let mut fory = Fory::builder().xlang(false).compatible(true).build(); - fory.register::(320).unwrap(); + fory.register_by_id::(320).unwrap(); let values = Payload::Values(vec![Some(1), None, Some(-300)]); let bytes = fory.serialize(&values).unwrap(); @@ -254,8 +254,9 @@ fn struct_with_enum_field_explicit_nullable() { ); let mut fory = Fory::builder().xlang(true).compatible(false).build(); - fory.register::(200).unwrap(); - fory.register::(201).unwrap(); + fory.register_by_id::(200).unwrap(); + fory.register_by_id::(201) + .unwrap(); let obj = StructWithExplicitNullable { name: "explicit".to_string(), diff --git a/rust/tests/tests/test_enum_compatible.rs b/rust/tests/tests/test_enum_compatible.rs index 2f1824e39a..71172521c5 100644 --- a/rust/tests/tests/test_enum_compatible.rs +++ b/rust/tests/tests/test_enum_compatible.rs @@ -41,10 +41,10 @@ fn test_unnamed_enum_variant_compatible() { // Test 1: Serialize v1 (2 fields), deserialize as v2 (3 fields) let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build(); - fory_v1.register::(2000).unwrap(); + fory_v1.register_by_id::(2000).unwrap(); let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build(); - fory_v2.register::(2000).unwrap(); + fory_v2.register_by_id::(2000).unwrap(); let event_v1 = EventV1::Message(42, "hello".to_string()); let bin = fory_v1.serialize(&event_v1).unwrap(); @@ -81,7 +81,7 @@ fn test_unnamed_enum_variant_compatible() { } let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build(); - fory_v3.register::(2000).unwrap(); + fory_v3.register_by_id::(2000).unwrap(); let event_v3 = EventV3::NewVariant(true); let bin = fory_v3.serialize(&event_v3).unwrap(); @@ -118,10 +118,10 @@ fn test_named_enum_variant_compatible() { } let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build(); - fory_v1.register::(3000).unwrap(); + fory_v1.register_by_id::(3000).unwrap(); let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build(); - fory_v2.register::(3000).unwrap(); + fory_v2.register_by_id::(3000).unwrap(); // Test 1: Serialize v1, deserialize as v2 (new field gets default value) let cmd_v1 = CommandV1::Execute { @@ -199,13 +199,13 @@ fn test_named_enum_field_evolution() { } let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build(); - fory_v1.register::(4000).unwrap(); + fory_v1.register_by_id::(4000).unwrap(); let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build(); - fory_v2.register::(4000).unwrap(); + fory_v2.register_by_id::(4000).unwrap(); let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build(); - fory_v3.register::(4000).unwrap(); + fory_v3.register_by_id::(4000).unwrap(); // Test V1 -> V2: New fields get default values let config_v1 = ConfigV1::Settings { @@ -320,13 +320,13 @@ fn test_named_enum_variant_add_remove() { } let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build(); - fory_v1.register::(5000).unwrap(); + fory_v1.register_by_id::(5000).unwrap(); let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build(); - fory_v2.register::(5000).unwrap(); + fory_v2.register_by_id::(5000).unwrap(); let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build(); - fory_v3.register::(5000).unwrap(); + fory_v3.register_by_id::(5000).unwrap(); // Test V2 (new variant Completed) -> V1: Unknown variant falls back to default let task_v2 = TaskV2::Completed { @@ -459,13 +459,13 @@ fn test_enum_variant_type_change() { } let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build(); - fory_v1.register::(6000).unwrap(); + fory_v1.register_by_id::(6000).unwrap(); let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build(); - fory_v2.register::(6000).unwrap(); + fory_v2.register_by_id::(6000).unwrap(); let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build(); - fory_v3.register::(6000).unwrap(); + fory_v3.register_by_id::(6000).unwrap(); // Test V1 Unit -> V2 Named: Type mismatch, uses default value let status_v1_active = StatusV1::Active; @@ -594,16 +594,16 @@ fn test_struct_with_enum_field_evolution() { } let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build(); - fory_v1.register::(7001).unwrap(); - fory_v1.register::(7000).unwrap(); + fory_v1.register_by_id::(7001).unwrap(); + fory_v1.register_by_id::(7000).unwrap(); let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build(); - fory_v2.register::(7001).unwrap(); - fory_v2.register::(7000).unwrap(); + fory_v2.register_by_id::(7001).unwrap(); + fory_v2.register_by_id::(7000).unwrap(); let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build(); - fory_v3.register::(7001).unwrap(); - fory_v3.register::(7000).unwrap(); + fory_v3.register_by_id::(7001).unwrap(); + fory_v3.register_by_id::(7000).unwrap(); // Test V1 -> V2: Enum field evolution let msg_v1 = MessageV1 { diff --git a/rust/tests/tests/test_ext.rs b/rust/tests/tests/test_ext.rs index 4f7103787e..075682a3ce 100644 --- a/rust/tests/tests/test_ext.rs +++ b/rust/tests/tests/test_ext.rs @@ -84,7 +84,7 @@ fn test_use() { } let mut fory = Fory::builder().compatible(true).xlang(true).build(); let item = Item { f1: 1, f2: 2 }; - fory.register_serializer::(100).unwrap(); + fory.register_serializer_by_id::(100).unwrap(); let bytes = fory.serialize(&item).unwrap(); let new_item: Item = fory.deserialize(&bytes).unwrap(); assert_eq!(new_item.f1, item.f1); diff --git a/rust/tests/tests/test_field_meta.rs b/rust/tests/tests/test_field_meta.rs index f99576b74b..bda3c45869 100644 --- a/rust/tests/tests/test_field_meta.rs +++ b/rust/tests/tests/test_field_meta.rs @@ -39,7 +39,7 @@ struct StructWithSkip { #[test] fn test_skip_field() { let mut fory = Fory::default(); - fory.register::(1).unwrap(); + fory.register_by_id::(1).unwrap(); let original = StructWithSkip { name: "Alice".to_string(), @@ -67,7 +67,7 @@ struct StructWithNullable { #[test] fn test_nullable_attribute() { let mut fory = Fory::default(); - fory.register::(2).unwrap(); + fory.register_by_id::(2).unwrap(); // Test with Some value let original = StructWithNullable { @@ -105,8 +105,8 @@ struct StructWithRefTracking { #[test] fn test_ref_tracking_disabled() { let mut fory = Fory::default(); - fory.register::(3).unwrap(); - fory.register::(4).unwrap(); + fory.register_by_id::(3).unwrap(); + fory.register_by_id::(4).unwrap(); let inner = Rc::new(InnerData { value: 100 }); let original = StructWithRefTracking { data: inner }; @@ -126,7 +126,7 @@ struct StructWithExplicitNotNull { #[test] fn test_explicit_not_nullable() { let mut fory = Fory::default(); - fory.register::(5).unwrap(); + fory.register_by_id::(5).unwrap(); let original = StructWithExplicitNotNull { required_option: Some("value".to_string()), @@ -145,8 +145,8 @@ struct StructWithArc { #[test] fn test_arc_default_ref_tracking() { let mut fory = Fory::default(); - fory.register::(6).unwrap(); - fory.register::(7).unwrap(); + fory.register_by_id::(6).unwrap(); + fory.register_by_id::(7).unwrap(); let inner = Arc::new(InnerData { value: 200 }); let original = StructWithArc { data: inner }; @@ -169,7 +169,7 @@ struct StructWithCombinedAttrs { #[test] fn test_combined_attributes() { let mut fory = Fory::default(); - fory.register::(8).unwrap(); + fory.register_by_id::(8).unwrap(); let original = StructWithCombinedAttrs { name: "Test".to_string(), @@ -196,7 +196,7 @@ struct StructWithPrimitives { #[test] fn test_primitive_defaults() { let mut fory = Fory::default(); - fory.register::(9).unwrap(); + fory.register_by_id::(9).unwrap(); let original = StructWithPrimitives { count: 42, @@ -613,7 +613,7 @@ fn serializer_backed_container_fields_write_declared_generic_payloads() { #[test] fn test_nested_codec_annotations_roundtrip() { let mut fory = Fory::default(); - fory.register::(10).unwrap(); + fory.register_by_id::(10).unwrap(); let original = NestedFixedEncoding { values: vec![Some(1), None, Some(-300)], @@ -629,10 +629,10 @@ fn test_nested_codec_annotations_roundtrip() { #[test] fn test_compatible_nested_integer_encoding_mismatch() { let mut writer = Fory::builder().compatible(true).build(); - writer.register::(11).unwrap(); + writer.register_by_id::(11).unwrap(); let mut reader = Fory::builder().compatible(true).build(); - reader.register::(11).unwrap(); + reader.register_by_id::(11).unwrap(); let original = NestedVarEncoding { values: vec![Some(1), None, Some(-300)], @@ -661,7 +661,7 @@ struct StructWithFieldIds { #[test] fn test_field_id_attribute() { let mut fory = Fory::default(); - fory.register::(10).unwrap(); + fory.register_by_id::(10).unwrap(); let original = StructWithFieldIds { name: "Bob".to_string(), @@ -687,7 +687,7 @@ struct StructWithMixedIds { #[test] fn test_mixed_field_ids() { let mut fory = Fory::default(); - fory.register::(11).unwrap(); + fory.register_by_id::(11).unwrap(); let original = StructWithMixedIds { id_field: 100, @@ -716,7 +716,8 @@ struct StructWithCombinedFieldAttrs { #[test] fn test_field_id_with_other_attrs() { let mut fory = Fory::default(); - fory.register::(12).unwrap(); + fory.register_by_id::(12) + .unwrap(); let original = StructWithCombinedFieldAttrs { name: "Test".to_string(), @@ -770,10 +771,14 @@ mod compatible_v2 { fn test_compatible_mode_v1_to_v2() { // Serialize with V1, deserialize with V2 (forward compatibility) let mut fory_v1 = Fory::builder().compatible(true).build(); - fory_v1.register::(100).unwrap(); + fory_v1 + .register_by_id::(100) + .unwrap(); let mut fory_v2 = Fory::builder().compatible(true).build(); - fory_v2.register::(100).unwrap(); + fory_v2 + .register_by_id::(100) + .unwrap(); let user_v1 = compatible_v1::UserV1 { name: "Alice".to_string(), @@ -795,10 +800,14 @@ fn test_compatible_mode_v1_to_v2() { fn test_compatible_mode_v2_to_v1() { // Serialize with V2, deserialize with V1 (backward compatibility) let mut fory_v1 = Fory::builder().compatible(true).build(); - fory_v1.register::(100).unwrap(); + fory_v1 + .register_by_id::(100) + .unwrap(); let mut fory_v2 = Fory::builder().compatible(true).build(); - fory_v2.register::(100).unwrap(); + fory_v2 + .register_by_id::(100) + .unwrap(); let user_v2 = compatible_v2::UserV2 { name: "Bob".to_string(), @@ -852,12 +861,12 @@ fn test_compatible_mode_field_reorder() { // Test that field IDs allow fields to be reordered between versions let mut fory_v1 = Fory::builder().compatible(true).build(); fory_v1 - .register::(200) + .register_by_id::(200) .unwrap(); let mut fory_v2 = Fory::builder().compatible(true).build(); fory_v2 - .register::(200) + .register_by_id::(200) .unwrap(); let data_v1 = compatible_reorder_v1::DataV1 { @@ -911,12 +920,12 @@ fn test_compatible_mode_field_removed() { // Test that removed fields are handled in compatible mode let mut fory_v1 = Fory::builder().compatible(true).build(); fory_v1 - .register::(300) + .register_by_id::(300) .unwrap(); let mut fory_v2 = Fory::builder().compatible(true).build(); fory_v2 - .register::(300) + .register_by_id::(300) .unwrap(); let config_v1 = compatible_remove_field_v1::ConfigV1 { @@ -949,7 +958,7 @@ struct StructWithSkipAndId { #[test] fn test_skip_with_field_id() { let mut fory = Fory::default(); - fory.register::(350).unwrap(); + fory.register_by_id::(350).unwrap(); let original = StructWithSkipAndId { name: "test".to_string(), @@ -969,7 +978,7 @@ fn test_skip_with_field_id() { fn test_compatible_mode_roundtrip() { // Test full roundtrip with compatible mode and field IDs let mut fory = Fory::builder().compatible(true).build(); - fory.register::(400).unwrap(); + fory.register_by_id::(400).unwrap(); let original = compatible_v2::UserV2 { name: "Charlie".to_string(), @@ -1027,12 +1036,12 @@ fn test_field_id_payload_compatible_mode() { // following the xlang serialization spec (TAG_ID encoding with 2-bit marker 0b11). let mut fory_compact = Fory::builder().compatible(true).build(); fory_compact - .register::(500) + .register_by_id::(500) .unwrap(); let mut fory_verbose = Fory::builder().compatible(true).build(); fory_verbose - .register::(501) + .register_by_id::(501) .unwrap(); let compact_user = payload_with_field_ids::CompactUser { diff --git a/rust/tests/tests/test_fory.rs b/rust/tests/tests/test_fory.rs index 3b141a0eef..652e6a6ccc 100644 --- a/rust/tests/tests/test_fory.rs +++ b/rust/tests/tests/test_fory.rs @@ -36,8 +36,8 @@ fn test_nested_struct_register_order() { let mut fory = Fory::default(); // outer struct registered first. building fields info should be executed lazily, // otherwise the inner struct won't be found. - fory.register::(100).unwrap(); - fory.register::(101).unwrap(); + fory.register_by_id::(100).unwrap(); + fory.register_by_id::(101).unwrap(); let data = Data1 { value: 42, data2: Data2 { value: 24 }, @@ -56,7 +56,7 @@ fn test_serialize_to_appends_bytes() { } let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let p1 = Point { x: 1, y: 2 }; let p2 = Point { x: -3, y: 4 }; @@ -91,8 +91,8 @@ fn test_serialize_to_detailed() { } let mut fory = Fory::default(); - fory.register::(100).unwrap(); - fory.register::(101).unwrap(); + fory.register_by_id::(100).unwrap(); + fory.register_by_id::(101).unwrap(); // Test 1: Basic serialization to empty buffer let p1 = Point { x: 10, y: 20 }; @@ -270,7 +270,7 @@ fn test_unregistered_type_error_message() { let mut fory = Fory::default(); // Register only the outer type; inner type is intentionally not registered - fory.register::(200).unwrap(); + fory.register_by_id::(200).unwrap(); let obj = Outer { v: 1, inner: Inner { v: 2 }, diff --git a/rust/tests/tests/test_generate_default.rs b/rust/tests/tests/test_generate_default.rs index 9e26ef7e34..1a0d785f92 100644 --- a/rust/tests/tests/test_generate_default.rs +++ b/rust/tests/tests/test_generate_default.rs @@ -42,7 +42,7 @@ impl Default for NodeWithCustomDefault { #[test] fn test_no_default_conflict() { let mut fory = Fory::default(); - fory.register::(1).unwrap(); + fory.register_by_id::(1).unwrap(); let node = NodeWithCustomDefault { addr: "192.168.1.1:3000".to_string(), @@ -81,7 +81,7 @@ impl Default for StatusWithCustomDefault { #[test] fn test_enum_no_default_conflict() { let mut fory = Fory::default(); - fory.register::(2).unwrap(); + fory.register_by_id::(2).unwrap(); let status = StatusWithCustomDefault::Active; let bytes = fory.serialize(&status).unwrap(); @@ -106,7 +106,8 @@ struct StructWithGeneratedDefault { #[test] fn test_generate_default_struct() { let mut fory = Fory::default(); - fory.register::(3).unwrap(); + fory.register_by_id::(3) + .unwrap(); let data = StructWithGeneratedDefault { value: 42 }; let bytes = fory.serialize(&data).unwrap(); @@ -130,7 +131,7 @@ enum EnumWithGeneratedDefault { #[test] fn test_generate_default_enum() { let mut fory = Fory::default(); - fory.register::(4).unwrap(); + fory.register_by_id::(4).unwrap(); let data = EnumWithGeneratedDefault::Second; let bytes = fory.serialize(&data).unwrap(); @@ -158,7 +159,8 @@ impl Default for StructWithoutGeneratedDefault { #[test] fn test_generate_default_false() { let mut fory = Fory::default(); - fory.register::(5).unwrap(); + fory.register_by_id::(5) + .unwrap(); let data = StructWithoutGeneratedDefault { value: 42 }; let bytes = fory.serialize(&data).unwrap(); diff --git a/rust/tests/tests/test_lifecycle_guard.rs b/rust/tests/tests/test_lifecycle_guard.rs index 193c37c4e1..64f53f42a8 100644 --- a/rust/tests/tests/test_lifecycle_guard.rs +++ b/rust/tests/tests/test_lifecycle_guard.rs @@ -43,7 +43,7 @@ struct Color { fn test_register_before_serialize_succeeds() { let mut fory = Fory::default(); // registration before any serialize/deserialize should succeed. - assert!(fory.register::(100).is_ok()); + assert!(fory.register_by_id::(100).is_ok()); let point = Point { x: 1, y: 2 }; let bytes = fory.serialize(&point).unwrap(); @@ -54,8 +54,8 @@ fn test_register_before_serialize_succeeds() { #[test] fn test_multiple_registrations_before_serialize_succeed() { let mut fory = Fory::default(); - assert!(fory.register::(100).is_ok()); - assert!(fory.register::(101).is_ok()); + assert!(fory.register_by_id::(100).is_ok()); + assert!(fory.register_by_id::(101).is_ok()); let point = Point { x: 10, y: 20 }; let bytes = fory.serialize(&point).unwrap(); @@ -63,13 +63,33 @@ fn test_multiple_registrations_before_serialize_succeed() { assert_eq!(point, result); } +#[test] +fn test_register_by_name_requires_type_name() { + let mut fory = Fory::default(); + let err = fory + .register_by_name::("com.example", "") + .unwrap_err(); + assert!(matches!(err, Error::NotAllowed(_))); +} + +#[test] +fn test_register_by_name_rejects_duplicate_identity() { + let mut fory = Fory::default(); + fory.register_by_name::("com.example", "Point") + .unwrap(); + let err = fory + .register_by_name::("com.example", "Point") + .unwrap_err(); + assert!(matches!(err, Error::TypeError(_))); +} + // Negative tests -/// ensures `register()` is forbidden after `serialize()` triggers snapshot init. +/// ensures `register_by_id()` is forbidden after `serialize()` triggers snapshot init. #[test] fn test_register_after_serialize_fails() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); // first serialize, this initializes the final_type_resolver snapshot. let point = Point { x: 1, y: 2 }; @@ -77,8 +97,8 @@ fn test_register_after_serialize_fails() { // now any registration must fail with NotAllowed. let err = fory - .register::(101) - .expect_err("register after serialize should fail"); + .register_by_id::(101) + .expect_err("register_by_id after serialize should fail"); assert!( matches!(err, Error::NotAllowed(_)), "expected NotAllowed, got: {:?}", @@ -92,11 +112,11 @@ fn test_register_after_serialize_fails() { ); } -/// Ensures `register()` is forbidden after `deserialize()` triggers snapshot init. +/// Ensures `register_by_id()` is forbidden after `deserialize()` triggers snapshot init. #[test] fn test_register_after_deserialize_fails() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let point = Point { x: 5, y: 10 }; let bytes = fory.serialize(&point).unwrap(); @@ -105,7 +125,7 @@ fn test_register_after_deserialize_fails() { let _result: Point = fory.deserialize(&bytes).unwrap(); let err = fory - .register::(101) + .register_by_id::(101) .expect_err("register after deserialize should fail"); assert!(matches!(err, Error::NotAllowed(_))); } @@ -114,38 +134,38 @@ fn test_register_after_deserialize_fails() { #[test] fn test_register_by_name_after_serialize_fails() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory - .register_by_name::("Color") + .register_by_name::("", "Color") .expect_err("register_by_name after serialize should fail"); assert!(matches!(err, Error::NotAllowed(_))); } -/// Ensures `register_by_namespace()` is forbidden after snapshot init. +/// Ensures `register_by_name()` with a non-empty namespace is forbidden after snapshot init. #[test] -fn test_register_by_namespace_after_serialize_fails() { +fn test_register_by_name_with_namespace_after_serialize_fails() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory - .register_by_namespace::("com.example", "Color") - .expect_err("register_by_namespace after serialize should fail"); + .register_by_name::("com.example", "Color") + .expect_err("register_by_name after serialize should fail"); assert!(matches!(err, Error::NotAllowed(_))); } -/// Ensures `register_serializer()` is forbidden after snapshot init. +/// Ensures `register_serializer_by_id()` is forbidden after snapshot init. #[test] fn test_register_serializer_after_serialize_fails() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory - .register_serializer::(102) - .expect_err("register_serializer after serialize should fail"); + .register_serializer_by_id::(102) + .expect_err("register_serializer_by_id after serialize should fail"); assert!(matches!(err, Error::NotAllowed(_))); } @@ -153,25 +173,25 @@ fn test_register_serializer_after_serialize_fails() { #[test] fn test_register_serializer_by_name_after_serialize_fails() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory - .register_serializer_by_name::("Color") + .register_serializer_by_name::("", "Color") .expect_err("register_serializer_by_name after serialize should fail"); assert!(matches!(err, Error::NotAllowed(_))); } -/// Ensures `register_serializer_by_namespace()` is forbidden after snapshot init. +/// Ensures `register_serializer_by_name()` with a non-empty namespace is forbidden after snapshot init. #[test] -fn test_register_serializer_by_namespace_after_serialize_fails() { +fn test_register_serializer_by_name_with_namespace_after_serialize_fails() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory - .register_serializer_by_namespace::("com.example", "Color") - .expect_err("register_serializer_by_namespace after serialize should fail"); + .register_serializer_by_name::("com.example", "Color") + .expect_err("register_serializer_by_name after serialize should fail"); assert!(matches!(err, Error::NotAllowed(_))); } @@ -179,7 +199,7 @@ fn test_register_serializer_by_namespace_after_serialize_fails() { #[test] fn test_register_generic_trait_after_serialize_fails() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory @@ -188,16 +208,16 @@ fn test_register_generic_trait_after_serialize_fails() { assert!(matches!(err, Error::NotAllowed(_))); } -/// Ensures `register_union()` is forbidden after snapshot init. +/// Ensures `register_union_by_id()` is forbidden after snapshot init. #[test] fn test_register_union_after_serialize_fails() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory - .register_union::(103) - .expect_err("register_union after serialize should fail"); + .register_union_by_id::(103) + .expect_err("register_union_by_id after serialize should fail"); assert!(matches!(err, Error::NotAllowed(_))); } @@ -205,25 +225,25 @@ fn test_register_union_after_serialize_fails() { #[test] fn test_register_union_by_name_after_serialize_fails() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory - .register_union_by_name::("Color") + .register_union_by_name::("", "Color") .expect_err("register_union_by_name after serialize should fail"); assert!(matches!(err, Error::NotAllowed(_))); } -/// Ensures `register_union_by_namespace()` is forbidden after snapshot init. +/// Ensures `register_union_by_name()` with a non-empty namespace is forbidden after snapshot init. #[test] -fn test_register_union_by_namespace_after_serialize_fails() { +fn test_register_union_by_name_with_namespace_after_serialize_fails() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory - .register_union_by_namespace::("com.example", "Color") - .expect_err("register_union_by_namespace after serialize should fail"); + .register_union_by_name::("com.example", "Color") + .expect_err("register_union_by_name after serialize should fail"); assert!(matches!(err, Error::NotAllowed(_))); } @@ -231,10 +251,10 @@ fn test_register_union_by_namespace_after_serialize_fails() { #[test] fn test_late_registration_error_message_is_descriptive() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); - let err = fory.register::(101).unwrap_err(); + let err = fory.register_by_id::(101).unwrap_err(); let msg = format!("{}", err); assert!( msg.contains("not allowed"), @@ -258,7 +278,7 @@ fn test_late_registration_error_message_is_descriptive() { #[test] fn test_serialize_multiple_times_after_registration_succeeds() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let p1 = Point { x: 1, y: 2 }; let p2 = Point { x: 3, y: 4 }; diff --git a/rust/tests/tests/test_list.rs b/rust/tests/tests/test_list.rs index cb9ad473fe..744204860e 100644 --- a/rust/tests/tests/test_list.rs +++ b/rust/tests/tests/test_list.rs @@ -117,7 +117,7 @@ struct CollectionStruct { #[test] fn test_struct_with_collections() { let mut fory = Fory::default(); - fory.register_by_name::("CollectionStruct") + fory.register_by_name::("", "CollectionStruct") .unwrap(); let mut deque = VecDeque::new(); diff --git a/rust/tests/tests/test_map.rs b/rust/tests/tests/test_map.rs index 9396baeb69..62436c6015 100644 --- a/rust/tests/tests/test_map.rs +++ b/rust/tests/tests/test_map.rs @@ -50,7 +50,7 @@ struct MapContainer { #[test] fn test_struct_with_maps() { let mut fory = Fory::default(); - fory.register_by_name::("MapContainer") + fory.register_by_name::("", "MapContainer") .unwrap(); let mut hash_map = HashMap::new(); hash_map.insert("foo".to_string(), "bar".to_string()); diff --git a/rust/tests/tests/test_marker.rs b/rust/tests/tests/test_marker.rs index 48401593f0..0ea7248714 100644 --- a/rust/tests/tests/test_marker.rs +++ b/rust/tests/tests/test_marker.rs @@ -40,7 +40,7 @@ struct StructWithPhantom { #[test] fn test_struct_with_phantom_data() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let value = StructWithPhantom { name: "test".to_string(), @@ -64,7 +64,8 @@ struct StructWithMultiplePhantom { #[test] fn test_struct_with_multiple_phantom_data() { let mut fory = Fory::default(); - fory.register::(101).unwrap(); + fory.register_by_id::(101) + .unwrap(); let value = StructWithMultiplePhantom { name: "test".to_string(), @@ -94,8 +95,8 @@ struct OuterWithPhantom { #[test] fn test_nested_struct_with_phantom_data() { let mut fory = Fory::default(); - fory.register::(102).unwrap(); - fory.register::(103).unwrap(); + fory.register_by_id::(102).unwrap(); + fory.register_by_id::(103).unwrap(); let value = OuterWithPhantom { inner: InnerWithPhantom { diff --git a/rust/tests/tests/test_max_dyn_depth.rs b/rust/tests/tests/test_max_dyn_depth.rs index 1e2eff8cef..1fc94ddfa7 100644 --- a/rust/tests/tests/test_max_dyn_depth.rs +++ b/rust/tests/tests/test_max_dyn_depth.rs @@ -36,7 +36,7 @@ fn test_max_dyn_depth_exceeded_box_dyn_any() { .max_dyn_depth(2) .compatible(compatible) .build(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let level3 = Container { value: 3, @@ -70,7 +70,7 @@ fn test_max_dyn_depth_within_limit_box_dyn_any() { return; } let mut fory = Fory::builder().max_dyn_depth(3).build(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let level3 = Container { value: 3, @@ -97,7 +97,7 @@ fn test_max_dyn_depth_default_exceeded() { return; } let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let mut current = Container { value: 6, @@ -128,7 +128,7 @@ fn test_max_dyn_depth_default_within_limit() { return; } let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let mut current = Container { value: 5, diff --git a/rust/tests/tests/test_multi_thread.rs b/rust/tests/tests/test_multi_thread.rs index e02c7a9076..001158c1ea 100644 --- a/rust/tests/tests/test_multi_thread.rs +++ b/rust/tests/tests/test_multi_thread.rs @@ -61,7 +61,7 @@ fn test_struct_multi_thread() { f1: i32, } let mut fory = Fory::default(); - fory.register::(101).unwrap(); + fory.register_by_id::(101).unwrap(); let fory = Arc::new(fory); let src: HashSet<_> = [ Item1 { f1: 42 }, @@ -130,7 +130,7 @@ fn test_multiple_threads_shared_fory() { } let mut fory = Fory::default(); - fory.register::(2) + fory.register_by_id::(2) .expect("register UserSessionMetrics"); let shared_fory = Arc::new(fory); let shared_value = Arc::new(UserSessionMetrics { diff --git a/rust/tests/tests/test_one_struct.rs b/rust/tests/tests/test_one_struct.rs index a4bfd9f5d9..3829701d8c 100644 --- a/rust/tests/tests/test_one_struct.rs +++ b/rust/tests/tests/test_one_struct.rs @@ -48,8 +48,8 @@ fn test_simple() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(999).unwrap(); - fory2.register::(999).unwrap(); + fory1.register_by_id::(999).unwrap(); + fory2.register_by_id::(999).unwrap(); let animal: Animal1 = Animal1 { f1: HashMap::from([(1, vec![2])]), f2: String::from("hello"), diff --git a/rust/tests/tests/test_rc_arc.rs b/rust/tests/tests/test_rc_arc.rs index 1cc93f821d..8184c46864 100644 --- a/rust/tests/tests/test_rc_arc.rs +++ b/rust/tests/tests/test_rc_arc.rs @@ -174,7 +174,7 @@ fn test_mixed_rc_arc_serialization() { #[test] fn test_nested_rc_arc() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); // Test Rc containing Arc with allowed struct type let inner_data = Arc::new(NestedData { diff --git a/rust/tests/tests/test_rc_arc_trait_object.rs b/rust/tests/tests/test_rc_arc_trait_object.rs index 3fff222d49..526fcf23ae 100644 --- a/rust/tests/tests/test_rc_arc_trait_object.rs +++ b/rust/tests/tests/test_rc_arc_trait_object.rs @@ -229,8 +229,8 @@ fn test_conversion_helper_macros() { #[test] fn test_nested_wrapper_collections() { let mut fory = fory_compatible(); - fory.register::(100).unwrap(); - fory.register::(101).unwrap(); + fory.register_by_id::(100).unwrap(); + fory.register_by_id::(101).unwrap(); // Wrapper types are not registered since they're transparent @@ -287,8 +287,8 @@ fn test_nested_wrapper_collections() { #[test] fn test_empty_wrapper_collections() { let mut fory = fory_compatible(); - fory.register::(8001).unwrap(); - fory.register::(8002).unwrap(); + fory.register_by_id::(8001).unwrap(); + fory.register_by_id::(8002).unwrap(); // Test empty collections let empty_rc_vec: Vec = vec![]; @@ -329,9 +329,9 @@ struct AnimalByCodeFixedKey { #[test] fn test_collections_of_wrappers() { let mut fory = fory_compatible(); - fory.register::(8001).unwrap(); - fory.register::(8002).unwrap(); - fory.register::(8011).unwrap(); + fory.register_by_id::(8001).unwrap(); + fory.register_by_id::(8002).unwrap(); + fory.register_by_id::(8011).unwrap(); let shelter = AnimalShelter { animals_rc: vec![ @@ -426,14 +426,14 @@ fn test_collections_of_wrappers() { #[test] fn test_hashmap_fixed_key_rc_trait_object_field_compatible() { let mut writer = fory_compatible(); - writer.register::(8101).unwrap(); - writer.register::(8102).unwrap(); - writer.register::(8111).unwrap(); + writer.register_by_id::(8101).unwrap(); + writer.register_by_id::(8102).unwrap(); + writer.register_by_id::(8111).unwrap(); let mut reader = fory_compatible(); - reader.register::(8101).unwrap(); - reader.register::(8102).unwrap(); - reader.register::(8111).unwrap(); + reader.register_by_id::(8101).unwrap(); + reader.register_by_id::(8102).unwrap(); + reader.register_by_id::(8111).unwrap(); let animals = AnimalByCodeFixedKey { animals: HashMap::from([ @@ -466,8 +466,8 @@ fn test_hashmap_fixed_key_rc_trait_object_field_compatible() { #[test] fn test_rc_shared_ref_tracking() { let mut fory = fory_compatible(); - fory.register::(200).unwrap(); - fory.register::(201).unwrap(); + fory.register_by_id::(200).unwrap(); + fory.register_by_id::(201).unwrap(); let dog = Rc::new(Dog { name: "Rex".to_string(), @@ -498,8 +498,8 @@ fn test_rc_shared_ref_tracking() { #[test] fn test_arc_shared_ref_tracking() { let mut fory = fory_compatible(); - fory.register::(200).unwrap(); - fory.register::(201).unwrap(); + fory.register_by_id::(200).unwrap(); + fory.register_by_id::(201).unwrap(); let cat = Arc::new(Cat { name: "Whiskers".to_string(), diff --git a/rust/tests/tests/test_refcell.rs b/rust/tests/tests/test_refcell.rs index dae3abf76c..55ab910dfe 100644 --- a/rust/tests/tests/test_refcell.rs +++ b/rust/tests/tests/test_refcell.rs @@ -28,7 +28,7 @@ struct Simple { #[test] fn test_rc_refcell_simple() { let mut fory = Fory::default(); - fory.register::(3000).unwrap(); + fory.register_by_id::(3000).unwrap(); let node = Rc::new(RefCell::new(Simple { value: 42 })); let serialized = fory.serialize(&node).unwrap(); @@ -45,8 +45,8 @@ struct Parent { #[test] fn test_rc_refcell_in_struct() { let mut fory = Fory::default(); - fory.register::(3001).unwrap(); - fory.register::(3002).unwrap(); + fory.register_by_id::(3001).unwrap(); + fory.register_by_id::(3002).unwrap(); let child = Rc::new(RefCell::new(Simple { value: 99 })); let parent = Parent { diff --git a/rust/tests/tests/test_simple_struct.rs b/rust/tests/tests/test_simple_struct.rs index dc3cc5dd95..5ad24d9ad8 100644 --- a/rust/tests/tests/test_simple_struct.rs +++ b/rust/tests/tests/test_simple_struct.rs @@ -30,7 +30,7 @@ fn test_one_field_primitive_non_compatible() { } let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let data = Data { value: 42 }; let bytes = fory.serialize(&data).unwrap(); let result: Data = fory.deserialize(&bytes).unwrap(); @@ -46,7 +46,7 @@ fn test_one_field_string_non_compatible() { } let mut fory = Fory::default(); - fory.register::(101).unwrap(); + fory.register_by_id::(101).unwrap(); let data = Data { name: String::from("hello"), }; @@ -70,8 +70,8 @@ fn test_compatible_field_type_change() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(100).unwrap(); - fory2.register::(100).unwrap(); + fory1.register_by_id::(100).unwrap(); + fory2.register_by_id::(100).unwrap(); let data1 = Data1 { value: 42 }; let bytes = fory1.serialize(&data1).unwrap(); @@ -97,8 +97,8 @@ fn test_struct_evolving_override() { .compatible(true) .track_ref(false) .build(); - fory.register::(100).unwrap(); - fory.register::(101).unwrap(); + fory.register_by_id::(100).unwrap(); + fory.register_by_id::(101).unwrap(); let evolving = Evolving { id: 123 }; let evolving_bytes = fory.serialize(&evolving).unwrap(); @@ -132,8 +132,8 @@ fn test_compatible_to_empty_struct() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(101).unwrap(); - fory2.register::(101).unwrap(); + fory1.register_by_id::(101).unwrap(); + fory2.register_by_id::(101).unwrap(); let data1 = DataWithField { value: 42, @@ -158,8 +158,8 @@ fn test_compatible_from_empty_struct() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(102).unwrap(); - fory2.register::(102).unwrap(); + fory1.register_by_id::(102).unwrap(); + fory2.register_by_id::(102).unwrap(); let data1 = EmptyData {}; let bytes = fory1.serialize(&data1).unwrap(); @@ -181,8 +181,8 @@ fn test_compatible_vec_to_empty_struct() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(101).unwrap(); - fory2.register::(101).unwrap(); + fory1.register_by_id::(101).unwrap(); + fory2.register_by_id::(101).unwrap(); let data1 = DataWithField { value: vec![32], @@ -206,8 +206,8 @@ fn test_compatible_map_to_empty_struct() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(101).unwrap(); - fory2.register::(101).unwrap(); + fory1.register_by_id::(101).unwrap(); + fory2.register_by_id::(101).unwrap(); let data1 = DataWithField { value: HashMap::from([(String::from("k1"), 1i32), (String::from("k2"), 2i32)]), @@ -230,7 +230,7 @@ fn test_struct_with_float16_fields() { } let mut fory = Fory::default(); - fory.register::(200).unwrap(); + fory.register_by_id::(200).unwrap(); let obj = Float16Data { scalar: float16::from_f32(1.5), @@ -272,7 +272,7 @@ fn test_struct_with_bfloat16_fields() { } let mut fory = Fory::default(); - fory.register::(201).unwrap(); + fory.register_by_id::(201).unwrap(); let obj = BFloat16Data { scalar: bfloat16::from_f32(1.5), diff --git a/rust/tests/tests/test_skip_fields.rs b/rust/tests/tests/test_skip_fields.rs index 51bc326520..fa8e059828 100644 --- a/rust/tests/tests/test_skip_fields.rs +++ b/rust/tests/tests/test_skip_fields.rs @@ -83,7 +83,7 @@ enum TestEnumSkip { #[test] fn test_basic_skip_functionality() { let mut fory = Fory::default(); - fory.register::(1).unwrap(); + fory.register_by_id::(1).unwrap(); let original = TestSkipFields { serialized_field: 42, @@ -109,8 +109,8 @@ fn test_basic_skip_functionality() { #[test] fn test_nested_skip_functionality() { let mut fory = Fory::default(); - fory.register::(2).unwrap(); - fory.register::(3).unwrap(); + fory.register_by_id::(2).unwrap(); + fory.register_by_id::(3).unwrap(); let original = TestNestedSkip { normal_field: 100, @@ -130,7 +130,7 @@ fn test_nested_skip_functionality() { #[test] fn test_multiple_skip_fields() { let mut fory = Fory::default(); - fory.register::(3).unwrap(); + fory.register_by_id::(3).unwrap(); let original = MultipleSkipFields { field1: 42, @@ -153,7 +153,7 @@ fn test_multiple_skip_fields() { #[test] fn test_all_fields_skipped() { let mut fory = Fory::default(); - fory.register::(4).unwrap(); + fory.register_by_id::(4).unwrap(); let original = AllFieldsSkipped { skipped1: "test1".to_string(), @@ -172,8 +172,8 @@ fn test_all_fields_skipped() { #[test] fn test_complex_nested_skip() { let mut fory = Fory::default(); - fory.register::(5).unwrap(); - fory.register::(6).unwrap(); + fory.register_by_id::(5).unwrap(); + fory.register_by_id::(6).unwrap(); let original = ComplexNestedSkip { normal_field: 1, @@ -207,7 +207,7 @@ fn test_complex_nested_skip() { #[test] fn test_enum_skip() { let mut fory = Fory::default(); - fory.register::(6).unwrap(); + fory.register_by_id::(6).unwrap(); let original_v1 = TestEnumSkip::Pending; @@ -225,7 +225,7 @@ fn test_enum_skip() { #[test] fn test_skip_serialization_size() { let mut fory = Fory::default(); - fory.register::(10).unwrap(); + fory.register_by_id::(10).unwrap(); let with_skip = TestSkipFields { serialized_field: 42, @@ -239,7 +239,7 @@ fn test_skip_serialization_size() { another_serialized: f64, } - fory.register::(11).unwrap(); + fory.register_by_id::(11).unwrap(); let without_skip = TestNoSkip { serialized_field: 42, @@ -275,7 +275,7 @@ fn test_skip_with_different_types() { } let mut fory = Fory::default(); - fory.register::(12).unwrap(); + fory.register_by_id::(12).unwrap(); let original = MultiTypeSkip { field1: 1, @@ -358,10 +358,10 @@ fn test_trait_object_serialization() { } let mut fory = Fory::builder().compatible(true).build(); - fory.register::(100).unwrap(); - fory.register::(101).unwrap(); - fory.register::(102).unwrap(); - fory.register::(103).unwrap(); + fory.register_by_id::(100).unwrap(); + fory.register_by_id::(101).unwrap(); + fory.register_by_id::(102).unwrap(); + fory.register_by_id::(103).unwrap(); let zoo_with_skip = ZooWithSkip { regular_animal: Box::new(Dog { @@ -398,7 +398,7 @@ fn test_trait_object_serialization() { } let mut fory = Fory::builder().compatible(true).build(); - fory.register::(106).unwrap(); + fory.register_by_id::(106).unwrap(); let complex = ComplexSkipExample { boxed_dyn: Box::new(Dog { diff --git a/rust/tests/tests/test_trait_object.rs b/rust/tests/tests/test_trait_object.rs index c06c0171b5..9ac7718329 100644 --- a/rust/tests/tests/test_trait_object.rs +++ b/rust/tests/tests/test_trait_object.rs @@ -156,7 +156,7 @@ struct Company { #[test] fn test_fory_derived_struct_as_trait_object() { let mut fory = fory_compatible(); - fory.register::(5000).unwrap(); + fory.register_by_id::(5000).unwrap(); let person = Person { name: String::from("Alice"), @@ -178,8 +178,8 @@ fn test_fory_derived_struct_as_trait_object() { #[test] fn test_vec_of_fory_derived_trait_objects() { let mut fory = fory_compatible(); - fory.register::(5000).unwrap(); - fory.register::(5001).unwrap(); + fory.register_by_id::(5000).unwrap(); + fory.register_by_id::(5001).unwrap(); let vec_of_trait_objects: Vec> = vec![ Box::new(Person { @@ -205,8 +205,8 @@ fn test_vec_of_fory_derived_trait_objects() { #[test] fn test_hashmap_with_fory_derived_values() { let mut fory = fory_compatible(); - fory.register::(5000).unwrap(); - fory.register::(5001).unwrap(); + fory.register_by_id::(5000).unwrap(); + fory.register_by_id::(5001).unwrap(); let mut map: HashMap> = HashMap::new(); map.insert( @@ -280,9 +280,9 @@ struct Zoo { #[test] fn test_custom_trait_object_basic() { let mut fory = fory_compatible(); - fory.register::(8001).unwrap(); - fory.register::(8002).unwrap(); - fory.register::(8003).unwrap(); + fory.register_by_id::(8001).unwrap(); + fory.register_by_id::(8002).unwrap(); + fory.register_by_id::(8003).unwrap(); let zoo_dog = Zoo { star_animal: Box::new(Dog { @@ -338,9 +338,9 @@ struct PetOwner { #[test] fn test_multiple_traits() { let mut fory = fory_compatible(); - fory.register::(8001).unwrap(); - fory.register::(8002).unwrap(); - fory.register::(9001).unwrap(); + fory.register_by_id::(8001).unwrap(); + fory.register_by_id::(8002).unwrap(); + fory.register_by_id::(9001).unwrap(); let owner = PetOwner { pets: vec![ @@ -384,8 +384,8 @@ fn test_multiple_traits() { #[test] fn test_single_custom_trait_object_direct() { let mut fory = fory_compatible(); - fory.register::(8001).unwrap(); - fory.register::(8002).unwrap(); + fory.register_by_id::(8001).unwrap(); + fory.register_by_id::(8002).unwrap(); let animal: Box = Box::new(Dog { name: "Rex".to_string(), @@ -402,8 +402,8 @@ fn test_single_custom_trait_object_direct() { #[test] fn test_vec_custom_trait_objects_direct() { let mut fory = fory_compatible(); - fory.register::(8001).unwrap(); - fory.register::(8002).unwrap(); + fory.register_by_id::(8001).unwrap(); + fory.register_by_id::(8002).unwrap(); let animals: Vec> = vec![ Box::new(Dog { @@ -435,8 +435,8 @@ fn test_vec_custom_trait_objects_direct() { #[test] fn test_hashmap_custom_trait_objects_direct() { let mut fory = fory_compatible(); - fory.register::(8001).unwrap(); - fory.register::(8002).unwrap(); + fory.register_by_id::(8001).unwrap(); + fory.register_by_id::(8002).unwrap(); let mut animal_map: std::collections::HashMap> = std::collections::HashMap::new(); @@ -478,8 +478,8 @@ fn test_hashmap_custom_trait_objects_direct() { #[test] fn test_nested_custom_trait_object_collections() { let mut fory = fory_compatible(); - fory.register::(8001).unwrap(); - fory.register::(8002).unwrap(); + fory.register_by_id::(8001).unwrap(); + fory.register_by_id::(8002).unwrap(); // Test Vec>> let nested_animals: Vec>> = vec![ @@ -516,8 +516,8 @@ fn test_nested_custom_trait_object_collections() { #[test] fn test_mixed_trait_object_collections() { let mut fory = fory_compatible(); - fory.register::(8001).unwrap(); - fory.register::(8002).unwrap(); + fory.register_by_id::(8001).unwrap(); + fory.register_by_id::(8002).unwrap(); // Test HashMap>> let mut groups: std::collections::HashMap>> = @@ -567,8 +567,8 @@ fn test_mixed_trait_object_collections() { #[test] fn test_empty_trait_object_collections() { let mut fory = fory_compatible(); - fory.register::(8001).unwrap(); - fory.register::(8002).unwrap(); + fory.register_by_id::(8001).unwrap(); + fory.register_by_id::(8002).unwrap(); // Test empty Vec> let empty_animals: Vec> = vec![]; @@ -588,8 +588,8 @@ fn test_empty_trait_object_collections() { #[test] fn test_single_item_trait_object_collections() { let mut fory = fory_compatible(); - fory.register::(8001).unwrap(); - fory.register::(8002).unwrap(); + fory.register_by_id::(8001).unwrap(); + fory.register_by_id::(8002).unwrap(); // Test single item Vec> let single_animal: Vec> = vec![Box::new(Dog { diff --git a/rust/tests/tests/test_tuple.rs b/rust/tests/tests/test_tuple.rs index 60663a7b23..3489366894 100644 --- a/rust/tests/tests/test_tuple.rs +++ b/rust/tests/tests/test_tuple.rs @@ -269,7 +269,7 @@ fn run_struct_with_simple_tuple_fields(xlang: bool) { } let mut fory = Fory::builder().xlang(xlang).build(); - fory.register::(1).unwrap(); + fory.register_by_id::(1).unwrap(); let data = SimpleTupleStruct { id: 42, @@ -305,7 +305,7 @@ fn run_struct_with_complex_tuple_fields(xlang: bool) { } let mut fory = Fory::builder().xlang(xlang).build(); - fory.register::(2).unwrap(); + fory.register_by_id::(2).unwrap(); let data = ComplexTupleStruct { name: "Complex Test".to_string(), @@ -376,7 +376,7 @@ struct StructWithUnit { #[test] fn test_struct_with_unit_field() { let mut fory = Fory::default(); - fory.register::(200).unwrap(); + fory.register_by_id::(200).unwrap(); let value = StructWithUnit { name: "test".to_string(), diff --git a/rust/tests/tests/test_tuple_compatible.rs b/rust/tests/tests/test_tuple_compatible.rs index 7811d0a21f..19cd52018b 100644 --- a/rust/tests/tests/test_tuple_compatible.rs +++ b/rust/tests/tests/test_tuple_compatible.rs @@ -502,10 +502,10 @@ fn run_struct_missing_tuple_field(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register::(1).unwrap(); + fory1.register_by_id::(1).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register::(1).unwrap(); + fory2.register_by_id::(1).unwrap(); // Serialize V1 and deserialize as V2 let v1 = StructV1 { @@ -554,10 +554,10 @@ fn run_struct_added_tuple_field(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register::(2).unwrap(); + fory1.register_by_id::(2).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register::(2).unwrap(); + fory2.register_by_id::(2).unwrap(); // Serialize V1 and deserialize as V2 (new tuple fields should be default) let v1 = StructV1 { @@ -602,10 +602,10 @@ fn run_struct_tuple_element_increase(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register::(3).unwrap(); + fory1.register_by_id::(3).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register::(3).unwrap(); + fory2.register_by_id::(3).unwrap(); // Serialize V1 and deserialize as V2 (extra elements should be default) let v1 = StructV1 { @@ -649,10 +649,10 @@ fn run_struct_tuple_element_decrease(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register::(4).unwrap(); + fory1.register_by_id::(4).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register::(4).unwrap(); + fory2.register_by_id::(4).unwrap(); // Serialize V1 and deserialize as V2 (extra elements should be dropped) let v1 = StructV1 { @@ -699,10 +699,10 @@ fn run_struct_nested_tuple_evolution(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register::(5).unwrap(); + fory1.register_by_id::(5).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register::(5).unwrap(); + fory2.register_by_id::(5).unwrap(); // Serialize V1 and deserialize as V2 let v1 = StructV1 { @@ -756,10 +756,10 @@ fn run_struct_multiple_tuple_fields_evolution(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register::(6).unwrap(); + fory1.register_by_id::(6).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register::(6).unwrap(); + fory2.register_by_id::(6).unwrap(); // Serialize V1 and deserialize as V2 let v1 = StructV1 { @@ -926,10 +926,10 @@ fn run_struct_complex_evolution_scenario(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register::(100).unwrap(); + fory1.register_by_id::(100).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register::(100).unwrap(); + fory2.register_by_id::(100).unwrap(); // Test V1 -> V2: Old schema to new schema let v1 = DataRecordV1 { @@ -1036,10 +1036,10 @@ fn test_tuple_alias() { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().compatible(true).build(); - fory1.register::(100).unwrap(); + fory1.register_by_id::(100).unwrap(); let mut fory2 = Fory::builder().compatible(true).build(); - fory2.register::(100).unwrap(); + fory2.register_by_id::(100).unwrap(); // Test record1 serialized by fory1, deserialized by fory2 let record1 = DataRecordV1 { diff --git a/rust/tests/tests/test_tuple_struct.rs b/rust/tests/tests/test_tuple_struct.rs index c01cc4c685..00ef12ef5e 100644 --- a/rust/tests/tests/test_tuple_struct.rs +++ b/rust/tests/tests/test_tuple_struct.rs @@ -43,7 +43,7 @@ struct Single(i32); #[test] fn test_basic_tuple_struct() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let point = Point(3.15, 2.72); let bytes = fory.serialize(&point).unwrap(); @@ -54,7 +54,7 @@ fn test_basic_tuple_struct() { #[test] fn test_single_field_tuple_struct() { let mut fory = Fory::default(); - fory.register::(101).unwrap(); + fory.register_by_id::(101).unwrap(); let single = Single(42); let bytes = fory.serialize(&single).unwrap(); @@ -65,7 +65,7 @@ fn test_single_field_tuple_struct() { #[test] fn test_string_wrapper_tuple_struct() { let mut fory = Fory::default(); - fory.register::(102).unwrap(); + fory.register_by_id::(102).unwrap(); let wrapper = Wrapper("hello world".to_string()); let bytes = fory.serialize(&wrapper).unwrap(); @@ -76,7 +76,7 @@ fn test_string_wrapper_tuple_struct() { #[test] fn test_triple_tuple_struct() { let mut fory = Fory::default(); - fory.register::(103).unwrap(); + fory.register_by_id::(103).unwrap(); let triple = Triple(1, 2, 3); let bytes = fory.serialize(&triple).unwrap(); @@ -98,7 +98,7 @@ struct WithMap(HashMap); #[test] fn test_tuple_struct_with_vec() { let mut fory = Fory::default(); - fory.register::(104).unwrap(); + fory.register_by_id::(104).unwrap(); let data = WithVec(vec![1, 2, 3, 4, 5], "test".to_string()); let bytes = fory.serialize(&data).unwrap(); @@ -109,7 +109,7 @@ fn test_tuple_struct_with_vec() { #[test] fn test_tuple_struct_with_option() { let mut fory = Fory::default(); - fory.register::(105).unwrap(); + fory.register_by_id::(105).unwrap(); // Test with Some values let data1 = WithOption(Some(42), Some("hello".to_string())); @@ -133,7 +133,7 @@ fn test_tuple_struct_with_option() { #[test] fn test_tuple_struct_with_map() { let mut fory = Fory::default(); - fory.register::(106).unwrap(); + fory.register_by_id::(106).unwrap(); let mut map = HashMap::new(); map.insert("one".to_string(), 1); @@ -157,8 +157,8 @@ struct Outer(Inner, Vec); #[test] fn test_nested_tuple_structs() { let mut fory = Fory::default(); - fory.register::(107).unwrap(); - fory.register::(108).unwrap(); + fory.register_by_id::(107).unwrap(); + fory.register_by_id::(108).unwrap(); let inner1 = Inner(1, "first".to_string()); let inner2 = Inner(2, "second".to_string()); @@ -178,7 +178,7 @@ struct WithRc(Rc, Rc); #[test] fn test_tuple_struct_with_rc() { let mut fory = Fory::default(); - fory.register::(109).unwrap(); + fory.register_by_id::(109).unwrap(); let data = WithRc(Rc::new("shared".to_string()), Rc::new(42)); let bytes = fory.serialize(&data).unwrap(); @@ -199,9 +199,9 @@ struct NamedWithTupleStruct { #[test] fn test_named_struct_with_tuple_struct_fields() { let mut fory = Fory::default(); - fory.register::(100).unwrap(); - fory.register::(102).unwrap(); - fory.register::(110).unwrap(); + fory.register_by_id::(100).unwrap(); + fory.register_by_id::(102).unwrap(); + fory.register_by_id::(110).unwrap(); let data = NamedWithTupleStruct { id: 1, @@ -222,7 +222,7 @@ struct TupleStructWithTuple(i32, (String, f64)); #[test] fn test_tuple_struct_with_tuple_field() { let mut fory = Fory::default(); - fory.register::(111).unwrap(); + fory.register_by_id::(111).unwrap(); let data = TupleStructWithTuple(42, ("hello".to_string(), 3.15)); let bytes = fory.serialize(&data).unwrap(); @@ -235,9 +235,9 @@ fn test_tuple_struct_with_tuple_field() { #[test] fn test_tuple_struct_xlang_mode() { let mut fory = Fory::builder().xlang(true).compatible(false).build(); - fory.register::(100).unwrap(); - fory.register::(102).unwrap(); - fory.register::(103).unwrap(); + fory.register_by_id::(100).unwrap(); + fory.register_by_id::(102).unwrap(); + fory.register_by_id::(103).unwrap(); let point = Point(3.15, 2.72); let bytes = fory.serialize(&point).unwrap(); @@ -263,7 +263,7 @@ struct EmptyVecTuple(Vec); #[test] fn test_tuple_struct_with_empty_vec() { let mut fory = Fory::default(); - fory.register::(112).unwrap(); + fory.register_by_id::(112).unwrap(); let data = EmptyVecTuple(vec![]); let bytes = fory.serialize(&data).unwrap(); @@ -277,7 +277,7 @@ struct LargeTupleStruct(i8, i16, i32, i64, u8, u16, u32, u64, f32, f64, bool, St #[test] fn test_large_tuple_struct() { let mut fory = Fory::default(); - fory.register::(113).unwrap(); + fory.register_by_id::(113).unwrap(); let data = LargeTupleStruct( 1, @@ -329,13 +329,13 @@ mod remote_v3 { #[test] fn test_tuple_struct_schema_evolution_add_field() { let mut fory_writer = Fory::builder().compatible(true).build(); - fory_writer.register::(100).unwrap(); + fory_writer.register_by_id::(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::builder().compatible(true).build(); - fory_reader.register::(100).unwrap(); + fory_reader.register_by_id::(100).unwrap(); let local_data: local_v2::Point = fory_reader.deserialize(&bytes).unwrap(); @@ -348,13 +348,13 @@ fn test_tuple_struct_schema_evolution_add_field() { #[test] fn test_tuple_struct_schema_evolution_remove_field() { let mut fory_writer = Fory::builder().compatible(true).build(); - fory_writer.register::(100).unwrap(); + fory_writer.register_by_id::(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::builder().compatible(true).build(); - fory_reader.register::(100).unwrap(); + fory_reader.register_by_id::(100).unwrap(); let local_data: remote_v1::Point = fory_reader.deserialize(&bytes).unwrap(); @@ -390,7 +390,7 @@ mod local_mixed_v3 { fn test_tuple_struct_schema_evolution_add_i64() { let mut fory_writer = Fory::builder().compatible(true).build(); fory_writer - .register::(100) + .register_by_id::(100) .unwrap(); let remote_data = remote_mixed_v1::MixedPoint(1.0, 2.0); @@ -398,7 +398,7 @@ fn test_tuple_struct_schema_evolution_add_i64() { let mut fory_reader = Fory::builder().compatible(true).build(); fory_reader - .register::(100) + .register_by_id::(100) .unwrap(); let local_data: local_mixed_v2::MixedPoint = fory_reader.deserialize(&bytes).unwrap(); @@ -413,7 +413,7 @@ fn test_tuple_struct_schema_evolution_add_i64() { fn test_tuple_struct_schema_evolution_add_u8() { let mut fory_writer = Fory::builder().compatible(true).build(); fory_writer - .register::(100) + .register_by_id::(100) .unwrap(); let remote_data = remote_mixed_v1::MixedPoint(1.0, 2.0); @@ -421,7 +421,7 @@ fn test_tuple_struct_schema_evolution_add_u8() { let mut fory_reader = Fory::builder().compatible(true).build(); fory_reader - .register::(100) + .register_by_id::(100) .unwrap(); let local_data: local_mixed_v3::MixedPoint = fory_reader.deserialize(&bytes).unwrap(); diff --git a/rust/tests/tests/test_unsigned.rs b/rust/tests/tests/test_unsigned.rs index 6dcb714926..ebdbf98ba2 100644 --- a/rust/tests/tests/test_unsigned.rs +++ b/rust/tests/tests/test_unsigned.rs @@ -63,7 +63,7 @@ fn test_binary_when_xlang() { struct UnsignedData { binary: Vec, } - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let binary = vec![0u8, 1, 2, u8::MAX]; test_roundtrip(&fory, binary.clone()); let data = UnsignedData { binary }; @@ -133,7 +133,7 @@ fn test_unsigned_struct_non_compatible() { } let mut fory = Fory::default(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let data = UnsignedData { a: u8::MAX, @@ -174,7 +174,7 @@ fn test_unsigned_struct_compatible() { } let mut fory = Fory::builder().compatible(true).build(); - fory.register::(100).unwrap(); + fory.register_by_id::(100).unwrap(); let data = UnsignedData { a: u8::MAX, @@ -213,8 +213,8 @@ fn test_unsigned_struct_compatible_add_field() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(101).unwrap(); - fory2.register::(101).unwrap(); + fory1.register_by_id::(101).unwrap(); + fory2.register_by_id::(101).unwrap(); let data_v1 = UnsignedDataV1 { a: 255, b: 65535 }; let bytes = fory1.serialize(&data_v1).unwrap(); @@ -241,8 +241,8 @@ fn test_unsigned_struct_compatible_remove_field() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(102).unwrap(); - fory2.register::(102).unwrap(); + fory1.register_by_id::(102).unwrap(); + fory2.register_by_id::(102).unwrap(); let data_v1 = UnsignedDataV1 { a: 255, @@ -298,7 +298,7 @@ fn test_unsigned_with_option_non_compatible() { } let mut fory = Fory::default(); - fory.register::(103).unwrap(); + fory.register_by_id::(103).unwrap(); // Test with Some values let data_some = OptionalUnsigned { @@ -342,7 +342,7 @@ fn test_unsigned_with_option_compatible() { } let mut fory = Fory::builder().compatible(true).build(); - fory.register::(104).unwrap(); + fory.register_by_id::(104).unwrap(); // Test with Some values let data_some = OptionalUnsigned { @@ -395,8 +395,8 @@ fn test_unsigned_mixed_fields_compatible() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register::(105).unwrap(); - fory2.register::(105).unwrap(); + fory1.register_by_id::(105).unwrap(); + fory2.register_by_id::(105).unwrap(); let data_v1 = MixedDataV1 { required_u8: 255, diff --git a/rust/tests/tests/test_weak.rs b/rust/tests/tests/test_weak.rs index 9949427c96..2ab49cbc22 100644 --- a/rust/tests/tests/test_weak.rs +++ b/rust/tests/tests/test_weak.rs @@ -134,7 +134,7 @@ fn test_rc_weak_field_in_struct() { } let mut fory = Fory::builder().track_ref(true).build(); - fory.register::(1000).unwrap(); + fory.register_by_id::(1000).unwrap(); let data = Rc::new(42i32); let node = SimpleNode { @@ -161,7 +161,7 @@ struct Node { fn test_node_circular_reference_with_parent_children() { // Register the Node type with Fory let mut fory = Fory::builder().track_ref(true).build(); - fory.register::(2000).unwrap(); + fory.register_by_id::(2000).unwrap(); // Create parent let parent = Rc::new(RefCell::new(Node { @@ -219,7 +219,7 @@ fn test_arc_mutex_circular_reference() { } let mut fory = Fory::builder().track_ref(true).build(); - fory.register::(6000).unwrap(); + fory.register_by_id::(6000).unwrap(); let parent = Arc::new(Mutex::new(Node { val: 10, From 0a1531beea9b54e572dee7fa7e1ccb34e820b91f Mon Sep 17 00:00:00 2001 From: chaokunyang Date: Sat, 9 May 2026 13:40:16 +0800 Subject: [PATCH 03/12] feat(go)!: rename name-based registration APIs BREAKING CHANGE: Go name-based registration methods now use RegisterStructByName, RegisterEnumByName, RegisterUnionByName, and RegisterExtensionByName instead of RegisterNamed*. --- README.md | 2 +- compiler/fory_compiler/generators/go.py | 6 +-- docs/compiler/generated-code.md | 4 +- docs/guide/go/basic-serialization.md | 2 +- docs/guide/go/custom-serializers.md | 2 +- docs/guide/go/troubleshooting.md | 2 +- docs/guide/go/type-registration.md | 8 ++-- docs/guide/xlang/field-nullability.md | 2 +- docs/guide/xlang/getting-started.md | 2 +- docs/guide/xlang/serialization.md | 4 +- go/fory/README.md | 2 +- go/fory/doc.go | 2 +- go/fory/enum_test.go | 2 +- go/fory/fory.go | 44 +++++++++---------- go/fory/fory_compatible_test.go | 24 +++++------ go/fory/fory_test.go | 32 +++++++------- go/fory/fory_typed_test.go | 4 +- go/fory/ref_resolver_test.go | 4 +- go/fory/serializer.go | 4 +- go/fory/struct_test.go | 16 +++---- go/fory/tests/generator_xlang_test.go | 6 +-- go/fory/tests/xlang/xlang_test_main.go | 20 ++++----- go/fory/threadsafe/fory.go | 6 +-- go/fory/type_def_test.go | 10 ++--- go/fory/type_resolver.go | 56 ++++++++----------------- go/fory/type_test.go | 4 +- 26 files changed, 124 insertions(+), 146 deletions(-) diff --git a/README.md b/README.md index 67bd4a46f3..8d856d2b7f 100644 --- a/README.md +++ b/README.md @@ -400,7 +400,7 @@ type Person struct { func main() { f := fory.New(fory.WithXlang(true), fory.WithCompatible(true)) - if err := f.RegisterNamedStruct(Person{}, "example.Person"); err != nil { + if err := f.RegisterStructByName(Person{}, "example.Person"); err != nil { panic(err) } diff --git a/compiler/fory_compiler/generators/go.py b/compiler/fory_compiler/generators/go.py index 3673b99d3b..b25e63c799 100644 --- a/compiler/fory_compiler/generators/go.py +++ b/compiler/fory_compiler/generators/go.py @@ -1570,7 +1570,7 @@ def generate_enum_registration( # Use FDL package for namespace (consistent across languages) ns = self.schema.package or "default" lines.append( - f'\tif err := f.RegisterNamedEnum({code_name}(0), "{ns}.{type_name}"); err != nil {{' + f'\tif err := f.RegisterEnumByName({code_name}(0), "{ns}.{type_name}"); err != nil {{' ) lines.append("\t\treturn err") lines.append("\t}") @@ -1613,7 +1613,7 @@ def generate_message_registration( # Use FDL package for namespace (consistent across languages) ns = self.schema.package or "default" lines.append( - f'\tif err := f.RegisterNamedStruct({code_name}{{}}, "{ns}.{type_name}"); err != nil {{' + f'\tif err := f.RegisterStructByName({code_name}{{}}, "{ns}.{type_name}"); err != nil {{' ) lines.append("\t\treturn err") lines.append("\t}") @@ -1647,7 +1647,7 @@ def generate_union_registration( else: ns = self.schema.package or "default" lines.append( - f'\tif err := f.RegisterNamedUnion({code_name}{{}}, "{ns}.{type_name}", {serializer_expr}); err != nil {{' + f'\tif err := f.RegisterUnionByName({code_name}{{}}, "{ns}.{type_name}", {serializer_expr}); err != nil {{' ) lines.append("\t\treturn err") lines.append("\t}") diff --git a/docs/compiler/generated-code.md b/docs/compiler/generated-code.md index 480980d9b1..d3a0d6af16 100644 --- a/docs/compiler/generated-code.md +++ b/docs/compiler/generated-code.md @@ -659,8 +659,8 @@ if err := f.RegisterStruct(Envelope_Payload{}, 2862577837); err != nil { ... } If `option enable_auto_type_id = false;` is set: ```go -if err := f.RegisterNamedStruct(Config{}, "myapp.models.Config"); err != nil { ... } -if err := f.RegisterNamedUnion(Holder{}, "myapp.models.Holder", fory.NewUnionSerializer(...)); err != nil { ... } +if err := f.RegisterStructByName(Config{}, "myapp.models.Config"); err != nil { ... } +if err := f.RegisterUnionByName(Holder{}, "myapp.models.Holder", fory.NewUnionSerializer(...)); err != nil { ... } ``` `go_nested_type_style` controls nested type naming: diff --git a/docs/guide/go/basic-serialization.md b/docs/guide/go/basic-serialization.md index c0617783b2..8fc7779337 100644 --- a/docs/guide/go/basic-serialization.md +++ b/docs/guide/go/basic-serialization.md @@ -35,7 +35,7 @@ f.RegisterStruct(User{}, 1) f.RegisterStruct(Order{}, 2) // Or register with a name (more flexible, less prone to ID conflicts, but higher serialization cost) -f.RegisterNamedStruct(User{}, "example.User") +f.RegisterStructByName(User{}, "example.User") // Register enum types f.RegisterEnum(Color(0), 3) diff --git a/docs/guide/go/custom-serializers.md b/docs/guide/go/custom-serializers.md index b3db628e27..96849d55d7 100644 --- a/docs/guide/go/custom-serializers.md +++ b/docs/guide/go/custom-serializers.md @@ -242,7 +242,7 @@ f.RegisterExtension(MyType{}, 100, &MySerializer{}) More flexible but more serialization cost, type name included in serialized data: ```go -f.RegisterNamedExtension(MyType{}, "myapp.MyType", &MySerializer{}) +f.RegisterExtensionByName(MyType{}, "myapp.MyType", &MySerializer{}) ``` ## Best Practices diff --git a/docs/guide/go/troubleshooting.md b/docs/guide/go/troubleshooting.md index 529bba8df4..f87ce5fc25 100644 --- a/docs/guide/go/troubleshooting.md +++ b/docs/guide/go/troubleshooting.md @@ -280,7 +280,7 @@ Ensure the same field IDs are used across all languages for corresponding fields ```go // Go -f.RegisterNamedStruct(User{}, "example.User") +f.RegisterStructByName(User{}, "example.User") // Java - must match exactly fory.register(User.class, "example.User"); diff --git a/docs/guide/go/type-registration.md b/docs/guide/go/type-registration.md index 97435a6398..edf5e5e114 100644 --- a/docs/guide/go/type-registration.md +++ b/docs/guide/go/type-registration.md @@ -58,7 +58,7 @@ Register a struct with a type name string. This is more flexible but has higher ```go f := fory.New() -err := f.RegisterNamedStruct(User{}, "example.User") +err := f.RegisterStructByName(User{}, "example.User") if err != nil { panic(err) } @@ -92,7 +92,7 @@ err := f.RegisterEnum(Status(0), 1) ### Register by Name ```go -err := f.RegisterNamedEnum(Status(0), "example.Status") +err := f.RegisterEnumByName(Status(0), "example.Status") ``` ## Extension Types @@ -106,7 +106,7 @@ f := fory.New() err := f.RegisterExtension(CustomType{}, 1, &CustomSerializer{}) // Or register by name -err = f.RegisterNamedExtension(CustomType{}, "example.Custom", &CustomSerializer{}) +err = f.RegisterExtensionByName(CustomType{}, "example.Custom", &CustomSerializer{}) ``` See [Custom Serializers](custom-serializers.md) for details on implementing the `ExtensionSerializer` interface. @@ -196,7 +196,7 @@ All languages use the same type name: **Go**: ```go -f.RegisterNamedStruct(User{}, "example.User") +f.RegisterStructByName(User{}, "example.User") ``` **Java**: diff --git a/docs/guide/xlang/field-nullability.md b/docs/guide/xlang/field-nullability.md index fc8d3736c9..5b9d645768 100644 --- a/docs/guide/xlang/field-nullability.md +++ b/docs/guide/xlang/field-nullability.md @@ -167,7 +167,7 @@ type Person struct { } fory := forygo.NewFory(forygo.WithXlang(true), forygo.WithCompatible(true)) -fory.RegisterNamedStruct(Person{}, "example.Person") +fory.RegisterStructByName(Person{}, "example.Person") ``` ### C++ diff --git a/docs/guide/xlang/getting-started.md b/docs/guide/xlang/getting-started.md index f5a81c209d..62f279b340 100644 --- a/docs/guide/xlang/getting-started.md +++ b/docs/guide/xlang/getting-started.md @@ -161,7 +161,7 @@ fory.register_type(Person, typename="example.Person") **Go:** ```go -fory.RegisterNamedStruct(Person{}, "example.Person") +fory.RegisterStructByName(Person{}, "example.Person") ``` **Rust:** diff --git a/docs/guide/xlang/serialization.md b/docs/guide/xlang/serialization.md index 4f37a1a1dc..68be9c5ef6 100644 --- a/docs/guide/xlang/serialization.md +++ b/docs/guide/xlang/serialization.md @@ -299,10 +299,10 @@ func main() { F12 []int16 } serializer := forygo.NewFory(forygo.WithXlang(true), forygo.WithCompatible(true)) - if err := serializer.RegisterNamedStruct(SomeClass1{}, "example.SomeClass1"); err != nil { + if err := serializer.RegisterStructByName(SomeClass1{}, "example.SomeClass1"); err != nil { panic(err) } - if err := serializer.RegisterNamedStruct(SomeClass2{}, "example.SomeClass2"); err != nil { + if err := serializer.RegisterStructByName(SomeClass2{}, "example.SomeClass2"); err != nil { panic(err) } obj1 := &SomeClass1{F1: true, F2: map[int8]int32{-1: 2}} diff --git a/go/fory/README.md b/go/fory/README.md index 69aa9dc98f..8a7ebafe55 100644 --- a/go/fory/README.md +++ b/go/fory/README.md @@ -103,7 +103,7 @@ Fory Go enables seamless data exchange with Java, Python, C++, Rust, and JavaScr ```go // Go f := fory.New() -f.RegisterNamedStruct(User{}, "example.User") +f.RegisterStructByName(User{}, "example.User") data, _ := f.Serialize(&User{ID: 1, Name: "Alice"}) // 'data' can be deserialized by Java, Python, etc. ``` diff --git a/go/fory/doc.go b/go/fory/doc.go index 84bd9dff32..055483ab1a 100644 --- a/go/fory/doc.go +++ b/go/fory/doc.go @@ -105,7 +105,7 @@ Types must be registered before serialization. Registration can be done by ID f.RegisterStruct(Order{}, 2) // Register by name (more flexible) - f.RegisterNamedStruct(User{}, "example.User") + f.RegisterStructByName(User{}, "example.User") // Register enum types f.RegisterEnum(Status(0), 3) diff --git a/go/fory/enum_test.go b/go/fory/enum_test.go index 3eebfbcd7c..90fa57ddf0 100644 --- a/go/fory/enum_test.go +++ b/go/fory/enum_test.go @@ -76,7 +76,7 @@ func TestEnumReadRejectsMismatchedRegisteredTypeInfo(t *testing.T) { func TestNamedEnumReadConsumesNamedTypeInfo(t *testing.T) { f := NewFory(WithXlang(true), WithCompatible(false)) - require.NoError(t, f.RegisterNamedEnum(namedAuditEnum(0), "example.NamedAuditEnum")) + require.NoError(t, f.RegisterEnumByName(namedAuditEnum(0), "example.NamedAuditEnum")) enumType := reflect.TypeOf(namedAuditEnum(0)) serializer, err := f.typeResolver.getSerializerByType(enumType, false) require.NoError(t, err) diff --git a/go/fory/fory.go b/go/fory/fory.go index c82f1e2625..6b9c48eacc 100644 --- a/go/fory/fory.go +++ b/go/fory/fory.go @@ -287,14 +287,14 @@ func (f *Fory) RegisterUnion(type_ any, typeID uint32, serializer Serializer) er return f.typeResolver.RegisterUnion(t, typeID, serializer) } -// RegisterNamedUnion registers a union type with a namespace + type name for cross-language serialization. +// RegisterUnionByName registers a union type by namespace + type name for cross-language serialization. // type_ can be either a reflect.Type or an instance of the union type. // serializer must implement union payload encoding/decoding. // //go:noinline -func (f *Fory) RegisterNamedUnion(type_ any, typeName string, serializer Serializer) error { +func (f *Fory) RegisterUnionByName(type_ any, typeName string, serializer Serializer) error { if serializer == nil { - return fmt.Errorf("RegisterNamedUnion requires a non-nil serializer") + return fmt.Errorf("RegisterUnionByName requires a non-nil serializer") } var t reflect.Type if rt, ok := type_.(reflect.Type); ok { @@ -306,7 +306,7 @@ func (f *Fory) RegisterNamedUnion(type_ any, typeName string, serializer Seriali } } if t.Kind() != reflect.Struct { - return fmt.Errorf("RegisterNamedUnion only supports struct types; got: %v", t.Kind()) + return fmt.Errorf("RegisterUnionByName only supports struct types; got: %v", t.Kind()) } namespace := "" name := typeName @@ -314,16 +314,16 @@ func (f *Fory) RegisterNamedUnion(type_ any, typeName string, serializer Seriali namespace = typeName[:lastDot] name = typeName[lastDot+1:] } - return f.typeResolver.RegisterNamedUnion(t, namespace, name, serializer) + return f.typeResolver.RegisterUnionByName(t, namespace, name, serializer) } -// RegisterNamedStruct registers a named struct type for cross-language serialization -// type_ can be either a reflect.Type or an instance of the type -// typeName can include a namespace prefix separated by "." (e.g., "example.Foo") -// Note: For enum types, use RegisterNamedEnum instead. +// RegisterStructByName registers a struct type by namespace + type name for cross-language serialization. +// type_ can be either a reflect.Type or an instance of the type. +// typeName can include a namespace prefix separated by "." (e.g., "example.Foo"). +// Note: For enum types, use RegisterEnumByName instead. // //go:noinline -func (f *Fory) RegisterNamedStruct(type_ any, typeName string) error { +func (f *Fory) RegisterStructByName(type_ any, typeName string) error { var t reflect.Type if rt, ok := type_.(reflect.Type); ok { t = rt @@ -334,7 +334,7 @@ func (f *Fory) RegisterNamedStruct(type_ any, typeName string) error { } } if t.Kind() != reflect.Struct { - return fmt.Errorf("RegisterNamedStruct only supports struct types; for enum types use RegisterNamedEnum. Got: %v", t.Kind()) + return fmt.Errorf("RegisterStructByName only supports struct types; for enum types use RegisterEnumByName. Got: %v", t.Kind()) } // Split typeName by last "." to extract namespace and type name namespace := "" @@ -343,7 +343,7 @@ func (f *Fory) RegisterNamedStruct(type_ any, typeName string) error { namespace = typeName[:lastDot] name = typeName[lastDot+1:] } - return f.typeResolver.RegisterNamedStruct(t, 0, namespace, name) + return f.typeResolver.RegisterStructByName(t, namespace, name) } // RegisterEnum registers an enum type with a numeric ID for cross-language serialization. @@ -379,13 +379,13 @@ func (f *Fory) RegisterEnum(type_ any, typeID uint32) error { return f.typeResolver.RegisterEnum(t, typeID) } -// RegisterNamedEnum registers an enum type with a name for cross-language serialization. +// RegisterEnumByName registers an enum type by namespace + type name for cross-language serialization. // In Go, enums are typically defined as int-based types (e.g., type Color int32). -// type_ can be either a reflect.Type or an instance of the enum type -// typeName can include a namespace prefix separated by "." (e.g., "example.Color") +// type_ can be either a reflect.Type or an instance of the enum type. +// typeName can include a namespace prefix separated by "." (e.g., "example.Color"). // //go:noinline -func (f *Fory) RegisterNamedEnum(type_ any, typeName string) error { +func (f *Fory) RegisterEnumByName(type_ any, typeName string) error { var t reflect.Type if rt, ok := type_.(reflect.Type); ok { t = rt @@ -402,7 +402,7 @@ func (f *Fory) RegisterNamedEnum(type_ any, typeName string) error { reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: // OK default: - return fmt.Errorf("RegisterNamedEnum only supports numeric types (Go enums); got: %v", t.Kind()) + return fmt.Errorf("RegisterEnumByName only supports numeric types (Go enums); got: %v", t.Kind()) } // Split typeName by last "." to extract namespace and type name @@ -412,7 +412,7 @@ func (f *Fory) RegisterNamedEnum(type_ any, typeName string) error { namespace = typeName[:lastDot] name = typeName[lastDot+1:] } - return f.typeResolver.RegisterNamedEnum(t, namespace, name) + return f.typeResolver.RegisterEnumByName(t, namespace, name) } // RegisterExtension registers a type as an extension type with a numeric ID. @@ -436,7 +436,7 @@ func (f *Fory) RegisterExtension(type_ any, typeID uint32, serializer ExtensionS return f.typeResolver.RegisterExtension(t, typeID, serializer) } -// RegisterNamedExtension registers a type as an extension type (NAMED_EXT) for cross-language serialization. +// RegisterExtensionByName registers an extension type by namespace + type name for cross-language serialization. // Extension types use a custom serializer provided by the user. // This is used for types with custom serializers in cross-language serialization. // @@ -456,10 +456,10 @@ func (f *Fory) RegisterExtension(type_ any, typeID uint32, serializer ExtensionS // } // // // Register with custom serializer -// f.RegisterNamedExtension(MyExt{}, "my_ext", &MyExtSerializer{}) +// f.RegisterExtensionByName(MyExt{}, "my_ext", &MyExtSerializer{}) // //go:noinline -func (f *Fory) RegisterNamedExtension(type_ any, typeName string, serializer ExtensionSerializer) error { +func (f *Fory) RegisterExtensionByName(type_ any, typeName string, serializer ExtensionSerializer) error { var t reflect.Type if rt, ok := type_.(reflect.Type); ok { t = rt @@ -469,7 +469,7 @@ func (f *Fory) RegisterNamedExtension(type_ any, typeName string, serializer Ext t = t.Elem() } } - return f.typeResolver.RegisterNamedExtension(t, "", typeName, serializer) + return f.typeResolver.RegisterExtensionByName(t, "", typeName, serializer) } // Reset clears internal state for reuse diff --git a/go/fory/fory_compatible_test.go b/go/fory/fory_compatible_test.go index 16ccca9cd2..4a78cd5c32 100644 --- a/go/fory/fory_compatible_test.go +++ b/go/fory/fory_compatible_test.go @@ -226,10 +226,10 @@ func TestCompatibleSerializationScenarios(t *testing.T) { } }(), writerSetup: func(f *Fory) error { - return f.RegisterNamedStruct(ComplexObject2{}, "test.ComplexObject2") + return f.RegisterStructByName(ComplexObject2{}, "test.ComplexObject2") }, readerSetup: func(f *Fory) error { - return f.RegisterNamedStruct(ComplexObject2{}, "test.ComplexObject2") + return f.RegisterStructByName(ComplexObject2{}, "test.ComplexObject2") }, assertFunc: func(t *testing.T, input any, output any) { in := input.(ComplexObject1) @@ -403,10 +403,10 @@ func TestCompatibleSerializationScenarios(t *testing.T) { } }(), writerSetup: func(f *Fory) error { - return f.RegisterNamedStruct(SimpleDataClass{}, "SimpleDataClass") + return f.RegisterStructByName(SimpleDataClass{}, "SimpleDataClass") }, readerSetup: func(f *Fory) error { - return f.RegisterNamedStruct(SimpleDataClass{}, "SimpleDataClass") + return f.RegisterStructByName(SimpleDataClass{}, "SimpleDataClass") }, assertFunc: func(t *testing.T, input any, output any) { in := input.(PointerDataClass) @@ -431,10 +431,10 @@ func TestCompatibleSerializationScenarios(t *testing.T) { } }(), writerSetup: func(f *Fory) error { - return f.RegisterNamedStruct(SimpleDataClass{}, "SimpleDataClass") + return f.RegisterStructByName(SimpleDataClass{}, "SimpleDataClass") }, readerSetup: func(f *Fory) error { - return f.RegisterNamedStruct(InconsistentDataClass{}, "SimpleDataClass") + return f.RegisterStructByName(InconsistentDataClass{}, "SimpleDataClass") }, assertFunc: func(t *testing.T, input any, output any) { in := input.(PointerDataClass) @@ -480,13 +480,13 @@ func TestCompatibleSerializationScenarios(t *testing.T) { Inner: SimpleDataClass{Name: "inner", Age: 18, Active: true}, }, writerSetup: func(f *Fory) error { - if err := f.RegisterNamedStruct(SimpleDataClass{}, "SimpleDataClass"); err != nil { + if err := f.RegisterStructByName(SimpleDataClass{}, "SimpleDataClass"); err != nil { return err } return nil }, readerSetup: func(f *Fory) error { - if err := f.RegisterNamedStruct(SimpleDataClass{}, "SimpleDataClass"); err != nil { + if err := f.RegisterStructByName(SimpleDataClass{}, "SimpleDataClass"); err != nil { return err } return nil @@ -508,13 +508,13 @@ func TestCompatibleSerializationScenarios(t *testing.T) { Inner: SimpleDataClass{Name: "inner", Age: 18, Active: true}, }, writerSetup: func(f *Fory) error { - if err := f.RegisterNamedStruct(SimpleDataClass{}, "SimpleDataClass"); err != nil { + if err := f.RegisterStructByName(SimpleDataClass{}, "SimpleDataClass"); err != nil { return err } return nil }, readerSetup: func(f *Fory) error { - if err := f.RegisterNamedStruct(InconsistentDataClass{}, "SimpleDataClass"); err != nil { + if err := f.RegisterStructByName(InconsistentDataClass{}, "SimpleDataClass"); err != nil { return err } return nil @@ -667,7 +667,7 @@ func runCompatibilityCase(t *testing.T, tc compatibilityCase) { err := tc.writerSetup(writer) assert.NoError(t, err) } - err := writer.RegisterNamedStruct(tc.writeType, tc.tag) + err := writer.RegisterStructByName(tc.writeType, tc.tag) assert.NoError(t, err) marshalInput := tc.input @@ -687,7 +687,7 @@ func runCompatibilityCase(t *testing.T, tc compatibilityCase) { err = tc.readerSetup(reader) assert.NoError(t, err) } - err = reader.RegisterNamedStruct(tc.readType, tc.tag) + err = reader.RegisterStructByName(tc.readType, tc.tag) assert.NoError(t, err) target := reflect.New(reflect.TypeOf(tc.readType)) diff --git a/go/fory/fory_test.go b/go/fory/fory_test.go index f50bde7914..e1e5f938dc 100644 --- a/go/fory/fory_test.go +++ b/go/fory/fory_test.go @@ -273,7 +273,7 @@ func TestSerializeStructSimple(t *testing.T) { type A struct { F1 []string } - require.Nil(t, fory.RegisterNamedStruct(A{}, "example.A")) + require.Nil(t, fory.RegisterStructByName(A{}, "example.A")) serde(t, fory, A{}) serde(t, fory, &A{}) serde(t, fory, A{F1: []string{"str1", "", "str2"}}) @@ -283,7 +283,7 @@ func TestSerializeStructSimple(t *testing.T) { F1 []string F2 map[string]int32 } - require.Nil(t, fory.RegisterNamedStruct(SimpleB{}, "example.SimpleB")) + require.Nil(t, fory.RegisterStructByName(SimpleB{}, "example.SimpleB")) serde(t, fory, SimpleB{}) serde(t, fory, SimpleB{ F1: []string{"str1", "", "str2"}, @@ -300,7 +300,7 @@ func TestRegisterById(t *testing.T) { type simple struct { Field string } - require.NoError(t, fory.RegisterNamedStruct(simple{}, "simple")) + require.NoError(t, fory.RegisterStructByName(simple{}, "simple")) serde(t, fory, simple{Field: "value"}) } @@ -350,7 +350,7 @@ func newFoo() Foo { func TestSerializeStruct(t *testing.T) { for _, referenceTracking := range []bool{false, true} { fory := NewFory(WithXlang(true), WithCompatible(false), WithRefTracking(referenceTracking)) - require.Nil(t, fory.RegisterNamedStruct(Bar{}, "example.Bar")) + require.Nil(t, fory.RegisterStructByName(Bar{}, "example.Bar")) serde(t, fory, &Bar{}) bar := Bar{F1: 1, F2: "str"} serde(t, fory, bar) @@ -360,14 +360,14 @@ func TestSerializeStruct(t *testing.T) { F1 Bar F2 any } - require.Nil(t, fory.RegisterNamedStruct(A{}, "example.A")) + require.Nil(t, fory.RegisterStructByName(A{}, "example.A")) serde(t, fory, A{}) serde(t, fory, &A{}) // Use int64 for any fields since xlang deserializes integers to int64 serde(t, fory, A{F1: Bar{F1: 1, F2: "str"}, F2: int64(-1)}) serde(t, fory, &A{F1: Bar{F1: 1, F2: "str"}, F2: int64(-1)}) - require.Nil(t, fory.RegisterNamedStruct(Foo{}, "example.Foo")) + require.Nil(t, fory.RegisterStructByName(Foo{}, "example.Foo")) foo := newFoo() serde(t, fory, foo) serde(t, fory, &foo) @@ -380,7 +380,7 @@ func TestSerializeCircularReference(t *testing.T) { type A struct { A1 *A } - require.Nil(t, fory.RegisterNamedStruct(A{}, "example.A")) + require.Nil(t, fory.RegisterStructByName(A{}, "example.A")) // If use `A{}` instead of `&A{}` and pass `a` instead of `&a`, there will be serialization data duplication // and can't be deserialized by other languages too. // TODO(chaokunyang) If pass by value(have a copy) and there are some inner value reference, return a readable @@ -400,7 +400,7 @@ func TestSerializeCircularReference(t *testing.T) { F2 *CircularRefB F3 *CircularRefB } - require.Nil(t, fory.RegisterNamedStruct(CircularRefB{}, "example.CircularRefB")) + require.Nil(t, fory.RegisterStructByName(CircularRefB{}, "example.CircularRefB")) b := &CircularRefB{F1: "str"} b.F2 = b b.F3 = b @@ -428,8 +428,8 @@ func TestSerializeComplexReference(t *testing.T) { F3 *A F4 *B } - require.Nil(t, fory.RegisterNamedStruct(A{}, "example.ComplexRefA")) - require.Nil(t, fory.RegisterNamedStruct(B{}, "example.ComplexRefB")) + require.Nil(t, fory.RegisterStructByName(A{}, "example.ComplexRefA")) + require.Nil(t, fory.RegisterStructByName(B{}, "example.ComplexRefB")) a := &A{F1: "str"} a.F2 = a @@ -563,8 +563,8 @@ func serde(t *testing.T, fory *Fory, value any) { func BenchmarkMarshal(b *testing.B) { fory := NewFory(WithXlang(true), WithCompatible(false), WithRefTracking(true)) - require.Nil(b, fory.RegisterNamedStruct(Foo{}, "example.Foo")) - require.Nil(b, fory.RegisterNamedStruct(Bar{}, "example.Bar")) + require.Nil(b, fory.RegisterStructByName(Foo{}, "example.Foo")) + require.Nil(b, fory.RegisterStructByName(Bar{}, "example.Bar")) value := benchData() for i := 0; i < b.N; i++ { _, err := fory.Marshal(value) @@ -576,8 +576,8 @@ func BenchmarkMarshal(b *testing.B) { func BenchmarkUnmarshal(b *testing.B) { fory := NewFory(WithXlang(true), WithCompatible(false), WithRefTracking(true)) - require.Nil(b, fory.RegisterNamedStruct(Foo{}, "example.Foo")) - require.Nil(b, fory.RegisterNamedStruct(Bar{}, "example.Bar")) + require.Nil(b, fory.RegisterStructByName(Foo{}, "example.Foo")) + require.Nil(b, fory.RegisterStructByName(Bar{}, "example.Bar")) value := benchData() data, err := fory.Marshal(value) if err != nil { @@ -695,10 +695,10 @@ func TestStructWithNestedSlice(t *testing.T) { } fory := NewFory(WithXlang(true), WithCompatible(false), WithRefTracking(true)) - if err := fory.RegisterNamedStruct(Example{}, "Example"); err != nil { + if err := fory.RegisterStructByName(Example{}, "Example"); err != nil { panic(err) } - if err := fory.RegisterNamedStruct(Item{}, "Item"); err != nil { + if err := fory.RegisterStructByName(Item{}, "Item"); err != nil { panic(err) } diff --git a/go/fory/fory_typed_test.go b/go/fory/fory_typed_test.go index 127c05c891..e1263772cd 100644 --- a/go/fory/fory_typed_test.go +++ b/go/fory/fory_typed_test.go @@ -180,7 +180,7 @@ func TestSerializeGenericComplex(t *testing.T) { Name string Value int32 } - err := f.RegisterNamedStruct(TestStruct{}, "example.TestStruct") + err := f.RegisterStructByName(TestStruct{}, "example.TestStruct") require.NoError(t, err) original := TestStruct{Name: "test", Value: 100} @@ -249,7 +249,7 @@ func TestSerializeDeserializeRoundTrip(t *testing.T) { ID int64 Name string } - f.RegisterNamedStruct(CustomStruct{}, "test.CustomStruct") + f.RegisterStructByName(CustomStruct{}, "test.CustomStruct") original := CustomStruct{ID: 123, Name: "test"} data, err := Serialize(f, &original) diff --git a/go/fory/ref_resolver_test.go b/go/fory/ref_resolver_test.go index 173043d182..2e5157c2cd 100644 --- a/go/fory/ref_resolver_test.go +++ b/go/fory/ref_resolver_test.go @@ -150,9 +150,9 @@ func TestRefTrackingLargeCount(t *testing.T) { t.Run(tt.name, func(t *testing.T) { f := New(WithXlang(true), WithCompatible(false), WithRefTracking(true)) - err := f.RegisterNamedStruct(&Inner{}, fmt.Sprintf("RefTest_Inner_%d", tt.count)) + err := f.RegisterStructByName(&Inner{}, fmt.Sprintf("RefTest_Inner_%d", tt.count)) require.NoError(t, err) - err = f.RegisterNamedStruct(&Outer{}, fmt.Sprintf("RefTest_Outer_%d", tt.count)) + err = f.RegisterStructByName(&Outer{}, fmt.Sprintf("RefTest_Outer_%d", tt.count)) require.NoError(t, err) original := make([]Outer, tt.count) diff --git a/go/fory/serializer.go b/go/fory/serializer.go index b79088874f..b4af6a4b76 100644 --- a/go/fory/serializer.go +++ b/go/fory/serializer.go @@ -109,7 +109,7 @@ type Serializer interface { // ExtensionSerializer is a simplified interface for user-implemented extension serializers. // Users implement this interface to provide custom serialization logic for types -// registered via RegisterNamedExtension. +// registered via RegisterExtensionByName. // // Unlike the full Serializer interface, ExtensionSerializer only requires implementing // the core data serialization logic - reference tracking, type info, and protocol @@ -130,7 +130,7 @@ type Serializer interface { // } // // // Register with custom serializer -// f.RegisterNamedExtension(MyExt{}, "my_ext", &MyExtSerializer{}) +// f.RegisterExtensionByName(MyExt{}, "my_ext", &MyExtSerializer{}) type ExtensionSerializer interface { // WriteData serializes the value's data to the buffer. // Only write the data fields - don't write ref flags or type info. diff --git a/go/fory/struct_test.go b/go/fory/struct_test.go index fe97316aaf..c98c2f0b40 100644 --- a/go/fory/struct_test.go +++ b/go/fory/struct_test.go @@ -246,12 +246,12 @@ func TestNumericPointerOptionalInterop(t *testing.T) { t.Run("PointerToOptionalNull", func(t *testing.T) { writer := New(WithXlang(true), WithCompatible(true)) - require.NoError(t, writer.RegisterNamedStruct(NumericPtrStruct{}, "NumericInterop")) + require.NoError(t, writer.RegisterStructByName(NumericPtrStruct{}, "NumericInterop")) data, err := writer.Marshal(&NumericPtrStruct{}) require.NoError(t, err) reader := New(WithXlang(true), WithCompatible(true)) - require.NoError(t, reader.RegisterNamedStruct(NumericOptStruct{}, "NumericInterop")) + require.NoError(t, reader.RegisterStructByName(NumericOptStruct{}, "NumericInterop")) var out NumericOptStruct require.NoError(t, reader.Unmarshal(data, &out)) @@ -271,12 +271,12 @@ func TestNumericPointerOptionalInterop(t *testing.T) { t.Run("PointerToOptionalValue", func(t *testing.T) { writer := New(WithXlang(true), WithCompatible(true)) - require.NoError(t, writer.RegisterNamedStruct(NumericPtrStruct{}, "NumericInterop")) + require.NoError(t, writer.RegisterStructByName(NumericPtrStruct{}, "NumericInterop")) data, err := writer.Marshal(&ptrValues) require.NoError(t, err) reader := New(WithXlang(true), WithCompatible(true)) - require.NoError(t, reader.RegisterNamedStruct(NumericOptStruct{}, "NumericInterop")) + require.NoError(t, reader.RegisterStructByName(NumericOptStruct{}, "NumericInterop")) var out NumericOptStruct require.NoError(t, reader.Unmarshal(data, &out)) @@ -285,12 +285,12 @@ func TestNumericPointerOptionalInterop(t *testing.T) { t.Run("OptionalToPointerNull", func(t *testing.T) { writer := New(WithXlang(true), WithCompatible(true)) - require.NoError(t, writer.RegisterNamedStruct(NumericOptStruct{}, "NumericInterop")) + require.NoError(t, writer.RegisterStructByName(NumericOptStruct{}, "NumericInterop")) data, err := writer.Marshal(&NumericOptStruct{}) require.NoError(t, err) reader := New(WithXlang(true), WithCompatible(true)) - require.NoError(t, reader.RegisterNamedStruct(NumericPtrStruct{}, "NumericInterop")) + require.NoError(t, reader.RegisterStructByName(NumericPtrStruct{}, "NumericInterop")) var out NumericPtrStruct require.NoError(t, reader.Unmarshal(data, &out)) @@ -310,12 +310,12 @@ func TestNumericPointerOptionalInterop(t *testing.T) { t.Run("OptionalToPointerValue", func(t *testing.T) { writer := New(WithXlang(true), WithCompatible(true)) - require.NoError(t, writer.RegisterNamedStruct(NumericOptStruct{}, "NumericInterop")) + require.NoError(t, writer.RegisterStructByName(NumericOptStruct{}, "NumericInterop")) data, err := writer.Marshal(&optValues) require.NoError(t, err) reader := New(WithXlang(true), WithCompatible(true)) - require.NoError(t, reader.RegisterNamedStruct(NumericPtrStruct{}, "NumericInterop")) + require.NoError(t, reader.RegisterStructByName(NumericPtrStruct{}, "NumericInterop")) var out NumericPtrStruct require.NoError(t, reader.Unmarshal(data, &out)) diff --git a/go/fory/tests/generator_xlang_test.go b/go/fory/tests/generator_xlang_test.go index 3584f04647..473d4d77eb 100644 --- a/go/fory/tests/generator_xlang_test.go +++ b/go/fory/tests/generator_xlang_test.go @@ -66,7 +66,7 @@ func TestValidationDemoXlang(t *testing.T) { // Reflect mode (register with full name) foryForReflect := forygo.NewFory(forygo.WithRefTracking(true)) - err := foryForReflect.RegisterNamedStruct(ReflectStruct{}, expectedTypeTag) + err := foryForReflect.RegisterStructByName(ReflectStruct{}, expectedTypeTag) require.NoError(t, err, "Should be able to register ReflectStruct with full name") // Serialization test @@ -131,7 +131,7 @@ func TestSliceDemoXlang(t *testing.T) { // Reflect mode - enable reference tracking foryForReflect := forygo.NewFory(forygo.WithRefTracking(true)) - err := foryForReflect.RegisterNamedStruct(ReflectSliceStruct{}, expectedTypeTag) + err := foryForReflect.RegisterStructByName(ReflectSliceStruct{}, expectedTypeTag) require.NoError(t, err, "Should be able to register ReflectSliceStruct with full name") // Serialization test @@ -205,7 +205,7 @@ func TestDynamicSliceDemoXlang(t *testing.T) { // Reflect mode - enable reference tracking foryForReflect := forygo.NewFory(forygo.WithRefTracking(true)) - err := foryForReflect.RegisterNamedStruct(ReflectDynamicStruct{}, expectedTypeTag) + err := foryForReflect.RegisterStructByName(ReflectDynamicStruct{}, expectedTypeTag) require.NoError(t, err, "Should be able to register ReflectDynamicStruct with full name") // Serialization test diff --git a/go/fory/tests/xlang/xlang_test_main.go b/go/fory/tests/xlang/xlang_test_main.go index c6342a9e6b..5dfba1f1a3 100644 --- a/go/fory/tests/xlang/xlang_test_main.go +++ b/go/fory/tests/xlang/xlang_test_main.go @@ -770,9 +770,9 @@ func testNamedSimpleStruct() { f := fory.New(fory.WithXlang(true), fory.WithCompatible(true)) // Use namespace "demo" to match Java's fory.register(Color.class, "demo", "color"), etc. - f.RegisterNamedEnum(Color(0), "demo.color") - f.RegisterNamedStruct(Item{}, "demo.item") - f.RegisterNamedStruct(SimpleStruct{}, "demo.simple_struct") + f.RegisterEnumByName(Color(0), "demo.color") + f.RegisterStructByName(Item{}, "demo.item") + f.RegisterStructByName(SimpleStruct{}, "demo.simple_struct") var obj SimpleStruct if err := f.Deserialize(data, &obj); err != nil { @@ -791,8 +791,8 @@ func testStructEvolvingOverride() { data := readFile(dataFile) f := fory.New(fory.WithXlang(true), fory.WithCompatible(true)) - f.RegisterNamedStruct(EvolvingOverrideStruct{}, "test.evolving_yes") - f.RegisterNamedStruct(FixedOverrideStruct{}, "test.evolving_off") + f.RegisterStructByName(EvolvingOverrideStruct{}, "test.evolving_yes") + f.RegisterStructByName(FixedOverrideStruct{}, "test.evolving_off") buffer := fory.NewByteBuffer(data) var evolving EvolvingOverrideStruct @@ -1174,8 +1174,8 @@ func testSkipNameCustom() { data := readFile(dataFile) f := fory.New(fory.WithXlang(true), fory.WithCompatible(true)) - f.RegisterNamedExtension(MyExt{}, "my_ext", &MyExtSerializer{}) - f.RegisterNamedStruct(EmptyWrapper{}, "my_wrapper") + f.RegisterExtensionByName(MyExt{}, "my_ext", &MyExtSerializer{}) + f.RegisterStructByName(EmptyWrapper{}, "my_wrapper") var obj EmptyWrapper if err := f.Deserialize(data, &obj); err != nil { @@ -1197,10 +1197,10 @@ func testConsistentNamed() { // Java uses SCHEMA_CONSISTENT mode which doesn't enable metaShare // So Go should NOT expect meta offset field f := fory.New(fory.WithXlang(true), fory.WithCompatible(false)) - f.RegisterNamedEnum(Color(0), "color") - f.RegisterNamedStruct(MyStruct{}, "my_struct") + f.RegisterEnumByName(Color(0), "color") + f.RegisterStructByName(MyStruct{}, "my_struct") // MyExt uses an extension serializer in Java (MyExtSerializer), so register as extension type - f.RegisterNamedExtension(MyExt{}, "my_ext", &MyExtSerializer{}) + f.RegisterExtensionByName(MyExt{}, "my_ext", &MyExtSerializer{}) buf := fory.NewByteBuffer(data) values := make([]any, 9) diff --git a/go/fory/threadsafe/fory.go b/go/fory/threadsafe/fory.go index aea6ca9460..02bf70284b 100644 --- a/go/fory/threadsafe/fory.go +++ b/go/fory/threadsafe/fory.go @@ -90,11 +90,11 @@ func (f *Fory) Deserialize(data []byte, v any) error { return inner.Deserialize(data, v) } -// RegisterNamedStruct registers a named struct type for cross-language serialization -func (f *Fory) RegisterNamedStruct(type_ any, typeName string) error { +// RegisterStructByName registers a struct type by namespace + type name for cross-language serialization. +func (f *Fory) RegisterStructByName(type_ any, typeName string) error { inner := f.acquire() defer f.release(inner) - return inner.RegisterNamedStruct(type_, typeName) + return inner.RegisterStructByName(type_, typeName) } // ============================================================================ diff --git a/go/fory/type_def_test.go b/go/fory/type_def_test.go index ef1627d7bd..09db8d4bee 100644 --- a/go/fory/type_def_test.go +++ b/go/fory/type_def_test.go @@ -111,7 +111,7 @@ func TestTypeDefEncodingDecoding(t *testing.T) { t.Run(tt.name, func(t *testing.T) { fory := NewFory(WithRefTracking(false)) - if err := fory.RegisterNamedStruct(tt.testStruct, tt.tagName); err != nil { + if err := fory.RegisterStructByName(tt.testStruct, tt.tagName); err != nil { t.Fatalf("Failed to register tag type: %v", err) } @@ -132,7 +132,7 @@ func TestTypeDefEncodingDecoding(t *testing.T) { // basic checks assert.True(t, decodedTypeDef.typeId == originalTypeDef.typeId || decodedTypeDef.typeId == -originalTypeDef.typeId, "TypeId mismatch") - assert.Equal(t, originalTypeDef.registerByName, decodedTypeDef.registerByName, "RegisterNamedStruct mismatch") + assert.Equal(t, originalTypeDef.registerByName, decodedTypeDef.registerByName, "RegisterStructByName mismatch") assert.Equal(t, originalTypeDef.compressed, decodedTypeDef.compressed, "Compressed flag mismatch") assert.Equal(t, len(originalTypeDef.fieldDefs), len(decodedTypeDef.fieldDefs), "Field count mismatch") @@ -224,7 +224,7 @@ func TestTypeDefNullableFields(t *testing.T) { fory := NewFory(WithRefTracking(false)) // Register the type - if err := fory.RegisterNamedStruct(Item1{}, "test.Item1"); err != nil { + if err := fory.RegisterStructByName(Item1{}, "test.Item1"); err != nil { t.Fatalf("Failed to register type: %v", err) } @@ -460,7 +460,7 @@ func TestTypeDefRejectsCompressedMetadata(t *testing.T) { func TestReadSharedTypeMetaCapsParsedTypeDefCache(t *testing.T) { fory := NewFory(WithCompatible(true)) - require.NoError(t, fory.RegisterNamedStruct(SimpleStruct{}, "example.SimpleStruct")) + require.NoError(t, fory.RegisterStructByName(SimpleStruct{}, "example.SimpleStruct")) typeDef, err := buildTypeDef(fory, reflect.ValueOf(SimpleStruct{})) require.NoError(t, err) require.NotEmpty(t, typeDef.encoded) @@ -486,7 +486,7 @@ func TestReadSharedTypeMetaCapsParsedTypeDefCache(t *testing.T) { func TestDecodeTypeDefFallbackNamedTypeCacheRespectsCap(t *testing.T) { fory := NewFory(WithCompatible(true)) - require.NoError(t, fory.RegisterNamedStruct(SimpleStruct{}, "example.SimpleStruct")) + require.NoError(t, fory.RegisterStructByName(SimpleStruct{}, "example.SimpleStruct")) typeDef, err := buildTypeDef(fory, reflect.ValueOf(SimpleStruct{})) require.NoError(t, err) require.NotNil(t, typeDef.nsName) diff --git a/go/fory/type_resolver.go b/go/fory/type_resolver.go index 1090871700..cd651aa6e1 100644 --- a/go/fory/type_resolver.go +++ b/go/fory/type_resolver.go @@ -680,8 +680,8 @@ func (r *TypeResolver) RegisterEnum(type_ reflect.Type, userTypeID uint32) error return nil } -// RegisterNamedEnum registers an enum type (numeric type in Go) with a namespace and type name -func (r *TypeResolver) RegisterNamedEnum(type_ reflect.Type, namespace, typeName string) error { +// RegisterEnumByName registers an enum type by namespace and type name. +func (r *TypeResolver) RegisterEnumByName(type_ reflect.Type, namespace, typeName string) error { // Check if already registered if prev, ok := r.typeToSerializers[type_]; ok { return fmt.Errorf("type %s already has a serializer %s registered", type_, prev) @@ -693,7 +693,7 @@ func (r *TypeResolver) RegisterNamedEnum(type_ reflect.Type, namespace, typeName reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: // OK default: - return fmt.Errorf("RegisterNamedEnum only supports numeric types; got: %v", type_.Kind()) + return fmt.Errorf("RegisterEnumByName only supports numeric types; got: %v", type_.Kind()) } // Parse namespace from typeName if not provided @@ -730,19 +730,11 @@ func (r *TypeResolver) RegisterNamedEnum(type_ reflect.Type, namespace, typeName return nil } -func (r *TypeResolver) RegisterNamedStruct( - type_ reflect.Type, - typeId uint32, - namespace string, - typeName string, -) error { +// RegisterStructByName registers a struct type by namespace and type name. +func (r *TypeResolver) RegisterStructByName(type_ reflect.Type, namespace, typeName string) error { if prev, ok := r.typeToSerializers[type_]; ok { return fmt.Errorf("type %s already has a serializer %s registered", type_, prev) } - registerById := (typeId != 0) - if registerById && typeName != "" { - return fmt.Errorf("typename %s and typeId %d cannot be both register", typeName, typeId) - } if namespace == "" { if idx := strings.LastIndex(typeName, "."); idx != -1 { namespace = typeName[:idx] @@ -752,9 +744,6 @@ func (r *TypeResolver) RegisterNamedStruct( if typeName == "" && namespace != "" { return fmt.Errorf("typeName cannot be empty if namespace is provided") } - if typeId > 0 && typeId > maxUserTypeID { - return fmt.Errorf("typeId must be in range [0, 0xfffffffe], got %d", typeId) - } var tag string if namespace == "" { tag = typeName @@ -776,47 +765,36 @@ func (r *TypeResolver) RegisterNamedStruct( r.typeTagToSerializers[tag] = ptrSerializer r.typeToTypeInfo[ptrType] = "*@" + tag r.typeInfoToType["*@"+tag] = ptrType - var internalTypeID TypeId + internalTypeID := r.structTypeID(type_, true) userTypeID := invalidUserTypeID - if typeId == 0 { - internalTypeID = r.structTypeID(type_, true) - } else { - internalTypeID = r.structTypeID(type_, false) - userTypeID = typeId - } - if registerById { - if info, ok := r.userTypeIdToTypeInfo[userTypeID]; ok { - return fmt.Errorf("type %s with id %d has been registered", info.Type, typeId) - } - } - // For named structs, directly register both their value and pointer types with same typeId + // For structs registered by name, directly register both their value and pointer types. _, err := r.registerType(type_, uint32(internalTypeID), userTypeID, namespace, typeName, nil, false) if err != nil { - return fmt.Errorf("failed to register named structs: %w", err) + return fmt.Errorf("failed to register struct by name: %w", err) } _, err = r.registerType(ptrType, uint32(internalTypeID), userTypeID, namespace, typeName, nil, false) if err != nil { - return fmt.Errorf("failed to register named structs: %w", err) + return fmt.Errorf("failed to register struct by name: %w", err) } return nil } -// RegisterNamedUnion registers a union type with a namespace and type name. +// RegisterUnionByName registers a union type by namespace and type name. // Union types always use NAMED_UNION and follow the same meta-share rules as other named types. -func (r *TypeResolver) RegisterNamedUnion( +func (r *TypeResolver) RegisterUnionByName( type_ reflect.Type, namespace string, typeName string, serializer Serializer, ) error { if serializer == nil { - return fmt.Errorf("RegisterNamedUnion requires a non-nil serializer") + return fmt.Errorf("RegisterUnionByName requires a non-nil serializer") } if prev, ok := r.typeToSerializers[type_]; ok { return fmt.Errorf("type %s already has a serializer %s registered", type_, prev) } if type_.Kind() != reflect.Struct { - return fmt.Errorf("RegisterNamedUnion only supports struct types; got: %v", type_.Kind()) + return fmt.Errorf("RegisterUnionByName only supports struct types; got: %v", type_.Kind()) } if namespace == "" { if idx := strings.LastIndex(typeName, "."); idx != -1 { @@ -861,10 +839,10 @@ func (r *TypeResolver) RegisterExt(extId int16, type_ reflect.Type) error { panic("not supported") } -// RegisterNamedExtension registers a type as an extension type (NAMED_EXT). +// RegisterExtensionByName registers an extension type by namespace and type name. // Extension types use a user-provided serializer for custom serialization logic. // This is used for types with custom serializers in cross-language serialization. -func (r *TypeResolver) RegisterNamedExtension( +func (r *TypeResolver) RegisterExtensionByName( type_ reflect.Type, namespace string, typeName string, @@ -1115,7 +1093,7 @@ func (r *TypeResolver) getTypeInfo(value reflect.Value, create bool) (*TypeInfo, // First register the value type elemPkgPath := elemType.PkgPath() elemTypeName := elemType.Name() - if err := r.RegisterNamedStruct(elemType, 0, elemPkgPath, elemTypeName); err != nil { + if err := r.RegisterStructByName(elemType, elemPkgPath, elemTypeName); err != nil { // Might already be registered, that's okay _ = err } @@ -1882,7 +1860,7 @@ func (r *TypeResolver) createSerializer(type_ reflect.Type, mapInStruct bool) (s return nil, fmt.Errorf("cannot auto-register anonymous struct type %s", type_.String()) } // For auto-registered types, use package path as namespace and type name - if err := r.RegisterNamedStruct(type_, 0, pkgPath, typeName); err != nil { + if err := r.RegisterStructByName(type_, pkgPath, typeName); err != nil { return nil, fmt.Errorf("failed to auto-register struct %s: %w", type_.String(), err) } serializer = r.typeToSerializers[type_] diff --git a/go/fory/type_test.go b/go/fory/type_test.go index c7713d03a0..fe47b0fe38 100644 --- a/go/fory/type_test.go +++ b/go/fory/type_test.go @@ -32,8 +32,8 @@ func TestTypeResolver(t *testing.T) { type A struct { F1 string } - require.Nil(t, typeResolver.RegisterNamedStruct(reflect.TypeOf(A{}), 0, "", "example.A")) - require.Error(t, typeResolver.RegisterNamedStruct(reflect.TypeOf(A{}), 0, "", "example.A")) + require.Nil(t, typeResolver.RegisterStructByName(reflect.TypeOf(A{}), "", "example.A")) + require.Error(t, typeResolver.RegisterStructByName(reflect.TypeOf(A{}), "", "example.A")) var tests = []struct { type_ reflect.Type From 5c09043c0ded55fc90ba4d63382d2d3efb57e5d7 Mon Sep 17 00:00:00 2001 From: chaokunyang Date: Sat, 9 May 2026 13:49:43 +0800 Subject: [PATCH 04/12] feat(rust)!: shorten id registration APIs BREAKING CHANGE: Rust ID-based registration now uses register, register_union, and register_serializer instead of the register_by_id variants. --- compiler/fory_compiler/generators/rust.py | 6 +- docs/compiler/generated-code.md | 24 ++-- docs/guide/rust/basic-serialization.md | 6 +- docs/guide/rust/cross-language.md | 6 +- docs/guide/rust/custom-serializers.md | 2 +- docs/guide/rust/index.md | 6 +- docs/guide/rust/polymorphism.md | 12 +- docs/guide/rust/references.md | 4 +- docs/guide/rust/schema-evolution.md | 6 +- docs/guide/rust/troubleshooting.md | 4 +- docs/guide/rust/type-registration.md | 20 +-- rust/README.md | 24 ++-- rust/fory-core/src/fory.rs | 22 +-- rust/fory-core/src/lib.rs | 8 +- rust/fory-core/src/resolver/type_resolver.rs | 8 +- rust/fory-core/src/serializer/trait_object.rs | 4 +- rust/fory-derive/src/lib.rs | 2 +- rust/fory/src/lib.rs | 50 +++---- rust/tests/tests/compatible/test_container.rs | 10 +- rust/tests/tests/compatible/test_struct.rs | 82 +++++------ .../tests/compatible/test_struct_enum.rs | 60 ++++---- rust/tests/tests/test_any.rs | 4 +- rust/tests/tests/test_array.rs | 8 +- rust/tests/tests/test_associated_types.rs | 8 +- rust/tests/tests/test_box.rs | 4 +- rust/tests/tests/test_collection.rs | 4 +- rust/tests/tests/test_complex_struct.rs | 14 +- rust/tests/tests/test_cross_language.rs | 136 +++++++++--------- rust/tests/tests/test_debug.rs | 4 +- rust/tests/tests/test_enum.rs | 21 ++- rust/tests/tests/test_enum_compatible.rs | 40 +++--- rust/tests/tests/test_ext.rs | 2 +- rust/tests/tests/test_field_meta.rs | 67 ++++----- rust/tests/tests/test_fory.rs | 12 +- rust/tests/tests/test_generate_default.rs | 12 +- rust/tests/tests/test_lifecycle_guard.rs | 56 ++++---- rust/tests/tests/test_marker.rs | 9 +- rust/tests/tests/test_max_dyn_depth.rs | 8 +- rust/tests/tests/test_multi_thread.rs | 4 +- rust/tests/tests/test_one_struct.rs | 4 +- rust/tests/tests/test_rc_arc.rs | 2 +- rust/tests/tests/test_rc_arc_trait_object.rs | 34 ++--- rust/tests/tests/test_refcell.rs | 6 +- rust/tests/tests/test_simple_struct.rs | 32 ++--- rust/tests/tests/test_skip_fields.rs | 32 ++--- rust/tests/tests/test_trait_object.rs | 50 +++---- rust/tests/tests/test_tuple.rs | 6 +- rust/tests/tests/test_tuple_compatible.rs | 32 ++--- rust/tests/tests/test_tuple_struct.rs | 54 +++---- rust/tests/tests/test_unsigned.rs | 22 +-- rust/tests/tests/test_weak.rs | 6 +- 51 files changed, 519 insertions(+), 540 deletions(-) diff --git a/compiler/fory_compiler/generators/rust.py b/compiler/fory_compiler/generators/rust.py index dc028ba4e0..167c722efe 100644 --- a/compiler/fory_compiler/generators/rust.py +++ b/compiler/fory_compiler/generators/rust.py @@ -1005,7 +1005,7 @@ def generate_enum_registration( reg_name = self.get_registration_type_name(enum.name, parent_stack) if self.should_register_by_id(enum): - lines.append(f" fory.register_by_id::<{type_name}>({enum.type_id})?;") + lines.append(f" fory.register::<{type_name}>({enum.type_id})?;") else: ns = self.package or "default" lines.append( @@ -1041,7 +1041,7 @@ def generate_message_registration( # Register this message if self.should_register_by_id(message): - lines.append(f" fory.register_by_id::<{type_name}>({message.type_id})?;") + lines.append(f" fory.register::<{type_name}>({message.type_id})?;") else: ns = self.package or "default" lines.append( @@ -1059,7 +1059,7 @@ def generate_union_registration( reg_name = self.get_registration_type_name(union.name, parent_stack) if self.should_register_by_id(union): - lines.append(f" fory.register_union_by_id::<{type_name}>({union.type_id})?;") + lines.append(f" fory.register_union::<{type_name}>({union.type_id})?;") else: ns = self.package or "default" lines.append( diff --git a/docs/compiler/generated-code.md b/docs/compiler/generated-code.md index d3a0d6af16..73746b877f 100644 --- a/docs/compiler/generated-code.md +++ b/docs/compiler/generated-code.md @@ -388,13 +388,13 @@ Generated registration function: ```rust pub fn register_types(fory: &mut Fory) -> Result<(), fory::Error> { - fory.register_union_by_id::(106)?; - fory.register_by_id::(101)?; - fory.register_by_id::(102)?; - fory.register_by_id::(100)?; - fory.register_by_id::(104)?; - fory.register_by_id::(105)?; - fory.register_by_id::(103)?; + fory.register_union::(106)?; + fory.register::(101)?; + fory.register::(102)?; + fory.register::(100)?; + fory.register::(104)?; + fory.register::(105)?; + fory.register::(103)?; Ok(()) } ``` @@ -402,11 +402,11 @@ pub fn register_types(fory: &mut Fory) -> Result<(), fory::Error> { For schemas without explicit `[id=...]`, generated registration uses computed numeric IDs: ```rust -fory.register_by_id::(1124725126)?; -fory.register_union_by_id::(1471345060)?; -fory.register_by_id::(3022445236)?; -fory.register_union_by_id::(1609214087)?; -fory.register_by_id::(2862577837)?; +fory.register::(1124725126)?; +fory.register_union::(1471345060)?; +fory.register::(3022445236)?; +fory.register_union::(1609214087)?; +fory.register::(2862577837)?; ``` If `option enable_auto_type_id = false;` is set: diff --git a/docs/guide/rust/basic-serialization.md b/docs/guide/rust/basic-serialization.md index 83bd590b51..2d2386f5a6 100644 --- a/docs/guide/rust/basic-serialization.md +++ b/docs/guide/rust/basic-serialization.md @@ -55,8 +55,8 @@ struct Address { } let mut fory = Fory::default(); -fory.register_by_id::
(100); -fory.register_by_id::(200); +fory.register::
(100); +fory.register::(200); let person = Person { name: "John Doe".to_string(), @@ -137,7 +137,7 @@ assert_eq!(person, decoded); use fory::{Fory, Reader}; let mut fory = Fory::default(); -fory.register_by_id::(1)?; +fory.register::(1)?; let obj = MyStruct { /* ... */ }; diff --git a/docs/guide/rust/cross-language.md b/docs/guide/rust/cross-language.md index 83065d2137..4223276a28 100644 --- a/docs/guide/rust/cross-language.md +++ b/docs/guide/rust/cross-language.md @@ -32,7 +32,7 @@ let mut fory = Fory::builder() .xlang(true).build(); // Register types with consistent IDs across languages -fory.register_by_id::(100); +fory.register::(100); // Or use name-based registration fory.register_by_name::("com.example", "MyStruct"); @@ -49,7 +49,7 @@ let mut fory = Fory::builder() .compatible(true) .xlang(true).build(); -fory.register_by_id::(100); // Same ID in Java, Python, etc. +fory.register::(100); // Same ID in Java, Python, etc. ``` ### Register by Name @@ -78,7 +78,7 @@ let mut fory = Fory::builder() .compatible(true) .xlang(true).build(); -fory.register_by_id::(100); +fory.register::(100); let person = Person { name: "Alice".to_string(), diff --git a/docs/guide/rust/custom-serializers.md b/docs/guide/rust/custom-serializers.md index 06e2b962bb..508e37e570 100644 --- a/docs/guide/rust/custom-serializers.md +++ b/docs/guide/rust/custom-serializers.md @@ -80,7 +80,7 @@ impl ForyDefault for CustomType { ```rust let mut fory = Fory::default(); -fory.register_serializer_by_id::(100); +fory.register_serializer::(100); let custom = CustomType { value: 42, diff --git a/docs/guide/rust/index.md b/docs/guide/rust/index.md index bf54dce2e4..3b32eac6dd 100644 --- a/docs/guide/rust/index.md +++ b/docs/guide/rust/index.md @@ -65,7 +65,7 @@ struct User { fn main() -> Result<(), Error> { let mut fory = Fory::default(); - fory.register_by_id::(1)?; + fory.register::(1)?; let user = User { name: "Alice".to_string(), @@ -107,7 +107,7 @@ struct Item { fn main() -> Result<(), Error> { let mut fory = Fory::default(); - fory.register_by_id::(1000)?; + fory.register::(1000)?; let fory = Arc::new(fory); let handles: Vec<_> = (0..8) @@ -130,7 +130,7 @@ fn main() -> Result<(), Error> { } ``` -**Tip:** Perform registrations (such as `fory.register_by_id::(id)`) before spawning threads so every worker sees the same metadata. Once configured, wrapping the instance in `Arc` is enough to fan out serialization and deserialization tasks safely. +**Tip:** Perform registrations (such as `fory.register::(id)`) before spawning threads so every worker sees the same metadata. Once configured, wrapping the instance in `Arc` is enough to fan out serialization and deserialization tasks safely. ## Architecture diff --git a/docs/guide/rust/polymorphism.md b/docs/guide/rust/polymorphism.md index e40f5b1017..f3b7bbbb1b 100644 --- a/docs/guide/rust/polymorphism.md +++ b/docs/guide/rust/polymorphism.md @@ -65,9 +65,9 @@ struct Zoo { } let mut fory = Fory::builder().compatible(true).build(); -fory.register_by_id::(100); -fory.register_by_id::(101); -fory.register_by_id::(102); +fory.register::(100); +fory.register::(101); +fory.register::(102); let zoo = Zoo { star_animal: Box::new(Dog { @@ -154,9 +154,9 @@ struct AnimalShelter { } let mut fory = Fory::builder().compatible(true).build(); -fory.register_by_id::(100); -fory.register_by_id::(101); -fory.register_by_id::(102); +fory.register::(100); +fory.register::(101); +fory.register::(102); let shelter = AnimalShelter { animals_rc: vec![ diff --git a/docs/guide/rust/references.md b/docs/guide/rust/references.md index 667ac5d6c2..f18d11cd17 100644 --- a/docs/guide/rust/references.md +++ b/docs/guide/rust/references.md @@ -103,7 +103,7 @@ struct Node { } let mut fory = Fory::default(); -fory.register_by_id::(2000); +fory.register::(2000); // Build a parent-child tree let parent = Rc::new(RefCell::new(Node { @@ -155,7 +155,7 @@ struct Node { } let mut fory = Fory::default(); -fory.register_by_id::(6000); +fory.register::(6000); let parent = Arc::new(Mutex::new(Node { val: 10, diff --git a/docs/guide/rust/schema-evolution.md b/docs/guide/rust/schema-evolution.md index 5fad31f30f..e6dbfced1d 100644 --- a/docs/guide/rust/schema-evolution.md +++ b/docs/guide/rust/schema-evolution.md @@ -48,10 +48,10 @@ struct PersonV2 { } let mut fory1 = Fory::builder().compatible(true).build(); -fory1.register_by_id::(1); +fory1.register::(1); let mut fory2 = Fory::builder().compatible(true).build(); -fory2.register_by_id::(1); +fory2.register::(1); let person_v1 = PersonV1 { name: "Alice".to_string(), @@ -121,7 +121,7 @@ enum Value { } let mut fory = Fory::default(); -fory.register_by_id::(1)?; +fory.register::(1)?; let value = Value::Object { name: "score".to_string(), value: 100 }; let bytes = fory.serialize(&value)?; diff --git a/docs/guide/rust/troubleshooting.md b/docs/guide/rust/troubleshooting.md index c12d828d79..90afa1369c 100644 --- a/docs/guide/rust/troubleshooting.md +++ b/docs/guide/rust/troubleshooting.md @@ -33,12 +33,12 @@ This page covers common issues and debugging techniques for Apache Fory™ Rust. ```rust let mut fory = Fory::default(); -fory.register_by_id::(100)?; // Register before use +fory.register::(100)?; // Register before use ``` Confirm that: -- Every serializable struct or trait implementation calls `fory.register_by_id::(type_id)` +- Every serializable struct or trait implementation calls `fory.register::(type_id)` - The same IDs are reused on the deserialize side ### Type Mismatch Errors diff --git a/docs/guide/rust/type-registration.md b/docs/guide/rust/type-registration.md index ddf1690e4c..0eedec6476 100644 --- a/docs/guide/rust/type-registration.md +++ b/docs/guide/rust/type-registration.md @@ -36,7 +36,7 @@ struct User { } let mut fory = Fory::default(); -fory.register_by_id::(1)?; +fory.register::(1)?; let user = User { name: "Alice".to_string(), @@ -66,7 +66,7 @@ For types that need custom serialization logic: ```rust let mut fory = Fory::default(); -fory.register_serializer_by_id::(100)?; +fory.register_serializer::(100)?; ``` ## Registration Consistency @@ -76,15 +76,15 @@ Rust registration APIs use explicit IDs or explicit namespace/type names. Keep t ```rust // Serializer side let mut fory = Fory::default(); -fory.register_by_id::(1)?; -fory.register_by_id::(2)?; -fory.register_by_id::(3)?; +fory.register::(1)?; +fory.register::(2)?; +fory.register::(3)?; // Deserializer side - MUST use the same ID mapping let mut fory = Fory::default(); -fory.register_by_id::(1)?; -fory.register_by_id::(2)?; -fory.register_by_id::(3)?; +fory.register::(1)?; +fory.register::(2)?; +fory.register::(3)?; ``` ## Thread-Safe Registration @@ -96,8 +96,8 @@ use std::sync::Arc; use std::thread; let mut fory = Fory::default(); -fory.register_by_id::(1)?; -fory.register_by_id::(2)?; +fory.register::(1)?; +fory.register::(2)?; // Now share across threads let fory = Arc::new(fory); diff --git a/rust/README.md b/rust/README.md index 8223db45bf..7714e22a24 100644 --- a/rust/README.md +++ b/rust/README.md @@ -51,7 +51,7 @@ struct User { fn main() -> Result<(), Error> { let mut fory = Fory::default(); - fory.register_by_id::(1)?; + fory.register::(1)?; let user = User { name: "Alice".to_string(), @@ -112,8 +112,8 @@ struct Address { } let mut fory = Fory::default(); -fory.register_by_id::
(100); -fory.register_by_id::(200); +fory.register::
(100); +fory.register::(200); let person = Person { name: "John Doe".to_string(), @@ -197,7 +197,7 @@ struct Node { } let mut fory = Fory::default(); -fory.register_by_id::(2000); +fory.register::(2000); // Build a parent-child tree let parent = Rc::new(RefCell::new(Node { @@ -282,9 +282,9 @@ struct Zoo { } let mut fory = Fory::builder().compatible(true).build(); -fory.register_by_id::(100); -fory.register_by_id::(101); -fory.register_by_id::(102); +fory.register::(100); +fory.register::(101); +fory.register::(102); let zoo = Zoo { star_animal: Box::new(Dog { @@ -341,10 +341,10 @@ struct PersonV2 { } let mut fory1 = Fory::builder().compatible(true).build(); -fory1.register_by_id::(1); +fory1.register::(1); let mut fory2 = Fory::builder().compatible(true).build(); -fory2.register_by_id::(1); +fory2.register::(1); let person_v1 = PersonV1 { name: "Alice".to_string(), @@ -393,7 +393,7 @@ enum Value { } let mut fory = Fory::default(); -fory.register_by_id::(1)?; +fory.register::(1)?; let value = Value::Object { name: "score".to_string(), value: 100 }; let bytes = fory.serialize(&value)?; @@ -496,7 +496,7 @@ impl ForyDefault for CustomType { } let mut fory = Fory::default(); -fory.register_serializer_by_id::(100); +fory.register_serializer::(100); let custom = CustomType { value: 42, @@ -607,7 +607,7 @@ let mut fory = Fory::builder() .xlang(true).build(); // Register types with consistent IDs across languages -fory.register_by_id::(100); +fory.register::(100); // Or use name-based registration fory.register_by_name::("com.example", "MyStruct"); diff --git a/rust/fory-core/src/fory.rs b/rust/fory-core/src/fory.rs index 2f6f952104..6ff698d59a 100644 --- a/rust/fory-core/src/fory.rs +++ b/rust/fory-core/src/fory.rs @@ -806,25 +806,25 @@ impl Fory { /// struct User { name: String, age: u32 } /// /// let mut fory = Fory::default(); - /// fory.register_by_id::(100); + /// fory.register::(100); /// ``` - pub fn register_by_id( + pub fn register( &mut self, id: u32, ) -> Result<(), Error> { self.check_registration_allowed()?; - self.type_resolver.register_by_id::(id) + self.type_resolver.register::(id) } /// Register a union type with a numeric type ID. /// /// This is intended for union-compatible enums generated by the compiler. - pub fn register_union_by_id( + pub fn register_union( &mut self, id: u32, ) -> Result<(), Error> { self.check_registration_allowed()?; - self.type_resolver.register_union_by_id::(id) + self.type_resolver.register_union::(id) } /// Registers a struct type with a namespace and type name for cross-language serialization. @@ -885,7 +885,7 @@ impl Fory { /// # Type Parameters /// /// * `T` - The type to register. Must implement `Serializer` and `ForyDefault`. - /// Unlike `register_by_id()`, this does not require `StructSerializer`, making it suitable + /// Unlike `register()`, this does not require `StructSerializer`, making it suitable /// for non-struct types or types with custom serialization logic. /// /// # Arguments @@ -905,14 +905,14 @@ impl Fory { /// use fory_core::Fory; /// /// let mut fory = Fory::default(); - /// fory.register_serializer_by_id::(200); + /// fory.register_serializer::(200); /// ``` - pub fn register_serializer_by_id( + pub fn register_serializer( &mut self, id: u32, ) -> Result<(), Error> { self.check_registration_allowed()?; - self.type_resolver.register_serializer_by_id::(id) + self.type_resolver.register_serializer::(id) } /// Registers a custom serializer type with a namespace and type name. @@ -928,7 +928,7 @@ impl Fory { /// /// # Notes /// - /// This is the named equivalent of `register_serializer_by_id()`, preferred for + /// This is the named equivalent of `register_serializer()`, preferred for /// cross-language serialization scenarios. /// pub fn register_serializer_by_name( @@ -943,7 +943,7 @@ impl Fory { /// Registers a generic trait object type for serialization. /// This method should be used to register collection types such as `Vec`, `HashMap`, etc. - /// Don't register concrete struct types with this method. Use `register_by_id()` instead. + /// Don't register concrete struct types with this method. Use `register()` instead. pub fn register_generic_trait( &mut self, ) -> Result<(), Error> { diff --git a/rust/fory-core/src/lib.rs b/rust/fory-core/src/lib.rs index bac59ebb25..4d1ac219b5 100644 --- a/rust/fory-core/src/lib.rs +++ b/rust/fory-core/src/lib.rs @@ -102,9 +102,9 @@ //! //! # fn main() { //! let mut fory = Fory::builder().compatible(true).build(); -//! fory.register_by_id::(100); -//! fory.register_by_id::(101); -//! fory.register_by_id::(102); +//! fory.register::(100); +//! fory.register::(101); +//! fory.register::(102); //! //! let zoo = Zoo { //! star_animal: Box::new(Dog { name: "Buddy".to_string() }), @@ -171,7 +171,7 @@ //! let deserialized_map: HashMap = fory.deserialize(&serialized_map).unwrap(); //! assert_eq!(map, deserialized_map); //! // Register types for object serialization -//! // fory.register_by_id::(type_id); +//! // fory.register::(type_id); //! //! // Use row-based serialization for zero-copy operations //! // let row_data = to_row(&my_data); diff --git a/rust/fory-core/src/resolver/type_resolver.rs b/rust/fory-core/src/resolver/type_resolver.rs index 73ab88fe7b..3fcacda798 100644 --- a/rust/fory-core/src/resolver/type_resolver.rs +++ b/rust/fory-core/src/resolver/type_resolver.rs @@ -809,20 +809,20 @@ impl TypeResolver { Ok(()) } - pub fn register_by_id( + pub fn register( &mut self, id: u32, ) -> Result<(), Error> { self.register_struct_type::(id, &EMPTY_STRING, &EMPTY_STRING, true) } - pub fn register_union_by_id( + pub fn register_union( &mut self, id: u32, ) -> Result<(), Error> { if T::fory_static_type_id() != TypeId::UNION { return Err(Error::not_allowed( - "register_union_by_id requires a union-compatible enum type", + "register_union requires a union-compatible enum type", )); } self.register_struct_type::(id, &EMPTY_STRING, &EMPTY_STRING, true) @@ -1035,7 +1035,7 @@ impl TypeResolver { Ok(()) } - pub fn register_serializer_by_id( + pub fn register_serializer( &mut self, id: u32, ) -> Result<(), Error> { diff --git a/rust/fory-core/src/serializer/trait_object.rs b/rust/fory-core/src/serializer/trait_object.rs index 1757217761..bcba476752 100644 --- a/rust/fory-core/src/serializer/trait_object.rs +++ b/rust/fory-core/src/serializer/trait_object.rs @@ -91,8 +91,8 @@ macro_rules! downcast_and_serialize { /// /// # fn main() { /// let mut fory = Fory::builder().compatible(true).build(); -/// fory.register_by_id::(100); -/// fory.register_by_id::(101); +/// fory.register::(100); +/// fory.register::(101); /// /// let dog: Box = Box::new(Dog { name: "Rex".to_string() }); /// let bytes = fory.serialize(&dog); diff --git a/rust/fory-derive/src/lib.rs b/rust/fory-derive/src/lib.rs index f7db564177..f8a726ef19 100644 --- a/rust/fory-derive/src/lib.rs +++ b/rust/fory-derive/src/lib.rs @@ -156,7 +156,7 @@ //! //! fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register_by_id::(100); +//! fory.register::(100); //! //! let data = MyData { //! value: 42, diff --git a/rust/fory/src/lib.rs b/rust/fory/src/lib.rs index 1afad5a1d4..af9e019fd0 100644 --- a/rust/fory/src/lib.rs +++ b/rust/fory/src/lib.rs @@ -68,7 +68,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register_by_id::(1)?; +//! fory.register::(1)?; //! //! let user = User { //! name: "Alice".to_string(), @@ -140,8 +140,8 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register_by_id::
(100); -//! fory.register_by_id::(200); +//! fory.register::
(100); +//! fory.register::(200); //! //! let person = Person { //! name: "John Doe".to_string(), @@ -252,7 +252,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::builder().track_ref(true).build(); -//! fory.register_by_id::(2000); +//! fory.register::(2000); //! //! let parent = Rc::new(RefCell::new(Node { //! value: 1, @@ -294,7 +294,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::builder().track_ref(true).build(); -//! fory.register_by_id::(6000); +//! fory.register::(6000); //! //! let parent = Arc::new(Mutex::new(Node { //! val: 10, @@ -375,9 +375,9 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::builder().compatible(true).build(); -//! fory.register_by_id::(100); -//! fory.register_by_id::(101); -//! fory.register_by_id::(102); +//! fory.register::(100); +//! fory.register::(101); +//! fory.register::(102); //! //! let zoo = Zoo { //! star_animal: Box::new(Dog { @@ -421,7 +421,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register_by_id::(100); +//! fory.register::(100); //! //! let dog: Rc = Rc::new(Dog { //! name: "Rex".to_string() @@ -450,7 +450,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register_by_id::(101); +//! fory.register::(101); //! //! let cat: Arc = Arc::new(Cat { //! name: "Whiskers".to_string() @@ -502,9 +502,9 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::builder().compatible(true).build(); -//! fory.register_by_id::(100); -//! fory.register_by_id::(101); -//! fory.register_by_id::(102); +//! fory.register::(100); +//! fory.register::(101); +//! fory.register::(102); //! //! let shelter = AnimalShelter { //! animals_rc: vec![ @@ -556,7 +556,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::builder().compatible(true).build(); -//! fory.register_by_id::(100); +//! fory.register::(100); //! //! // For Rc //! let dog_rc: Rc = Rc::new(Dog { name: "Rex".to_string() }); @@ -631,10 +631,10 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory1 = Fory::builder().compatible(true).build(); -//! fory1.register_by_id::(1); +//! fory1.register::(1); //! //! let mut fory2 = Fory::builder().compatible(true).build(); -//! fory2.register_by_id::(1); +//! fory2.register::(1); //! //! let person_v1 = PersonV1 { //! name: "Alice".to_string(), @@ -695,7 +695,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register_by_id::(1)?; +//! fory.register::(1)?; //! //! let value = Value::Object { name: "score".to_string(), value: 100 }; //! let bytes = fory.serialize(&value)?; @@ -728,10 +728,10 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory_old = Fory::builder().compatible(true).build(); -//! fory_old.register_by_id::(5)?; +//! fory_old.register::(5)?; //! //! let mut fory_new = Fory::builder().compatible(true).build(); -//! fory_new.register_by_id::(5)?; +//! fory_new.register::(5)?; //! //! // Serialize with old schema (2 fields) //! let old_bytes = fory_old.serialize(&OldEvent::Click { x: 100, y: 200 })?; @@ -856,7 +856,7 @@ //! //! # fn main() -> Result<(), Error> { //! let mut fory = Fory::default(); -//! fory.register_serializer_by_id::(100); +//! fory.register_serializer::(100); //! //! let custom = CustomType { //! value: 42, @@ -1066,7 +1066,7 @@ //! //! **Type registration strategies:** //! -//! - **ID-based registration**: `fory.register_by_id::(id)` - Fastest, requires coordination +//! - **ID-based registration**: `fory.register::(id)` - Fastest, requires coordination //! - **Name-based registration**: `fory.register_by_name::(namespace, name)` - Automatic cross-language mapping //! //! ## Performance Characteristics @@ -1109,7 +1109,7 @@ //! //! fn process_data(bytes: &[u8]) -> Result { //! let mut fory = Fory::default(); -//! fory.register_by_id::(100); +//! fory.register::(100); //! //! let data: Data = fory.deserialize(bytes)?; //! Ok(data) @@ -1135,7 +1135,7 @@ //! } //! //! let mut fory = Fory::default(); -//! fory.register_by_id::(1000).unwrap(); +//! fory.register::(1000).unwrap(); //! let fory = Arc::new(fory); //! let handles: Vec<_> = (0..8) //! .map(|i| { @@ -1154,7 +1154,7 @@ //! } //! ``` //! -//! **Best practice:** Perform type registration (e.g., `fory.register_by_id::(id)`) before +//! **Best practice:** Perform type registration (e.g., `fory.register::(id)`) before //! spawning worker threads so metadata is ready, then share the configured instance. //! //! ## Examples @@ -1170,7 +1170,7 @@ //! //! - **Type registry errors**: Errors such as `TypeId ... not found in type_info registry` mean //! the type was never registered with the active `Fory` instance. Ensure every serializable -//! struct, enum, or trait implementation calls `register_by_id::(type_id)` before use, and reuse +//! struct, enum, or trait implementation calls `register::(type_id)` before use, and reuse //! the same IDs when deserializing. //! - **Quick error lookup**: Always prefer the static constructors on //! [`fory_core::error::Error`]—for example `Error::type_mismatch`, `Error::invalid_data`, or diff --git a/rust/tests/tests/compatible/test_container.rs b/rust/tests/tests/compatible/test_container.rs index d2470da2f0..d9ff1139c3 100644 --- a/rust/tests/tests/compatible/test_container.rs +++ b/rust/tests/tests/compatible/test_container.rs @@ -286,7 +286,7 @@ fn container_outer_auto_conv() { #[test] fn collection_inner() { let mut fory1 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(101).unwrap(); + fory1.register::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).build(); fory2.register_by_name::("", "item").unwrap(); for fory in [fory1, fory2] { @@ -349,7 +349,7 @@ fn collection_inner() { #[test] fn collection_inner_auto_conv() { let mut fory1 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(101).unwrap(); + fory1.register::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).build(); fory2.register_by_name::("", "item").unwrap(); for fory in [fory1, fory2] { @@ -417,7 +417,7 @@ fn collection_inner_auto_conv() { #[test] fn map_inner() { let mut fory1 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(101).unwrap(); + fory1.register::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).build(); fory2.register_by_name::("", "item").unwrap(); for fory in [fory1, fory2] { @@ -454,7 +454,7 @@ fn map_inner() { #[test] fn map_inner_auto_conv() { let mut fory1 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(101).unwrap(); + fory1.register::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).build(); fory2.register_by_name::("", "item").unwrap(); for fory in [fory1, fory2] { @@ -494,7 +494,7 @@ fn map_inner_auto_conv() { #[test] fn complex() { let mut fory1 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(101).unwrap(); + fory1.register::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).build(); fory2.register_by_name::("", "item").unwrap(); for fory in [fory1, fory2] { diff --git a/rust/tests/tests/compatible/test_struct.rs b/rust/tests/tests/compatible/test_struct.rs index ade9df5116..38a7f38560 100644 --- a/rust/tests/tests/compatible/test_struct.rs +++ b/rust/tests/tests/compatible/test_struct.rs @@ -47,8 +47,8 @@ fn simple() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(999).unwrap(); - fory2.register_by_id::(999).unwrap(); + fory1.register::(999).unwrap(); + fory2.register::(999).unwrap(); let animal: Animal1 = Animal1 { f1: HashMap::from([(1, vec![2])]), f2: String::from("hello"), @@ -101,8 +101,8 @@ fn compatible_list_array_field_pairs() { let mut writer = Fory::builder().compatible(true).build(); let mut reader = Fory::builder().compatible(true).build(); - writer.register_by_id::(991).unwrap(); - reader.register_by_id::(991).unwrap(); + writer.register::(991).unwrap(); + reader.register::(991).unwrap(); let bytes = writer .serialize(&ListPayload { payload: vec![1, 2, 3], @@ -113,8 +113,8 @@ fn compatible_list_array_field_pairs() { let mut writer = Fory::builder().compatible(true).build(); let mut reader = Fory::builder().compatible(true).build(); - writer.register_by_id::(992).unwrap(); - reader.register_by_id::(992).unwrap(); + writer.register::(992).unwrap(); + reader.register::(992).unwrap(); let bytes = writer .serialize(&ArrayPayload { payload: vec![1, 2, 3], @@ -125,8 +125,8 @@ fn compatible_list_array_field_pairs() { let mut writer = Fory::builder().compatible(true).build(); let mut reader = Fory::builder().compatible(true).build(); - writer.register_by_id::(993).unwrap(); - reader.register_by_id::(993).unwrap(); + writer.register::(993).unwrap(); + reader.register::(993).unwrap(); let bytes = writer .serialize(&NullableListPayload { payload: vec![Some(1), Some(2), Some(3)], @@ -151,8 +151,8 @@ fn compatible_list_array_field_pairs() { let mut writer = Fory::builder().compatible(true).build(); let mut reader = Fory::builder().compatible(true).build(); - writer.register_by_id::(994).unwrap(); - reader.register_by_id::(994).unwrap(); + writer.register::(994).unwrap(); + reader.register::(994).unwrap(); let bytes = writer .serialize(&NestedListPayload { payload: vec![vec![1, 2], vec![3]], @@ -179,8 +179,8 @@ fn skip_option() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(999).unwrap(); - fory2.register_by_id::(999).unwrap(); + fory1.register::(999).unwrap(); + fory2.register::(999).unwrap(); let item1 = Item1 { f1: None, f2: Some(String::from("f2")), @@ -218,10 +218,10 @@ fn nonexistent_struct() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(899).unwrap(); - fory1.register_by_id::(999).unwrap(); - fory2.register_by_id::(799).unwrap(); - fory2.register_by_id::(999).unwrap(); + fory1.register::(899).unwrap(); + fory1.register::(999).unwrap(); + fory2.register::(799).unwrap(); + fory2.register::(999).unwrap(); let person = Person1 { f2: Item1 { f1: 42 }, f3: 24, @@ -249,7 +249,7 @@ fn option() { last: i64, } let mut fory = Fory::builder().compatible(true).build(); - fory.register_by_id::(999).unwrap(); + fory.register::(999).unwrap(); let animal: Animal = Animal { f1: Some(String::from("f1")), f2: None, @@ -294,8 +294,8 @@ fn nullable() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(999).unwrap(); - fory2.register_by_id::(999).unwrap(); + fory1.register::(999).unwrap(); + fory2.register::(999).unwrap(); let item1 = Item1 { f2: 43, @@ -348,8 +348,8 @@ fn nullable_container() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(999).unwrap(); - fory2.register_by_id::(999).unwrap(); + fory1.register::(999).unwrap(); + fory2.register::(999).unwrap(); let item1 = Item1 { f1: vec![44, 45], @@ -400,8 +400,8 @@ fn inner_nullable() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(999).unwrap(); - fory2.register_by_id::(999).unwrap(); + fory1.register::(999).unwrap(); + fory2.register::(999).unwrap(); let item1 = Item1 { f1: vec![None, Some("hello".to_string())], @@ -447,10 +447,10 @@ fn nullable_struct() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(199).unwrap(); - fory1.register_by_id::(200).unwrap(); - fory2.register_by_id::(199).unwrap(); - fory2.register_by_id::(200).unwrap(); + fory1.register::(199).unwrap(); + fory1.register::(200).unwrap(); + fory2.register::(199).unwrap(); + fory2.register::(200).unwrap(); let person1 = Person1 { f1: Item { @@ -523,13 +523,13 @@ fn enum_without_payload() { } let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); - fory1.register_by_id::(101).unwrap(); - fory1.register_by_id::(102).unwrap(); - fory1.register_by_id::(103).unwrap(); + fory1.register::(101).unwrap(); + fory1.register::(102).unwrap(); + fory1.register::(103).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); - fory2.register_by_id::(101).unwrap(); - fory2.register_by_id::(102).unwrap(); - fory2.register_by_id::(103).unwrap(); + fory2.register::(101).unwrap(); + fory2.register::(102).unwrap(); + fory2.register::(103).unwrap(); let person1 = Person1 { f1: Color1::Blue, @@ -590,10 +590,10 @@ fn named_enum() { } let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); fory1.register_by_name::("", "a").unwrap(); - fory1.register_by_id::(101).unwrap(); + fory1.register::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); fory2.register_by_name::("", "a").unwrap(); - fory2.register_by_id::(101).unwrap(); + fory2.register::(101).unwrap(); let item1 = Item1 { f1: Color::Red, f2: Color::Blue, @@ -645,9 +645,9 @@ fn boxed() { } let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); - fory1.register_by_id::(101).unwrap(); + fory1.register::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); - fory2.register_by_id::(101).unwrap(); + fory2.register::(101).unwrap(); let f1 = 1; let f2 = 2; @@ -765,10 +765,10 @@ fn test_struct_with_generic() { let mut fory3 = Fory::builder().xlang(true).compatible(false).build(); fn inner_test(fory: &mut Fory) -> Result<(), Error> { - fory.register_by_id::(1)?; - fory.register_by_id::(2)?; - fory.register_serializer_by_id::>(3)?; - fory.register_serializer_by_id::>(4)?; + fory.register::(1)?; + fory.register::(2)?; + fory.register_serializer::>(3)?; + fory.register_serializer::>(4)?; let w1 = Wrapper:: { value: "Value1".into(), diff --git a/rust/tests/tests/compatible/test_struct_enum.rs b/rust/tests/tests/compatible/test_struct_enum.rs index 60dc4611d7..36b75d7fef 100644 --- a/rust/tests/tests/compatible/test_struct_enum.rs +++ b/rust/tests/tests/compatible/test_struct_enum.rs @@ -46,8 +46,8 @@ fn simple() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(999).unwrap(); - fory2.register_by_id::(999).unwrap(); + fory1.register::(999).unwrap(); + fory2.register::(999).unwrap(); let animal: Animal1 = Animal1 { f1: HashMap::from([(1, vec![2])]), f2: String::from("hello"), @@ -82,7 +82,7 @@ fn simple_write_continuous() { } let mut fory = Fory::builder().compatible(true).build(); - fory.register_by_id::(999).unwrap(); + fory.register::(999).unwrap(); let animal: Animal1 = Animal1 { f1: HashMap::from([(1, vec![2])]), f2: String::from("hello"), @@ -130,8 +130,8 @@ fn skip_option() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(999).unwrap(); - fory2.register_by_id::(999).unwrap(); + fory1.register::(999).unwrap(); + fory2.register::(999).unwrap(); let item1 = Item1 { f1: None, f2: Some(String::from("f2")), @@ -169,10 +169,10 @@ fn nonexistent_struct() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(899).unwrap(); - fory1.register_by_id::(999).unwrap(); - fory2.register_by_id::(799).unwrap(); - fory2.register_by_id::(999).unwrap(); + fory1.register::(899).unwrap(); + fory1.register::(999).unwrap(); + fory2.register::(799).unwrap(); + fory2.register::(999).unwrap(); let person = Person1 { f2: Item1 { f1: 42 }, f3: 24, @@ -200,7 +200,7 @@ fn option() { last: i64, } let mut fory = Fory::builder().compatible(true).build(); - fory.register_by_id::(999).unwrap(); + fory.register::(999).unwrap(); let animal: Animal = Animal { f1: Some(String::from("f1")), f2: None, @@ -245,8 +245,8 @@ fn nullable() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(999).unwrap(); - fory2.register_by_id::(999).unwrap(); + fory1.register::(999).unwrap(); + fory2.register::(999).unwrap(); let item1 = Item1 { f2: 43, @@ -299,8 +299,8 @@ fn nullable_container() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(999).unwrap(); - fory2.register_by_id::(999).unwrap(); + fory1.register::(999).unwrap(); + fory2.register::(999).unwrap(); let item1 = Item1 { f1: vec![44, 45], @@ -351,8 +351,8 @@ fn inner_nullable() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(999).unwrap(); - fory2.register_by_id::(999).unwrap(); + fory1.register::(999).unwrap(); + fory2.register::(999).unwrap(); let item1 = Item1 { f1: vec![None, Some("hello".to_string())], @@ -398,10 +398,10 @@ fn nullable_struct() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(199).unwrap(); - fory1.register_by_id::(200).unwrap(); - fory2.register_by_id::(199).unwrap(); - fory2.register_by_id::(200).unwrap(); + fory1.register::(199).unwrap(); + fory1.register::(200).unwrap(); + fory2.register::(199).unwrap(); + fory2.register::(200).unwrap(); let person1 = Person1 { f1: Item { @@ -474,13 +474,13 @@ fn enum_without_payload() { } let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); - fory1.register_by_id::(101).unwrap(); - fory1.register_by_id::(102).unwrap(); - fory1.register_by_id::(103).unwrap(); + fory1.register::(101).unwrap(); + fory1.register::(102).unwrap(); + fory1.register::(103).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); - fory2.register_by_id::(101).unwrap(); - fory2.register_by_id::(102).unwrap(); - fory2.register_by_id::(103).unwrap(); + fory2.register::(101).unwrap(); + fory2.register::(102).unwrap(); + fory2.register::(103).unwrap(); let person1 = Person1 { f1: Color1::Blue, @@ -541,10 +541,10 @@ fn named_enum() { } let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); fory1.register_by_name::("", "a").unwrap(); - fory1.register_by_id::(101).unwrap(); + fory1.register::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); fory2.register_by_name::("", "a").unwrap(); - fory2.register_by_id::(101).unwrap(); + fory2.register::(101).unwrap(); let item1 = Item1 { f1: Color::Red, f2: Color::Blue, @@ -596,9 +596,9 @@ fn boxed() { } let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); - fory1.register_by_id::(101).unwrap(); + fory1.register::(101).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); - fory2.register_by_id::(101).unwrap(); + fory2.register::(101).unwrap(); let f1 = 1; let f2 = 2; diff --git a/rust/tests/tests/test_any.rs b/rust/tests/tests/test_any.rs index 9f984a851a..ecca768fcb 100644 --- a/rust/tests/tests/test_any.rs +++ b/rust/tests/tests/test_any.rs @@ -222,10 +222,10 @@ struct AnyMapFixedKey { #[test] fn test_hashmap_fixed_key_rc_any_field_compatible() { let mut writer = Fory::builder().compatible(true).build(); - writer.register_by_id::(700).unwrap(); + writer.register::(700).unwrap(); let mut reader = Fory::builder().compatible(true).build(); - reader.register_by_id::(700).unwrap(); + reader.register::(700).unwrap(); let original = AnyMapFixedKey { values: HashMap::from([ diff --git a/rust/tests/tests/test_array.rs b/rust/tests/tests/test_array.rs index 5e89765840..fb2e55e2bb 100644 --- a/rust/tests/tests/test_array.rs +++ b/rust/tests/tests/test_array.rs @@ -257,8 +257,8 @@ register_trait_type!(Shape, Circle, Rectangle); #[test] fn test_array_box_trait_objects() { let mut fory = Fory::builder().compatible(true).build(); - fory.register_by_id::(9001).unwrap(); - fory.register_by_id::(9002).unwrap(); + fory.register::(9001).unwrap(); + fory.register::(9002).unwrap(); // Create an array of Box let shapes: [Box; 3] = [ @@ -336,8 +336,8 @@ fn test_struct_with_vec_of_arrays() { #[test] fn test_array_rc_trait_objects() { let mut fory = Fory::builder().compatible(true).build(); - fory.register_by_id::(9001).unwrap(); - fory.register_by_id::(9002).unwrap(); + fory.register::(9001).unwrap(); + fory.register::(9002).unwrap(); // Create Rc instances and convert to wrappers let circle1: Rc = Rc::new(Circle { radius: 2.0 }); diff --git a/rust/tests/tests/test_associated_types.rs b/rust/tests/tests/test_associated_types.rs index 1aea0b3a8c..ef787baece 100644 --- a/rust/tests/tests/test_associated_types.rs +++ b/rust/tests/tests/test_associated_types.rs @@ -68,7 +68,7 @@ where #[test] fn test_leader_id_with_associated_types() { let mut fory = Fory::default(); - fory.register_by_id::>(100).unwrap(); + fory.register::>(100).unwrap(); let leader_id: LeaderId = LeaderId { term: 1, @@ -84,7 +84,7 @@ fn test_leader_id_with_associated_types() { #[test] fn test_leader_id_default_values() { let mut fory = Fory::default(); - fory.register_by_id::>(100).unwrap(); + fory.register::>(100).unwrap(); let leader_id: LeaderId = LeaderId { term: 0, @@ -100,7 +100,7 @@ fn test_leader_id_default_values() { #[test] fn test_vec_of_leader_ids() { let mut fory = Fory::default(); - fory.register_by_id::>(100).unwrap(); + fory.register::>(100).unwrap(); let leader_ids: Vec> = vec![ LeaderId { @@ -126,7 +126,7 @@ fn test_vec_of_leader_ids() { #[test] fn test_option_leader_id() { let mut fory = Fory::default(); - fory.register_by_id::>(100).unwrap(); + fory.register::>(100).unwrap(); // Test with Some value let some_leader: Option> = Some(LeaderId { diff --git a/rust/tests/tests/test_box.rs b/rust/tests/tests/test_box.rs index 76a3314001..66dba99db0 100644 --- a/rust/tests/tests/test_box.rs +++ b/rust/tests/tests/test_box.rs @@ -53,7 +53,7 @@ fn test_box_struct() { } let mut fory = Fory::default(); - fory.register_by_id::(999).unwrap(); + fory.register::(999).unwrap(); let person = Person { name: "John Doe".to_string(), @@ -76,7 +76,7 @@ fn test_box_struct_separate() { } let mut fory = Fory::default(); - fory.register_by_id::(999).unwrap(); + fory.register::(999).unwrap(); // Test serializing the Box directly, not as a field let person = Person { diff --git a/rust/tests/tests/test_collection.rs b/rust/tests/tests/test_collection.rs index 6f6fbdac50..b883d9202c 100644 --- a/rust/tests/tests/test_collection.rs +++ b/rust/tests/tests/test_collection.rs @@ -65,7 +65,7 @@ struct SetContainer { #[test] fn test_set_container() { let mut fory: Fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let mut btree = BTreeSet::new(); btree.insert("apple".to_string()); @@ -104,7 +104,7 @@ struct HeapContainer { #[test] fn test_heap_container() { let mut fory: Fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let mut binary_heap = BinaryHeap::new(); binary_heap.push(3); diff --git a/rust/tests/tests/test_complex_struct.rs b/rust/tests/tests/test_complex_struct.rs index 2d943ab92e..55e4a4f68e 100644 --- a/rust/tests/tests/test_complex_struct.rs +++ b/rust/tests/tests/test_complex_struct.rs @@ -41,8 +41,8 @@ use std::collections::HashMap; // }; // // let mut fory = Fory::default(); -// fory.register_by_id::(999); -// fory.register_by_id::(1000); +// fory.register::(999); +// fory.register::(1000); // let bin = fory.serialize(&person); // let obj: Person = fory.deserialize(&bin).expect(""); // assert!(obj.f1.is::()) @@ -58,7 +58,7 @@ fn enum_without_payload() { Blue, } let mut fory = Fory::default(); - fory.register_by_id::(999).unwrap(); + fory.register::(999).unwrap(); let color = Color::Red; let bin = fory.serialize(&color).unwrap(); let color2: Color = fory.deserialize(&bin).expect(""); @@ -109,8 +109,8 @@ fn complex_struct() { c6: 4.0, }; let mut fory = Fory::default(); - fory.register_by_id::(899).unwrap(); - fory.register_by_id::(999).unwrap(); + fory.register::(899).unwrap(); + fory.register::(999).unwrap(); let bin: Vec = fory.serialize(&person).unwrap(); let obj: Person = fory.deserialize(&bin).expect("should success"); assert_eq!(person, obj); @@ -142,8 +142,8 @@ fn encode_to_obin() { f10: HashMap, } let mut fory = Fory::default(); - fory.register_by_id::(999).unwrap(); - fory.register_by_id::(899).unwrap(); + fory.register::(999).unwrap(); + fory.register::(899).unwrap(); let bin: Vec = fory .serialize(&Person { f1: "Hello".to_string(), diff --git a/rust/tests/tests/test_cross_language.rs b/rust/tests/tests/test_cross_language.rs index b26932b71f..fcf5f0d261 100644 --- a/rust/tests/tests/test_cross_language.rs +++ b/rust/tests/tests/test_cross_language.rs @@ -346,7 +346,7 @@ fn test_cross_language_serializer() { let bytes = fs::read(&data_file_path).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(101).unwrap(); + fory.register::(101).unwrap(); assert_de!(fory, reader, bool, true); assert_de!(fory, reader, bool, false); assert_de!(fory, reader, i32, -1); @@ -413,9 +413,9 @@ fn test_simple_struct() { let data_file_path = get_data_file(); let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(101).unwrap(); - fory.register_by_id::(102).unwrap(); - fory.register_by_id::(103).unwrap(); + fory.register::(101).unwrap(); + fory.register::(102).unwrap(); + fory.register::(103).unwrap(); let local_obj = SimpleStruct { f1: HashMap::from([(1, 1.0f64), (2, 2.0f64)]), @@ -510,7 +510,7 @@ fn test_list() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(102).unwrap(); + fory.register::(102).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let str_list = vec![Some("a".to_string()), Some("b".to_string())]; @@ -552,7 +552,7 @@ fn test_map() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(102).unwrap(); + fory.register::(102).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let str_map = HashMap::from([ @@ -625,7 +625,7 @@ fn test_integer() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(101).unwrap(); + fory.register::(101).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let f1 = 1; let f2 = 2; @@ -773,13 +773,13 @@ fn _test_skip_custom(fory1: &Fory, fory2: &Fory) { #[ignore] fn test_skip_id_custom() { let mut fory1 = Fory::builder().compatible(true).xlang(true).build(); - fory1.register_serializer_by_id::(103).unwrap(); - fory1.register_by_id::(104).unwrap(); + fory1.register_serializer::(103).unwrap(); + fory1.register::(104).unwrap(); let mut fory2 = Fory::builder().compatible(true).xlang(true).build(); - fory2.register_by_id::(101).unwrap(); - fory2.register_by_id::(102).unwrap(); - fory2.register_serializer_by_id::(103).unwrap(); - fory2.register_by_id::(104).unwrap(); + fory2.register::(101).unwrap(); + fory2.register::(102).unwrap(); + fory2.register_serializer::(103).unwrap(); + fory2.register::(104).unwrap(); _test_skip_custom(&fory1, &fory2); } @@ -947,7 +947,7 @@ fn test_struct_version_check() { .xlang(true) .check_struct_version(true) .build(); - fory.register_by_id::(201).unwrap(); + fory.register::(201).unwrap(); let local_obj = VersionCheckStruct { f1: 10, @@ -969,7 +969,7 @@ fn test_item() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(102).unwrap(); + fory.register::(102).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let item1 = Item { @@ -1004,7 +1004,7 @@ fn test_color() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(101).unwrap(); + fory.register::(101).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let remote_green: Color = fory.deserialize_from(&mut reader).unwrap(); @@ -1031,7 +1031,7 @@ fn test_struct_with_list() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(201).unwrap(); + fory.register::(201).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let struct1 = StructWithList { @@ -1063,7 +1063,7 @@ fn test_struct_with_map() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(202).unwrap(); + fory.register::(202).unwrap(); let mut reader = Reader::new(bytes.as_slice()); let struct1 = StructWithMap { @@ -1097,7 +1097,7 @@ fn test_nested_annotated_container_schema_consistent() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register_by_id::(801) + fory.register::(801) .unwrap(); let local_obj = NestedAnnotatedContainerSchemaConsistent { @@ -1124,7 +1124,7 @@ fn test_nested_annotated_container_compatible() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(802) + fory.register::(802) .unwrap(); let local_obj = NestedAnnotatedContainerCompatible { @@ -1180,9 +1180,9 @@ fn test_polymorphic_list() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(302).unwrap(); - fory.register_by_id::(303).unwrap(); - fory.register_by_id::(304).unwrap(); + fory.register::(302).unwrap(); + fory.register::(303).unwrap(); + fory.register::(304).unwrap(); let mut reader = Reader::new(bytes.as_slice()); // Part 1: Read List with polymorphic elements (Dog, Cat) @@ -1231,9 +1231,9 @@ fn test_polymorphic_map() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(302).unwrap(); - fory.register_by_id::(303).unwrap(); - fory.register_by_id::(305).unwrap(); + fory.register::(302).unwrap(); + fory.register::(303).unwrap(); + fory.register::(305).unwrap(); let mut reader = Reader::new(bytes.as_slice()); // Part 1: Read Map with polymorphic values @@ -1294,7 +1294,7 @@ fn test_one_string_field_schema() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register_by_id::(200).unwrap(); + fory.register::(200).unwrap(); let value: OneStringFieldStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.f1, Some("hello".to_string())); @@ -1310,7 +1310,7 @@ fn test_one_string_field_compatible() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(200).unwrap(); + fory.register::(200).unwrap(); let value: OneStringFieldStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.f1, Some("hello".to_string())); @@ -1326,7 +1326,7 @@ fn test_two_string_field_compatible() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(201).unwrap(); + fory.register::(201).unwrap(); let value: TwoStringFieldStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.f1, "first".to_string()); @@ -1344,7 +1344,7 @@ fn test_schema_evolution_compatible() { // Read TwoStringFieldStruct data as EmptyStructEvolution let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(200).unwrap(); + fory.register::(200).unwrap(); let value: EmptyStructEvolution = fory.deserialize(&bytes).unwrap(); @@ -1361,7 +1361,7 @@ fn test_schema_evolution_compatible_reverse() { // Read OneStringFieldStruct data as TwoStringFieldStruct (missing f2) let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(200).unwrap(); + fory.register::(200).unwrap(); let value: TwoStringFieldStruct = fory.deserialize(&bytes).unwrap(); @@ -1381,8 +1381,7 @@ fn test_reduced_precision_float_struct() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register_by_id::(213) - .unwrap(); + fory.register::(213).unwrap(); let value: ReducedPrecisionFloatStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.float16_value.to_bits(), 0x3E00); @@ -1415,7 +1414,7 @@ fn test_reduced_precision_float_struct_compatible_skip() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(213).unwrap(); + fory.register::(213).unwrap(); let value: EmptyStructEvolution = fory.deserialize(&bytes).unwrap(); @@ -1430,8 +1429,7 @@ fn test_list_array_compatible_list_to_array() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(901) - .unwrap(); + fory.register::(901).unwrap(); let value: CompatibleInt32ArrayField = fory.deserialize(&bytes).unwrap(); let new_bytes = fory.serialize(&value).unwrap(); fs::write(&data_file_path, new_bytes).unwrap(); @@ -1444,8 +1442,7 @@ fn test_list_array_compatible_array_to_list() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(901) - .unwrap(); + fory.register::(901).unwrap(); let value: CompatibleInt32ListField = fory.deserialize(&bytes).unwrap(); let new_bytes = fory.serialize(&value).unwrap(); fs::write(&data_file_path, new_bytes).unwrap(); @@ -1458,8 +1455,7 @@ fn test_list_array_compatible_nullable_list_to_array_error() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(901) - .unwrap(); + fory.register::(901).unwrap(); let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { fory.deserialize::(&bytes) })); @@ -1481,8 +1477,8 @@ fn test_one_enum_field_schema() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register_by_id::(210).unwrap(); - fory.register_by_id::(211).unwrap(); + fory.register::(210).unwrap(); + fory.register::(211).unwrap(); let value: OneEnumFieldStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.f1, TestEnum::VALUE_B); @@ -1498,8 +1494,8 @@ fn test_one_enum_field_compatible() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(210).unwrap(); - fory.register_by_id::(211).unwrap(); + fory.register::(210).unwrap(); + fory.register::(211).unwrap(); let value: OneEnumFieldStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.f1, TestEnum::VALUE_A); @@ -1515,8 +1511,8 @@ fn test_two_enum_field_compatible() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(210).unwrap(); - fory.register_by_id::(212).unwrap(); + fory.register::(210).unwrap(); + fory.register::(212).unwrap(); let value: TwoEnumFieldStruct = fory.deserialize(&bytes).unwrap(); assert_eq!(value.f1, TestEnum::VALUE_A); @@ -1534,8 +1530,8 @@ fn test_enum_schema_evolution_compatible() { // Read TwoEnumFieldStruct data as EmptyStructEvolution let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(210).unwrap(); - fory.register_by_id::(211).unwrap(); + fory.register::(210).unwrap(); + fory.register::(211).unwrap(); let value: EmptyStructEvolution = fory.deserialize(&bytes).unwrap(); @@ -1552,8 +1548,8 @@ fn test_enum_schema_evolution_compatible_reverse() { // Read OneEnumFieldStruct data as TwoEnumFieldStruct (missing f2) let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(210).unwrap(); - fory.register_by_id::(211).unwrap(); + fory.register::(210).unwrap(); + fory.register::(211).unwrap(); let value: TwoEnumFieldStruct = fory.deserialize(&bytes).unwrap(); @@ -1687,7 +1683,7 @@ fn test_nullable_field_schema_consistent_not_null() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register_by_id::(401) + fory.register::(401) .unwrap(); let local_obj = NullableComprehensiveSchemaConsistent { @@ -1737,7 +1733,7 @@ fn test_nullable_field_schema_consistent_null() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register_by_id::(401) + fory.register::(401) .unwrap(); let local_obj = NullableComprehensiveSchemaConsistent { @@ -1790,7 +1786,7 @@ fn test_nullable_field_compatible_not_null() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(402) + fory.register::(402) .unwrap(); let local_obj = NullableComprehensiveCompatible { @@ -1850,7 +1846,7 @@ fn test_nullable_field_compatible_null() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(402) + fory.register::(402) .unwrap(); let local_obj = NullableComprehensiveCompatible { @@ -1935,8 +1931,8 @@ fn test_union_xlang() { let mut fory = Fory::builder().compatible(true).xlang(true).build(); // Register both the enum and the struct that contains it - fory.register_by_id::(300).unwrap(); - fory.register_by_id::(301).unwrap(); + fory.register::(300).unwrap(); + fory.register::(301).unwrap(); // Read struct1 with String value (index 0) let mut reader = Reader::new(bytes.as_slice()); @@ -2033,10 +2029,8 @@ fn test_ref_schema_consistent() { .xlang(true) .track_ref(true) .build(); - fory.register_by_id::(501) - .unwrap(); - fory.register_by_id::(502) - .unwrap(); + fory.register::(501).unwrap(); + fory.register::(502).unwrap(); let outer: RefOuterSchemaConsistent = fory.deserialize(&bytes).unwrap(); @@ -2083,8 +2077,8 @@ fn test_ref_compatible() { .xlang(true) .track_ref(true) .build(); - fory.register_by_id::(503).unwrap(); - fory.register_by_id::(504).unwrap(); + fory.register::(503).unwrap(); + fory.register::(504).unwrap(); let outer: RefOuterCompatible = fory.deserialize(&bytes).unwrap(); @@ -2127,8 +2121,8 @@ fn test_collection_element_ref_override() { .xlang(true) .track_ref(true) .build(); - fory.register_by_id::(701).unwrap(); - fory.register_by_id::(702).unwrap(); + fory.register::(701).unwrap(); + fory.register::(702).unwrap(); let outer: RefOverrideContainer = fory.deserialize(&bytes).unwrap(); assert!( @@ -2185,8 +2179,8 @@ fn test_collection_element_ref_remote_tracking() { .xlang(true) .track_ref(true) .build(); - fory.register_by_id::(701).unwrap(); - fory.register_by_id::(702).unwrap(); + fory.register::(701).unwrap(); + fory.register::(702).unwrap(); let shared = Rc::new(RefOverrideElement { id: 7, @@ -2244,7 +2238,7 @@ fn test_circular_ref_schema_consistent() { .xlang(true) .track_ref(true) .build(); - fory.register_by_id::(601).unwrap(); + fory.register::(601).unwrap(); // Deserialize as Rc since the whole struct needs ref tracking let obj: Rc = fory.deserialize(&bytes).unwrap(); @@ -2289,7 +2283,7 @@ fn test_circular_ref_compatible() { .xlang(true) .track_ref(true) .build(); - fory.register_by_id::(602).unwrap(); + fory.register::(602).unwrap(); // Deserialize as Rc since the whole struct needs ref tracking let obj: Rc = fory.deserialize(&bytes).unwrap(); @@ -2404,8 +2398,7 @@ fn test_unsigned_schema_consistent() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(false).xlang(true).build(); - fory.register_by_id::(501) - .unwrap(); + fory.register::(501).unwrap(); let local_obj = UnsignedSchemaConsistent { // Primitive unsigned fields @@ -2442,8 +2435,7 @@ fn test_unsigned_schema_compatible() { let bytes = fs::read(&data_file_path).unwrap(); let mut fory = Fory::builder().compatible(true).xlang(true).build(); - fory.register_by_id::(502) - .unwrap(); + fory.register::(502).unwrap(); let local_obj = UnsignedSchemaCompatible { // Group 1: Option fields (values from Java's non-nullable fields) diff --git a/rust/tests/tests/test_debug.rs b/rust/tests/tests/test_debug.rs index b1556126af..2908d0769b 100644 --- a/rust/tests/tests/test_debug.rs +++ b/rust/tests/tests/test_debug.rs @@ -108,7 +108,7 @@ fn debug_hooks_trigger_for_struct() { set_after_read_field_func(after_read); let mut fory = Fory::default(); - fory.register_by_id::(4001).unwrap(); + fory.register::(4001).unwrap(); let sample = DebugSample { a: 7, b: "debug".to_string(), @@ -151,7 +151,7 @@ fn debug_hooks_trigger_for_struct() { event_log().lock().unwrap().clear(); let mut fory_compat = Fory::builder().compatible(true).build(); - fory_compat.register_by_id::(4001).unwrap(); + fory_compat.register::(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 6798bc5286..b5ae1385c3 100644 --- a/rust/tests/tests/test_enum.rs +++ b/rust/tests/tests/test_enum.rs @@ -35,7 +35,7 @@ fn basic() { } let mut fory = Fory::builder().xlang(false).build(); - fory.register_by_id::(1000).unwrap(); + fory.register::(1000).unwrap(); let mut map = HashMap::new(); map.insert("one".to_string(), Token::Number(1)); @@ -76,10 +76,10 @@ fn named_enum() { } let mut fory1 = Fory::builder().xlang(false).build(); - fory1.register_by_id::(1000).unwrap(); + fory1.register::(1000).unwrap(); let mut fory2 = Fory::builder().xlang(false).build(); - fory2.register_by_id::(1000).unwrap(); + fory2.register::(1000).unwrap(); let token = Token1::Assign { target: "bar".to_string(), @@ -133,8 +133,8 @@ fn struct_with_enum_field() { ); let mut fory = Fory::builder().xlang(true).compatible(false).build(); - fory.register_by_id::(100).unwrap(); - fory.register_by_id::(101).unwrap(); + fory.register::(100).unwrap(); + fory.register::(101).unwrap(); let obj = StructWithEnum { name: "test".to_string(), @@ -177,8 +177,8 @@ fn union_compatible_enum_xlang_format() { // Test xlang mode serialization let mut fory = Fory::builder().xlang(true).compatible(false).build(); - fory.register_by_id::(300).unwrap(); - fory.register_by_id::(301).unwrap(); + fory.register::(300).unwrap(); + fory.register::(301).unwrap(); // Test with String variant (index 0) let obj1 = StructWithUnion { @@ -211,7 +211,7 @@ fn union_payload_nested_codec_annotations_roundtrip() { } let mut fory = Fory::builder().xlang(false).compatible(true).build(); - fory.register_by_id::(320).unwrap(); + fory.register::(320).unwrap(); let values = Payload::Values(vec![Some(1), None, Some(-300)]); let bytes = fory.serialize(&values).unwrap(); @@ -254,9 +254,8 @@ fn struct_with_enum_field_explicit_nullable() { ); let mut fory = Fory::builder().xlang(true).compatible(false).build(); - fory.register_by_id::(200).unwrap(); - fory.register_by_id::(201) - .unwrap(); + fory.register::(200).unwrap(); + fory.register::(201).unwrap(); let obj = StructWithExplicitNullable { name: "explicit".to_string(), diff --git a/rust/tests/tests/test_enum_compatible.rs b/rust/tests/tests/test_enum_compatible.rs index 71172521c5..2f1824e39a 100644 --- a/rust/tests/tests/test_enum_compatible.rs +++ b/rust/tests/tests/test_enum_compatible.rs @@ -41,10 +41,10 @@ fn test_unnamed_enum_variant_compatible() { // Test 1: Serialize v1 (2 fields), deserialize as v2 (3 fields) let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build(); - fory_v1.register_by_id::(2000).unwrap(); + fory_v1.register::(2000).unwrap(); let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build(); - fory_v2.register_by_id::(2000).unwrap(); + fory_v2.register::(2000).unwrap(); let event_v1 = EventV1::Message(42, "hello".to_string()); let bin = fory_v1.serialize(&event_v1).unwrap(); @@ -81,7 +81,7 @@ fn test_unnamed_enum_variant_compatible() { } let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build(); - fory_v3.register_by_id::(2000).unwrap(); + fory_v3.register::(2000).unwrap(); let event_v3 = EventV3::NewVariant(true); let bin = fory_v3.serialize(&event_v3).unwrap(); @@ -118,10 +118,10 @@ fn test_named_enum_variant_compatible() { } let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build(); - fory_v1.register_by_id::(3000).unwrap(); + fory_v1.register::(3000).unwrap(); let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build(); - fory_v2.register_by_id::(3000).unwrap(); + fory_v2.register::(3000).unwrap(); // Test 1: Serialize v1, deserialize as v2 (new field gets default value) let cmd_v1 = CommandV1::Execute { @@ -199,13 +199,13 @@ fn test_named_enum_field_evolution() { } let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build(); - fory_v1.register_by_id::(4000).unwrap(); + fory_v1.register::(4000).unwrap(); let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build(); - fory_v2.register_by_id::(4000).unwrap(); + fory_v2.register::(4000).unwrap(); let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build(); - fory_v3.register_by_id::(4000).unwrap(); + fory_v3.register::(4000).unwrap(); // Test V1 -> V2: New fields get default values let config_v1 = ConfigV1::Settings { @@ -320,13 +320,13 @@ fn test_named_enum_variant_add_remove() { } let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build(); - fory_v1.register_by_id::(5000).unwrap(); + fory_v1.register::(5000).unwrap(); let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build(); - fory_v2.register_by_id::(5000).unwrap(); + fory_v2.register::(5000).unwrap(); let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build(); - fory_v3.register_by_id::(5000).unwrap(); + fory_v3.register::(5000).unwrap(); // Test V2 (new variant Completed) -> V1: Unknown variant falls back to default let task_v2 = TaskV2::Completed { @@ -459,13 +459,13 @@ fn test_enum_variant_type_change() { } let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build(); - fory_v1.register_by_id::(6000).unwrap(); + fory_v1.register::(6000).unwrap(); let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build(); - fory_v2.register_by_id::(6000).unwrap(); + fory_v2.register::(6000).unwrap(); let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build(); - fory_v3.register_by_id::(6000).unwrap(); + fory_v3.register::(6000).unwrap(); // Test V1 Unit -> V2 Named: Type mismatch, uses default value let status_v1_active = StatusV1::Active; @@ -594,16 +594,16 @@ fn test_struct_with_enum_field_evolution() { } let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build(); - fory_v1.register_by_id::(7001).unwrap(); - fory_v1.register_by_id::(7000).unwrap(); + fory_v1.register::(7001).unwrap(); + fory_v1.register::(7000).unwrap(); let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build(); - fory_v2.register_by_id::(7001).unwrap(); - fory_v2.register_by_id::(7000).unwrap(); + fory_v2.register::(7001).unwrap(); + fory_v2.register::(7000).unwrap(); let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build(); - fory_v3.register_by_id::(7001).unwrap(); - fory_v3.register_by_id::(7000).unwrap(); + fory_v3.register::(7001).unwrap(); + fory_v3.register::(7000).unwrap(); // Test V1 -> V2: Enum field evolution let msg_v1 = MessageV1 { diff --git a/rust/tests/tests/test_ext.rs b/rust/tests/tests/test_ext.rs index 075682a3ce..4f7103787e 100644 --- a/rust/tests/tests/test_ext.rs +++ b/rust/tests/tests/test_ext.rs @@ -84,7 +84,7 @@ fn test_use() { } let mut fory = Fory::builder().compatible(true).xlang(true).build(); let item = Item { f1: 1, f2: 2 }; - fory.register_serializer_by_id::(100).unwrap(); + fory.register_serializer::(100).unwrap(); let bytes = fory.serialize(&item).unwrap(); let new_item: Item = fory.deserialize(&bytes).unwrap(); assert_eq!(new_item.f1, item.f1); diff --git a/rust/tests/tests/test_field_meta.rs b/rust/tests/tests/test_field_meta.rs index bda3c45869..d09d586ac1 100644 --- a/rust/tests/tests/test_field_meta.rs +++ b/rust/tests/tests/test_field_meta.rs @@ -39,7 +39,7 @@ struct StructWithSkip { #[test] fn test_skip_field() { let mut fory = Fory::default(); - fory.register_by_id::(1).unwrap(); + fory.register::(1).unwrap(); let original = StructWithSkip { name: "Alice".to_string(), @@ -67,7 +67,7 @@ struct StructWithNullable { #[test] fn test_nullable_attribute() { let mut fory = Fory::default(); - fory.register_by_id::(2).unwrap(); + fory.register::(2).unwrap(); // Test with Some value let original = StructWithNullable { @@ -105,8 +105,8 @@ struct StructWithRefTracking { #[test] fn test_ref_tracking_disabled() { let mut fory = Fory::default(); - fory.register_by_id::(3).unwrap(); - fory.register_by_id::(4).unwrap(); + fory.register::(3).unwrap(); + fory.register::(4).unwrap(); let inner = Rc::new(InnerData { value: 100 }); let original = StructWithRefTracking { data: inner }; @@ -126,7 +126,7 @@ struct StructWithExplicitNotNull { #[test] fn test_explicit_not_nullable() { let mut fory = Fory::default(); - fory.register_by_id::(5).unwrap(); + fory.register::(5).unwrap(); let original = StructWithExplicitNotNull { required_option: Some("value".to_string()), @@ -145,8 +145,8 @@ struct StructWithArc { #[test] fn test_arc_default_ref_tracking() { let mut fory = Fory::default(); - fory.register_by_id::(6).unwrap(); - fory.register_by_id::(7).unwrap(); + fory.register::(6).unwrap(); + fory.register::(7).unwrap(); let inner = Arc::new(InnerData { value: 200 }); let original = StructWithArc { data: inner }; @@ -169,7 +169,7 @@ struct StructWithCombinedAttrs { #[test] fn test_combined_attributes() { let mut fory = Fory::default(); - fory.register_by_id::(8).unwrap(); + fory.register::(8).unwrap(); let original = StructWithCombinedAttrs { name: "Test".to_string(), @@ -196,7 +196,7 @@ struct StructWithPrimitives { #[test] fn test_primitive_defaults() { let mut fory = Fory::default(); - fory.register_by_id::(9).unwrap(); + fory.register::(9).unwrap(); let original = StructWithPrimitives { count: 42, @@ -394,9 +394,9 @@ fn annotated_primitive_vec_field_uses_list_element_type_meta() { #[test] fn unannotated_non_primitive_vec_field_keeps_declared_element_type_meta() { let mut type_resolver = TypeResolver::default(); - type_resolver.register_by_id::(401).unwrap(); + type_resolver.register::(401).unwrap(); type_resolver - .register_by_id::(402) + .register::(402) .unwrap(); let field_type = only_field_type::(&type_resolver); @@ -613,7 +613,7 @@ fn serializer_backed_container_fields_write_declared_generic_payloads() { #[test] fn test_nested_codec_annotations_roundtrip() { let mut fory = Fory::default(); - fory.register_by_id::(10).unwrap(); + fory.register::(10).unwrap(); let original = NestedFixedEncoding { values: vec![Some(1), None, Some(-300)], @@ -629,10 +629,10 @@ fn test_nested_codec_annotations_roundtrip() { #[test] fn test_compatible_nested_integer_encoding_mismatch() { let mut writer = Fory::builder().compatible(true).build(); - writer.register_by_id::(11).unwrap(); + writer.register::(11).unwrap(); let mut reader = Fory::builder().compatible(true).build(); - reader.register_by_id::(11).unwrap(); + reader.register::(11).unwrap(); let original = NestedVarEncoding { values: vec![Some(1), None, Some(-300)], @@ -661,7 +661,7 @@ struct StructWithFieldIds { #[test] fn test_field_id_attribute() { let mut fory = Fory::default(); - fory.register_by_id::(10).unwrap(); + fory.register::(10).unwrap(); let original = StructWithFieldIds { name: "Bob".to_string(), @@ -687,7 +687,7 @@ struct StructWithMixedIds { #[test] fn test_mixed_field_ids() { let mut fory = Fory::default(); - fory.register_by_id::(11).unwrap(); + fory.register::(11).unwrap(); let original = StructWithMixedIds { id_field: 100, @@ -716,8 +716,7 @@ struct StructWithCombinedFieldAttrs { #[test] fn test_field_id_with_other_attrs() { let mut fory = Fory::default(); - fory.register_by_id::(12) - .unwrap(); + fory.register::(12).unwrap(); let original = StructWithCombinedFieldAttrs { name: "Test".to_string(), @@ -771,14 +770,10 @@ mod compatible_v2 { fn test_compatible_mode_v1_to_v2() { // Serialize with V1, deserialize with V2 (forward compatibility) let mut fory_v1 = Fory::builder().compatible(true).build(); - fory_v1 - .register_by_id::(100) - .unwrap(); + fory_v1.register::(100).unwrap(); let mut fory_v2 = Fory::builder().compatible(true).build(); - fory_v2 - .register_by_id::(100) - .unwrap(); + fory_v2.register::(100).unwrap(); let user_v1 = compatible_v1::UserV1 { name: "Alice".to_string(), @@ -800,14 +795,10 @@ fn test_compatible_mode_v1_to_v2() { fn test_compatible_mode_v2_to_v1() { // Serialize with V2, deserialize with V1 (backward compatibility) let mut fory_v1 = Fory::builder().compatible(true).build(); - fory_v1 - .register_by_id::(100) - .unwrap(); + fory_v1.register::(100).unwrap(); let mut fory_v2 = Fory::builder().compatible(true).build(); - fory_v2 - .register_by_id::(100) - .unwrap(); + fory_v2.register::(100).unwrap(); let user_v2 = compatible_v2::UserV2 { name: "Bob".to_string(), @@ -861,12 +852,12 @@ fn test_compatible_mode_field_reorder() { // Test that field IDs allow fields to be reordered between versions let mut fory_v1 = Fory::builder().compatible(true).build(); fory_v1 - .register_by_id::(200) + .register::(200) .unwrap(); let mut fory_v2 = Fory::builder().compatible(true).build(); fory_v2 - .register_by_id::(200) + .register::(200) .unwrap(); let data_v1 = compatible_reorder_v1::DataV1 { @@ -920,12 +911,12 @@ fn test_compatible_mode_field_removed() { // Test that removed fields are handled in compatible mode let mut fory_v1 = Fory::builder().compatible(true).build(); fory_v1 - .register_by_id::(300) + .register::(300) .unwrap(); let mut fory_v2 = Fory::builder().compatible(true).build(); fory_v2 - .register_by_id::(300) + .register::(300) .unwrap(); let config_v1 = compatible_remove_field_v1::ConfigV1 { @@ -958,7 +949,7 @@ struct StructWithSkipAndId { #[test] fn test_skip_with_field_id() { let mut fory = Fory::default(); - fory.register_by_id::(350).unwrap(); + fory.register::(350).unwrap(); let original = StructWithSkipAndId { name: "test".to_string(), @@ -978,7 +969,7 @@ fn test_skip_with_field_id() { fn test_compatible_mode_roundtrip() { // Test full roundtrip with compatible mode and field IDs let mut fory = Fory::builder().compatible(true).build(); - fory.register_by_id::(400).unwrap(); + fory.register::(400).unwrap(); let original = compatible_v2::UserV2 { name: "Charlie".to_string(), @@ -1036,12 +1027,12 @@ fn test_field_id_payload_compatible_mode() { // following the xlang serialization spec (TAG_ID encoding with 2-bit marker 0b11). let mut fory_compact = Fory::builder().compatible(true).build(); fory_compact - .register_by_id::(500) + .register::(500) .unwrap(); let mut fory_verbose = Fory::builder().compatible(true).build(); fory_verbose - .register_by_id::(501) + .register::(501) .unwrap(); let compact_user = payload_with_field_ids::CompactUser { diff --git a/rust/tests/tests/test_fory.rs b/rust/tests/tests/test_fory.rs index 652e6a6ccc..3b141a0eef 100644 --- a/rust/tests/tests/test_fory.rs +++ b/rust/tests/tests/test_fory.rs @@ -36,8 +36,8 @@ fn test_nested_struct_register_order() { let mut fory = Fory::default(); // outer struct registered first. building fields info should be executed lazily, // otherwise the inner struct won't be found. - fory.register_by_id::(100).unwrap(); - fory.register_by_id::(101).unwrap(); + fory.register::(100).unwrap(); + fory.register::(101).unwrap(); let data = Data1 { value: 42, data2: Data2 { value: 24 }, @@ -56,7 +56,7 @@ fn test_serialize_to_appends_bytes() { } let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let p1 = Point { x: 1, y: 2 }; let p2 = Point { x: -3, y: 4 }; @@ -91,8 +91,8 @@ fn test_serialize_to_detailed() { } let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); - fory.register_by_id::(101).unwrap(); + fory.register::(100).unwrap(); + fory.register::(101).unwrap(); // Test 1: Basic serialization to empty buffer let p1 = Point { x: 10, y: 20 }; @@ -270,7 +270,7 @@ fn test_unregistered_type_error_message() { let mut fory = Fory::default(); // Register only the outer type; inner type is intentionally not registered - fory.register_by_id::(200).unwrap(); + fory.register::(200).unwrap(); let obj = Outer { v: 1, inner: Inner { v: 2 }, diff --git a/rust/tests/tests/test_generate_default.rs b/rust/tests/tests/test_generate_default.rs index 1a0d785f92..9e26ef7e34 100644 --- a/rust/tests/tests/test_generate_default.rs +++ b/rust/tests/tests/test_generate_default.rs @@ -42,7 +42,7 @@ impl Default for NodeWithCustomDefault { #[test] fn test_no_default_conflict() { let mut fory = Fory::default(); - fory.register_by_id::(1).unwrap(); + fory.register::(1).unwrap(); let node = NodeWithCustomDefault { addr: "192.168.1.1:3000".to_string(), @@ -81,7 +81,7 @@ impl Default for StatusWithCustomDefault { #[test] fn test_enum_no_default_conflict() { let mut fory = Fory::default(); - fory.register_by_id::(2).unwrap(); + fory.register::(2).unwrap(); let status = StatusWithCustomDefault::Active; let bytes = fory.serialize(&status).unwrap(); @@ -106,8 +106,7 @@ struct StructWithGeneratedDefault { #[test] fn test_generate_default_struct() { let mut fory = Fory::default(); - fory.register_by_id::(3) - .unwrap(); + fory.register::(3).unwrap(); let data = StructWithGeneratedDefault { value: 42 }; let bytes = fory.serialize(&data).unwrap(); @@ -131,7 +130,7 @@ enum EnumWithGeneratedDefault { #[test] fn test_generate_default_enum() { let mut fory = Fory::default(); - fory.register_by_id::(4).unwrap(); + fory.register::(4).unwrap(); let data = EnumWithGeneratedDefault::Second; let bytes = fory.serialize(&data).unwrap(); @@ -159,8 +158,7 @@ impl Default for StructWithoutGeneratedDefault { #[test] fn test_generate_default_false() { let mut fory = Fory::default(); - fory.register_by_id::(5) - .unwrap(); + fory.register::(5).unwrap(); let data = StructWithoutGeneratedDefault { value: 42 }; let bytes = fory.serialize(&data).unwrap(); diff --git a/rust/tests/tests/test_lifecycle_guard.rs b/rust/tests/tests/test_lifecycle_guard.rs index 64f53f42a8..a12dd63e87 100644 --- a/rust/tests/tests/test_lifecycle_guard.rs +++ b/rust/tests/tests/test_lifecycle_guard.rs @@ -43,7 +43,7 @@ struct Color { fn test_register_before_serialize_succeeds() { let mut fory = Fory::default(); // registration before any serialize/deserialize should succeed. - assert!(fory.register_by_id::(100).is_ok()); + assert!(fory.register::(100).is_ok()); let point = Point { x: 1, y: 2 }; let bytes = fory.serialize(&point).unwrap(); @@ -54,8 +54,8 @@ fn test_register_before_serialize_succeeds() { #[test] fn test_multiple_registrations_before_serialize_succeed() { let mut fory = Fory::default(); - assert!(fory.register_by_id::(100).is_ok()); - assert!(fory.register_by_id::(101).is_ok()); + assert!(fory.register::(100).is_ok()); + assert!(fory.register::(101).is_ok()); let point = Point { x: 10, y: 20 }; let bytes = fory.serialize(&point).unwrap(); @@ -85,11 +85,11 @@ fn test_register_by_name_rejects_duplicate_identity() { // Negative tests -/// ensures `register_by_id()` is forbidden after `serialize()` triggers snapshot init. +/// ensures `register()` is forbidden after `serialize()` triggers snapshot init. #[test] fn test_register_after_serialize_fails() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); // first serialize, this initializes the final_type_resolver snapshot. let point = Point { x: 1, y: 2 }; @@ -97,8 +97,8 @@ fn test_register_after_serialize_fails() { // now any registration must fail with NotAllowed. let err = fory - .register_by_id::(101) - .expect_err("register_by_id after serialize should fail"); + .register::(101) + .expect_err("register after serialize should fail"); assert!( matches!(err, Error::NotAllowed(_)), "expected NotAllowed, got: {:?}", @@ -112,11 +112,11 @@ fn test_register_after_serialize_fails() { ); } -/// Ensures `register_by_id()` is forbidden after `deserialize()` triggers snapshot init. +/// Ensures `register()` is forbidden after `deserialize()` triggers snapshot init. #[test] fn test_register_after_deserialize_fails() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let point = Point { x: 5, y: 10 }; let bytes = fory.serialize(&point).unwrap(); @@ -125,7 +125,7 @@ fn test_register_after_deserialize_fails() { let _result: Point = fory.deserialize(&bytes).unwrap(); let err = fory - .register_by_id::(101) + .register::(101) .expect_err("register after deserialize should fail"); assert!(matches!(err, Error::NotAllowed(_))); } @@ -134,7 +134,7 @@ fn test_register_after_deserialize_fails() { #[test] fn test_register_by_name_after_serialize_fails() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory @@ -147,7 +147,7 @@ fn test_register_by_name_after_serialize_fails() { #[test] fn test_register_by_name_with_namespace_after_serialize_fails() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory @@ -156,16 +156,16 @@ fn test_register_by_name_with_namespace_after_serialize_fails() { assert!(matches!(err, Error::NotAllowed(_))); } -/// Ensures `register_serializer_by_id()` is forbidden after snapshot init. +/// Ensures `register_serializer()` is forbidden after snapshot init. #[test] fn test_register_serializer_after_serialize_fails() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory - .register_serializer_by_id::(102) - .expect_err("register_serializer_by_id after serialize should fail"); + .register_serializer::(102) + .expect_err("register_serializer after serialize should fail"); assert!(matches!(err, Error::NotAllowed(_))); } @@ -173,7 +173,7 @@ fn test_register_serializer_after_serialize_fails() { #[test] fn test_register_serializer_by_name_after_serialize_fails() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory @@ -186,7 +186,7 @@ fn test_register_serializer_by_name_after_serialize_fails() { #[test] fn test_register_serializer_by_name_with_namespace_after_serialize_fails() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory @@ -199,7 +199,7 @@ fn test_register_serializer_by_name_with_namespace_after_serialize_fails() { #[test] fn test_register_generic_trait_after_serialize_fails() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory @@ -208,16 +208,16 @@ fn test_register_generic_trait_after_serialize_fails() { assert!(matches!(err, Error::NotAllowed(_))); } -/// Ensures `register_union_by_id()` is forbidden after snapshot init. +/// Ensures `register_union()` is forbidden after snapshot init. #[test] fn test_register_union_after_serialize_fails() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory - .register_union_by_id::(103) - .expect_err("register_union_by_id after serialize should fail"); + .register_union::(103) + .expect_err("register_union after serialize should fail"); assert!(matches!(err, Error::NotAllowed(_))); } @@ -225,7 +225,7 @@ fn test_register_union_after_serialize_fails() { #[test] fn test_register_union_by_name_after_serialize_fails() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory @@ -238,7 +238,7 @@ fn test_register_union_by_name_after_serialize_fails() { #[test] fn test_register_union_by_name_with_namespace_after_serialize_fails() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); let err = fory @@ -251,10 +251,10 @@ fn test_register_union_by_name_with_namespace_after_serialize_fails() { #[test] fn test_late_registration_error_message_is_descriptive() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let _bytes = fory.serialize(&Point { x: 0, y: 0 }).unwrap(); - let err = fory.register_by_id::(101).unwrap_err(); + let err = fory.register::(101).unwrap_err(); let msg = format!("{}", err); assert!( msg.contains("not allowed"), @@ -278,7 +278,7 @@ fn test_late_registration_error_message_is_descriptive() { #[test] fn test_serialize_multiple_times_after_registration_succeeds() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let p1 = Point { x: 1, y: 2 }; let p2 = Point { x: 3, y: 4 }; diff --git a/rust/tests/tests/test_marker.rs b/rust/tests/tests/test_marker.rs index 0ea7248714..48401593f0 100644 --- a/rust/tests/tests/test_marker.rs +++ b/rust/tests/tests/test_marker.rs @@ -40,7 +40,7 @@ struct StructWithPhantom { #[test] fn test_struct_with_phantom_data() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let value = StructWithPhantom { name: "test".to_string(), @@ -64,8 +64,7 @@ struct StructWithMultiplePhantom { #[test] fn test_struct_with_multiple_phantom_data() { let mut fory = Fory::default(); - fory.register_by_id::(101) - .unwrap(); + fory.register::(101).unwrap(); let value = StructWithMultiplePhantom { name: "test".to_string(), @@ -95,8 +94,8 @@ struct OuterWithPhantom { #[test] fn test_nested_struct_with_phantom_data() { let mut fory = Fory::default(); - fory.register_by_id::(102).unwrap(); - fory.register_by_id::(103).unwrap(); + fory.register::(102).unwrap(); + fory.register::(103).unwrap(); let value = OuterWithPhantom { inner: InnerWithPhantom { diff --git a/rust/tests/tests/test_max_dyn_depth.rs b/rust/tests/tests/test_max_dyn_depth.rs index 1fc94ddfa7..1e2eff8cef 100644 --- a/rust/tests/tests/test_max_dyn_depth.rs +++ b/rust/tests/tests/test_max_dyn_depth.rs @@ -36,7 +36,7 @@ fn test_max_dyn_depth_exceeded_box_dyn_any() { .max_dyn_depth(2) .compatible(compatible) .build(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let level3 = Container { value: 3, @@ -70,7 +70,7 @@ fn test_max_dyn_depth_within_limit_box_dyn_any() { return; } let mut fory = Fory::builder().max_dyn_depth(3).build(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let level3 = Container { value: 3, @@ -97,7 +97,7 @@ fn test_max_dyn_depth_default_exceeded() { return; } let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let mut current = Container { value: 6, @@ -128,7 +128,7 @@ fn test_max_dyn_depth_default_within_limit() { return; } let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let mut current = Container { value: 5, diff --git a/rust/tests/tests/test_multi_thread.rs b/rust/tests/tests/test_multi_thread.rs index 001158c1ea..e02c7a9076 100644 --- a/rust/tests/tests/test_multi_thread.rs +++ b/rust/tests/tests/test_multi_thread.rs @@ -61,7 +61,7 @@ fn test_struct_multi_thread() { f1: i32, } let mut fory = Fory::default(); - fory.register_by_id::(101).unwrap(); + fory.register::(101).unwrap(); let fory = Arc::new(fory); let src: HashSet<_> = [ Item1 { f1: 42 }, @@ -130,7 +130,7 @@ fn test_multiple_threads_shared_fory() { } let mut fory = Fory::default(); - fory.register_by_id::(2) + fory.register::(2) .expect("register UserSessionMetrics"); let shared_fory = Arc::new(fory); let shared_value = Arc::new(UserSessionMetrics { diff --git a/rust/tests/tests/test_one_struct.rs b/rust/tests/tests/test_one_struct.rs index 3829701d8c..a4bfd9f5d9 100644 --- a/rust/tests/tests/test_one_struct.rs +++ b/rust/tests/tests/test_one_struct.rs @@ -48,8 +48,8 @@ fn test_simple() { } let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(999).unwrap(); - fory2.register_by_id::(999).unwrap(); + fory1.register::(999).unwrap(); + fory2.register::(999).unwrap(); let animal: Animal1 = Animal1 { f1: HashMap::from([(1, vec![2])]), f2: String::from("hello"), diff --git a/rust/tests/tests/test_rc_arc.rs b/rust/tests/tests/test_rc_arc.rs index 8184c46864..1cc93f821d 100644 --- a/rust/tests/tests/test_rc_arc.rs +++ b/rust/tests/tests/test_rc_arc.rs @@ -174,7 +174,7 @@ fn test_mixed_rc_arc_serialization() { #[test] fn test_nested_rc_arc() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); // Test Rc containing Arc with allowed struct type let inner_data = Arc::new(NestedData { diff --git a/rust/tests/tests/test_rc_arc_trait_object.rs b/rust/tests/tests/test_rc_arc_trait_object.rs index 526fcf23ae..3fff222d49 100644 --- a/rust/tests/tests/test_rc_arc_trait_object.rs +++ b/rust/tests/tests/test_rc_arc_trait_object.rs @@ -229,8 +229,8 @@ fn test_conversion_helper_macros() { #[test] fn test_nested_wrapper_collections() { let mut fory = fory_compatible(); - fory.register_by_id::(100).unwrap(); - fory.register_by_id::(101).unwrap(); + fory.register::(100).unwrap(); + fory.register::(101).unwrap(); // Wrapper types are not registered since they're transparent @@ -287,8 +287,8 @@ fn test_nested_wrapper_collections() { #[test] fn test_empty_wrapper_collections() { let mut fory = fory_compatible(); - fory.register_by_id::(8001).unwrap(); - fory.register_by_id::(8002).unwrap(); + fory.register::(8001).unwrap(); + fory.register::(8002).unwrap(); // Test empty collections let empty_rc_vec: Vec = vec![]; @@ -329,9 +329,9 @@ struct AnimalByCodeFixedKey { #[test] fn test_collections_of_wrappers() { let mut fory = fory_compatible(); - fory.register_by_id::(8001).unwrap(); - fory.register_by_id::(8002).unwrap(); - fory.register_by_id::(8011).unwrap(); + fory.register::(8001).unwrap(); + fory.register::(8002).unwrap(); + fory.register::(8011).unwrap(); let shelter = AnimalShelter { animals_rc: vec![ @@ -426,14 +426,14 @@ fn test_collections_of_wrappers() { #[test] fn test_hashmap_fixed_key_rc_trait_object_field_compatible() { let mut writer = fory_compatible(); - writer.register_by_id::(8101).unwrap(); - writer.register_by_id::(8102).unwrap(); - writer.register_by_id::(8111).unwrap(); + writer.register::(8101).unwrap(); + writer.register::(8102).unwrap(); + writer.register::(8111).unwrap(); let mut reader = fory_compatible(); - reader.register_by_id::(8101).unwrap(); - reader.register_by_id::(8102).unwrap(); - reader.register_by_id::(8111).unwrap(); + reader.register::(8101).unwrap(); + reader.register::(8102).unwrap(); + reader.register::(8111).unwrap(); let animals = AnimalByCodeFixedKey { animals: HashMap::from([ @@ -466,8 +466,8 @@ fn test_hashmap_fixed_key_rc_trait_object_field_compatible() { #[test] fn test_rc_shared_ref_tracking() { let mut fory = fory_compatible(); - fory.register_by_id::(200).unwrap(); - fory.register_by_id::(201).unwrap(); + fory.register::(200).unwrap(); + fory.register::(201).unwrap(); let dog = Rc::new(Dog { name: "Rex".to_string(), @@ -498,8 +498,8 @@ fn test_rc_shared_ref_tracking() { #[test] fn test_arc_shared_ref_tracking() { let mut fory = fory_compatible(); - fory.register_by_id::(200).unwrap(); - fory.register_by_id::(201).unwrap(); + fory.register::(200).unwrap(); + fory.register::(201).unwrap(); let cat = Arc::new(Cat { name: "Whiskers".to_string(), diff --git a/rust/tests/tests/test_refcell.rs b/rust/tests/tests/test_refcell.rs index 55ab910dfe..dae3abf76c 100644 --- a/rust/tests/tests/test_refcell.rs +++ b/rust/tests/tests/test_refcell.rs @@ -28,7 +28,7 @@ struct Simple { #[test] fn test_rc_refcell_simple() { let mut fory = Fory::default(); - fory.register_by_id::(3000).unwrap(); + fory.register::(3000).unwrap(); let node = Rc::new(RefCell::new(Simple { value: 42 })); let serialized = fory.serialize(&node).unwrap(); @@ -45,8 +45,8 @@ struct Parent { #[test] fn test_rc_refcell_in_struct() { let mut fory = Fory::default(); - fory.register_by_id::(3001).unwrap(); - fory.register_by_id::(3002).unwrap(); + fory.register::(3001).unwrap(); + fory.register::(3002).unwrap(); let child = Rc::new(RefCell::new(Simple { value: 99 })); let parent = Parent { diff --git a/rust/tests/tests/test_simple_struct.rs b/rust/tests/tests/test_simple_struct.rs index 5ad24d9ad8..dc3cc5dd95 100644 --- a/rust/tests/tests/test_simple_struct.rs +++ b/rust/tests/tests/test_simple_struct.rs @@ -30,7 +30,7 @@ fn test_one_field_primitive_non_compatible() { } let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let data = Data { value: 42 }; let bytes = fory.serialize(&data).unwrap(); let result: Data = fory.deserialize(&bytes).unwrap(); @@ -46,7 +46,7 @@ fn test_one_field_string_non_compatible() { } let mut fory = Fory::default(); - fory.register_by_id::(101).unwrap(); + fory.register::(101).unwrap(); let data = Data { name: String::from("hello"), }; @@ -70,8 +70,8 @@ fn test_compatible_field_type_change() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(100).unwrap(); - fory2.register_by_id::(100).unwrap(); + fory1.register::(100).unwrap(); + fory2.register::(100).unwrap(); let data1 = Data1 { value: 42 }; let bytes = fory1.serialize(&data1).unwrap(); @@ -97,8 +97,8 @@ fn test_struct_evolving_override() { .compatible(true) .track_ref(false) .build(); - fory.register_by_id::(100).unwrap(); - fory.register_by_id::(101).unwrap(); + fory.register::(100).unwrap(); + fory.register::(101).unwrap(); let evolving = Evolving { id: 123 }; let evolving_bytes = fory.serialize(&evolving).unwrap(); @@ -132,8 +132,8 @@ fn test_compatible_to_empty_struct() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(101).unwrap(); - fory2.register_by_id::(101).unwrap(); + fory1.register::(101).unwrap(); + fory2.register::(101).unwrap(); let data1 = DataWithField { value: 42, @@ -158,8 +158,8 @@ fn test_compatible_from_empty_struct() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(102).unwrap(); - fory2.register_by_id::(102).unwrap(); + fory1.register::(102).unwrap(); + fory2.register::(102).unwrap(); let data1 = EmptyData {}; let bytes = fory1.serialize(&data1).unwrap(); @@ -181,8 +181,8 @@ fn test_compatible_vec_to_empty_struct() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(101).unwrap(); - fory2.register_by_id::(101).unwrap(); + fory1.register::(101).unwrap(); + fory2.register::(101).unwrap(); let data1 = DataWithField { value: vec![32], @@ -206,8 +206,8 @@ fn test_compatible_map_to_empty_struct() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(101).unwrap(); - fory2.register_by_id::(101).unwrap(); + fory1.register::(101).unwrap(); + fory2.register::(101).unwrap(); let data1 = DataWithField { value: HashMap::from([(String::from("k1"), 1i32), (String::from("k2"), 2i32)]), @@ -230,7 +230,7 @@ fn test_struct_with_float16_fields() { } let mut fory = Fory::default(); - fory.register_by_id::(200).unwrap(); + fory.register::(200).unwrap(); let obj = Float16Data { scalar: float16::from_f32(1.5), @@ -272,7 +272,7 @@ fn test_struct_with_bfloat16_fields() { } let mut fory = Fory::default(); - fory.register_by_id::(201).unwrap(); + fory.register::(201).unwrap(); let obj = BFloat16Data { scalar: bfloat16::from_f32(1.5), diff --git a/rust/tests/tests/test_skip_fields.rs b/rust/tests/tests/test_skip_fields.rs index fa8e059828..51bc326520 100644 --- a/rust/tests/tests/test_skip_fields.rs +++ b/rust/tests/tests/test_skip_fields.rs @@ -83,7 +83,7 @@ enum TestEnumSkip { #[test] fn test_basic_skip_functionality() { let mut fory = Fory::default(); - fory.register_by_id::(1).unwrap(); + fory.register::(1).unwrap(); let original = TestSkipFields { serialized_field: 42, @@ -109,8 +109,8 @@ fn test_basic_skip_functionality() { #[test] fn test_nested_skip_functionality() { let mut fory = Fory::default(); - fory.register_by_id::(2).unwrap(); - fory.register_by_id::(3).unwrap(); + fory.register::(2).unwrap(); + fory.register::(3).unwrap(); let original = TestNestedSkip { normal_field: 100, @@ -130,7 +130,7 @@ fn test_nested_skip_functionality() { #[test] fn test_multiple_skip_fields() { let mut fory = Fory::default(); - fory.register_by_id::(3).unwrap(); + fory.register::(3).unwrap(); let original = MultipleSkipFields { field1: 42, @@ -153,7 +153,7 @@ fn test_multiple_skip_fields() { #[test] fn test_all_fields_skipped() { let mut fory = Fory::default(); - fory.register_by_id::(4).unwrap(); + fory.register::(4).unwrap(); let original = AllFieldsSkipped { skipped1: "test1".to_string(), @@ -172,8 +172,8 @@ fn test_all_fields_skipped() { #[test] fn test_complex_nested_skip() { let mut fory = Fory::default(); - fory.register_by_id::(5).unwrap(); - fory.register_by_id::(6).unwrap(); + fory.register::(5).unwrap(); + fory.register::(6).unwrap(); let original = ComplexNestedSkip { normal_field: 1, @@ -207,7 +207,7 @@ fn test_complex_nested_skip() { #[test] fn test_enum_skip() { let mut fory = Fory::default(); - fory.register_by_id::(6).unwrap(); + fory.register::(6).unwrap(); let original_v1 = TestEnumSkip::Pending; @@ -225,7 +225,7 @@ fn test_enum_skip() { #[test] fn test_skip_serialization_size() { let mut fory = Fory::default(); - fory.register_by_id::(10).unwrap(); + fory.register::(10).unwrap(); let with_skip = TestSkipFields { serialized_field: 42, @@ -239,7 +239,7 @@ fn test_skip_serialization_size() { another_serialized: f64, } - fory.register_by_id::(11).unwrap(); + fory.register::(11).unwrap(); let without_skip = TestNoSkip { serialized_field: 42, @@ -275,7 +275,7 @@ fn test_skip_with_different_types() { } let mut fory = Fory::default(); - fory.register_by_id::(12).unwrap(); + fory.register::(12).unwrap(); let original = MultiTypeSkip { field1: 1, @@ -358,10 +358,10 @@ fn test_trait_object_serialization() { } let mut fory = Fory::builder().compatible(true).build(); - fory.register_by_id::(100).unwrap(); - fory.register_by_id::(101).unwrap(); - fory.register_by_id::(102).unwrap(); - fory.register_by_id::(103).unwrap(); + fory.register::(100).unwrap(); + fory.register::(101).unwrap(); + fory.register::(102).unwrap(); + fory.register::(103).unwrap(); let zoo_with_skip = ZooWithSkip { regular_animal: Box::new(Dog { @@ -398,7 +398,7 @@ fn test_trait_object_serialization() { } let mut fory = Fory::builder().compatible(true).build(); - fory.register_by_id::(106).unwrap(); + fory.register::(106).unwrap(); let complex = ComplexSkipExample { boxed_dyn: Box::new(Dog { diff --git a/rust/tests/tests/test_trait_object.rs b/rust/tests/tests/test_trait_object.rs index 9ac7718329..c06c0171b5 100644 --- a/rust/tests/tests/test_trait_object.rs +++ b/rust/tests/tests/test_trait_object.rs @@ -156,7 +156,7 @@ struct Company { #[test] fn test_fory_derived_struct_as_trait_object() { let mut fory = fory_compatible(); - fory.register_by_id::(5000).unwrap(); + fory.register::(5000).unwrap(); let person = Person { name: String::from("Alice"), @@ -178,8 +178,8 @@ fn test_fory_derived_struct_as_trait_object() { #[test] fn test_vec_of_fory_derived_trait_objects() { let mut fory = fory_compatible(); - fory.register_by_id::(5000).unwrap(); - fory.register_by_id::(5001).unwrap(); + fory.register::(5000).unwrap(); + fory.register::(5001).unwrap(); let vec_of_trait_objects: Vec> = vec![ Box::new(Person { @@ -205,8 +205,8 @@ fn test_vec_of_fory_derived_trait_objects() { #[test] fn test_hashmap_with_fory_derived_values() { let mut fory = fory_compatible(); - fory.register_by_id::(5000).unwrap(); - fory.register_by_id::(5001).unwrap(); + fory.register::(5000).unwrap(); + fory.register::(5001).unwrap(); let mut map: HashMap> = HashMap::new(); map.insert( @@ -280,9 +280,9 @@ struct Zoo { #[test] fn test_custom_trait_object_basic() { let mut fory = fory_compatible(); - fory.register_by_id::(8001).unwrap(); - fory.register_by_id::(8002).unwrap(); - fory.register_by_id::(8003).unwrap(); + fory.register::(8001).unwrap(); + fory.register::(8002).unwrap(); + fory.register::(8003).unwrap(); let zoo_dog = Zoo { star_animal: Box::new(Dog { @@ -338,9 +338,9 @@ struct PetOwner { #[test] fn test_multiple_traits() { let mut fory = fory_compatible(); - fory.register_by_id::(8001).unwrap(); - fory.register_by_id::(8002).unwrap(); - fory.register_by_id::(9001).unwrap(); + fory.register::(8001).unwrap(); + fory.register::(8002).unwrap(); + fory.register::(9001).unwrap(); let owner = PetOwner { pets: vec![ @@ -384,8 +384,8 @@ fn test_multiple_traits() { #[test] fn test_single_custom_trait_object_direct() { let mut fory = fory_compatible(); - fory.register_by_id::(8001).unwrap(); - fory.register_by_id::(8002).unwrap(); + fory.register::(8001).unwrap(); + fory.register::(8002).unwrap(); let animal: Box = Box::new(Dog { name: "Rex".to_string(), @@ -402,8 +402,8 @@ fn test_single_custom_trait_object_direct() { #[test] fn test_vec_custom_trait_objects_direct() { let mut fory = fory_compatible(); - fory.register_by_id::(8001).unwrap(); - fory.register_by_id::(8002).unwrap(); + fory.register::(8001).unwrap(); + fory.register::(8002).unwrap(); let animals: Vec> = vec![ Box::new(Dog { @@ -435,8 +435,8 @@ fn test_vec_custom_trait_objects_direct() { #[test] fn test_hashmap_custom_trait_objects_direct() { let mut fory = fory_compatible(); - fory.register_by_id::(8001).unwrap(); - fory.register_by_id::(8002).unwrap(); + fory.register::(8001).unwrap(); + fory.register::(8002).unwrap(); let mut animal_map: std::collections::HashMap> = std::collections::HashMap::new(); @@ -478,8 +478,8 @@ fn test_hashmap_custom_trait_objects_direct() { #[test] fn test_nested_custom_trait_object_collections() { let mut fory = fory_compatible(); - fory.register_by_id::(8001).unwrap(); - fory.register_by_id::(8002).unwrap(); + fory.register::(8001).unwrap(); + fory.register::(8002).unwrap(); // Test Vec>> let nested_animals: Vec>> = vec![ @@ -516,8 +516,8 @@ fn test_nested_custom_trait_object_collections() { #[test] fn test_mixed_trait_object_collections() { let mut fory = fory_compatible(); - fory.register_by_id::(8001).unwrap(); - fory.register_by_id::(8002).unwrap(); + fory.register::(8001).unwrap(); + fory.register::(8002).unwrap(); // Test HashMap>> let mut groups: std::collections::HashMap>> = @@ -567,8 +567,8 @@ fn test_mixed_trait_object_collections() { #[test] fn test_empty_trait_object_collections() { let mut fory = fory_compatible(); - fory.register_by_id::(8001).unwrap(); - fory.register_by_id::(8002).unwrap(); + fory.register::(8001).unwrap(); + fory.register::(8002).unwrap(); // Test empty Vec> let empty_animals: Vec> = vec![]; @@ -588,8 +588,8 @@ fn test_empty_trait_object_collections() { #[test] fn test_single_item_trait_object_collections() { let mut fory = fory_compatible(); - fory.register_by_id::(8001).unwrap(); - fory.register_by_id::(8002).unwrap(); + fory.register::(8001).unwrap(); + fory.register::(8002).unwrap(); // Test single item Vec> let single_animal: Vec> = vec![Box::new(Dog { diff --git a/rust/tests/tests/test_tuple.rs b/rust/tests/tests/test_tuple.rs index 3489366894..60663a7b23 100644 --- a/rust/tests/tests/test_tuple.rs +++ b/rust/tests/tests/test_tuple.rs @@ -269,7 +269,7 @@ fn run_struct_with_simple_tuple_fields(xlang: bool) { } let mut fory = Fory::builder().xlang(xlang).build(); - fory.register_by_id::(1).unwrap(); + fory.register::(1).unwrap(); let data = SimpleTupleStruct { id: 42, @@ -305,7 +305,7 @@ fn run_struct_with_complex_tuple_fields(xlang: bool) { } let mut fory = Fory::builder().xlang(xlang).build(); - fory.register_by_id::(2).unwrap(); + fory.register::(2).unwrap(); let data = ComplexTupleStruct { name: "Complex Test".to_string(), @@ -376,7 +376,7 @@ struct StructWithUnit { #[test] fn test_struct_with_unit_field() { let mut fory = Fory::default(); - fory.register_by_id::(200).unwrap(); + fory.register::(200).unwrap(); let value = StructWithUnit { name: "test".to_string(), diff --git a/rust/tests/tests/test_tuple_compatible.rs b/rust/tests/tests/test_tuple_compatible.rs index 19cd52018b..7811d0a21f 100644 --- a/rust/tests/tests/test_tuple_compatible.rs +++ b/rust/tests/tests/test_tuple_compatible.rs @@ -502,10 +502,10 @@ fn run_struct_missing_tuple_field(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register_by_id::(1).unwrap(); + fory1.register::(1).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register_by_id::(1).unwrap(); + fory2.register::(1).unwrap(); // Serialize V1 and deserialize as V2 let v1 = StructV1 { @@ -554,10 +554,10 @@ fn run_struct_added_tuple_field(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register_by_id::(2).unwrap(); + fory1.register::(2).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register_by_id::(2).unwrap(); + fory2.register::(2).unwrap(); // Serialize V1 and deserialize as V2 (new tuple fields should be default) let v1 = StructV1 { @@ -602,10 +602,10 @@ fn run_struct_tuple_element_increase(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register_by_id::(3).unwrap(); + fory1.register::(3).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register_by_id::(3).unwrap(); + fory2.register::(3).unwrap(); // Serialize V1 and deserialize as V2 (extra elements should be default) let v1 = StructV1 { @@ -649,10 +649,10 @@ fn run_struct_tuple_element_decrease(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register_by_id::(4).unwrap(); + fory1.register::(4).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register_by_id::(4).unwrap(); + fory2.register::(4).unwrap(); // Serialize V1 and deserialize as V2 (extra elements should be dropped) let v1 = StructV1 { @@ -699,10 +699,10 @@ fn run_struct_nested_tuple_evolution(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register_by_id::(5).unwrap(); + fory1.register::(5).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register_by_id::(5).unwrap(); + fory2.register::(5).unwrap(); // Serialize V1 and deserialize as V2 let v1 = StructV1 { @@ -756,10 +756,10 @@ fn run_struct_multiple_tuple_fields_evolution(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register_by_id::(6).unwrap(); + fory1.register::(6).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register_by_id::(6).unwrap(); + fory2.register::(6).unwrap(); // Serialize V1 and deserialize as V2 let v1 = StructV1 { @@ -926,10 +926,10 @@ fn run_struct_complex_evolution_scenario(xlang: bool) { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build(); - fory1.register_by_id::(100).unwrap(); + fory1.register::(100).unwrap(); let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build(); - fory2.register_by_id::(100).unwrap(); + fory2.register::(100).unwrap(); // Test V1 -> V2: Old schema to new schema let v1 = DataRecordV1 { @@ -1036,10 +1036,10 @@ fn test_tuple_alias() { // Use separate Fory instances with the same type ID let mut fory1 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(100).unwrap(); + fory1.register::(100).unwrap(); let mut fory2 = Fory::builder().compatible(true).build(); - fory2.register_by_id::(100).unwrap(); + fory2.register::(100).unwrap(); // Test record1 serialized by fory1, deserialized by fory2 let record1 = DataRecordV1 { diff --git a/rust/tests/tests/test_tuple_struct.rs b/rust/tests/tests/test_tuple_struct.rs index 00ef12ef5e..c01cc4c685 100644 --- a/rust/tests/tests/test_tuple_struct.rs +++ b/rust/tests/tests/test_tuple_struct.rs @@ -43,7 +43,7 @@ struct Single(i32); #[test] fn test_basic_tuple_struct() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let point = Point(3.15, 2.72); let bytes = fory.serialize(&point).unwrap(); @@ -54,7 +54,7 @@ fn test_basic_tuple_struct() { #[test] fn test_single_field_tuple_struct() { let mut fory = Fory::default(); - fory.register_by_id::(101).unwrap(); + fory.register::(101).unwrap(); let single = Single(42); let bytes = fory.serialize(&single).unwrap(); @@ -65,7 +65,7 @@ fn test_single_field_tuple_struct() { #[test] fn test_string_wrapper_tuple_struct() { let mut fory = Fory::default(); - fory.register_by_id::(102).unwrap(); + fory.register::(102).unwrap(); let wrapper = Wrapper("hello world".to_string()); let bytes = fory.serialize(&wrapper).unwrap(); @@ -76,7 +76,7 @@ fn test_string_wrapper_tuple_struct() { #[test] fn test_triple_tuple_struct() { let mut fory = Fory::default(); - fory.register_by_id::(103).unwrap(); + fory.register::(103).unwrap(); let triple = Triple(1, 2, 3); let bytes = fory.serialize(&triple).unwrap(); @@ -98,7 +98,7 @@ struct WithMap(HashMap); #[test] fn test_tuple_struct_with_vec() { let mut fory = Fory::default(); - fory.register_by_id::(104).unwrap(); + fory.register::(104).unwrap(); let data = WithVec(vec![1, 2, 3, 4, 5], "test".to_string()); let bytes = fory.serialize(&data).unwrap(); @@ -109,7 +109,7 @@ fn test_tuple_struct_with_vec() { #[test] fn test_tuple_struct_with_option() { let mut fory = Fory::default(); - fory.register_by_id::(105).unwrap(); + fory.register::(105).unwrap(); // Test with Some values let data1 = WithOption(Some(42), Some("hello".to_string())); @@ -133,7 +133,7 @@ fn test_tuple_struct_with_option() { #[test] fn test_tuple_struct_with_map() { let mut fory = Fory::default(); - fory.register_by_id::(106).unwrap(); + fory.register::(106).unwrap(); let mut map = HashMap::new(); map.insert("one".to_string(), 1); @@ -157,8 +157,8 @@ struct Outer(Inner, Vec); #[test] fn test_nested_tuple_structs() { let mut fory = Fory::default(); - fory.register_by_id::(107).unwrap(); - fory.register_by_id::(108).unwrap(); + fory.register::(107).unwrap(); + fory.register::(108).unwrap(); let inner1 = Inner(1, "first".to_string()); let inner2 = Inner(2, "second".to_string()); @@ -178,7 +178,7 @@ struct WithRc(Rc, Rc); #[test] fn test_tuple_struct_with_rc() { let mut fory = Fory::default(); - fory.register_by_id::(109).unwrap(); + fory.register::(109).unwrap(); let data = WithRc(Rc::new("shared".to_string()), Rc::new(42)); let bytes = fory.serialize(&data).unwrap(); @@ -199,9 +199,9 @@ struct NamedWithTupleStruct { #[test] fn test_named_struct_with_tuple_struct_fields() { let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); - fory.register_by_id::(102).unwrap(); - fory.register_by_id::(110).unwrap(); + fory.register::(100).unwrap(); + fory.register::(102).unwrap(); + fory.register::(110).unwrap(); let data = NamedWithTupleStruct { id: 1, @@ -222,7 +222,7 @@ struct TupleStructWithTuple(i32, (String, f64)); #[test] fn test_tuple_struct_with_tuple_field() { let mut fory = Fory::default(); - fory.register_by_id::(111).unwrap(); + fory.register::(111).unwrap(); let data = TupleStructWithTuple(42, ("hello".to_string(), 3.15)); let bytes = fory.serialize(&data).unwrap(); @@ -235,9 +235,9 @@ fn test_tuple_struct_with_tuple_field() { #[test] fn test_tuple_struct_xlang_mode() { let mut fory = Fory::builder().xlang(true).compatible(false).build(); - fory.register_by_id::(100).unwrap(); - fory.register_by_id::(102).unwrap(); - fory.register_by_id::(103).unwrap(); + fory.register::(100).unwrap(); + fory.register::(102).unwrap(); + fory.register::(103).unwrap(); let point = Point(3.15, 2.72); let bytes = fory.serialize(&point).unwrap(); @@ -263,7 +263,7 @@ struct EmptyVecTuple(Vec); #[test] fn test_tuple_struct_with_empty_vec() { let mut fory = Fory::default(); - fory.register_by_id::(112).unwrap(); + fory.register::(112).unwrap(); let data = EmptyVecTuple(vec![]); let bytes = fory.serialize(&data).unwrap(); @@ -277,7 +277,7 @@ struct LargeTupleStruct(i8, i16, i32, i64, u8, u16, u32, u64, f32, f64, bool, St #[test] fn test_large_tuple_struct() { let mut fory = Fory::default(); - fory.register_by_id::(113).unwrap(); + fory.register::(113).unwrap(); let data = LargeTupleStruct( 1, @@ -329,13 +329,13 @@ mod remote_v3 { #[test] fn test_tuple_struct_schema_evolution_add_field() { let mut fory_writer = Fory::builder().compatible(true).build(); - fory_writer.register_by_id::(100).unwrap(); + fory_writer.register::(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::builder().compatible(true).build(); - fory_reader.register_by_id::(100).unwrap(); + fory_reader.register::(100).unwrap(); let local_data: local_v2::Point = fory_reader.deserialize(&bytes).unwrap(); @@ -348,13 +348,13 @@ fn test_tuple_struct_schema_evolution_add_field() { #[test] fn test_tuple_struct_schema_evolution_remove_field() { let mut fory_writer = Fory::builder().compatible(true).build(); - fory_writer.register_by_id::(100).unwrap(); + fory_writer.register::(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::builder().compatible(true).build(); - fory_reader.register_by_id::(100).unwrap(); + fory_reader.register::(100).unwrap(); let local_data: remote_v1::Point = fory_reader.deserialize(&bytes).unwrap(); @@ -390,7 +390,7 @@ mod local_mixed_v3 { fn test_tuple_struct_schema_evolution_add_i64() { let mut fory_writer = Fory::builder().compatible(true).build(); fory_writer - .register_by_id::(100) + .register::(100) .unwrap(); let remote_data = remote_mixed_v1::MixedPoint(1.0, 2.0); @@ -398,7 +398,7 @@ fn test_tuple_struct_schema_evolution_add_i64() { let mut fory_reader = Fory::builder().compatible(true).build(); fory_reader - .register_by_id::(100) + .register::(100) .unwrap(); let local_data: local_mixed_v2::MixedPoint = fory_reader.deserialize(&bytes).unwrap(); @@ -413,7 +413,7 @@ fn test_tuple_struct_schema_evolution_add_i64() { fn test_tuple_struct_schema_evolution_add_u8() { let mut fory_writer = Fory::builder().compatible(true).build(); fory_writer - .register_by_id::(100) + .register::(100) .unwrap(); let remote_data = remote_mixed_v1::MixedPoint(1.0, 2.0); @@ -421,7 +421,7 @@ fn test_tuple_struct_schema_evolution_add_u8() { let mut fory_reader = Fory::builder().compatible(true).build(); fory_reader - .register_by_id::(100) + .register::(100) .unwrap(); let local_data: local_mixed_v3::MixedPoint = fory_reader.deserialize(&bytes).unwrap(); diff --git a/rust/tests/tests/test_unsigned.rs b/rust/tests/tests/test_unsigned.rs index ebdbf98ba2..6dcb714926 100644 --- a/rust/tests/tests/test_unsigned.rs +++ b/rust/tests/tests/test_unsigned.rs @@ -63,7 +63,7 @@ fn test_binary_when_xlang() { struct UnsignedData { binary: Vec, } - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let binary = vec![0u8, 1, 2, u8::MAX]; test_roundtrip(&fory, binary.clone()); let data = UnsignedData { binary }; @@ -133,7 +133,7 @@ fn test_unsigned_struct_non_compatible() { } let mut fory = Fory::default(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let data = UnsignedData { a: u8::MAX, @@ -174,7 +174,7 @@ fn test_unsigned_struct_compatible() { } let mut fory = Fory::builder().compatible(true).build(); - fory.register_by_id::(100).unwrap(); + fory.register::(100).unwrap(); let data = UnsignedData { a: u8::MAX, @@ -213,8 +213,8 @@ fn test_unsigned_struct_compatible_add_field() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(101).unwrap(); - fory2.register_by_id::(101).unwrap(); + fory1.register::(101).unwrap(); + fory2.register::(101).unwrap(); let data_v1 = UnsignedDataV1 { a: 255, b: 65535 }; let bytes = fory1.serialize(&data_v1).unwrap(); @@ -241,8 +241,8 @@ fn test_unsigned_struct_compatible_remove_field() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(102).unwrap(); - fory2.register_by_id::(102).unwrap(); + fory1.register::(102).unwrap(); + fory2.register::(102).unwrap(); let data_v1 = UnsignedDataV1 { a: 255, @@ -298,7 +298,7 @@ fn test_unsigned_with_option_non_compatible() { } let mut fory = Fory::default(); - fory.register_by_id::(103).unwrap(); + fory.register::(103).unwrap(); // Test with Some values let data_some = OptionalUnsigned { @@ -342,7 +342,7 @@ fn test_unsigned_with_option_compatible() { } let mut fory = Fory::builder().compatible(true).build(); - fory.register_by_id::(104).unwrap(); + fory.register::(104).unwrap(); // Test with Some values let data_some = OptionalUnsigned { @@ -395,8 +395,8 @@ fn test_unsigned_mixed_fields_compatible() { let mut fory1 = Fory::builder().compatible(true).build(); let mut fory2 = Fory::builder().compatible(true).build(); - fory1.register_by_id::(105).unwrap(); - fory2.register_by_id::(105).unwrap(); + fory1.register::(105).unwrap(); + fory2.register::(105).unwrap(); let data_v1 = MixedDataV1 { required_u8: 255, diff --git a/rust/tests/tests/test_weak.rs b/rust/tests/tests/test_weak.rs index 2ab49cbc22..9949427c96 100644 --- a/rust/tests/tests/test_weak.rs +++ b/rust/tests/tests/test_weak.rs @@ -134,7 +134,7 @@ fn test_rc_weak_field_in_struct() { } let mut fory = Fory::builder().track_ref(true).build(); - fory.register_by_id::(1000).unwrap(); + fory.register::(1000).unwrap(); let data = Rc::new(42i32); let node = SimpleNode { @@ -161,7 +161,7 @@ struct Node { fn test_node_circular_reference_with_parent_children() { // Register the Node type with Fory let mut fory = Fory::builder().track_ref(true).build(); - fory.register_by_id::(2000).unwrap(); + fory.register::(2000).unwrap(); // Create parent let parent = Rc::new(RefCell::new(Node { @@ -219,7 +219,7 @@ fn test_arc_mutex_circular_reference() { } let mut fory = Fory::builder().track_ref(true).build(); - fory.register_by_id::(6000).unwrap(); + fory.register::(6000).unwrap(); let parent = Arc::new(Mutex::new(Node { val: 10, From 812285add8bdf52f5297a994aa7dd38340bf3e08 Mon Sep 17 00:00:00 2001 From: chaokunyang Date: Sat, 9 May 2026 14:04:05 +0800 Subject: [PATCH 05/12] docs: simplify README performance section --- README.md | 32 ++++++++++---------------------- 1 file changed, 10 insertions(+), 22 deletions(-) diff --git a/README.md b/README.md index 8d856d2b7f..fc2b116aa5 100644 --- a/README.md +++ b/README.md @@ -50,38 +50,26 @@ exchange, and row-format random access. ## Performance -Charts labeled "compatible" use schema evolution mode. Other Java charts use -schema-consistent mode, where writer and reader class schemas are expected to -match. - -### Java serialization +**Java serialization** In Java serialization benchmarks, Fory reaches up to **170x** the throughput of JDK serialization on selected workloads. -**Serialization throughput** -

Java serialization throughput

-**Deserialization throughput** -

Java deserialization throughput

-**Xlang throughput** -

Java xlang throughput

-See [Java benchmarks](docs/benchmarks/java) for the full methodology and data. - -### Other runtime benchmarks +See [Java benchmarks](docs/benchmarks/java) for methodology and data. -### Rust +**Rust**

Rust serialization throughput @@ -89,7 +77,7 @@ See [Java benchmarks](docs/benchmarks/java) for the full methodology and data. See [Rust benchmarks](benchmarks/rust). -### C++ +**C++**

C++ serialization throughput @@ -97,7 +85,7 @@ See [Rust benchmarks](benchmarks/rust). See [C++ benchmarks](benchmarks/cpp). -### Go +**Go**

Go serialization throughput @@ -105,7 +93,7 @@ See [C++ benchmarks](benchmarks/cpp). See [Go benchmarks](benchmarks/go). -### Python +**Python**

Python serialization throughput @@ -113,7 +101,7 @@ See [Go benchmarks](benchmarks/go). See [Python benchmarks](benchmarks/python). -### JavaScript/TypeScript +**JavaScript/TypeScript**

JavaScript serialization throughput @@ -121,7 +109,7 @@ See [Python benchmarks](benchmarks/python). See [JavaScript benchmarks](docs/benchmarks/javascript). -### C# +**C#**

C# serialization throughput @@ -129,7 +117,7 @@ See [JavaScript benchmarks](docs/benchmarks/javascript). See [C# benchmarks](docs/benchmarks/csharp). -### Swift +**Swift**

Swift serialization throughput @@ -137,7 +125,7 @@ See [C# benchmarks](docs/benchmarks/csharp). See [Swift benchmarks](docs/benchmarks/swift). -### Dart +**Dart**

Dart serialization throughput From e3dd6699ce64cb1996c36adf265c175697c79a1b Mon Sep 17 00:00:00 2001 From: chaokunyang Date: Sat, 9 May 2026 14:06:54 +0800 Subject: [PATCH 06/12] docs: inline README benchmark links --- README.md | 36 +++++++++--------------------------- 1 file changed, 9 insertions(+), 27 deletions(-) diff --git a/README.md b/README.md index fc2b116aa5..33434fe82d 100644 --- a/README.md +++ b/README.md @@ -50,7 +50,7 @@ exchange, and row-format random access. ## Performance -**Java serialization** +**Java** ([benchmarks](docs/benchmarks/java)) In Java serialization benchmarks, Fory reaches up to **170x** the throughput of JDK serialization on selected workloads. @@ -67,72 +67,54 @@ JDK serialization on selected workloads. Java xlang throughput

-See [Java benchmarks](docs/benchmarks/java) for methodology and data. - -**Rust** +**Rust** ([benchmarks](benchmarks/rust))

Rust serialization throughput

-See [Rust benchmarks](benchmarks/rust). - -**C++** +**C++** ([benchmarks](benchmarks/cpp))

C++ serialization throughput

-See [C++ benchmarks](benchmarks/cpp). - -**Go** +**Go** ([benchmarks](benchmarks/go))

Go serialization throughput

-See [Go benchmarks](benchmarks/go). - -**Python** +**Python** ([benchmarks](benchmarks/python))

Python serialization throughput

-See [Python benchmarks](benchmarks/python). - -**JavaScript/TypeScript** +**JavaScript/TypeScript** ([benchmarks](docs/benchmarks/javascript))

JavaScript serialization throughput

-See [JavaScript benchmarks](docs/benchmarks/javascript). - -**C#** +**C#** ([benchmarks](docs/benchmarks/csharp))

C# serialization throughput

-See [C# benchmarks](docs/benchmarks/csharp). - -**Swift** +**Swift** ([benchmarks](docs/benchmarks/swift))

Swift serialization throughput

-See [Swift benchmarks](docs/benchmarks/swift). - -**Dart** +**Dart** ([benchmarks](docs/benchmarks/dart))

Dart serialization throughput

-See [Dart benchmarks](docs/benchmarks/dart). - ## Installation Pick the runtime you use and run the package-manager command, or paste the From acda7f961b20da867332dd2e9ec22473332c099f Mon Sep 17 00:00:00 2001 From: chaokunyang Date: Sat, 9 May 2026 14:09:11 +0800 Subject: [PATCH 07/12] docs: refine README section labels --- README.md | 82 +++++++++++++++++++++++++++---------------------------- 1 file changed, 41 insertions(+), 41 deletions(-) diff --git a/README.md b/README.md index 33434fe82d..6b5c5d3961 100644 --- a/README.md +++ b/README.md @@ -50,7 +50,7 @@ exchange, and row-format random access. ## Performance -**Java** ([benchmarks](docs/benchmarks/java)) +**Java** [Benchmarks](docs/benchmarks/java) In Java serialization benchmarks, Fory reaches up to **170x** the throughput of JDK serialization on selected workloads. @@ -67,49 +67,49 @@ JDK serialization on selected workloads. Java xlang throughput

-**Rust** ([benchmarks](benchmarks/rust)) +**Rust** [Benchmarks](benchmarks/rust)

Rust serialization throughput

-**C++** ([benchmarks](benchmarks/cpp)) +**C++** [Benchmarks](benchmarks/cpp)

C++ serialization throughput

-**Go** ([benchmarks](benchmarks/go)) +**Go** [Benchmarks](benchmarks/go)

Go serialization throughput

-**Python** ([benchmarks](benchmarks/python)) +**Python** [Benchmarks](benchmarks/python)

Python serialization throughput

-**JavaScript/TypeScript** ([benchmarks](docs/benchmarks/javascript)) +**JavaScript/TypeScript** [Benchmarks](docs/benchmarks/javascript)

JavaScript serialization throughput

-**C#** ([benchmarks](docs/benchmarks/csharp)) +**C#** [Benchmarks](docs/benchmarks/csharp)

C# serialization throughput

-**Swift** ([benchmarks](docs/benchmarks/swift)) +**Swift** [Benchmarks](docs/benchmarks/swift)

Swift serialization throughput

-**Dart** ([benchmarks](docs/benchmarks/dart)) +**Dart** [Benchmarks](docs/benchmarks/dart)

Dart serialization throughput @@ -120,7 +120,7 @@ JDK serialization on selected workloads. Pick the runtime you use and run the package-manager command, or paste the dependency block into your build file. -### Java +**Java** Maven: @@ -138,7 +138,7 @@ Gradle: implementation "org.apache.fory:fory-core:0.17.0" ``` -### Scala +**Scala** sbt: @@ -146,7 +146,7 @@ sbt: libraryDependencies += "org.apache.fory" %% "fory-scala" % "0.17.0" ``` -### Kotlin +**Kotlin** Gradle: @@ -164,7 +164,7 @@ Maven: ``` -### Python +**Python** ```bash pip install pyfory @@ -176,7 +176,7 @@ For row-format support: pip install "pyfory[format]" ``` -### Rust +**Rust** `Cargo.toml`: @@ -185,7 +185,7 @@ pip install "pyfory[format]" fory = "0.17" ``` -### C++ +**C++** CMake: @@ -217,13 +217,13 @@ deps = ["@fory//cpp/fory/serialization:fory_serialization"] See the [C++ installation guide](https://fory.apache.org/docs/guide/cpp/#installation) for complete CMake, Bazel, and source-build details. -### Go +**Go** ```bash go get github.com/apache/fory/go/fory ``` -### JavaScript/TypeScript +**JavaScript/TypeScript** ```bash npm install @apache-fory/core @@ -235,20 +235,20 @@ For the Node.js string fast path: npm install @apache-fory/core @apache-fory/hps ``` -### C# +**C#** ```bash dotnet add package Apache.Fory --version 0.17.0 ``` -### Dart +**Dart** ```bash dart pub add fory:^0.17.0 dart pub add dev:build_runner ``` -### Swift +**Swift** Add Fory to `Package.swift`: @@ -267,14 +267,14 @@ targets: [ See the [Swift guide](https://fory.apache.org/docs/guide/swift/) for generated serializer setup. -### Development from source +**Development From Source** See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md). Snapshots for Java, Scala, and Kotlin are available from `https://repository.apache.org/snapshots/` with the matching `-SNAPSHOT` version. -## Choose a mode +## Choose Serialization Mode | Mode | Use it when | Start here | | -------------------- | ------------------------------------------------------------- | -------------------------------------------------------- | @@ -300,13 +300,13 @@ For xlang, all peers must agree on type identity. Name-based registration is easier to read in examples. Numeric IDs are smaller and faster, but they require coordination across every reader and writer. -## Quick start: xlang serialization +## Cross-Language Serialization Xlang mode writes the cross-language Fory wire format. Bytes produced by one runtime can be read by another when the runtimes use the same type identity, compatible mode setting, and field schema. -### Java +**Java** ```java import org.apache.fory.Fory; @@ -332,7 +332,7 @@ public class Example { } ``` -### Python +**Python** ```python from dataclasses import dataclass @@ -352,7 +352,7 @@ person = fory.deserialize(data) print(person.name) ``` -### Go +**Go** ```go package main @@ -383,7 +383,7 @@ func main() { } ``` -### Rust +**Rust** ```rust use fory::{Error, Fory, ForyStruct}; @@ -408,7 +408,7 @@ fn main() -> Result<(), Error> { } ``` -### C++ +**C++** ```cpp #include "fory/serialization/fory.h" @@ -434,7 +434,7 @@ int main() { } ``` -### JavaScript/TypeScript +**JavaScript/TypeScript** ```ts import Fory, { Type } from "@apache-fory/core"; @@ -455,7 +455,7 @@ const person = deserialize(bytes); console.log(person.name); ``` -### C# +**C#** ```csharp using Apache.Fory; @@ -480,7 +480,7 @@ Console.WriteLine(person.Name); C# always writes the xlang frame header, so there is no separate xlang builder flag. -### Dart +**Dart** ```dart import 'package:fory/fory.dart'; @@ -521,7 +521,7 @@ running: dart run build_runner build --delete-conflicting-outputs ``` -### Swift +**Swift** ```swift import Fory @@ -540,7 +540,7 @@ let person: Person = try fory.deserialize(bytes) print(person.name) ``` -### Scala +**Scala** ```scala import org.apache.fory.Fory @@ -560,7 +560,7 @@ val person = fory.deserialize(bytes).asInstanceOf[Person] println(person.name) ``` -### Kotlin +**Kotlin** ```kotlin import org.apache.fory.Fory @@ -586,7 +586,7 @@ For shared/circular references, polymorphism, numeric IDs versus names, and type-mapping rules, see the [cross-language guide](docs/guide/xlang) and [type mapping specification](docs/specification/xlang_type_mapping.md). -## Native mode: same-language serialization +## Native Serialization Use native mode when the writer and reader are in the same language. Java and Python can serialize broader language-specific object graphs this way. The @@ -656,13 +656,13 @@ KotlinSerializers.registerSerializers(fory) // Register, serialize, and deserialize as in the xlang example above. ``` -## Row format +## Row Format Row format is for random access and partial reads. These examples encode an object with an integer array field, then read one array element from the binary row without rebuilding the object. -### Python +**Python** ```python from dataclasses import dataclass @@ -684,7 +684,7 @@ print(row.name) print(row.scores[1]) ``` -### Java +**Java** ```java public class User { @@ -719,7 +719,7 @@ deserialization, see the ## Documentation -### User guides +**User Guides** | Guide | Source | Website | | --------------------- | ------------------------------------------------------------------------ | --------------------------------------------------------------- | @@ -739,7 +739,7 @@ deserialization, see the | GraalVM native image | [docs/guide/java/graalvm-support.md](docs/guide/java/graalvm-support.md) | [View](https://fory.apache.org/docs/guide/java/graalvm_support) | | Development | [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) | [View](docs/DEVELOPMENT.md) | -### Specifications +**Specifications** | Specification | Source | Website | | ---------------------- | ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | @@ -748,7 +748,7 @@ deserialization, see the | Row format | [row_format_spec.md](docs/specification/row_format_spec.md) | [View](https://fory.apache.org/docs/specification/fory_row_format_spec) | | Cross-language mapping | [xlang_type_mapping.md](docs/specification/xlang_type_mapping.md) | [View](https://fory.apache.org/docs/specification/fory_xlang_serialization_spec) | -## Community and support +## Community - [Slack workspace](https://join.slack.com/t/fory-project/shared_invite/zt-36g0qouzm-kcQSvV_dtfbtBKHRwT5gsw) - [@ApacheFory on X](https://x.com/ApacheFory) From 5de249d527a129cef1b3788a73ee7f24c7ceb1bc Mon Sep 17 00:00:00 2001 From: chaokunyang Date: Sat, 9 May 2026 14:27:17 +0800 Subject: [PATCH 08/12] docs: strengthen README performance summary --- README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/README.md b/README.md index 6b5c5d3961..3990850657 100644 --- a/README.md +++ b/README.md @@ -50,6 +50,11 @@ exchange, and row-format random access. ## Performance +Benchmarks show Fory delivering higher throughput and smaller serialized +payloads than common serialization frameworks on representative workloads. Java +has the broadest comparison set; the other charts show runtime-specific results +across supported languages. + **Java** [Benchmarks](docs/benchmarks/java) In Java serialization benchmarks, Fory reaches up to **170x** the throughput of From b42b9891679faca62e7290cbc33fcc6f06069bb5 Mon Sep 17 00:00:00 2001 From: chaokunyang Date: Sat, 9 May 2026 14:29:58 +0800 Subject: [PATCH 09/12] docs: condense README benchmark charts --- README.md | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 3990850657..eb8b025a44 100644 --- a/README.md +++ b/README.md @@ -72,12 +72,21 @@ JDK serialization on selected workloads. Java xlang throughput

+**Python** [Benchmarks](benchmarks/python) + +

+Python serialization throughput +

+ **Rust** [Benchmarks](benchmarks/rust)

Rust serialization throughput

+
+Benchmarks for C++, Go, JavaScript/TypeScript, C#, Swift, and Dart + **C++** [Benchmarks](benchmarks/cpp)

@@ -90,12 +99,6 @@ JDK serialization on selected workloads. Go serialization throughput

-**Python** [Benchmarks](benchmarks/python) - -

-Python serialization throughput -

- **JavaScript/TypeScript** [Benchmarks](docs/benchmarks/javascript)

@@ -120,6 +123,8 @@ JDK serialization on selected workloads. Dart serialization throughput

+
+ ## Installation Pick the runtime you use and run the package-manager command, or paste the From 2a34ef7d534cf5a1d15de44890d804a3d9c98f3d Mon Sep 17 00:00:00 2001 From: chaokunyang Date: Sat, 9 May 2026 14:38:24 +0800 Subject: [PATCH 10/12] docs: update project description --- .asf.yaml | 2 +- README.md | 5 ++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/.asf.yaml b/.asf.yaml index 4dece2dacb..dc7a48f32c 100644 --- a/.asf.yaml +++ b/.asf.yaml @@ -19,7 +19,7 @@ github: description: >- - A multi-language serialization framework for idiomatic domain objects, schema IDL, fast object serialization, cross-language data exchange, and row-format random access. + A blazingly fast multi-language serialization framework for idiomatic domain objects, schema IDL, and cross-language data exchange. homepage: https://fory.apache.org labels: - javascript diff --git a/README.md b/README.md index eb8b025a44..9489c28ac5 100644 --- a/README.md +++ b/README.md @@ -12,9 +12,8 @@ [![NuGet](https://img.shields.io/nuget/v/Apache.Fory?logo=nuget&style=for-the-badge)](https://www.nuget.org/packages/Apache.Fory) [![pub.dev](https://img.shields.io/pub/v/fory?logo=dart&style=for-the-badge)](https://pub.dev/packages/fory) -**Apache Fory™** is a multi-language serialization framework for idiomatic -domain objects, schema IDL, fast object serialization, cross-language data -exchange, and row-format random access. +**Apache Fory™** is a blazingly fast multi-language serialization framework for +idiomatic domain objects, schema IDL, and cross-language data exchange. From 8a24449783f10dc80400a421a71eebc857300acf Mon Sep 17 00:00:00 2001 From: chaokunyang Date: Sat, 9 May 2026 14:56:17 +0800 Subject: [PATCH 11/12] docs: restructure README Why Fory --- README.md | 40 ++++++++++++++++++++++------------------ 1 file changed, 22 insertions(+), 18 deletions(-) diff --git a/README.md b/README.md index 9489c28ac5..c9b1c668d6 100644 --- a/README.md +++ b/README.md @@ -25,25 +25,29 @@ idiomatic domain objects, schema IDL, and cross-language data exchange. ## Why Fory -- **Domain-object first**: Serialize Java classes, Python dataclasses, Go +Fory is built for fast, compact serialization across languages and runtimes. It +works with idiomatic objects in each language, supports shared schemas when you +need a contract, and preserves object features such as shared and circular +references. + +- **Efficient Cross-Language Encoding**: Exchange payloads across supported + languages with compact binary encoding, metadata packing, schema evolution, + type mapping, shared/circular references, and polymorphic runtime types. +- **Domain Objects First**: Serialize Java classes, Python dataclasses, Go structs, Rust/C++ structs, and generated or annotated model types directly. - You do not need an IDL file to start. -- **Schema IDL with native domain objects**: For shared schemas, define numbers, - strings, lists, maps, arrays, enums, structs, and unions once, then generate - domain objects that use each language's native types. -- **Fast paths in one codebase**: Native serialization, xlang serialization, - and row format all benefit from Fory's optimized runtime work, including Java - JIT serializers and generated/static serializers in other runtimes. -- **Xlang wire format**: Exchange payloads across supported languages with - compact binary encoding, metadata packing, cross-language type mapping, and - polymorphic runtime types. -- **Shared and circular references**: Preserve object identity for graphs that - need it. -- **Schema evolution**: Add or delete fields while services deploy - independently, with compatible mode handling forward and backward reads. -- **Row format**: Use zero-copy random access, partial reads/deserialization, - and Arrow integration when jobs need fields instead of whole objects. -- **Broad runtime support**: Java, Python, C++, Go, Rust, + Preserve shared and circular references when object identity matters. +- **Reference-Aware Schema IDL**: Fory is the first schema IDL to bring + references into the type system, so shared and circular references are part of + the schema instead of runtime-only behavior. It also provides a rich type + system for numbers, strings, lists, maps, arrays, enums, structs, and unions. + Define schemas once, then generate native domain objects that fit each + language's type system without forcing wrapper types into user code. +- **Row-Format Random Access**: Read fields, arrays, and nested values without + rebuilding full objects, with zero-copy access, partial reads, and Arrow + integration. +- **Optimized Runtimes**: Java JIT serializers and generated/static serializers + in other runtimes keep hot paths fast and payloads compact. +- **Language And Platform Support**: Java, Python, C++, Go, Rust, JavaScript/TypeScript, C#, Swift, Dart, Scala, and Kotlin, including GraalVM native image, Dart VM/Flutter/web, and Node.js/browser JavaScript. From 0199bc920104fed59bb6ce24fbe571d1e2d706a7 Mon Sep 17 00:00:00 2001 From: chaokunyang Date: Sat, 9 May 2026 15:09:10 +0800 Subject: [PATCH 12/12] docs: refine README wording --- README.md | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index c9b1c668d6..6964aa0f48 100644 --- a/README.md +++ b/README.md @@ -32,16 +32,14 @@ references. - **Efficient Cross-Language Encoding**: Exchange payloads across supported languages with compact binary encoding, metadata packing, schema evolution, - type mapping, shared/circular references, and polymorphic runtime types. + shared/circular references, and polymorphic runtime types. - **Domain Objects First**: Serialize Java classes, Python dataclasses, Go structs, Rust/C++ structs, and generated or annotated model types directly. Preserve shared and circular references when object identity matters. -- **Reference-Aware Schema IDL**: Fory is the first schema IDL to bring - references into the type system, so shared and circular references are part of - the schema instead of runtime-only behavior. It also provides a rich type - system for numbers, strings, lists, maps, arrays, enums, structs, and unions. - Define schemas once, then generate native domain objects that fit each - language's type system without forcing wrapper types into user code. +- **Reference-Aware Schema IDL**: Support shared and circular references + directly in the schema, alongside numbers, strings, lists, maps, arrays, + enums, structs, and unions. Define schemas once, then generate native domain + objects for each language without forcing wrapper types into user code. - **Row-Format Random Access**: Read fields, arrays, and nested values without rebuilding full objects, with zero-copy access, partial reads, and Arrow integration. @@ -214,16 +212,14 @@ FetchContent_MakeAvailable(fory) target_link_libraries(my_app PRIVATE fory::serialization) ``` -Bazel `MODULE.bazel`: +Bazel: ```bazel +# MODULE.bazel bazel_dep(name = "fory", version = "0.17.0") git_override(module_name = "fory", remote = "https://github.com/apache/fory.git", commit = "v0.17.0") -``` - -Bazel `BUILD`: -```bazel +# BUILD deps = ["@fory//cpp/fory/serialization:fory_serialization"] ```