You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@fory.apache.org by ch...@apache.org on 2025/10/15 15:50:39 UTC
(fory) branch main updated: feat(rust): refactor rust serialization system (#2774)
This is an automated email from the ASF dual-hosted git repository.
chaokunyang pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/fory.git
The following commit(s) were added to refs/heads/main by this push:
new e2f1f84e7 feat(rust): refactor rust serialization system (#2774)
e2f1f84e7 is described below
commit e2f1f84e78577ea36f40f8bdeff2c5be89593969
Author: Shawn Yang <sh...@gmail.com>
AuthorDate: Wed Oct 15 21:20:36 2025 +0530
feat(rust): refactor rust serialization system (#2774)
## Why?
Simplify the serialization interface for better ergonomics API
## What does this PR do?
- Remove `Fory` from `Serializer` trait
- Make `WriteContext` as only enviroment for serialization
- Make `ReadContext` as only enviroment for deserialization
- Use `OnceLock` for thread-safe, lazily initialization for `Pool`
## Related issues
#2737
## Does this PR introduce any user-facing change?
<!--
If any user-facing interface changes, please [open an
issue](https://github.com/apache/fory/issues/new/choose) describing the
need to do so and update the document if necessary.
Delete section if not applicable.
-->
- [ ] Does this PR introduce any public API change?
- [ ] Does this PR introduce any binary protocol compatibility change?
## Benchmark
<!--
When the PR has an impact on performance (if you don't know whether the
PR will have an impact on performance, you can submit the PR first, and
if it will have impact on performance, the code reviewer will explain
it), be sure to attach a benchmark data here.
Delete section if not applicable.
-->
---
rust/README.md | 4 +-
rust/fory-core/src/error.rs | 4 +-
rust/fory-core/src/fory.rs | 144 +++++++++-----
rust/fory-core/src/resolver/context.rs | 212 +++++++++++++++++----
rust/fory-core/src/resolver/meta_resolver.rs | 14 +-
rust/fory-core/src/resolver/type_resolver.rs | 238 ++++++++++++------------
rust/fory-core/src/serializer/any.rs | 173 ++++++-----------
rust/fory-core/src/serializer/arc.rs | 58 ++----
rust/fory-core/src/serializer/bool.rs | 35 +---
rust/fory-core/src/serializer/box_.rs | 43 ++---
rust/fory-core/src/serializer/collection.rs | 27 +--
rust/fory-core/src/serializer/datetime.rs | 68 ++-----
rust/fory-core/src/serializer/enum_.rs | 36 ++--
rust/fory-core/src/serializer/heap.rs | 35 +---
rust/fory-core/src/serializer/list.rs | 109 +++--------
rust/fory-core/src/serializer/map.rs | 139 +++++---------
rust/fory-core/src/serializer/mod.rs | 127 +++++--------
rust/fory-core/src/serializer/mutex.rs | 56 ++----
rust/fory-core/src/serializer/number.rs | 25 +--
rust/fory-core/src/serializer/option.rs | 45 ++---
rust/fory-core/src/serializer/rc.rs | 58 ++----
rust/fory-core/src/serializer/refcell.rs | 56 ++----
rust/fory-core/src/serializer/set.rs | 76 +++-----
rust/fory-core/src/serializer/skip.rs | 33 ++--
rust/fory-core/src/serializer/string.rs | 37 +---
rust/fory-core/src/serializer/struct_.rs | 71 ++-----
rust/fory-core/src/serializer/trait_object.rs | 135 ++++++--------
rust/fory-core/src/serializer/weak.rs | 114 ++++--------
rust/fory-derive/src/object/derive_enum.rs | 14 +-
rust/fory-derive/src/object/misc.rs | 4 +-
rust/fory-derive/src/object/read.rs | 70 +++----
rust/fory-derive/src/object/serializer.rs | 36 ++--
rust/fory-derive/src/object/util.rs | 2 +-
rust/fory-derive/src/object/write.rs | 26 +--
rust/fory/src/lib.rs | 12 +-
rust/tests/tests/compatible/test_basic_type.rs | 16 +-
rust/tests/tests/compatible/test_container.rs | 40 ++--
rust/tests/tests/compatible/test_struct_enum.rs | 59 +++---
rust/tests/tests/test_cross_language.rs | 53 +++---
rust/tests/tests/test_ext.rs | 25 +--
40 files changed, 1068 insertions(+), 1461 deletions(-)
diff --git a/rust/README.md b/rust/README.md
index 5891cd95e..607c556be 100644
--- a/rust/README.md
+++ b/rust/README.md
@@ -616,8 +616,8 @@ impl Serializer for CustomType {
Ok(Self { value, name })
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> u32 {
- Self::fory_get_type_id(fory)
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> u32 {
+ Self::fory_get_type_id(type_resolver)
}
fn as_any(&self) -> &dyn Any {
diff --git a/rust/fory-core/src/error.rs b/rust/fory-core/src/error.rs
index 4cbee205c..291608033 100644
--- a/rust/fory-core/src/error.rs
+++ b/rust/fory-core/src/error.rs
@@ -78,7 +78,7 @@ impl Error {
}
}
-/// Ensures a condition is true; otherwise returns an [`Error`].
+/// Ensures a condition is true; otherwise returns an [`enum@Error`].
///
/// # Examples
/// ```
@@ -110,7 +110,7 @@ macro_rules! ensure {
};
}
-/// Returns early with an [`Error`].
+/// Returns early with an [`enum@Error`].
///
/// # Examples
/// ```
diff --git a/rust/fory-core/src/fory.rs b/rust/fory-core/src/fory.rs
index 2a6322ff4..c80b1a2dc 100644
--- a/rust/fory-core/src/fory.rs
+++ b/rust/fory-core/src/fory.rs
@@ -29,6 +29,7 @@ use crate::types::{
Language, MAGIC_NUMBER, SIZE_OF_REF_AND_TYPE,
};
use crate::util::get_ext_actual_type_id;
+use std::sync::OnceLock;
static EMPTY_STRING: String = String::new();
@@ -82,21 +83,13 @@ pub struct Fory {
type_resolver: TypeResolver,
compress_string: bool,
max_dyn_depth: u32,
- write_context_pool: Pool<WriteContext>,
- read_context_pool: Pool<ReadContext>,
+ // Lazy-initialized pools (thread-safe, one-time initialization)
+ write_context_pool: OnceLock<Pool<WriteContext>>,
+ read_context_pool: OnceLock<Pool<ReadContext>>,
}
impl Default for Fory {
fn default() -> Self {
- let write_context_constructor = || {
- let writer = Writer::default();
- WriteContext::new(writer)
- };
- let read_context_constructor = || {
- let reader = Reader::new(&[]);
- // when context is popped out, max_dyn_depth will be assigned a valid value
- ReadContext::new(reader, 0)
- };
Fory {
compatible: false,
xlang: true,
@@ -104,8 +97,8 @@ impl Default for Fory {
type_resolver: TypeResolver::default(),
compress_string: false,
max_dyn_depth: 5,
- write_context_pool: Pool::new(write_context_constructor),
- read_context_pool: Pool::new(read_context_constructor),
+ write_context_pool: OnceLock::new(),
+ read_context_pool: OnceLock::new(),
}
}
}
@@ -248,6 +241,11 @@ impl Fory {
self
}
+ /// Returns whether cross-language serialization is enabled.
+ pub fn is_xlang(&self) -> bool {
+ self.xlang
+ }
+
/// Returns the current serialization mode.
///
/// # Returns
@@ -275,12 +273,13 @@ impl Fory {
self.share_meta
}
- /// Returns a reference to the type resolver.
- ///
- /// # Returns
- ///
- /// A reference to the internal `TypeResolver` used for type registration and lookup.
- pub fn get_type_resolver(&self) -> &TypeResolver {
+ /// Returns the maximum depth for nested dynamic object serialization.
+ pub fn get_max_dyn_depth(&self) -> u32 {
+ self.max_dyn_depth
+ }
+
+ /// Returns a type resolver for type lookups.
+ pub(crate) fn get_type_resolver(&self) -> &TypeResolver {
&self.type_resolver
}
@@ -384,14 +383,34 @@ impl Fory {
/// let deserialized: Point = fory.deserialize(&bytes).unwrap();
/// ```
pub fn deserialize<T: Serializer + ForyDefault>(&self, bf: &[u8]) -> Result<T, Error> {
- let mut context = self.read_context_pool.get();
+ let pool = self.read_context_pool.get_or_init(|| {
+ let type_resolver = self.type_resolver.clone();
+ let compatible = self.compatible;
+ let share_meta = self.share_meta;
+ let xlang = self.xlang;
+ let max_dyn_depth = self.max_dyn_depth;
+
+ let factory = move || {
+ let reader = Reader::new(&[]);
+ ReadContext::new(
+ reader,
+ type_resolver.clone(),
+ compatible,
+ share_meta,
+ xlang,
+ max_dyn_depth,
+ )
+ };
+ Pool::new(factory)
+ });
+ let mut context = pool.get();
context.init(bf, self.max_dyn_depth);
let result = self.deserialize_with_context(&mut context);
if result.is_ok() {
assert_eq!(context.reader.slice_after_cursor().len(), 0);
}
context.reset();
- self.read_context_pool.put(context);
+ pool.put(context);
result
}
@@ -404,14 +423,13 @@ impl Fory {
return Ok(T::fory_default());
}
let mut bytes_to_skip = 0;
- if self.compatible {
+ if context.is_compatible() {
let meta_offset = context.reader.read_i32()?;
if meta_offset != -1 {
- bytes_to_skip =
- context.load_meta(self.get_type_resolver(), meta_offset as usize)?;
+ bytes_to_skip = context.load_meta(meta_offset as usize)?;
}
}
- let result = <T as Serializer>::fory_read(self, context, false);
+ let result = <T as Serializer>::fory_read(context, false);
if bytes_to_skip > 0 {
context.reader.skip(bytes_to_skip)?;
}
@@ -447,10 +465,30 @@ impl Fory {
/// let bytes = fory.serialize(&point);
/// ```
pub fn serialize<T: Serializer>(&self, record: &T) -> Result<Vec<u8>, Error> {
- let mut context = self.write_context_pool.get();
+ let pool = self.write_context_pool.get_or_init(|| {
+ let type_resolver = self.type_resolver.clone();
+ let compatible = self.compatible;
+ let share_meta = self.share_meta;
+ let compress_string = self.compress_string;
+ let xlang = self.xlang;
+
+ let factory = move || {
+ let writer = Writer::default();
+ WriteContext::new(
+ writer,
+ type_resolver.clone(),
+ compatible,
+ share_meta,
+ compress_string,
+ xlang,
+ )
+ };
+ Pool::new(factory)
+ });
+ let mut context = pool.get();
let result = self.serialize_with_context(record, &mut context)?;
context.reset();
- self.write_context_pool.put(context);
+ pool.put(context);
Ok(result)
}
@@ -463,11 +501,11 @@ impl Fory {
self.write_head::<T>(is_none, &mut context.writer);
let meta_start_offset = context.writer.len();
if !is_none {
- if self.compatible {
+ if context.is_compatible() {
context.writer.write_i32(-1);
};
- <T as Serializer>::fory_write(record, self, context, false)?;
- if self.compatible && !context.empty() {
+ <T as Serializer>::fory_write(record, context, false)?;
+ if context.is_compatible() && !context.empty() {
context.write_meta(meta_start_offset);
}
}
@@ -506,9 +544,15 @@ impl Fory {
id: u32,
) -> Result<(), Error> {
let actual_type_id = T::fory_actual_type_id(id, false, self.compatible);
- let type_info =
- TypeInfo::new::<T>(self, actual_type_id, &EMPTY_STRING, &EMPTY_STRING, false)?;
- self.type_resolver.register::<T>(&type_info)
+ let type_info = TypeInfo::new::<T>(
+ &self.type_resolver,
+ actual_type_id,
+ &EMPTY_STRING,
+ &EMPTY_STRING,
+ false,
+ )?;
+ self.type_resolver.register::<T>(&type_info)?;
+ Ok(())
}
/// Registers a struct type with a namespace and type name for cross-language serialization.
@@ -547,8 +591,15 @@ impl Fory {
type_name: &str,
) -> Result<(), Error> {
let actual_type_id = T::fory_actual_type_id(0, true, self.compatible);
- let type_info = TypeInfo::new::<T>(self, actual_type_id, namespace, type_name, true)?;
- self.type_resolver.register::<T>(&type_info)
+ let type_info = TypeInfo::new::<T>(
+ &self.type_resolver,
+ actual_type_id,
+ namespace,
+ type_name,
+ true,
+ )?;
+ self.type_resolver.register::<T>(&type_info)?;
+ Ok(())
}
/// Registers a struct type with a type name (using the default namespace).
@@ -617,13 +668,14 @@ impl Fory {
) -> Result<(), Error> {
let actual_type_id = get_ext_actual_type_id(id, false);
let type_info = TypeInfo::new_with_empty_fields::<T>(
- self,
+ &self.type_resolver,
actual_type_id,
&EMPTY_STRING,
&EMPTY_STRING,
false,
)?;
- self.type_resolver.register_serializer::<T>(&type_info)
+ self.type_resolver.register_serializer::<T>(&type_info)?;
+ Ok(())
}
/// Registers a custom serializer type with a namespace and type name.
@@ -648,9 +700,15 @@ impl Fory {
type_name: &str,
) -> Result<(), Error> {
let actual_type_id = get_ext_actual_type_id(0, true);
- let type_info =
- TypeInfo::new_with_empty_fields::<T>(self, actual_type_id, namespace, type_name, true)?;
- self.type_resolver.register_serializer::<T>(&type_info)
+ let type_info = TypeInfo::new_with_empty_fields::<T>(
+ &self.type_resolver,
+ actual_type_id,
+ namespace,
+ type_name,
+ true,
+ )?;
+ self.type_resolver.register_serializer::<T>(&type_info)?;
+ Ok(())
}
/// Registers a custom serializer type with a type name (using the default namespace).
@@ -676,17 +734,15 @@ impl Fory {
pub fn write_data<T: Serializer>(
this: &T,
- fory: &Fory,
context: &mut WriteContext,
is_field: bool,
) -> Result<(), Error> {
- T::fory_write_data(this, fory, context, is_field)
+ T::fory_write_data(this, context, is_field)
}
pub fn read_data<T: Serializer + ForyDefault>(
- fory: &Fory,
context: &mut ReadContext,
is_field: bool,
) -> Result<T, Error> {
- T::fory_read_data(fory, context, is_field)
+ T::fory_read_data(context, is_field)
}
diff --git a/rust/fory-core/src/resolver/context.rs b/rust/fory-core/src/resolver/context.rs
index e95ad95f3..94aaa45b3 100644
--- a/rust/fory-core/src/resolver/context.rs
+++ b/rust/fory-core/src/resolver/context.rs
@@ -16,9 +16,9 @@
// under the License.
use crate::buffer::{Reader, Writer};
-use crate::fory::Fory;
use crate::error::Error;
+use crate::fory::Fory;
use crate::meta::{MetaString, TypeMeta};
use crate::resolver::meta_resolver::{MetaReaderResolver, MetaWriterResolver};
use crate::resolver::metastring_resolver::{
@@ -29,6 +29,14 @@ use crate::resolver::type_resolver::{Harness, TypeResolver};
use std::sync::{Arc, Mutex};
pub struct WriteContext {
+ // Replicated environment fields (direct access, no Arc indirection for flags)
+ type_resolver: TypeResolver,
+ compatible: bool,
+ share_meta: bool,
+ compress_string: bool,
+ xlang: bool,
+
+ // Context-specific fields
pub writer: Writer,
meta_resolver: MetaWriterResolver,
meta_string_resolver: MetaStringWriterResolver,
@@ -36,8 +44,34 @@ pub struct WriteContext {
}
impl WriteContext {
- pub fn new(writer: Writer) -> WriteContext {
+ pub fn new(
+ writer: Writer,
+ type_resolver: TypeResolver,
+ compatible: bool,
+ share_meta: bool,
+ compress_string: bool,
+ xlang: bool,
+ ) -> WriteContext {
+ WriteContext {
+ type_resolver,
+ compatible,
+ share_meta,
+ compress_string,
+ xlang,
+ writer,
+ meta_resolver: MetaWriterResolver::default(),
+ meta_string_resolver: MetaStringWriterResolver::default(),
+ ref_writer: RefWriter::new(),
+ }
+ }
+
+ pub fn new_from_fory(writer: Writer, fory: &Fory) -> WriteContext {
WriteContext {
+ type_resolver: fory.get_type_resolver().clone(),
+ compatible: fory.is_compatible(),
+ share_meta: fory.is_share_meta(),
+ compress_string: fory.is_compress_string(),
+ xlang: fory.is_xlang(),
writer,
meta_resolver: MetaWriterResolver::default(),
meta_string_resolver: MetaStringWriterResolver::default(),
@@ -45,14 +79,44 @@ impl WriteContext {
}
}
+ /// Get type resolver
+ #[inline(always)]
+ pub fn get_type_resolver(&self) -> &TypeResolver {
+ &self.type_resolver
+ }
+
+ /// Check if compatible mode is enabled
+ #[inline(always)]
+ pub fn is_compatible(&self) -> bool {
+ self.compatible
+ }
+
+ /// Check if meta sharing is enabled
+ #[inline(always)]
+ pub fn is_share_meta(&self) -> bool {
+ self.share_meta
+ }
+
+ /// Check if string compression is enabled
+ #[inline(always)]
+ pub fn is_compress_string(&self) -> bool {
+ self.compress_string
+ }
+
+ /// Check if cross-language mode is enabled
+ #[inline(always)]
+ pub fn is_xlang(&self) -> bool {
+ self.xlang
+ }
+
#[inline(always)]
pub fn empty(&mut self) -> bool {
self.meta_resolver.empty()
}
#[inline(always)]
- pub fn push_meta(&mut self, fory: &Fory, type_id: std::any::TypeId) -> Result<usize, Error> {
- self.meta_resolver.push(type_id, fory)
+ pub fn push_meta(&mut self, type_id: std::any::TypeId) -> Result<usize, Error> {
+ self.meta_resolver.push(type_id, &self.type_resolver)
}
#[inline(always)]
@@ -66,46 +130,49 @@ impl WriteContext {
pub fn write_any_typeinfo(
&mut self,
- fory: &Fory,
concrete_type_id: std::any::TypeId,
) -> Result<Arc<Harness>, Error> {
use crate::types::TypeId as ForyTypeId;
- let type_resolver = fory.get_type_resolver();
- let type_info = type_resolver.get_type_info(concrete_type_id)?;
+ let type_info = self.type_resolver.get_type_info(concrete_type_id)?;
let fory_type_id = type_info.get_type_id();
- if type_info.is_registered_by_name() {
+ // Clone out the data we need from `type_info` to break the borrow
+ let namespace = type_info.get_namespace().clone();
+ let type_name = type_info.get_type_name().clone();
+ let registered_by_name = type_info.is_registered_by_name();
+
+ if registered_by_name {
if fory_type_id & 0xff == ForyTypeId::NAMED_STRUCT as u32 {
self.writer.write_varuint32(fory_type_id);
- if fory.is_share_meta() {
- let meta_index = self.push_meta(fory, concrete_type_id)? as u32;
+ if self.is_share_meta() {
+ let meta_index = self.push_meta(concrete_type_id)? as u32;
self.writer.write_varuint32(meta_index);
} else {
- type_info.get_namespace().write_to(&mut self.writer);
- type_info.get_type_name().write_to(&mut self.writer);
+ namespace.write_to(&mut self.writer);
+ type_name.write_to(&mut self.writer);
}
} else if fory_type_id & 0xff == ForyTypeId::NAMED_COMPATIBLE_STRUCT as u32 {
self.writer.write_varuint32(fory_type_id);
- let meta_index = self.push_meta(fory, concrete_type_id)? as u32;
+ let meta_index = self.push_meta(concrete_type_id)? as u32;
self.writer.write_varuint32(meta_index);
} else {
self.writer.write_varuint32(u32::MAX);
- type_info.get_namespace().write_to(&mut self.writer);
- type_info.get_type_name().write_to(&mut self.writer);
+ namespace.write_to(&mut self.writer);
+ type_name.write_to(&mut self.writer);
}
- type_resolver
- .get_name_harness(type_info.get_namespace(), type_info.get_type_name())
+ self.type_resolver
+ .get_name_harness(&namespace, &type_name)
.ok_or_else(|| Error::TypeError("Name harness not found".into()))
} else {
if fory_type_id & 0xff == ForyTypeId::COMPATIBLE_STRUCT as u32 {
self.writer.write_varuint32(fory_type_id);
- let meta_index = self.push_meta(fory, concrete_type_id)? as u32;
+ let meta_index = self.push_meta(concrete_type_id)? as u32;
self.writer.write_varuint32(meta_index);
} else {
self.writer.write_varuint32(fory_type_id);
}
- type_resolver
+ self.type_resolver
.get_harness(fory_type_id)
.ok_or_else(|| Error::TypeError("ID harness not found".into()))
}
@@ -126,26 +193,89 @@ impl WriteContext {
}
pub struct ReadContext {
+ // Replicated environment fields (direct access, no Arc indirection for flags)
+ type_resolver: TypeResolver,
+ compatible: bool,
+ share_meta: bool,
+ xlang: bool,
+ max_dyn_depth: u32,
+
+ // Context-specific fields
pub reader: Reader,
pub meta_resolver: MetaReaderResolver,
meta_string_resolver: MetaStringReaderResolver,
pub ref_reader: RefReader,
- max_dyn_depth: u32,
current_depth: u32,
}
impl ReadContext {
- pub fn new(reader: Reader, max_dyn_depth: u32) -> ReadContext {
+ pub fn new(
+ reader: Reader,
+ type_resolver: TypeResolver,
+ compatible: bool,
+ share_meta: bool,
+ xlang: bool,
+ max_dyn_depth: u32,
+ ) -> ReadContext {
ReadContext {
+ type_resolver,
+ compatible,
+ share_meta,
+ xlang,
+ max_dyn_depth,
reader,
meta_resolver: MetaReaderResolver::default(),
meta_string_resolver: MetaStringReaderResolver::default(),
ref_reader: RefReader::new(),
- max_dyn_depth,
current_depth: 0,
}
}
+ pub fn new_from_fory(reader: Reader, fory: &Fory) -> ReadContext {
+ ReadContext {
+ type_resolver: fory.get_type_resolver().clone(),
+ compatible: fory.is_compatible(),
+ share_meta: fory.is_share_meta(),
+ xlang: fory.is_xlang(),
+ max_dyn_depth: fory.get_max_dyn_depth(),
+ reader,
+ meta_resolver: MetaReaderResolver::default(),
+ meta_string_resolver: MetaStringReaderResolver::default(),
+ ref_reader: RefReader::new(),
+ current_depth: 0,
+ }
+ }
+
+ /// Get type resolver
+ #[inline(always)]
+ pub fn get_type_resolver(&self) -> &TypeResolver {
+ &self.type_resolver
+ }
+
+ /// Check if compatible mode is enabled
+ #[inline(always)]
+ pub fn is_compatible(&self) -> bool {
+ self.compatible
+ }
+
+ /// Check if meta sharing is enabled
+ #[inline(always)]
+ pub fn is_share_meta(&self) -> bool {
+ self.share_meta
+ }
+
+ /// Check if cross-language mode is enabled
+ #[inline(always)]
+ pub fn is_xlang(&self) -> bool {
+ self.xlang
+ }
+
+ /// Get maximum dynamic depth
+ #[inline(always)]
+ pub fn max_dyn_depth(&self) -> u32 {
+ self.max_dyn_depth
+ }
+
#[inline(always)]
pub fn init(&mut self, bytes: &[u8], max_dyn_depth: u32) {
self.reader.init(bytes);
@@ -159,51 +289,47 @@ impl ReadContext {
}
#[inline(always)]
- pub fn load_meta(
- &mut self,
- type_resolver: &TypeResolver,
- offset: usize,
- ) -> Result<usize, Error> {
+ pub fn load_meta(&mut self, offset: usize) -> Result<usize, Error> {
self.meta_resolver.load(
- type_resolver,
+ &self.type_resolver,
&mut Reader::new(&self.reader.slice_after_cursor()[offset..]),
)
}
- pub fn read_any_typeinfo(&mut self, fory: &Fory) -> Result<Arc<Harness>, Error> {
+ pub fn read_any_typeinfo(&mut self) -> Result<Arc<Harness>, Error> {
use crate::types::TypeId as ForyTypeId;
let fory_type_id = self.reader.read_varuint32()?;
- let type_resolver = fory.get_type_resolver();
if fory_type_id == u32::MAX {
let namespace = self.meta_resolver.read_metastring(&mut self.reader)?;
let type_name = self.meta_resolver.read_metastring(&mut self.reader)?;
- type_resolver
+ self.type_resolver
.get_name_harness(&namespace, &type_name)
.ok_or_else(|| Error::TypeError("Name harness not found".into()))
} else if fory_type_id & 0xff == ForyTypeId::NAMED_STRUCT as u32 {
- if fory.is_share_meta() {
+ if self.is_share_meta() {
let _meta_index = self.reader.read_varuint32();
} else {
let namespace = self.meta_resolver.read_metastring(&mut self.reader)?;
let type_name = self.meta_resolver.read_metastring(&mut self.reader)?;
- return type_resolver
+ return self
+ .type_resolver
.get_name_harness(&namespace, &type_name)
.ok_or_else(|| Error::TypeError("Name harness not found".into()));
}
- type_resolver
+ self.type_resolver
.get_harness(fory_type_id)
.ok_or_else(|| Error::TypeError("ID harness not found".into()))
} else if fory_type_id & 0xff == ForyTypeId::NAMED_COMPATIBLE_STRUCT as u32
|| fory_type_id & 0xff == ForyTypeId::COMPATIBLE_STRUCT as u32
{
let _meta_index = self.reader.read_varuint32();
- type_resolver
+ self.type_resolver
.get_harness(fory_type_id)
.ok_or_else(|| Error::TypeError("ID harness not found".into()))
} else {
- type_resolver
+ self.type_resolver
.get_harness(fory_type_id)
.ok_or_else(|| Error::TypeError("ID harness not found".into()))
}
@@ -217,13 +343,14 @@ impl ReadContext {
#[inline(always)]
pub fn inc_depth(&mut self) -> Result<(), Error> {
self.current_depth += 1;
- if self.current_depth > self.max_dyn_depth {
+ if self.current_depth > self.max_dyn_depth() {
return Err(Error::DepthExceed(
format!(
"Maximum dynamic object nesting depth ({}) exceeded. Current depth: {}. \
This may indicate a circular reference or overly deep object graph. \
Consider increasing max_dyn_depth if this is expected.",
- self.max_dyn_depth, self.current_depth
+ self.max_dyn_depth(),
+ self.current_depth
)
.into(),
));
@@ -246,14 +373,17 @@ impl ReadContext {
pub struct Pool<T> {
items: Mutex<Vec<T>>,
- factory: fn() -> T,
+ factory: Box<dyn Fn() -> T + Send + Sync>,
}
impl<T> Pool<T> {
- pub fn new(factory: fn() -> T) -> Self {
+ pub fn new<F>(factory: F) -> Self
+ where
+ F: Fn() -> T + Send + Sync + 'static,
+ {
Pool {
items: Mutex::new(vec![]),
- factory,
+ factory: Box::new(factory),
}
}
diff --git a/rust/fory-core/src/resolver/meta_resolver.rs b/rust/fory-core/src/resolver/meta_resolver.rs
index 2fb0b5b08..2e1e09bab 100644
--- a/rust/fory-core/src/resolver/meta_resolver.rs
+++ b/rust/fory-core/src/resolver/meta_resolver.rs
@@ -17,7 +17,6 @@
use crate::buffer::{Reader, Writer};
use crate::error::Error;
-use crate::fory::Fory;
use crate::meta::{Encoding, MetaString, TypeMeta, NAMESPACE_DECODER};
use crate::TypeResolver;
use std::collections::HashMap;
@@ -33,15 +32,16 @@ const MAX_PARSED_NUM_TYPE_DEFS: usize = 8192;
#[allow(dead_code)]
impl MetaWriterResolver {
- pub fn push(&mut self, type_id: std::any::TypeId, fory: &Fory) -> Result<usize, Error> {
+ pub fn push(
+ &mut self,
+ type_id: std::any::TypeId,
+ type_resolver: &TypeResolver,
+ ) -> Result<usize, Error> {
match self.type_id_index_map.get(&type_id) {
None => {
let index = self.type_defs.len();
- self.type_defs.push(
- fory.get_type_resolver()
- .get_type_info(type_id)?
- .get_type_def(),
- );
+ self.type_defs
+ .push(type_resolver.get_type_info(type_id)?.get_type_def());
self.type_id_index_map.insert(type_id, index);
Ok(index)
}
diff --git a/rust/fory-core/src/resolver/type_resolver.rs b/rust/fory-core/src/resolver/type_resolver.rs
index 7cd89cd66..8321efc60 100644
--- a/rust/fory-core/src/resolver/type_resolver.rs
+++ b/rust/fory-core/src/resolver/type_resolver.rs
@@ -17,9 +17,8 @@
use super::context::{ReadContext, WriteContext};
use crate::error::Error;
-use crate::fory::Fory;
use crate::meta::{
- MetaString, TypeMeta, NAMESPACE_ENCODER, NAMESPACE_ENCODINGS, TYPE_NAME_ENCODER,
+ FieldInfo, MetaString, TypeMeta, NAMESPACE_ENCODER, NAMESPACE_ENCODINGS, TYPE_NAME_ENCODER,
TYPE_NAME_ENCODINGS,
};
use crate::serializer::{ForyDefault, Serializer, StructSerializer};
@@ -27,17 +26,12 @@ use crate::Reader;
use std::sync::Arc;
use std::{any::Any, collections::HashMap};
-type WriteFn = fn(&dyn Any, fory: &Fory, &mut WriteContext, is_field: bool) -> Result<(), Error>;
-type ReadFn = fn(
- fory: &Fory,
- &mut ReadContext,
- is_field: bool,
- skip_ref_flag: bool,
-) -> Result<Box<dyn Any>, Error>;
-
-type WriteDataFn =
- fn(&dyn Any, fory: &Fory, &mut WriteContext, is_field: bool) -> Result<(), Error>;
-type ReadDataFn = fn(fory: &Fory, &mut ReadContext, is_field: bool) -> Result<Box<dyn Any>, Error>;
+type WriteFn = fn(&dyn Any, &mut WriteContext, is_field: bool) -> Result<(), Error>;
+type ReadFn =
+ fn(&mut ReadContext, is_field: bool, skip_ref_flag: bool) -> Result<Box<dyn Any>, Error>;
+
+type WriteDataFn = fn(&dyn Any, &mut WriteContext, is_field: bool) -> Result<(), Error>;
+type ReadDataFn = fn(&mut ReadContext, is_field: bool) -> Result<Box<dyn Any>, Error>;
type ToSerializerFn = fn(Box<dyn Any>) -> Result<Box<dyn Serializer>, Error>;
#[derive(Clone)]
@@ -99,7 +93,7 @@ pub struct TypeInfo {
impl TypeInfo {
pub fn new<T: StructSerializer>(
- fory: &Fory,
+ type_resolver: &TypeResolver,
type_id: u32,
namespace: &str,
type_name: &str,
@@ -109,16 +103,38 @@ impl TypeInfo {
NAMESPACE_ENCODER.encode_with_encodings(namespace, NAMESPACE_ENCODINGS)?;
let type_name_metastring =
TYPE_NAME_ENCODER.encode_with_encodings(type_name, TYPE_NAME_ENCODINGS)?;
- let (type_def_bytes, type_meta) = T::fory_type_def(
- fory,
+ let mut fields_info = T::fory_fields_info(type_resolver)?;
+ let sorted_field_names = T::fory_get_sorted_field_names();
+ let mut sorted_field_infos: Vec<FieldInfo> = Vec::with_capacity(fields_info.len());
+ for name in sorted_field_names.iter() {
+ let mut found = false;
+ for i in 0..fields_info.len() {
+ if &fields_info[i].field_name == name {
+ // swap_remove is faster
+ sorted_field_infos.push(fields_info.swap_remove(i));
+ found = true;
+ break;
+ }
+ }
+ if !found {
+ unreachable!("Field {} not found in fields_info", name);
+ }
+ }
+ // assign field id in ascending order
+ for (i, field_info) in sorted_field_infos.iter_mut().enumerate() {
+ field_info.field_id = i as i16;
+ }
+ let type_meta = Arc::new(TypeMeta::from_fields(
type_id,
namespace_metastring.clone(),
type_name_metastring.clone(),
register_by_name,
- )?;
+ sorted_field_infos,
+ ));
+ let type_def_bytes = type_meta.to_bytes()?;
Ok(TypeInfo {
type_def: Arc::from(type_def_bytes),
- type_meta: Arc::new(type_meta),
+ type_meta,
type_id,
namespace: namespace_metastring,
type_name: type_name_metastring,
@@ -127,7 +143,7 @@ impl TypeInfo {
}
pub fn new_with_empty_fields<T: Serializer>(
- _fory: &Fory,
+ type_resolver: &TypeResolver,
type_id: u32,
namespace: &str,
type_name: &str,
@@ -145,7 +161,6 @@ impl TypeInfo {
vec![],
);
let type_def = meta.to_bytes()?;
- let type_resolver = _fory.get_type_resolver();
let meta = TypeMeta::from_bytes(&mut Reader::new(&type_def), type_resolver)?;
Ok(TypeInfo {
type_def: Arc::from(type_def),
@@ -182,6 +197,8 @@ impl TypeInfo {
}
}
+/// TypeResolver is a resolver for fast type/serializer dispatch.
+#[derive(Clone)]
pub struct TypeResolver {
serializer_map: HashMap<u32, Arc<Harness>>,
name_serializer_map: HashMap<(MetaString, MetaString), Arc<Harness>>,
@@ -198,7 +215,7 @@ const NO_TYPE_ID: u32 = 1000000000;
impl Default for TypeResolver {
fn default() -> Self {
- let mut resolver = TypeResolver {
+ let mut registry = TypeResolver {
serializer_map: HashMap::new(),
name_serializer_map: HashMap::new(),
type_id_map: HashMap::new(),
@@ -208,12 +225,86 @@ impl Default for TypeResolver {
type_info_map_by_name: HashMap::new(),
type_id_index: Vec::new(),
};
- resolver.register_builtin_types().unwrap();
- resolver
+ registry.register_builtin_types().unwrap();
+ registry
}
}
impl TypeResolver {
+ pub fn get_type_info(&self, type_id: std::any::TypeId) -> Result<&TypeInfo, Error> {
+ self.type_info_cache.get(&type_id)
+ .ok_or_else(|| Error::TypeError(format!(
+ "TypeId {:?} not found in type_info registry, maybe you forgot to register some types",
+ type_id
+ ).into()))
+ }
+
+ pub fn get_type_info_by_id(&self, id: u32) -> Option<&TypeInfo> {
+ self.type_info_map_by_id.get(&id)
+ }
+
+ pub fn get_type_info_by_name(&self, namespace: &str, type_name: &str) -> Option<&TypeInfo> {
+ self.type_info_map_by_name
+ .get(&(namespace.to_owned(), type_name.to_owned()))
+ }
+
+ /// Fast path for getting type info by numeric ID (avoids HashMap lookup by TypeId)
+ pub fn get_type_id(&self, type_id: &std::any::TypeId, id: u32) -> Result<u32, Error> {
+ let id_usize = id as usize;
+ if id_usize < self.type_id_index.len() {
+ let type_id = self.type_id_index[id_usize];
+ if type_id != NO_TYPE_ID {
+ return Ok(type_id);
+ }
+ }
+ Err(Error::TypeError(
+ format!(
+ "TypeId {:?} not found in type_id_index, maybe you forgot to register some types",
+ type_id
+ )
+ .into(),
+ ))
+ }
+
+ pub fn get_harness(&self, id: u32) -> Option<Arc<Harness>> {
+ self.serializer_map.get(&id).cloned()
+ }
+
+ pub fn get_name_harness(
+ &self,
+ namespace: &MetaString,
+ type_name: &MetaString,
+ ) -> Option<Arc<Harness>> {
+ let key = (namespace.clone(), type_name.clone());
+ self.name_serializer_map.get(&key).cloned()
+ }
+
+ pub fn get_ext_harness(&self, id: u32) -> Result<Arc<Harness>, Error> {
+ self.serializer_map
+ .get(&id)
+ .cloned()
+ .ok_or_else(|| Error::TypeError("ext type must be registered in both peers".into()))
+ }
+
+ pub fn get_ext_name_harness(
+ &self,
+ namespace: &MetaString,
+ type_name: &MetaString,
+ ) -> Result<Arc<Harness>, Error> {
+ let key = (namespace.clone(), type_name.clone());
+ self.name_serializer_map.get(&key).cloned().ok_or_else(|| {
+ Error::TypeError("named_ext type must be registered in both peers".into())
+ })
+ }
+
+ pub fn get_fory_type_id(&self, rust_type_id: std::any::TypeId) -> Option<u32> {
+ if let Some(type_info) = self.type_info_cache.get(&rust_type_id) {
+ Some(type_info.get_type_id())
+ } else {
+ self.type_id_map.get(&rust_type_id).copied()
+ }
+ }
+
fn register_builtin_types(&mut self) -> Result<(), Error> {
use crate::types::TypeId;
let namespace = NAMESPACE_ENCODER.encode_with_encodings("", NAMESPACE_ENCODINGS)?;
@@ -253,58 +344,22 @@ impl TypeResolver {
Ok(())
}
- pub fn get_type_info(&self, type_id: std::any::TypeId) -> Result<&TypeInfo, Error> {
- self.type_info_cache.get(&type_id)
- .ok_or_else(|| Error::TypeError(format!(
- "TypeId {:?} not found in type_info registry, maybe you forgot to register some types",
- type_id
- ).into()))
- }
-
- pub fn get_type_info_by_id(&self, id: u32) -> Option<&TypeInfo> {
- self.type_info_map_by_id.get(&id)
- }
-
- pub fn get_type_info_by_name(&self, namespace: &str, type_name: &str) -> Option<&TypeInfo> {
- self.type_info_map_by_name
- .get(&(namespace.to_owned(), type_name.to_owned()))
- }
-
- /// Fast path for getting type info by numeric ID (avoids HashMap lookup by TypeId)
- pub fn get_type_id(&self, type_id: &std::any::TypeId, id: u32) -> Result<u32, Error> {
- let id_usize = id as usize;
- if id_usize < self.type_id_index.len() {
- let type_id = self.type_id_index[id_usize];
- if type_id != NO_TYPE_ID {
- return Ok(type_id);
- }
- }
- Err(Error::TypeError(
- format!(
- "TypeId {:?} not found in type_id_index, maybe you forgot to register some types",
- type_id
- )
- .into(),
- ))
- }
-
pub fn register<T: StructSerializer + Serializer + ForyDefault>(
&mut self,
type_info: &TypeInfo,
) -> Result<(), Error> {
fn write<T2: 'static + Serializer>(
this: &dyn Any,
- fory: &Fory,
context: &mut WriteContext,
is_field: bool,
) -> Result<(), Error> {
let this = this.downcast_ref::<T2>();
match this {
Some(v) => {
- let skip_ref_flag = crate::serializer::get_skip_ref_flag::<T2>(fory)?;
+ let skip_ref_flag =
+ crate::serializer::get_skip_ref_flag::<T2>(context.get_type_resolver())?;
crate::serializer::write_ref_info_data(
v,
- fory,
context,
is_field,
skip_ref_flag,
@@ -317,13 +372,11 @@ impl TypeResolver {
}
fn read<T2: 'static + Serializer + ForyDefault>(
- fory: &Fory,
context: &mut ReadContext,
is_field: bool,
skip_ref_flag: bool,
) -> Result<Box<dyn Any>, Error> {
match crate::serializer::read_ref_info_data::<T2>(
- fory,
context,
is_field,
skip_ref_flag,
@@ -336,23 +389,21 @@ impl TypeResolver {
fn write_data<T2: 'static + Serializer>(
this: &dyn Any,
- fory: &Fory,
context: &mut WriteContext,
is_field: bool,
) -> Result<(), Error> {
let this = this.downcast_ref::<T2>();
match this {
- Some(v) => T2::fory_write_data(v, fory, context, is_field),
+ Some(v) => T2::fory_write_data(v, context, is_field),
None => todo!(),
}
}
fn read_data<T2: 'static + Serializer + ForyDefault>(
- fory: &Fory,
context: &mut ReadContext,
is_field: bool,
) -> Result<Box<dyn Any>, Error> {
- match T2::fory_read_data(fory, context, is_field) {
+ match T2::fory_read_data(context, is_field) {
Ok(v) => Ok(Box::new(v)),
Err(e) => Err(e),
}
@@ -443,30 +494,28 @@ impl TypeResolver {
) -> Result<(), Error> {
fn write<T2: 'static + Serializer>(
this: &dyn Any,
- fory: &Fory,
context: &mut WriteContext,
is_field: bool,
) -> Result<(), Error> {
let this = this.downcast_ref::<T2>();
match this {
- Some(v) => Ok(v.fory_write(fory, context, is_field)?),
+ Some(v) => Ok(v.fory_write(context, is_field)?),
None => todo!(),
}
}
fn read<T2: 'static + Serializer + ForyDefault>(
- fory: &Fory,
context: &mut ReadContext,
is_field: bool,
skip_ref_flag: bool,
) -> Result<Box<dyn Any>, Error> {
if skip_ref_flag {
- match T2::fory_read_data(fory, context, is_field) {
+ match T2::fory_read_data(context, is_field) {
Ok(v) => Ok(Box::new(v)),
Err(e) => Err(e),
}
} else {
- match T2::fory_read(fory, context, is_field) {
+ match T2::fory_read(context, is_field) {
Ok(v) => Ok(Box::new(v)),
Err(e) => Err(e),
}
@@ -475,23 +524,21 @@ impl TypeResolver {
fn write_data<T2: 'static + Serializer>(
this: &dyn Any,
- fory: &Fory,
context: &mut WriteContext,
is_field: bool,
) -> Result<(), Error> {
let this = this.downcast_ref::<T2>();
match this {
- Some(v) => T2::fory_write_data(v, fory, context, is_field),
+ Some(v) => T2::fory_write_data(v, context, is_field),
None => todo!(),
}
}
fn read_data<T2: 'static + Serializer + ForyDefault>(
- fory: &Fory,
context: &mut ReadContext,
is_field: bool,
) -> Result<Box<dyn Any>, Error> {
- match T2::fory_read_data(fory, context, is_field) {
+ match T2::fory_read_data(context, is_field) {
Ok(v) => Ok(Box::new(v)),
Err(e) => Err(e),
}
@@ -560,43 +607,4 @@ impl TypeResolver {
}
Ok(())
}
-
- pub fn get_harness(&self, id: u32) -> Option<Arc<Harness>> {
- self.serializer_map.get(&id).cloned()
- }
-
- pub fn get_name_harness(
- &self,
- namespace: &MetaString,
- type_name: &MetaString,
- ) -> Option<Arc<Harness>> {
- let key = (namespace.clone(), type_name.clone());
- self.name_serializer_map.get(&key).cloned()
- }
-
- pub fn get_ext_harness(&self, id: u32) -> Result<Arc<Harness>, Error> {
- self.serializer_map
- .get(&id)
- .cloned()
- .ok_or_else(|| Error::TypeError("ext type must be registered in both peers".into()))
- }
-
- pub fn get_ext_name_harness(
- &self,
- namespace: &MetaString,
- type_name: &MetaString,
- ) -> Result<Arc<Harness>, Error> {
- let key = (namespace.clone(), type_name.clone());
- self.name_serializer_map.get(&key).cloned().ok_or_else(|| {
- Error::TypeError("named_ext type must be registered in both peers".into())
- })
- }
-
- pub fn get_fory_type_id(&self, rust_type_id: std::any::TypeId) -> Option<u32> {
- if let Some(type_info) = self.type_info_cache.get(&rust_type_id) {
- Some(type_info.get_type_id())
- } else {
- self.type_id_map.get(&rust_type_id).copied()
- }
- }
}
diff --git a/rust/fory-core/src/serializer/any.rs b/rust/fory-core/src/serializer/any.rs
index 52e63675f..1bbfd5d3a 100644
--- a/rust/fory-core/src/serializer/any.rs
+++ b/rust/fory-core/src/serializer/any.rs
@@ -16,8 +16,8 @@
// under the License.
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::{ReadContext, WriteContext};
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{ForyDefault, Serializer};
use crate::types::RefFlag;
use std::any::Any;
@@ -27,20 +27,19 @@ use std::sync::Arc;
/// Helper function to serialize a `Box<dyn Any>`
pub fn serialize_any_box(
any_box: &Box<dyn Any>,
- fory: &Fory,
context: &mut WriteContext,
is_field: bool,
) -> Result<(), Error> {
context.writer.write_i8(RefFlag::NotNullValue as i8);
let concrete_type_id = (**any_box).type_id();
- let harness = context.write_any_typeinfo(fory, concrete_type_id)?;
+ let harness = context.write_any_typeinfo(concrete_type_id)?;
let serializer_fn = harness.get_write_data_fn();
- serializer_fn(&**any_box, fory, context, is_field)
+ serializer_fn(&**any_box, context, is_field)
}
/// Helper function to deserialize to `Box<dyn Any>`
-pub fn deserialize_any_box(fory: &Fory, context: &mut ReadContext) -> Result<Box<dyn Any>, Error> {
+pub fn deserialize_any_box(context: &mut ReadContext) -> Result<Box<dyn Any>, Error> {
context.inc_depth()?;
let ref_flag = context.reader.read_i8()?;
if ref_flag != RefFlag::NotNullValue as i8 {
@@ -48,9 +47,9 @@ pub fn deserialize_any_box(fory: &Fory, context: &mut ReadContext) -> Result<Box
"Expected NotNullValue for Box<dyn Any>".into(),
));
}
- let harness = context.read_any_typeinfo(fory)?;
+ let harness = context.read_any_typeinfo()?;
let deserializer_fn = harness.get_read_data_fn();
- let result = deserializer_fn(fory, context, true);
+ let result = deserializer_fn(context, true);
context.dec_depth();
result
}
@@ -62,43 +61,29 @@ impl ForyDefault for Box<dyn Any> {
}
impl Serializer for Box<dyn Any> {
- fn fory_write(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- serialize_any_box(self, fory, context, is_field)
+ fn fory_write(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ serialize_any_box(self, context, is_field)
}
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- serialize_any_box(self, fory, context, is_field)
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ serialize_any_box(self, context, is_field)
}
- fn fory_read(fory: &Fory, context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
- deserialize_any_box(fory, context)
+ fn fory_read(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
+ deserialize_any_box(context)
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
- deserialize_any_box(fory, context)
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
+ deserialize_any_box(context)
}
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
unreachable!("Box<dyn Any> has no static type ID - use fory_type_id_dyn")
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
let concrete_type_id = (**self).type_id();
- fory.get_type_resolver()
+ type_resolver
.get_fory_type_id(concrete_type_id)
.ok_or_else(|| Error::TypeError("Type not registered".into()))
}
@@ -107,20 +92,12 @@ impl Serializer for Box<dyn Any> {
true
}
- fn fory_write_type_info(
- _fory: &Fory,
- _context: &mut WriteContext,
- _is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_type_info(_context: &mut WriteContext, _is_field: bool) -> Result<(), Error> {
// Rc<dyn Any> is polymorphic - type info is written per element
Ok(())
}
- fn fory_read_type_info(
- _fory: &Fory,
- _context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_read_type_info(_context: &mut ReadContext, _is_field: bool) -> Result<(), Error> {
// Rc<dyn Any> is polymorphic - type info is read per element
Ok(())
}
@@ -137,34 +114,24 @@ impl ForyDefault for Rc<dyn Any> {
}
impl Serializer for Rc<dyn Any> {
- fn fory_write(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
if !context
.ref_writer
.try_write_rc_ref(&mut context.writer, self)
{
let concrete_type_id = (**self).type_id();
- let harness = context.write_any_typeinfo(fory, concrete_type_id)?;
+ let harness = context.write_any_typeinfo(concrete_type_id)?;
let serializer_fn = harness.get_write_data_fn();
- serializer_fn(&**self, fory, context, is_field)?
+ serializer_fn(&**self, context, is_field)?
};
Ok(())
}
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- self.fory_write(fory, context, is_field)
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ self.fory_write(context, is_field)
}
- fn fory_read(fory: &Fory, context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
+ fn fory_read(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
let ref_flag = context.ref_reader.read_ref_flag(&mut context.reader)?;
match ref_flag {
@@ -182,17 +149,17 @@ impl Serializer for Rc<dyn Any> {
}
RefFlag::NotNullValue => {
context.inc_depth()?;
- let harness = context.read_any_typeinfo(fory)?;
+ let harness = context.read_any_typeinfo()?;
let deserializer_fn = harness.get_read_data_fn();
- let boxed = deserializer_fn(fory, context, true)?;
+ let boxed = deserializer_fn(context, true)?;
context.dec_depth();
Ok(Rc::<dyn Any>::from(boxed))
}
RefFlag::RefValue => {
context.inc_depth()?;
- let harness = context.read_any_typeinfo(fory)?;
+ let harness = context.read_any_typeinfo()?;
let deserializer_fn = harness.get_read_data_fn();
- let boxed = deserializer_fn(fory, context, true)?;
+ let boxed = deserializer_fn(context, true)?;
context.dec_depth();
let rc: Rc<dyn Any> = Rc::from(boxed);
context.ref_reader.store_rc_ref(rc.clone());
@@ -201,21 +168,17 @@ impl Serializer for Rc<dyn Any> {
}
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
- Self::fory_read(fory, context, is_field)
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
+ Self::fory_read(context, is_field)
}
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
unreachable!("Rc<dyn Any> has no static type ID - use fory_type_id_dyn")
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
let concrete_type_id = (**self).type_id();
- fory.get_type_resolver()
+ type_resolver
.get_fory_type_id(concrete_type_id)
.ok_or_else(|| Error::TypeError("Type not registered".into()))
}
@@ -224,20 +187,12 @@ impl Serializer for Rc<dyn Any> {
true
}
- fn fory_write_type_info(
- _fory: &Fory,
- _context: &mut WriteContext,
- _is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_type_info(_context: &mut WriteContext, _is_field: bool) -> Result<(), Error> {
// Rc<dyn Any> is polymorphic - type info is written per element
Ok(())
}
- fn fory_read_type_info(
- _fory: &Fory,
- _context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_read_type_info(_context: &mut ReadContext, _is_field: bool) -> Result<(), Error> {
// Rc<dyn Any> is polymorphic - type info is read per element
Ok(())
}
@@ -254,34 +209,24 @@ impl ForyDefault for Arc<dyn Any> {
}
impl Serializer for Arc<dyn Any> {
- fn fory_write(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
if !context
.ref_writer
.try_write_arc_ref(&mut context.writer, self)
{
let concrete_type_id = (**self).type_id();
- let harness = context.write_any_typeinfo(fory, concrete_type_id)?;
+ let harness = context.write_any_typeinfo(concrete_type_id)?;
let serializer_fn = harness.get_write_data_fn();
- serializer_fn(&**self, fory, context, is_field)?;
+ serializer_fn(&**self, context, is_field)?;
}
Ok(())
}
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- self.fory_write(fory, context, is_field)
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ self.fory_write(context, is_field)
}
- fn fory_read(fory: &Fory, context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
+ fn fory_read(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
let ref_flag = context.ref_reader.read_ref_flag(&mut context.reader)?;
match ref_flag {
@@ -299,17 +244,17 @@ impl Serializer for Arc<dyn Any> {
}
RefFlag::NotNullValue => {
context.inc_depth()?;
- let harness = context.read_any_typeinfo(fory)?;
+ let harness = context.read_any_typeinfo()?;
let deserializer_fn = harness.get_read_data_fn();
- let boxed = deserializer_fn(fory, context, true)?;
+ let boxed = deserializer_fn(context, true)?;
context.dec_depth();
Ok(Arc::<dyn Any>::from(boxed))
}
RefFlag::RefValue => {
context.inc_depth()?;
- let harness = context.read_any_typeinfo(fory)?;
+ let harness = context.read_any_typeinfo()?;
let deserializer_fn = harness.get_read_data_fn();
- let boxed = deserializer_fn(fory, context, true)?;
+ let boxed = deserializer_fn(context, true)?;
context.dec_depth();
let arc: Arc<dyn Any> = Arc::from(boxed);
context.ref_reader.store_arc_ref(arc.clone());
@@ -318,21 +263,17 @@ impl Serializer for Arc<dyn Any> {
}
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
- Self::fory_read(fory, context, is_field)
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
+ Self::fory_read(context, is_field)
}
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_type_resolver: &TypeResolver) -> Result<u32, Error> {
unreachable!("Arc<dyn Any> has no static type ID - use fory_type_id_dyn")
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
let concrete_type_id = (**self).type_id();
- fory.get_type_resolver()
+ type_resolver
.get_fory_type_id(concrete_type_id)
.ok_or_else(|| Error::TypeError("Type not registered".into()))
}
@@ -341,20 +282,12 @@ impl Serializer for Arc<dyn Any> {
true
}
- fn fory_write_type_info(
- _fory: &Fory,
- _context: &mut WriteContext,
- _is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_type_info(_context: &mut WriteContext, _is_field: bool) -> Result<(), Error> {
// Arc<dyn Any> is polymorphic - type info is written per element
Ok(())
}
- fn fory_read_type_info(
- _fory: &Fory,
- _context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_read_type_info(_context: &mut ReadContext, _is_field: bool) -> Result<(), Error> {
// Arc<dyn Any> is polymorphic - type info is read per element
Ok(())
}
diff --git a/rust/fory-core/src/serializer/arc.rs b/rust/fory-core/src/serializer/arc.rs
index 41377a98a..e4cbda85e 100644
--- a/rust/fory-core/src/serializer/arc.rs
+++ b/rust/fory-core/src/serializer/arc.rs
@@ -16,8 +16,8 @@
// under the License.
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::{ReadContext, WriteContext};
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{ForyDefault, Serializer};
use crate::types::RefFlag;
use std::sync::Arc;
@@ -27,42 +27,28 @@ impl<T: Serializer + ForyDefault + Send + Sync + 'static> Serializer for Arc<T>
true
}
- fn fory_write(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
if !context
.ref_writer
.try_write_arc_ref(&mut context.writer, self)
{
- T::fory_write_data(self.as_ref(), fory, context, is_field)?
+ T::fory_write_data(self.as_ref(), context, is_field)?
};
Ok(())
}
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
// When Arc is nested inside another shared ref (like Rc<Arc<T>>),
// the outer ref calls fory_write_data on the inner Arc.
// We still need to track the Arc's own references here.
- self.fory_write(fory, context, is_field)
+ self.fory_write(context, is_field)
}
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_write_type_info(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ T::fory_write_type_info(context, is_field)
}
- fn fory_read(fory: &Fory, context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
+ fn fory_read(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
let ref_flag = context.ref_reader.read_ref_flag(&mut context.reader)?;
Ok(match ref_flag {
@@ -77,12 +63,12 @@ impl<T: Serializer + ForyDefault + Send + Sync + 'static> Serializer for Arc<T>
))?
}
RefFlag::NotNullValue => {
- let inner = T::fory_read_data(fory, context, is_field)?;
+ let inner = T::fory_read_data(context, is_field)?;
Arc::new(inner)
}
RefFlag::RefValue => {
let ref_id = context.ref_reader.reserve_ref_id();
- let inner = T::fory_read_data(fory, context, is_field)?;
+ let inner = T::fory_read_data(context, is_field)?;
let arc = Arc::new(inner);
context.ref_reader.store_arc_ref_at(ref_id, arc.clone());
arc
@@ -90,22 +76,14 @@ impl<T: Serializer + ForyDefault + Send + Sync + 'static> Serializer for Arc<T>
})
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
// When Arc is nested inside another shared ref, fory_read_data is called.
// Delegate to fory_read which handles ref tracking properly.
- Self::fory_read(fory, context, is_field)
+ Self::fory_read(context, is_field)
}
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_read_type_info(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ T::fory_read_type_info(context, is_field)
}
fn fory_reserved_space() -> usize {
@@ -114,12 +92,12 @@ impl<T: Serializer + ForyDefault + Send + Sync + 'static> Serializer for Arc<T>
4
}
- fn fory_get_type_id(fory: &Fory) -> Result<u32, Error> {
- T::fory_get_type_id(fory)
+ fn fory_get_type_id(type_resolver: &TypeResolver) -> Result<u32, Error> {
+ T::fory_get_type_id(type_resolver)
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error> {
- (**self).fory_type_id_dyn(fory)
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
+ (**self).fory_type_id_dyn(type_resolver)
}
fn as_any(&self) -> &dyn std::any::Any {
diff --git a/rust/fory-core/src/serializer/bool.rs b/rust/fory-core/src/serializer/bool.rs
index 709503842..9c1642bcd 100644
--- a/rust/fory-core/src/serializer/bool.rs
+++ b/rust/fory-core/src/serializer/bool.rs
@@ -16,31 +16,22 @@
// under the License.
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::ReadContext;
use crate::resolver::context::WriteContext;
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{read_type_info, write_type_info, ForyDefault, Serializer};
use crate::types::TypeId;
use std::mem;
impl Serializer for bool {
#[inline(always)]
- fn fory_write_data(
- &self,
- _fory: &Fory,
- context: &mut WriteContext,
- _is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, _is_field: bool) -> Result<(), Error> {
context.writer.write_u8(if *self { 1 } else { 0 });
Ok(())
}
#[inline(always)]
- fn fory_read_data(
- _fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
Ok(context.reader.read_u8()? == 1)
}
@@ -50,11 +41,11 @@ impl Serializer for bool {
}
#[inline(always)]
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::BOOL as u32)
}
- fn fory_type_id_dyn(&self, _fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::BOOL as u32)
}
@@ -64,21 +55,13 @@ impl Serializer for bool {
}
#[inline(always)]
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_type_info::<Self>(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_type_info::<Self>(context, is_field)
}
#[inline(always)]
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- read_type_info::<Self>(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ read_type_info::<Self>(context, is_field)
}
}
diff --git a/rust/fory-core/src/serializer/box_.rs b/rust/fory-core/src/serializer/box_.rs
index 63063649d..6cf873007 100644
--- a/rust/fory-core/src/serializer/box_.rs
+++ b/rust/fory-core/src/serializer/box_.rs
@@ -16,55 +16,38 @@
// under the License.
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::ReadContext;
use crate::resolver::context::WriteContext;
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{ForyDefault, Serializer};
impl<T: Serializer + ForyDefault> Serializer for Box<T> {
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
- Ok(Box::new(T::fory_read_data(fory, context, is_field)?))
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
+ Ok(Box::new(T::fory_read_data(context, is_field)?))
}
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_read_type_info(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ T::fory_read_type_info(context, is_field)
}
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_write_data(self.as_ref(), fory, context, is_field)
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ T::fory_write_data(self.as_ref(), context, is_field)
}
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_write_type_info(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ T::fory_write_type_info(context, is_field)
}
fn fory_reserved_space() -> usize {
T::fory_reserved_space()
}
- fn fory_get_type_id(fory: &Fory) -> Result<u32, Error> {
- T::fory_get_type_id(fory)
+ fn fory_get_type_id(type_resolver: &TypeResolver) -> Result<u32, Error> {
+ T::fory_get_type_id(type_resolver)
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error> {
- (**self).fory_type_id_dyn(fory)
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
+ (**self).fory_type_id_dyn(type_resolver)
}
fn as_any(&self) -> &dyn std::any::Any {
diff --git a/rust/fory-core/src/serializer/collection.rs b/rust/fory-core/src/serializer/collection.rs
index 45938f4be..25469c589 100644
--- a/rust/fory-core/src/serializer/collection.rs
+++ b/rust/fory-core/src/serializer/collection.rs
@@ -15,12 +15,12 @@
// specific language governing permissions and limitations
// under the License.
+use crate::ensure;
use crate::error::Error;
use crate::resolver::context::ReadContext;
use crate::resolver::context::WriteContext;
use crate::serializer::{ForyDefault, Serializer};
use crate::types::PRIMITIVE_ARRAY_TYPES;
-use crate::{ensure, Fory};
// const TRACKING_REF: u8 = 0b1;
@@ -46,7 +46,7 @@ pub fn write_collection_type_info(
pub fn write_collection<'a, T, I>(
iter: I,
- fory: &Fory,
+
context: &mut WriteContext,
is_field: bool,
) -> Result<(), Error>
@@ -83,26 +83,19 @@ where
header |= IS_SAME_TYPE;
}
context.writer.write_u8(header);
- T::fory_write_type_info(fory, context, is_field)?;
+ T::fory_write_type_info(context, is_field)?;
// context.writer.reserve((T::reserved_space() + SIZE_OF_REF_AND_TYPE) * len);
if T::fory_is_polymorphic() || T::fory_is_shared_ref() {
// TOTO: make it xlang compatible
for item in iter {
- item.fory_write(fory, context, is_field)?;
+ item.fory_write(context, is_field)?;
}
Ok(())
} else {
// let skip_ref_flag = crate::serializer::get_skip_ref_flag::<T>(context.get_fory());
let skip_ref_flag = is_same_type && !has_null;
for item in iter {
- crate::serializer::write_ref_info_data(
- item,
- fory,
- context,
- is_field,
- skip_ref_flag,
- true,
- )?;
+ crate::serializer::write_ref_info_data(item, context, is_field, skip_ref_flag, true)?;
}
Ok(())
}
@@ -132,7 +125,7 @@ pub fn read_collection_type_info(
Ok(())
}
-pub fn read_collection<C, T>(fory: &Fory, context: &mut ReadContext) -> Result<C, Error>
+pub fn read_collection<C, T>(context: &mut ReadContext) -> Result<C, Error>
where
T: Serializer + ForyDefault,
C: FromIterator<T>,
@@ -143,20 +136,18 @@ where
}
let header = context.reader.read_u8()?;
let declared = (header & DECL_ELEMENT_TYPE) != 0;
- T::fory_read_type_info(fory, context, declared)?;
+ T::fory_read_type_info(context, declared)?;
let has_null = (header & HAS_NULL) != 0;
let is_same_type = (header & IS_SAME_TYPE) != 0;
if T::fory_is_polymorphic() || T::fory_is_shared_ref() {
(0..len)
- .map(|_| T::fory_read(fory, context, declared))
+ .map(|_| T::fory_read(context, declared))
.collect::<Result<C, Error>>()
} else {
let skip_ref_flag = is_same_type && !has_null;
// let skip_ref_flag = crate::serializer::get_skip_ref_flag::<T>(context.get_fory());
(0..len)
- .map(|_| {
- crate::serializer::read_ref_info_data(fory, context, declared, skip_ref_flag, true)
- })
+ .map(|_| crate::serializer::read_ref_info_data(context, declared, skip_ref_flag, true))
.collect::<Result<C, Error>>()
}
}
diff --git a/rust/fory-core/src/serializer/datetime.rs b/rust/fory-core/src/serializer/datetime.rs
index 4c49e26cc..7ef84a305 100644
--- a/rust/fory-core/src/serializer/datetime.rs
+++ b/rust/fory-core/src/serializer/datetime.rs
@@ -16,9 +16,9 @@
// under the License.
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::ReadContext;
use crate::resolver::context::WriteContext;
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::Serializer;
use crate::serializer::{read_type_info, write_type_info, ForyDefault};
use crate::types::TypeId;
@@ -27,23 +27,14 @@ use chrono::{DateTime, Days, NaiveDate, NaiveDateTime};
use std::mem;
impl Serializer for NaiveDateTime {
- fn fory_write_data(
- &self,
- _fory: &Fory,
- context: &mut WriteContext,
- _is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, _is_field: bool) -> Result<(), Error> {
let dt = self.and_utc();
let micros = dt.timestamp() * 1_000_000 + dt.timestamp_subsec_micros() as i64;
context.writer.write_i64(micros);
Ok(())
}
- fn fory_read_data(
- _fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
let micros = context.reader.read_i64()?;
let seconds = micros / 1_000_000;
let subsec_micros = (micros % 1_000_000) as u32;
@@ -59,11 +50,11 @@ impl Serializer for NaiveDateTime {
mem::size_of::<u64>()
}
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::TIMESTAMP as u32)
}
- fn fory_type_id_dyn(&self, _fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::TIMESTAMP as u32)
}
@@ -71,40 +62,23 @@ impl Serializer for NaiveDateTime {
self
}
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_type_info::<Self>(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_type_info::<Self>(context, is_field)
}
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- read_type_info::<Self>(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ read_type_info::<Self>(context, is_field)
}
}
impl Serializer for NaiveDate {
- fn fory_write_data(
- &self,
- _fory: &Fory,
- context: &mut WriteContext,
- _is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, _is_field: bool) -> Result<(), Error> {
let days_since_epoch = self.signed_duration_since(EPOCH).num_days();
context.writer.write_i32(days_since_epoch as i32);
Ok(())
}
- fn fory_read_data(
- _fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
let days = context.reader.read_i32()?;
EPOCH
.checked_add_days(Days::new(days as u64))
@@ -117,11 +91,11 @@ impl Serializer for NaiveDate {
mem::size_of::<i32>()
}
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::LOCAL_DATE as u32)
}
- fn fory_type_id_dyn(&self, _fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::LOCAL_DATE as u32)
}
@@ -129,20 +103,12 @@ impl Serializer for NaiveDate {
self
}
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_type_info::<Self>(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_type_info::<Self>(context, is_field)
}
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- read_type_info::<Self>(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ read_type_info::<Self>(context, is_field)
}
}
diff --git a/rust/fory-core/src/serializer/enum_.rs b/rust/fory-core/src/serializer/enum_.rs
index 60d6930fb..3cb323211 100644
--- a/rust/fory-core/src/serializer/enum_.rs
+++ b/rust/fory-core/src/serializer/enum_.rs
@@ -17,7 +17,6 @@
use crate::ensure;
use crate::error::Error;
-use crate::fory::Fory;
use crate::meta::{MetaString, TypeMeta};
use crate::resolver::context::{ReadContext, WriteContext};
use crate::serializer::{ForyDefault, Serializer};
@@ -34,7 +33,6 @@ pub fn actual_type_id(type_id: u32, register_by_name: bool, _compatible: bool) -
#[inline(always)]
pub fn type_def(
- _fory: &Fory,
type_id: u32,
namespace: MetaString,
type_name: MetaString,
@@ -47,25 +45,24 @@ pub fn type_def(
#[inline(always)]
pub fn write_type_info<T: Serializer>(
- fory: &Fory,
context: &mut WriteContext,
is_field: bool,
) -> Result<(), Error> {
if is_field {
return Ok(());
}
- let type_id = T::fory_get_type_id(fory)?;
+ let type_id = T::fory_get_type_id(context.get_type_resolver())?;
context.writer.write_varuint32(type_id);
let is_named_enum = type_id & 0xff == TypeId::NAMED_ENUM as u32;
if !is_named_enum {
return Ok(());
}
let rs_type_id = std::any::TypeId::of::<T>();
- if fory.is_share_meta() {
- let meta_index = context.push_meta(fory, rs_type_id)? as u32;
+ if context.is_share_meta() {
+ let meta_index = context.push_meta(rs_type_id)? as u32;
context.writer.write_varuint32(meta_index);
} else {
- let type_info = fory.get_type_resolver().get_type_info(rs_type_id)?;
+ let type_info = context.get_type_resolver().get_type_info(rs_type_id)?;
let namespace = type_info.get_namespace().to_owned();
let type_name = type_info.get_type_name().to_owned();
context.write_meta_string_bytes(&namespace)?;
@@ -76,14 +73,13 @@ pub fn write_type_info<T: Serializer>(
#[inline(always)]
pub fn read_type_info<T: Serializer>(
- fory: &Fory,
context: &mut ReadContext,
is_field: bool,
) -> Result<(), Error> {
if is_field {
return Ok(());
}
- let local_type_id = T::fory_get_type_id(fory)?;
+ let local_type_id = T::fory_get_type_id(context.get_type_resolver())?;
let remote_type_id = context.reader.read_varuint32()?;
ensure!(
local_type_id == remote_type_id,
@@ -93,7 +89,7 @@ pub fn read_type_info<T: Serializer>(
if !is_named_enum {
return Ok(());
}
- if fory.is_share_meta() {
+ if context.is_share_meta() {
let _meta_index = context.reader.read_varuint32()?;
} else {
let _namespace_msb = context.read_meta_string_bytes()?;
@@ -103,29 +99,25 @@ pub fn read_type_info<T: Serializer>(
}
#[inline(always)]
-pub fn read_compatible<T: Serializer + ForyDefault>(
- fory: &Fory,
- context: &mut ReadContext,
-) -> Result<T, Error> {
- T::fory_read_type_info(fory, context, true)?;
- T::fory_read_data(fory, context, true)
+pub fn read_compatible<T: Serializer + ForyDefault>(context: &mut ReadContext) -> Result<T, Error> {
+ T::fory_read_type_info(context, true)?;
+ T::fory_read_data(context, true)
}
#[inline(always)]
pub fn write<T: Serializer>(
this: &T,
- fory: &Fory,
+
context: &mut WriteContext,
is_field: bool,
) -> Result<(), Error> {
context.writer.write_i8(RefFlag::NotNullValue as i8);
- T::fory_write_type_info(fory, context, is_field)?;
- this.fory_write_data(fory, context, is_field)
+ T::fory_write_type_info(context, is_field)?;
+ this.fory_write_data(context, is_field)
}
#[inline(always)]
pub fn read<T: Serializer + ForyDefault>(
- fory: &Fory,
context: &mut ReadContext,
is_field: bool,
) -> Result<T, Error> {
@@ -133,8 +125,8 @@ pub fn read<T: Serializer + ForyDefault>(
if ref_flag == RefFlag::Null as i8 {
Ok(T::fory_default())
} else if ref_flag == (RefFlag::NotNullValue as i8) {
- T::fory_read_type_info(fory, context, false)?;
- T::fory_read_data(fory, context, is_field)
+ T::fory_read_type_info(context, false)?;
+ T::fory_read_data(context, is_field)
} else {
unimplemented!()
}
diff --git a/rust/fory-core/src/serializer/heap.rs b/rust/fory-core/src/serializer/heap.rs
index 94532ec07..7c9af1871 100644
--- a/rust/fory-core/src/serializer/heap.rs
+++ b/rust/fory-core/src/serializer/heap.rs
@@ -16,9 +16,9 @@
// under the License.
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::ReadContext;
use crate::resolver::context::WriteContext;
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::collection::{
read_collection, read_collection_type_info, write_collection, write_collection_type_info,
};
@@ -29,36 +29,19 @@ use std::collections::BinaryHeap;
use std::mem;
impl<T: Serializer + ForyDefault + Ord> Serializer for BinaryHeap<T> {
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_collection(self, fory, context, is_field)
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_collection(self, context, is_field)
}
- fn fory_write_type_info(
- _fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
write_collection_type_info(context, is_field, TypeId::SET as u32)
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
- read_collection(fory, context)
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
+ read_collection(context)
}
- fn fory_read_type_info(
- _fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
read_collection_type_info(context, is_field, TypeId::SET as u32)
}
@@ -66,11 +49,11 @@ impl<T: Serializer + ForyDefault + Ord> Serializer for BinaryHeap<T> {
mem::size_of::<i32>()
}
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::SET as u32)
}
- fn fory_type_id_dyn(&self, _fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::SET as u32)
}
diff --git a/rust/fory-core/src/serializer/list.rs b/rust/fory-core/src/serializer/list.rs
index 399ad8c51..ba3a954af 100644
--- a/rust/fory-core/src/serializer/list.rs
+++ b/rust/fory-core/src/serializer/list.rs
@@ -16,9 +16,9 @@
// under the License.
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::ReadContext;
use crate::resolver::context::WriteContext;
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::primitive_list;
use crate::serializer::{ForyDefault, Serializer};
use crate::types::TypeId;
@@ -44,45 +44,28 @@ fn check_primitive<T: 'static>() -> Option<TypeId> {
}
impl<T: Serializer + ForyDefault> Serializer for Vec<T> {
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
match check_primitive::<T>() {
Some(_) => primitive_list::fory_write_data(self, context),
- None => write_collection(self, fory, context, is_field),
+ None => write_collection(self, context, is_field),
}
}
- fn fory_write_type_info(
- _fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
match check_primitive::<T>() {
Some(type_id) => primitive_list::fory_write_type_info(context, is_field, type_id),
None => write_collection_type_info(context, is_field, TypeId::LIST as u32),
}
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
match check_primitive::<T>() {
Some(_) => primitive_list::fory_read_data(context),
- None => read_collection(fory, context),
+ None => read_collection(context),
}
}
- fn fory_read_type_info(
- _fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
match check_primitive::<T>() {
Some(type_id) => primitive_list::fory_read_type_info(context, is_field, type_id),
None => read_collection_type_info(context, is_field, TypeId::LIST as u32),
@@ -99,14 +82,14 @@ impl<T: Serializer + ForyDefault> Serializer for Vec<T> {
}
}
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
Ok(match check_primitive::<T>() {
Some(type_id) => type_id as u32,
None => TypeId::LIST as u32,
})
}
- fn fory_type_id_dyn(&self, _fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<u32, Error> {
Ok(match check_primitive::<T>() {
Some(type_id) => type_id as u32,
None => TypeId::LIST as u32,
@@ -125,36 +108,19 @@ impl<T> ForyDefault for Vec<T> {
}
impl<T: Serializer + ForyDefault> Serializer for VecDeque<T> {
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_collection(self, fory, context, is_field)
- }
-
- fn fory_write_type_info(
- _fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_collection(self, context, is_field)
+ }
+
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
write_collection_type_info(context, is_field, TypeId::LIST as u32)
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
- read_collection(fory, context)
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
+ read_collection(context)
}
- fn fory_read_type_info(
- _fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
read_collection_type_info(context, is_field, TypeId::LIST as u32)
}
@@ -162,11 +128,11 @@ impl<T: Serializer + ForyDefault> Serializer for VecDeque<T> {
mem::size_of::<u32>()
}
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::LIST as u32)
}
- fn fory_type_id_dyn(&self, _fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::LIST as u32)
}
@@ -182,36 +148,19 @@ impl<T> ForyDefault for VecDeque<T> {
}
impl<T: Serializer + ForyDefault> Serializer for LinkedList<T> {
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_collection(self, fory, context, is_field)
- }
-
- fn fory_write_type_info(
- _fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_collection(self, context, is_field)
+ }
+
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
write_collection_type_info(context, is_field, TypeId::LIST as u32)
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
- read_collection(fory, context)
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
+ read_collection(context)
}
- fn fory_read_type_info(
- _fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
read_collection_type_info(context, is_field, TypeId::LIST as u32)
}
@@ -219,11 +168,11 @@ impl<T: Serializer + ForyDefault> Serializer for LinkedList<T> {
mem::size_of::<u32>()
}
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::LIST as u32)
}
- fn fory_type_id_dyn(&self, _fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::LIST as u32)
}
diff --git a/rust/fory-core/src/serializer/map.rs b/rust/fory-core/src/serializer/map.rs
index 27045f482..526ef8927 100644
--- a/rust/fory-core/src/serializer/map.rs
+++ b/rust/fory-core/src/serializer/map.rs
@@ -17,8 +17,8 @@
use crate::ensure;
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::{ReadContext, WriteContext};
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{
read_ref_info_data, read_type_info, write_ref_info_data, write_type_info, ForyDefault,
Serializer,
@@ -36,7 +36,6 @@ pub const VALUE_NULL: u8 = 0b10000;
const DECL_VALUE_TYPE: u8 = 0b100000;
fn check_and_write_null<K: Serializer + Eq + std::hash::Hash, V: Serializer>(
- fory: &Fory,
context: &mut WriteContext,
is_field: bool,
key: &K,
@@ -50,7 +49,7 @@ fn check_and_write_null<K: Serializer + Eq + std::hash::Hash, V: Serializer>(
let mut chunk_header = KEY_NULL;
let skip_ref_flag;
if is_field {
- skip_ref_flag = crate::serializer::get_skip_ref_flag::<V>(fory)?;
+ skip_ref_flag = crate::serializer::get_skip_ref_flag::<V>(context.get_type_resolver())?;
chunk_header |= DECL_VALUE_TYPE;
} else {
skip_ref_flag = false;
@@ -58,7 +57,7 @@ fn check_and_write_null<K: Serializer + Eq + std::hash::Hash, V: Serializer>(
}
context.writer.write_u8(chunk_header);
- write_ref_info_data(value, fory, context, is_field, skip_ref_flag, false)?;
+ write_ref_info_data(value, context, is_field, skip_ref_flag, false)?;
return Ok(true);
}
if value.fory_is_none() {
@@ -73,7 +72,7 @@ fn check_and_write_null<K: Serializer + Eq + std::hash::Hash, V: Serializer>(
chunk_header |= TRACKING_KEY_REF;
}
context.writer.write_u8(chunk_header);
- write_ref_info_data(key, fory, context, is_field, skip_ref_flag, false)?;
+ write_ref_info_data(key, context, is_field, skip_ref_flag, false)?;
return Ok(true);
}
Ok(false)
@@ -86,7 +85,7 @@ fn write_chunk_size(context: &mut WriteContext, header_offset: usize, size: u8)
fn write_map_data<'a, K, V, I>(
iter: I,
length: usize,
- fory: &Fory,
+
context: &mut WriteContext,
is_field: bool,
) -> Result<(), Error>
@@ -110,7 +109,7 @@ where
let mut skip_val_ref_flag = false;
for (key, value) in iter {
if need_write_header {
- if check_and_write_null(fory, context, is_field, key, value)? {
+ if check_and_write_null(context, is_field, key, value)? {
continue;
}
header_offset = context.writer.len();
@@ -127,8 +126,8 @@ where
if !skip_val_ref_flag {
chunk_header |= TRACKING_VALUE_REF;
}
- K::fory_write_type_info(fory, context, is_field)?;
- V::fory_write_type_info(fory, context, is_field)?;
+ K::fory_write_type_info(context, is_field)?;
+ V::fory_write_type_info(context, is_field)?;
context.writer.set_bytes(header_offset, &[chunk_header]);
need_write_header = false;
}
@@ -136,18 +135,18 @@ where
write_chunk_size(context, header_offset, pair_counter);
pair_counter = 0;
need_write_header = true;
- check_and_write_null(fory, context, is_field, key, value)?;
+ check_and_write_null(context, is_field, key, value)?;
continue;
}
if K::fory_is_polymorphic() || K::fory_is_shared_ref() {
- key.fory_write(fory, context, is_field)?;
+ key.fory_write(context, is_field)?;
} else {
- write_ref_info_data(key, fory, context, is_field, skip_key_ref_flag, true)?;
+ write_ref_info_data(key, context, is_field, skip_key_ref_flag, true)?;
}
if V::fory_is_polymorphic() || V::fory_is_shared_ref() {
- value.fory_write(fory, context, is_field)?;
+ value.fory_write(context, is_field)?;
} else {
- write_ref_info_data(value, fory, context, is_field, skip_val_ref_flag, true)?;
+ write_ref_info_data(value, context, is_field, skip_val_ref_flag, true)?;
}
pair_counter += 1;
if pair_counter == MAX_CHUNK_SIZE {
@@ -165,20 +164,11 @@ where
impl<K: Serializer + ForyDefault + Eq + std::hash::Hash, V: Serializer + ForyDefault> Serializer
for HashMap<K, V>
{
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_map_data(self.iter(), self.len(), fory, context, is_field)
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_map_data(self.iter(), self.len(), context, is_field)
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
let len = context.reader.read_varuint32()?;
let mut map = HashMap::<K, V>::with_capacity(len as usize);
if len == 0 {
@@ -199,30 +189,29 @@ impl<K: Serializer + ForyDefault + Eq + std::hash::Hash, V: Serializer + ForyDef
let value_declared = (header & DECL_VALUE_TYPE) != 0;
if header & KEY_NULL != 0 {
let skip_ref_flag = if value_declared {
- crate::serializer::get_skip_ref_flag::<V>(fory)?
+ crate::serializer::get_skip_ref_flag::<V>(context.get_type_resolver())?
} else {
false
};
- let value =
- read_ref_info_data(fory, context, value_declared, skip_ref_flag, false)?;
+ let value = read_ref_info_data(context, value_declared, skip_ref_flag, false)?;
map.insert(K::fory_default(), value);
len_counter += 1;
continue;
}
if header & VALUE_NULL != 0 {
let skip_ref_flag = if key_declared {
- crate::serializer::get_skip_ref_flag::<K>(fory)?
+ crate::serializer::get_skip_ref_flag::<K>(context.get_type_resolver())?
} else {
false
};
- let key = read_ref_info_data(fory, context, key_declared, skip_ref_flag, false)?;
+ let key = read_ref_info_data(context, key_declared, skip_ref_flag, false)?;
map.insert(key, V::fory_default());
len_counter += 1;
continue;
}
let chunk_size = context.reader.read_u8()?;
- K::fory_read_type_info(fory, context, key_declared)?;
- V::fory_read_type_info(fory, context, value_declared)?;
+ K::fory_read_type_info(context, key_declared)?;
+ V::fory_read_type_info(context, value_declared)?;
let cur_len = len_counter + chunk_size as u32;
ensure!(
@@ -234,16 +223,16 @@ impl<K: Serializer + ForyDefault + Eq + std::hash::Hash, V: Serializer + ForyDef
assert!(len_counter + chunk_size as u32 <= len);
for _ in 0..chunk_size {
let key = if K::fory_is_polymorphic() {
- K::fory_read(fory, context, key_declared)?
+ K::fory_read(context, key_declared)?
} else {
// let skip_ref_flag = crate::serializer::get_skip_ref_flag::<K>(context.get_fory());
- read_ref_info_data(fory, context, key_declared, true, true)?
+ read_ref_info_data(context, key_declared, true, true)?
};
let value = if V::fory_is_polymorphic() {
- V::fory_read(fory, context, value_declared)?
+ V::fory_read(context, value_declared)?
} else {
// let skip_ref_flag = crate::serializer::get_skip_ref_flag::<V>(context.get_fory());
- read_ref_info_data(fory, context, value_declared, true, true)?
+ read_ref_info_data(context, value_declared, true, true)?
};
map.insert(key, value);
}
@@ -256,11 +245,11 @@ impl<K: Serializer + ForyDefault + Eq + std::hash::Hash, V: Serializer + ForyDef
size_of::<i32>()
}
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::MAP as u32)
}
- fn fory_type_id_dyn(&self, _fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::MAP as u32)
}
@@ -268,20 +257,12 @@ impl<K: Serializer + ForyDefault + Eq + std::hash::Hash, V: Serializer + ForyDef
self
}
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_type_info::<Self>(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_type_info::<Self>(context, is_field)
}
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- read_type_info::<Self>(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ read_type_info::<Self>(context, is_field)
}
}
@@ -294,20 +275,11 @@ impl<K, V> ForyDefault for HashMap<K, V> {
impl<K: Serializer + ForyDefault + Ord + std::hash::Hash, V: Serializer + ForyDefault> Serializer
for BTreeMap<K, V>
{
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_map_data(self.iter(), self.len(), fory, context, is_field)
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_map_data(self.iter(), self.len(), context, is_field)
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
let len = context.reader.read_varuint32()?;
let mut map = BTreeMap::<K, V>::new();
if len == 0 {
@@ -328,41 +300,40 @@ impl<K: Serializer + ForyDefault + Ord + std::hash::Hash, V: Serializer + ForyDe
let value_declared = (header & DECL_VALUE_TYPE) != 0;
if header & KEY_NULL != 0 {
let skip_ref_flag = if value_declared {
- crate::serializer::get_skip_ref_flag::<V>(fory)?
+ crate::serializer::get_skip_ref_flag::<V>(context.get_type_resolver())?
} else {
false
};
- let value =
- read_ref_info_data(fory, context, value_declared, skip_ref_flag, false)?;
+ let value = read_ref_info_data(context, value_declared, skip_ref_flag, false)?;
map.insert(K::fory_default(), value);
len_counter += 1;
continue;
}
if header & VALUE_NULL != 0 {
let skip_ref_flag = if key_declared {
- crate::serializer::get_skip_ref_flag::<K>(fory)?
+ crate::serializer::get_skip_ref_flag::<K>(context.get_type_resolver())?
} else {
false
};
- let key = read_ref_info_data(fory, context, key_declared, skip_ref_flag, false)?;
+ let key = read_ref_info_data(context, key_declared, skip_ref_flag, false)?;
map.insert(key, V::fory_default());
len_counter += 1;
continue;
}
let chunk_size = context.reader.read_u8()?;
- K::fory_read_type_info(fory, context, key_declared)?;
- V::fory_read_type_info(fory, context, value_declared)?;
+ K::fory_read_type_info(context, key_declared)?;
+ V::fory_read_type_info(context, value_declared)?;
assert!(len_counter + chunk_size as u32 <= len);
for _ in 0..chunk_size {
let key = if K::fory_is_polymorphic() {
- K::fory_read(fory, context, key_declared)?
+ K::fory_read(context, key_declared)?
} else {
- read_ref_info_data(fory, context, key_declared, true, true)?
+ read_ref_info_data(context, key_declared, true, true)?
};
let value = if V::fory_is_polymorphic() {
- V::fory_read(fory, context, value_declared)?
+ V::fory_read(context, value_declared)?
} else {
- read_ref_info_data(fory, context, value_declared, true, true)?
+ read_ref_info_data(context, value_declared, true, true)?
};
map.insert(key, value);
}
@@ -375,11 +346,11 @@ impl<K: Serializer + ForyDefault + Ord + std::hash::Hash, V: Serializer + ForyDe
size_of::<i32>()
}
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::MAP as u32)
}
- fn fory_type_id_dyn(&self, _fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::MAP as u32)
}
@@ -387,20 +358,12 @@ impl<K: Serializer + ForyDefault + Ord + std::hash::Hash, V: Serializer + ForyDe
self
}
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_type_info::<Self>(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_type_info::<Self>(context, is_field)
}
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- read_type_info::<Self>(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ read_type_info::<Self>(context, is_field)
}
}
diff --git a/rust/fory-core/src/serializer/mod.rs b/rust/fory-core/src/serializer/mod.rs
index 3962f70a8..4e1eca404 100644
--- a/rust/fory-core/src/serializer/mod.rs
+++ b/rust/fory-core/src/serializer/mod.rs
@@ -15,12 +15,11 @@
// specific language governing permissions and limitations
// under the License.
-use crate::ensure;
use crate::error::Error;
-use crate::fory::Fory;
-use crate::meta::{MetaString, TypeMeta, NAMESPACE_DECODER, TYPE_NAME_DECODER};
+use crate::meta::{FieldInfo, NAMESPACE_DECODER, TYPE_NAME_DECODER};
use crate::resolver::context::{ReadContext, WriteContext};
use crate::types::{RefFlag, TypeId, PRIMITIVE_TYPES};
+use crate::{ensure, TypeResolver};
use std::any::Any;
pub mod any;
@@ -49,7 +48,6 @@ pub mod weak;
#[inline(always)]
pub fn write_ref_info_data<T: Serializer + 'static>(
record: &T,
- fory: &Fory,
context: &mut WriteContext,
is_field: bool,
skip_ref_flag: bool,
@@ -62,16 +60,15 @@ pub fn write_ref_info_data<T: Serializer + 'static>(
context.writer.write_i8(RefFlag::NotNullValue as i8);
}
if !skip_type_info {
- T::fory_write_type_info(fory, context, is_field)?;
+ T::fory_write_type_info(context, is_field)?;
}
- record.fory_write_data(fory, context, is_field)?;
+ record.fory_write_data(context, is_field)?;
}
Ok(())
}
#[inline(always)]
pub fn read_ref_info_data<T: Serializer + ForyDefault>(
- fory: &Fory,
context: &mut ReadContext,
is_field: bool,
skip_ref_flag: bool,
@@ -83,15 +80,15 @@ pub fn read_ref_info_data<T: Serializer + ForyDefault>(
Ok(T::fory_default())
} else if ref_flag == (RefFlag::NotNullValue as i8) {
if !skip_type_info {
- T::fory_read_type_info(fory, context, is_field)?;
+ T::fory_read_type_info(context, is_field)?;
}
- T::fory_read_data(fory, context, is_field)
+ T::fory_read_data(context, is_field)
} else if ref_flag == (RefFlag::RefValue as i8) {
// First time seeing this referenceable object
if !skip_type_info {
- T::fory_read_type_info(fory, context, is_field)?;
+ T::fory_read_type_info(context, is_field)?;
}
- T::fory_read_data(fory, context, is_field)
+ T::fory_read_data(context, is_field)
} else if ref_flag == (RefFlag::Ref as i8) {
// This is a reference to a previously deserialized object
// For now, just return default - this should be handled by specific types
@@ -101,36 +98,34 @@ pub fn read_ref_info_data<T: Serializer + ForyDefault>(
}
} else {
if !skip_type_info {
- T::fory_read_type_info(fory, context, is_field)?;
+ T::fory_read_type_info(context, is_field)?;
}
- T::fory_read_data(fory, context, is_field)
+ T::fory_read_data(context, is_field)
}
}
#[inline(always)]
-fn write_type_info<T: Serializer>(
- fory: &Fory,
+pub fn write_type_info<T: Serializer>(
context: &mut WriteContext,
is_field: bool,
) -> Result<(), Error> {
if is_field {
return Ok(());
}
- let type_id = T::fory_get_type_id(fory)?;
+ let type_id = T::fory_get_type_id(context.get_type_resolver())?;
context.writer.write_varuint32(type_id);
Ok(())
}
#[inline(always)]
-fn read_type_info<T: Serializer>(
- fory: &Fory,
+pub fn read_type_info<T: Serializer>(
context: &mut ReadContext,
is_field: bool,
) -> Result<(), Error> {
if is_field {
return Ok(());
}
- let local_type_id = T::fory_get_type_id(fory)?;
+ let local_type_id = T::fory_get_type_id(context.get_type_resolver())?;
let remote_type_id = context.reader.read_varuint32()?;
ensure!(
local_type_id == remote_type_id,
@@ -140,8 +135,8 @@ fn read_type_info<T: Serializer>(
}
#[inline(always)]
-pub fn get_skip_ref_flag<T: Serializer>(fory: &Fory) -> Result<bool, Error> {
- let elem_type_id = T::fory_get_type_id(fory)?;
+pub fn get_skip_ref_flag<T: Serializer>(type_resolver: &TypeResolver) -> Result<bool, Error> {
+ let elem_type_id = T::fory_get_type_id(type_resolver)?;
Ok(!T::fory_is_option() && PRIMITIVE_TYPES.contains(&elem_type_id))
}
@@ -160,23 +155,18 @@ pub trait ForyDefault: Sized {
pub trait Serializer: 'static {
/// Entry point of the serialization.
- fn fory_write(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error>
+ fn fory_write(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error>
where
Self: Sized,
{
- write_ref_info_data(self, fory, context, is_field, false, false)
+ write_ref_info_data(self, context, is_field, false, false)
}
- fn fory_read(fory: &Fory, context: &mut ReadContext, is_field: bool) -> Result<Self, Error>
+ fn fory_read(context: &mut ReadContext, is_field: bool) -> Result<Self, Error>
where
Self: Sized + ForyDefault,
{
- read_ref_info_data(fory, context, is_field, false, false)
+ read_ref_info_data(context, is_field, false, false)
}
fn fory_is_option() -> bool
@@ -204,17 +194,16 @@ pub trait Serializer: 'static {
false
}
- fn fory_get_type_id(fory: &Fory) -> Result<u32, Error>
+ fn fory_get_type_id(type_resolver: &TypeResolver) -> Result<u32, Error>
where
Self: Sized,
{
- Ok(fory
- .get_type_resolver()
+ Ok(type_resolver
.get_type_info(std::any::TypeId::of::<Self>())?
.get_type_id())
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error>;
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error>;
/// The possible max memory size of the type.
/// Used to reserve the buffer space to avoid reallocation, which may hurt performance.
@@ -225,29 +214,22 @@ pub trait Serializer: 'static {
0
}
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- _is_field: bool,
- ) -> Result<(), Error>
+ fn fory_write_type_info(context: &mut WriteContext, _is_field: bool) -> Result<(), Error>
where
Self: Sized,
{
// default implementation only for ext/named_ext
- let type_id = Self::fory_get_type_id(fory)?;
+ let type_id = Self::fory_get_type_id(context.get_type_resolver())?;
context.writer.write_varuint32(type_id);
if type_id & 0xff == TypeId::EXT as u32 {
return Ok(());
}
let rs_type_id = std::any::TypeId::of::<Self>();
- if fory.is_share_meta() {
- let meta_index = context.push_meta(fory, rs_type_id)? as u32;
+ if context.is_share_meta() {
+ let meta_index = context.push_meta(rs_type_id)? as u32;
context.writer.write_varuint32(meta_index);
} else {
- let type_info = {
- let type_resolver = fory.get_type_resolver();
- type_resolver.get_type_info(rs_type_id)?
- };
+ let type_info = context.get_type_resolver().get_type_info(rs_type_id)?;
let namespace = type_info.get_namespace().to_owned();
let type_name = type_info.get_type_name().to_owned();
context.write_meta_string_bytes(&namespace)?;
@@ -256,16 +238,12 @@ pub trait Serializer: 'static {
Ok(())
}
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<(), Error>
+ fn fory_read_type_info(context: &mut ReadContext, _is_field: bool) -> Result<(), Error>
where
Self: Sized,
{
// default implementation only for ext/named_ext
- let local_type_id = Self::fory_get_type_id(fory)?;
+ let local_type_id = Self::fory_get_type_id(context.get_type_resolver())?;
let remote_type_id = context.reader.read_varuint32()?;
ensure!(
local_type_id == remote_type_id,
@@ -274,7 +252,7 @@ pub trait Serializer: 'static {
if local_type_id & 0xff == TypeId::EXT as u32 {
return Ok(());
}
- if fory.is_share_meta() {
+ if context.is_share_meta() {
let _meta_index = context.reader.read_varuint32()?;
} else {
let _namespace_msb = context.read_meta_string_bytes()?;
@@ -284,29 +262,29 @@ pub trait Serializer: 'static {
}
// only used by struct/enum/ext
- fn fory_read_compatible(fory: &Fory, context: &mut ReadContext) -> Result<Self, Error>
+ fn fory_read_compatible(context: &mut ReadContext) -> Result<Self, Error>
where
Self: Sized,
{
// default logic only for ext/named_ext
let remote_type_id = context.reader.read_varuint32()?;
- let local_type_id = Self::fory_get_type_id(fory)?;
+ let local_type_id = Self::fory_get_type_id(context.get_type_resolver())?;
ensure!(
local_type_id == remote_type_id,
Error::TypeMismatch(local_type_id, remote_type_id)
);
if local_type_id & 0xff == TypeId::EXT as u32 {
- let type_resolver = fory.get_type_resolver();
- type_resolver
+ context
+ .get_type_resolver()
.get_ext_harness(local_type_id)?
- .get_read_data_fn()(fory, context, true)
+ .get_read_data_fn()(context, true)
.and_then(|b: Box<dyn Any>| {
b.downcast::<Self>()
.map(|boxed_self| *boxed_self)
.map_err(|_| Error::TypeError("downcast to Self failed".into()))
})
} else {
- let (namespace, type_name) = if fory.is_share_meta() {
+ let (namespace, type_name) = if context.is_share_meta() {
let meta_index = context.reader.read_varuint32()?;
let type_meta = context.get_meta(meta_index as usize);
(type_meta.get_namespace(), type_meta.get_type_name())
@@ -317,10 +295,10 @@ pub trait Serializer: 'static {
let ts = TYPE_NAME_DECODER.decode(&tsb.bytes, tsb.encoding)?;
(ns, ts)
};
- let type_resolver = fory.get_type_resolver();
- type_resolver
+ context
+ .get_type_resolver()
.get_ext_name_harness(&namespace, &type_name)?
- .get_read_data_fn()(fory, context, true)
+ .get_read_data_fn()(context, true)
.and_then(|b: Box<dyn Any>| {
b.downcast::<Self>()
.map(|boxed_self| *boxed_self)
@@ -330,18 +308,9 @@ pub trait Serializer: 'static {
}
/// Write/Read the data into the buffer. Need to be implemented.
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error>;
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error>;
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error>
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error>
where
Self: Sized + ForyDefault;
@@ -353,14 +322,8 @@ pub trait Serializer: 'static {
}
pub trait StructSerializer: Serializer + 'static {
- fn fory_type_def(
- _fory: &Fory,
- _type_id: u32,
- _namespace: MetaString,
- _type_name: MetaString,
- _register_by_name: bool,
- ) -> Result<(Vec<u8>, TypeMeta), Error> {
- Ok((Vec::default(), TypeMeta::empty()))
+ fn fory_fields_info(_: &TypeResolver) -> Result<Vec<FieldInfo>, Error> {
+ Ok(Vec::default())
}
fn fory_type_index() -> u32 {
@@ -370,7 +333,7 @@ pub trait StructSerializer: Serializer + 'static {
struct_::actual_type_id(type_id, register_by_name, compatible)
}
- fn fory_get_sorted_field_names(_fory: &Fory) -> &'static [&'static str] {
+ fn fory_get_sorted_field_names() -> &'static [&'static str] {
&[]
}
}
diff --git a/rust/fory-core/src/serializer/mutex.rs b/rust/fory-core/src/serializer/mutex.rs
index 0d0fcf098..b3bb0cb45 100644
--- a/rust/fory-core/src/serializer/mutex.rs
+++ b/rust/fory-core/src/serializer/mutex.rs
@@ -42,8 +42,8 @@
//! - A poisoned mutex (from a panicked holder) will cause `.lock().unwrap()` to panic
//! during serialization — it is assumed this is a programmer error.
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::{ReadContext, WriteContext};
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{ForyDefault, Serializer};
use std::sync::Mutex;
@@ -52,35 +52,21 @@ use std::sync::Mutex;
/// Simply delegates to the serializer for `T`, allowing thread-safe interior mutable
/// containers to be included in serialized graphs.
impl<T: Serializer + ForyDefault> Serializer for Mutex<T> {
- fn fory_write(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
// Don't add ref tracking for Mutex itself, just delegate to inner type
// The inner type will handle its own ref tracking
let guard = self.lock().unwrap();
- T::fory_write(&*guard, fory, context, is_field)
+ T::fory_write(&*guard, context, is_field)
}
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
// When called from Rc/Arc, just delegate to inner type's data serialization
let guard = self.lock().unwrap();
- T::fory_write_data(&*guard, fory, context, is_field)
+ T::fory_write_data(&*guard, context, is_field)
}
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_write_type_info(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ T::fory_write_type_info(context, is_field)
}
fn fory_reserved_space() -> usize {
@@ -88,36 +74,28 @@ impl<T: Serializer + ForyDefault> Serializer for Mutex<T> {
T::fory_reserved_space()
}
- fn fory_read(fory: &Fory, context: &mut ReadContext, is_field: bool) -> Result<Self, Error>
+ fn fory_read(context: &mut ReadContext, is_field: bool) -> Result<Self, Error>
where
Self: Sized + ForyDefault,
{
- Ok(Mutex::new(T::fory_read(fory, context, is_field)?))
+ Ok(Mutex::new(T::fory_read(context, is_field)?))
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
- Ok(Mutex::new(T::fory_read_data(fory, context, is_field)?))
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
+ Ok(Mutex::new(T::fory_read_data(context, is_field)?))
}
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_read_type_info(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ T::fory_read_type_info(context, is_field)
}
- fn fory_get_type_id(fory: &Fory) -> Result<u32, Error> {
- T::fory_get_type_id(fory)
+ fn fory_get_type_id(type_resolver: &TypeResolver) -> Result<u32, Error> {
+ T::fory_get_type_id(type_resolver)
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
let guard = self.lock().unwrap();
- (*guard).fory_type_id_dyn(fory)
+ (*guard).fory_type_id_dyn(type_resolver)
}
fn as_any(&self) -> &dyn std::any::Any {
diff --git a/rust/fory-core/src/serializer/number.rs b/rust/fory-core/src/serializer/number.rs
index abe4f6239..c923bb15f 100644
--- a/rust/fory-core/src/serializer/number.rs
+++ b/rust/fory-core/src/serializer/number.rs
@@ -17,9 +17,9 @@
use crate::buffer::{Reader, Writer};
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::ReadContext;
use crate::resolver::context::WriteContext;
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{read_type_info, write_type_info, ForyDefault, Serializer};
use crate::types::TypeId;
@@ -29,7 +29,7 @@ macro_rules! impl_num_serializer {
#[inline]
fn fory_write_data(
&self,
- _fory: &Fory,
+
context: &mut WriteContext,
_is_field: bool,
) -> Result<(), Error> {
@@ -38,11 +38,7 @@ macro_rules! impl_num_serializer {
}
#[inline]
- fn fory_read_data(
- _fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
$reader(&mut context.reader)
}
@@ -52,11 +48,11 @@ macro_rules! impl_num_serializer {
}
#[inline]
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
Ok($field_type as u32)
}
- fn fory_type_id_dyn(&self, _fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<u32, Error> {
Ok($field_type as u32)
}
@@ -67,20 +63,15 @@ macro_rules! impl_num_serializer {
#[inline]
fn fory_write_type_info(
- fory: &Fory,
context: &mut WriteContext,
is_field: bool,
) -> Result<(), Error> {
- write_type_info::<Self>(fory, context, is_field)
+ write_type_info::<Self>(context, is_field)
}
#[inline]
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- read_type_info::<Self>(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ read_type_info::<Self>(context, is_field)
}
}
impl ForyDefault for $ty {
diff --git a/rust/fory-core/src/serializer/option.rs b/rust/fory-core/src/serializer/option.rs
index 6ea9c58c2..1a6dc0339 100644
--- a/rust/fory-core/src/serializer/option.rs
+++ b/rust/fory-core/src/serializer/option.rs
@@ -16,51 +16,34 @@
// under the License.
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::ReadContext;
use crate::resolver::context::WriteContext;
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{ForyDefault, Serializer};
impl<T: Serializer + ForyDefault> Serializer for Option<T> {
#[inline(always)]
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
- Ok(Some(T::fory_read_data(fory, context, is_field)?))
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
+ Ok(Some(T::fory_read_data(context, is_field)?))
}
#[inline(always)]
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_read_type_info(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ T::fory_read_type_info(context, is_field)
}
#[inline(always)]
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
if let Some(v) = self {
- T::fory_write_data(v, fory, context, is_field)
+ T::fory_write_data(v, context, is_field)
} else {
unreachable!("write should be call by serialize")
}
}
#[inline(always)]
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_write_type_info(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ T::fory_write_type_info(context, is_field)
}
#[inline(always)]
@@ -69,15 +52,15 @@ impl<T: Serializer + ForyDefault> Serializer for Option<T> {
}
#[inline(always)]
- fn fory_get_type_id(fory: &Fory) -> Result<u32, Error> {
- T::fory_get_type_id(fory)
+ fn fory_get_type_id(type_resolver: &TypeResolver) -> Result<u32, Error> {
+ T::fory_get_type_id(type_resolver)
}
#[inline(always)]
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
match self {
- Some(val) => val.fory_type_id_dyn(fory),
- None => T::fory_get_type_id(fory),
+ Some(val) => val.fory_type_id_dyn(type_resolver),
+ None => T::fory_get_type_id(type_resolver),
}
}
diff --git a/rust/fory-core/src/serializer/rc.rs b/rust/fory-core/src/serializer/rc.rs
index 86953ce68..c8750b4a9 100644
--- a/rust/fory-core/src/serializer/rc.rs
+++ b/rust/fory-core/src/serializer/rc.rs
@@ -16,8 +16,8 @@
// under the License.
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::{ReadContext, WriteContext};
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{ForyDefault, Serializer};
use crate::types::RefFlag;
use std::rc::Rc;
@@ -27,42 +27,28 @@ impl<T: Serializer + ForyDefault + 'static> Serializer for Rc<T> {
true
}
- fn fory_write(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
if !context
.ref_writer
.try_write_rc_ref(&mut context.writer, self)
{
- T::fory_write_data(self.as_ref(), fory, context, is_field)?
+ T::fory_write_data(self.as_ref(), context, is_field)?
};
Ok(())
}
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
// When Rc is nested inside another shared ref (like Arc<Rc<T>>),
// the outer ref calls fory_write_data on the inner Rc.
// We still need to track the Rc's own references here.
- self.fory_write(fory, context, is_field)
+ self.fory_write(context, is_field)
}
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_write_type_info(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ T::fory_write_type_info(context, is_field)
}
- fn fory_read(fory: &Fory, context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
+ fn fory_read(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
let ref_flag = context.ref_reader.read_ref_flag(&mut context.reader)?;
match ref_flag {
RefFlag::Null => Err(Error::InvalidRef("Rc cannot be null".into())),
@@ -73,12 +59,12 @@ impl<T: Serializer + ForyDefault + 'static> Serializer for Rc<T> {
})
}
RefFlag::NotNullValue => {
- let inner = T::fory_read_data(fory, context, is_field)?;
+ let inner = T::fory_read_data(context, is_field)?;
Ok(Rc::new(inner))
}
RefFlag::RefValue => {
let ref_id = context.ref_reader.reserve_ref_id();
- let inner = T::fory_read_data(fory, context, is_field)?;
+ let inner = T::fory_read_data(context, is_field)?;
let rc = Rc::new(inner);
context.ref_reader.store_rc_ref_at(ref_id, rc.clone());
Ok(rc)
@@ -86,22 +72,14 @@ impl<T: Serializer + ForyDefault + 'static> Serializer for Rc<T> {
}
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
// When Rc is nested inside another shared ref, fory_read_data is called.
// Delegate to fory_read which handles ref tracking properly.
- Self::fory_read(fory, context, is_field)
+ Self::fory_read(context, is_field)
}
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_read_type_info(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ T::fory_read_type_info(context, is_field)
}
fn fory_reserved_space() -> usize {
@@ -110,12 +88,12 @@ impl<T: Serializer + ForyDefault + 'static> Serializer for Rc<T> {
4
}
- fn fory_get_type_id(fory: &Fory) -> Result<u32, Error> {
- T::fory_get_type_id(fory)
+ fn fory_get_type_id(type_resolver: &TypeResolver) -> Result<u32, Error> {
+ T::fory_get_type_id(type_resolver)
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error> {
- (**self).fory_type_id_dyn(fory)
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
+ (**self).fory_type_id_dyn(type_resolver)
}
fn as_any(&self) -> &dyn std::any::Any {
diff --git a/rust/fory-core/src/serializer/refcell.rs b/rust/fory-core/src/serializer/refcell.rs
index 7dcba1660..e1c194d8d 100644
--- a/rust/fory-core/src/serializer/refcell.rs
+++ b/rust/fory-core/src/serializer/refcell.rs
@@ -33,8 +33,8 @@
//! // Can be serialized by the Fory framework
//! ```
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::{ReadContext, WriteContext};
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{ForyDefault, Serializer};
use std::cell::RefCell;
@@ -43,56 +43,34 @@ use std::cell::RefCell;
/// Simply delegates to the serializer for `T`, allowing interior mutable
/// containers to be included in serialized graphs.
impl<T: Serializer + ForyDefault> Serializer for RefCell<T> {
- fn fory_read(fory: &Fory, context: &mut ReadContext, is_field: bool) -> Result<Self, Error>
+ fn fory_read(context: &mut ReadContext, is_field: bool) -> Result<Self, Error>
where
Self: Sized + ForyDefault,
{
- Ok(RefCell::new(T::fory_read(fory, context, is_field)?))
+ Ok(RefCell::new(T::fory_read(context, is_field)?))
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
- Ok(RefCell::new(T::fory_read_data(fory, context, is_field)?))
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
+ Ok(RefCell::new(T::fory_read_data(context, is_field)?))
}
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_read_type_info(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ T::fory_read_type_info(context, is_field)
}
- fn fory_write(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
// Don't add ref tracking for RefCell itself, just delegate to inner type
// The inner type will handle its own ref tracking
- T::fory_write(&*self.borrow(), fory, context, is_field)
+ T::fory_write(&*self.borrow(), context, is_field)
}
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
// When called from Rc, just delegate to inner type's data serialization
- T::fory_write_data(&*self.borrow(), fory, context, is_field)
+ T::fory_write_data(&*self.borrow(), context, is_field)
}
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_write_type_info(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ T::fory_write_type_info(context, is_field)
}
fn fory_reserved_space() -> usize {
@@ -100,12 +78,12 @@ impl<T: Serializer + ForyDefault> Serializer for RefCell<T> {
T::fory_reserved_space()
}
- fn fory_get_type_id(fory: &Fory) -> Result<u32, Error> {
- T::fory_get_type_id(fory)
+ fn fory_get_type_id(type_resolver: &TypeResolver) -> Result<u32, Error> {
+ T::fory_get_type_id(type_resolver)
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error> {
- (*self.borrow()).fory_type_id_dyn(fory)
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
+ (*self.borrow()).fory_type_id_dyn(type_resolver)
}
fn as_any(&self) -> &dyn std::any::Any {
diff --git a/rust/fory-core/src/serializer/set.rs b/rust/fory-core/src/serializer/set.rs
index fc50b958d..dd0bfaa0d 100644
--- a/rust/fory-core/src/serializer/set.rs
+++ b/rust/fory-core/src/serializer/set.rs
@@ -16,9 +16,9 @@
// under the License.
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::ReadContext;
use crate::resolver::context::WriteContext;
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::collection::{
read_collection, read_collection_type_info, write_collection, write_collection_type_info,
};
@@ -29,36 +29,19 @@ use std::collections::{BTreeSet, HashSet};
use std::mem;
impl<T: Serializer + ForyDefault + Eq + std::hash::Hash> Serializer for HashSet<T> {
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_collection(self, fory, context, is_field)
- }
-
- fn fory_write_type_info(
- _fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_collection(self, context, is_field)
+ }
+
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
write_collection_type_info(context, is_field, TypeId::SET as u32)
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
- read_collection(fory, context)
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
+ read_collection(context)
}
- fn fory_read_type_info(
- _fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
read_collection_type_info(context, is_field, TypeId::SET as u32)
}
@@ -66,11 +49,11 @@ impl<T: Serializer + ForyDefault + Eq + std::hash::Hash> Serializer for HashSet<
mem::size_of::<i32>()
}
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::SET as u32)
}
- fn fory_type_id_dyn(&self, _fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::SET as u32)
}
@@ -86,36 +69,19 @@ impl<T> ForyDefault for HashSet<T> {
}
impl<T: Serializer + ForyDefault + Ord> Serializer for BTreeSet<T> {
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_collection(self, fory, context, is_field)
- }
-
- fn fory_write_type_info(
- _fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_collection(self, context, is_field)
+ }
+
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
write_collection_type_info(context, is_field, TypeId::SET as u32)
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
- read_collection(fory, context)
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
+ read_collection(context)
}
- fn fory_read_type_info(
- _fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
read_collection_type_info(context, is_field, TypeId::SET as u32)
}
@@ -123,11 +89,11 @@ impl<T: Serializer + ForyDefault + Ord> Serializer for BTreeSet<T> {
mem::size_of::<i32>()
}
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::SET as u32)
}
- fn fory_type_id_dyn(&self, _fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::SET as u32)
}
diff --git a/rust/fory-core/src/serializer/skip.rs b/rust/fory-core/src/serializer/skip.rs
index aa9feda19..8baf7eaaa 100644
--- a/rust/fory-core/src/serializer/skip.rs
+++ b/rust/fory-core/src/serializer/skip.rs
@@ -15,13 +15,13 @@
// specific language governing permissions and limitations
// under the License.
+use crate::ensure;
use crate::error::Error;
use crate::meta::FieldType;
use crate::resolver::context::ReadContext;
use crate::serializer::collection::{HAS_NULL, IS_SAME_TYPE};
use crate::serializer::Serializer;
use crate::types::{RefFlag, TypeId, BASIC_TYPES, CONTAINER_TYPES, PRIMITIVE_TYPES};
-use crate::{ensure, Fory};
use chrono::{NaiveDate, NaiveDateTime};
pub fn get_read_ref_flag(field_type: &FieldType) -> bool {
@@ -30,11 +30,11 @@ pub fn get_read_ref_flag(field_type: &FieldType) -> bool {
}
macro_rules! basic_type_deserialize {
- ($fory:expr, $tid:expr, $context:expr; $(($ty:ty, $id:ident)),+ $(,)?) => {
+ ($tid:expr, $context:expr; $(($ty:ty, $id:ident)),+ $(,)?) => {
$(
if $tid == TypeId::$id {
- <$ty as Serializer>::fory_read_type_info($fory, $context, true)?;
- <$ty as Serializer>::fory_read_data($fory, $context, true)?;
+ <$ty as Serializer>::fory_read_type_info($context, true)?;
+ <$ty as Serializer>::fory_read_data($context, true)?;
return Ok(());
}
)+else {
@@ -46,7 +46,6 @@ macro_rules! basic_type_deserialize {
// call when is_field && is_compatible_mode
#[allow(unreachable_code)]
pub fn skip_field_value(
- fory: &Fory,
context: &mut ReadContext,
field_type: &FieldType,
read_ref_flag: bool,
@@ -61,7 +60,7 @@ pub fn skip_field_value(
match TypeId::try_from(type_id_num as i16) {
Ok(type_id) => {
if BASIC_TYPES.contains(&type_id) {
- basic_type_deserialize!(fory, type_id, context;
+ basic_type_deserialize!(type_id, context;
(bool, BOOL),
(i8, INT8),
(i16, INT16),
@@ -93,7 +92,7 @@ pub fn skip_field_value(
let elem_type = field_type.generics.first().unwrap();
context.inc_depth()?;
for _ in 0..length {
- skip_field_value(fory, context, elem_type, !skip_ref_flag)?;
+ skip_field_value(context, elem_type, !skip_ref_flag)?;
}
context.dec_depth();
} else if type_id == TypeId::MAP {
@@ -118,7 +117,7 @@ pub fn skip_field_value(
if header & crate::serializer::map::KEY_NULL != 0 {
// let read_ref_flag = get_read_ref_flag(value_type);
context.inc_depth()?;
- skip_field_value(fory, context, value_type, false)?;
+ skip_field_value(context, value_type, false)?;
context.dec_depth();
len_counter += 1;
continue;
@@ -126,7 +125,7 @@ pub fn skip_field_value(
if header & crate::serializer::map::VALUE_NULL != 0 {
// let read_ref_flag = get_read_ref_flag(key_type);
context.inc_depth()?;
- skip_field_value(fory, context, key_type, false)?;
+ skip_field_value(context, key_type, false)?;
context.dec_depth();
len_counter += 1;
continue;
@@ -135,9 +134,9 @@ pub fn skip_field_value(
context.inc_depth()?;
for _ in (0..chunk_size).enumerate() {
// let read_ref_flag = get_read_ref_flag(key_type);
- skip_field_value(fory, context, key_type, false)?;
+ skip_field_value(context, key_type, false)?;
// let read_ref_flag = get_read_ref_flag(value_type);
- skip_field_value(fory, context, value_type, false)?;
+ skip_field_value(context, value_type, false)?;
}
context.dec_depth();
len_counter += chunk_size as u32;
@@ -159,7 +158,7 @@ pub fn skip_field_value(
context.inc_depth()?;
for field_info in field_infos.iter() {
let read_ref_flag = get_read_ref_flag(&field_info.field_type);
- skip_field_value(fory, context, &field_info.field_type, read_ref_flag)?;
+ skip_field_value(context, &field_info.field_type, read_ref_flag)?;
}
context.dec_depth();
Ok(())
@@ -171,10 +170,10 @@ pub fn skip_field_value(
);
let meta_index = context.reader.read_varuint32()?;
let type_meta = context.get_meta(meta_index as usize);
- let type_resolver = fory.get_type_resolver();
+ let type_resolver = context.get_type_resolver();
type_resolver
.get_ext_name_harness(&type_meta.get_namespace(), &type_meta.get_type_name())?
- .get_read_data_fn()(fory, context, true)?;
+ .get_read_data_fn()(context, true)?;
Ok(())
} else {
unreachable!("unimplemented type: {:?}", type_id);
@@ -197,7 +196,7 @@ pub fn skip_field_value(
context.inc_depth()?;
for field_info in field_infos.iter() {
let read_ref_flag = get_read_ref_flag(&field_info.field_type);
- skip_field_value(fory, context, &field_info.field_type, read_ref_flag)?;
+ skip_field_value(context, &field_info.field_type, read_ref_flag)?;
}
context.dec_depth();
} else if internal_id == ENUM_ID {
@@ -209,10 +208,10 @@ pub fn skip_field_value(
Error::TypeMismatch(type_id_num, remote_type_id)
);
context.inc_depth()?;
- let type_resolver = fory.get_type_resolver();
+ let type_resolver = context.get_type_resolver();
type_resolver
.get_ext_harness(type_id_num)?
- .get_read_data_fn()(fory, context, true)?;
+ .get_read_data_fn()(context, true)?;
context.dec_depth();
} else {
unreachable!("unimplemented skipped type: {:?}", type_id_num);
diff --git a/rust/fory-core/src/serializer/string.rs b/rust/fory-core/src/serializer/string.rs
index a0ce9d02a..ad9b2c25c 100644
--- a/rust/fory-core/src/serializer/string.rs
+++ b/rust/fory-core/src/serializer/string.rs
@@ -16,10 +16,10 @@
// under the License.
use crate::error::Error;
-use crate::fory::Fory;
use crate::meta::get_latin1_length;
use crate::resolver::context::ReadContext;
use crate::resolver::context::WriteContext;
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{read_type_info, write_type_info, ForyDefault, Serializer};
use crate::types::TypeId;
use std::mem;
@@ -32,18 +32,13 @@ enum StrEncoding {
impl Serializer for String {
#[inline]
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- _is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, context: &mut WriteContext, _is_field: bool) -> Result<(), Error> {
let mut len = get_latin1_length(self);
if len >= 0 {
let bitor = (len as u64) << 2 | StrEncoding::Latin1 as u64;
context.writer.write_varuint36_small(bitor);
context.writer.write_latin1_string(self);
- } else if fory.is_compress_string() {
+ } else if context.is_compress_string() {
// todo: support `writeNumUtf16BytesForUtf8Encoding` like in java
len = self.len() as i32;
let bitor = (len as u64) << 2 | StrEncoding::Utf8 as u64;
@@ -59,11 +54,7 @@ impl Serializer for String {
}
#[inline]
- fn fory_read_data(
- _fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
let bitor = context.reader.read_varuint36small()?;
let len = bitor >> 2;
let encoding = bitor & 0b11;
@@ -91,11 +82,11 @@ impl Serializer for String {
}
#[inline(always)]
- fn fory_get_type_id(_fory: &Fory) -> Result<u32, Error> {
+ fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::STRING as u32)
}
- fn fory_type_id_dyn(&self, _fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<u32, Error> {
Ok(TypeId::STRING as u32)
}
@@ -105,21 +96,13 @@ impl Serializer for String {
}
#[inline(always)]
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_type_info::<Self>(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_type_info::<Self>(context, is_field)
}
#[inline(always)]
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- read_type_info::<Self>(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ read_type_info::<Self>(context, is_field)
}
}
diff --git a/rust/fory-core/src/serializer/struct_.rs b/rust/fory-core/src/serializer/struct_.rs
index 4f1003d8d..5ec0137d6 100644
--- a/rust/fory-core/src/serializer/struct_.rs
+++ b/rust/fory-core/src/serializer/struct_.rs
@@ -17,10 +17,8 @@
use crate::ensure;
use crate::error::Error;
-use crate::fory::Fory;
-use crate::meta::{FieldInfo, MetaString, TypeMeta};
use crate::resolver::context::{ReadContext, WriteContext};
-use crate::serializer::{Serializer, StructSerializer};
+use crate::serializer::Serializer;
use crate::types::{RefFlag, TypeId};
#[inline(always)]
@@ -38,62 +36,21 @@ pub fn actual_type_id(type_id: u32, register_by_name: bool, compatible: bool) ->
}
}
-#[inline(always)]
-pub fn type_def<T: Serializer + StructSerializer>(
- fory: &Fory,
- type_id: u32,
- namespace: MetaString,
- type_name: MetaString,
- register_by_name: bool,
- mut field_infos: Vec<FieldInfo>,
-) -> (Vec<u8>, TypeMeta) {
- let sorted_field_names = T::fory_get_sorted_field_names(fory);
- let mut sorted_field_infos: Vec<FieldInfo> = Vec::with_capacity(field_infos.len());
- for name in sorted_field_names.iter() {
- let mut found = false;
- for i in 0..field_infos.len() {
- if &field_infos[i].field_name == name {
- // swap_remove is faster
- sorted_field_infos.push(field_infos.swap_remove(i));
- found = true;
- break;
- }
- }
- if !found {
- unreachable!("Field {} not found in field_infos", name);
- }
- }
- // assign field id in ascending order
- for (i, field_info) in sorted_field_infos.iter_mut().enumerate() {
- field_info.field_id = i as i16;
- }
- let meta = TypeMeta::from_fields(
- type_id,
- namespace,
- type_name,
- register_by_name,
- sorted_field_infos,
- );
- let bytes = meta.to_bytes().unwrap();
- (bytes, meta)
-}
-
#[inline(always)]
pub fn write_type_info<T: Serializer>(
- fory: &Fory,
context: &mut WriteContext,
_is_field: bool,
) -> Result<(), Error> {
- let type_id = T::fory_get_type_id(fory)?;
+ let type_id = T::fory_get_type_id(context.get_type_resolver())?;
context.writer.write_varuint32(type_id);
let rs_type_id = std::any::TypeId::of::<T>();
if type_id & 0xff == TypeId::NAMED_STRUCT as u32 {
- if fory.is_share_meta() {
- let meta_index = context.push_meta(fory, rs_type_id)? as u32;
+ if context.is_share_meta() {
+ let meta_index = context.push_meta(rs_type_id)? as u32;
context.writer.write_varuint32(meta_index);
} else {
- let type_info = fory.get_type_resolver().get_type_info(rs_type_id)?;
+ let type_info = context.get_type_resolver().get_type_info(rs_type_id)?;
let namespace = type_info.get_namespace().to_owned();
let type_name = type_info.get_type_name().to_owned();
context.write_meta_string_bytes(&namespace)?;
@@ -102,7 +59,7 @@ pub fn write_type_info<T: Serializer>(
} else if type_id & 0xff == TypeId::NAMED_COMPATIBLE_STRUCT as u32
|| type_id & 0xff == TypeId::COMPATIBLE_STRUCT as u32
{
- let meta_index = context.push_meta(fory, rs_type_id)? as u32;
+ let meta_index = context.push_meta(rs_type_id)? as u32;
context.writer.write_varuint32(meta_index);
}
Ok(())
@@ -110,19 +67,18 @@ pub fn write_type_info<T: Serializer>(
#[inline(always)]
pub fn read_type_info<T: Serializer>(
- fory: &Fory,
context: &mut ReadContext,
_is_field: bool,
) -> Result<(), Error> {
let remote_type_id = context.reader.read_varuint32()?;
- let local_type_id = T::fory_get_type_id(fory)?;
+ let local_type_id = T::fory_get_type_id(context.get_type_resolver())?;
ensure!(
local_type_id == remote_type_id,
Error::TypeMismatch(local_type_id, remote_type_id)
);
if local_type_id & 0xff == TypeId::NAMED_STRUCT as u32 {
- if fory.is_share_meta() {
+ if context.is_share_meta() {
let _meta_index = context.reader.read_varuint32()?;
} else {
let _namespace_msb = context.read_meta_string_bytes()?;
@@ -139,19 +95,18 @@ pub fn read_type_info<T: Serializer>(
#[inline(always)]
pub fn write<T: Serializer>(
this: &T,
- fory: &Fory,
context: &mut WriteContext,
_is_field: bool,
) -> Result<(), Error> {
- if fory.is_compatible() {
+ if context.is_compatible() {
context.writer.write_i8(RefFlag::NotNullValue as i8);
- T::fory_write_type_info(fory, context, false)?;
- this.fory_write_data(fory, context, true)?;
+ T::fory_write_type_info(context, false)?;
+ this.fory_write_data(context, true)?;
} else {
// currently same
context.writer.write_i8(RefFlag::NotNullValue as i8);
- T::fory_write_type_info(fory, context, false)?;
- this.fory_write_data(fory, context, true)?;
+ T::fory_write_type_info(context, false)?;
+ this.fory_write_data(context, true)?;
}
Ok(())
}
diff --git a/rust/fory-core/src/serializer/trait_object.rs b/rust/fory-core/src/serializer/trait_object.rs
index 6d434f552..7ee6daf92 100644
--- a/rust/fory-core/src/serializer/trait_object.rs
+++ b/rust/fory-core/src/serializer/trait_object.rs
@@ -16,15 +16,14 @@
// under the License.
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::{ReadContext, WriteContext};
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{ForyDefault, Serializer};
/// Helper functions for trait object serialization to reduce code duplication
///
/// Writes common trait object headers (ref flag, type ID, compatibility metadata)
pub fn write_trait_object_headers(
- fory: &Fory,
context: &mut WriteContext,
fory_type_id: u32,
concrete_type_id: std::any::TypeId,
@@ -34,18 +33,18 @@ pub fn write_trait_object_headers(
context.writer.write_i8(RefFlag::NotNullValue as i8);
context.writer.write_varuint32(fory_type_id);
- if fory.is_compatible()
+ if context.is_compatible()
&& (fory_type_id & 0xff == TypeId::NAMED_COMPATIBLE_STRUCT as u32
|| fory_type_id & 0xff == TypeId::COMPATIBLE_STRUCT as u32)
{
- let meta_index = context.push_meta(fory, concrete_type_id)? as u32;
+ let meta_index = context.push_meta(concrete_type_id)? as u32;
context.writer.write_varuint32(meta_index);
};
Ok(())
}
/// Reads common trait object headers and returns the type ID
-pub fn read_trait_object_headers(fory: &Fory, context: &mut ReadContext) -> Result<u32, Error> {
+pub fn read_trait_object_headers(context: &mut ReadContext) -> Result<u32, Error> {
use crate::types::{RefFlag, TypeId};
let ref_flag = context.reader.read_i8()?;
@@ -57,7 +56,7 @@ pub fn read_trait_object_headers(fory: &Fory, context: &mut ReadContext) -> Resu
let fory_type_id = context.reader.read_varuint32()?;
- if fory.is_compatible()
+ if context.is_compatible()
&& (fory_type_id & 0xff == TypeId::NAMED_COMPATIBLE_STRUCT as u32
|| fory_type_id & 0xff == TypeId::COMPATIBLE_STRUCT as u32)
{
@@ -69,11 +68,11 @@ pub fn read_trait_object_headers(fory: &Fory, context: &mut ReadContext) -> Resu
/// Helper macro for common type resolution and downcasting pattern
#[macro_export]
macro_rules! downcast_and_serialize {
- ($any_ref:expr, $fory:expr, $context:expr, $is_field:expr, $trait_name:ident, $($impl_type:ty),+) => {{
+ ($any_ref:expr, $context:expr, $is_field:expr, $trait_name:ident, $($impl_type:ty),+) => {{
$(
if $any_ref.type_id() == std::any::TypeId::of::<$impl_type>() {
if let Some(concrete) = $any_ref.downcast_ref::<$impl_type>() {
- concrete.fory_write_data($fory, $context, $is_field)?;
+ concrete.fory_write_data($context, $is_field)?;
return Ok(());
}
}
@@ -85,11 +84,11 @@ macro_rules! downcast_and_serialize {
/// Helper macro for common type resolution and deserialization pattern
#[macro_export]
macro_rules! resolve_and_deserialize {
- ($fory_type_id:expr, $fory:expr, $context:expr, $is_field:expr, $constructor:expr, $trait_name:ident, $($impl_type:ty),+) => {{
+ ($fory_type_id:expr, $context:expr, $is_field:expr, $constructor:expr, $trait_name:ident, $($impl_type:ty),+) => {{
$(
- if let Some(registered_type_id) = $fory.get_type_resolver().get_fory_type_id(std::any::TypeId::of::<$impl_type>()) {
+ if let Some(registered_type_id) = $context.get_type_resolver().get_fory_type_id(std::any::TypeId::of::<$impl_type>()) {
if $fory_type_id == registered_type_id {
- let concrete_obj = <$impl_type as $crate::serializer::Serializer>::fory_read_data($fory, $context, $is_field)?;
+ let concrete_obj = <$impl_type as $crate::serializer::Serializer>::fory_read_data($context, $is_field)?;
return Ok($constructor(concrete_obj));
}
}
@@ -200,27 +199,27 @@ macro_rules! register_trait_type {
// 4. Serializer implementation for Box<dyn Trait> (existing functionality)
impl $crate::serializer::Serializer for Box<dyn $trait_name> {
- fn fory_write(&self, fory: &$crate::fory::Fory, context: &mut $crate::resolver::context::WriteContext, is_field: bool) -> Result<(), $crate::error::Error> {
+ fn fory_write(&self, context: &mut $crate::resolver::context::WriteContext, is_field: bool) -> Result<(), $crate::error::Error> {
let any_ref = <dyn $trait_name as $crate::serializer::Serializer>::as_any(&**self);
let concrete_type_id = any_ref.type_id();
- if let Some(fory_type_id) = fory.get_type_resolver().get_fory_type_id(concrete_type_id) {
- $crate::serializer::trait_object::write_trait_object_headers(fory, context, fory_type_id, concrete_type_id)?;
- $crate::downcast_and_serialize!(any_ref, fory, context, is_field, $trait_name, $($impl_type),+);
+ if let Some(fory_type_id) = context.get_type_resolver().get_fory_type_id(concrete_type_id) {
+ $crate::serializer::trait_object::write_trait_object_headers(context, fory_type_id, concrete_type_id)?;
+ $crate::downcast_and_serialize!(any_ref, context, is_field, $trait_name, $($impl_type),+);
} else {
return Err($crate::error::Error::TypeError(format!("Type {:?} not registered for Box<dyn {}> serialization", concrete_type_id, stringify!($trait_name)).into()));
}
}
- fn fory_write_data(&self, fory: &$crate::fory::Fory, context: &mut $crate::resolver::context::WriteContext, is_field: bool) -> Result<(), $crate::error::Error> {
+ fn fory_write_data(&self, context: &mut $crate::resolver::context::WriteContext, is_field: bool) -> Result<(), $crate::error::Error> {
// Delegate to fory_write since this handles the polymorphic dispatch
- self.fory_write(fory, context, is_field)
+ self.fory_write(context, is_field)
}
- fn fory_type_id_dyn(&self, fory: &$crate::fory::Fory) -> Result<u32, $crate::error::Error> {
+ fn fory_type_id_dyn(&self, type_resolver: &$crate::resolver::type_resolver::TypeResolver) -> Result<u32, $crate::error::Error> {
let any_ref = <dyn $trait_name as $crate::serializer::Serializer>::as_any(&**self);
let concrete_type_id = any_ref.type_id();
- fory.get_type_resolver()
+ type_resolver
.get_fory_type_id(concrete_type_id)
.ok_or_else(|| $crate::error::Error::TypeError("Type not registered for trait object".into()))
}
@@ -229,21 +228,21 @@ macro_rules! register_trait_type {
true
}
- fn fory_write_type_info(fory: &$crate::fory::Fory, _context: &mut $crate::resolver::context::WriteContext, _is_field: bool) -> Result<(), $crate::error::Error> {
+ fn fory_write_type_info(_context: &mut $crate::resolver::context::WriteContext, _is_field: bool) -> Result<(), $crate::error::Error> {
// Box<dyn Trait> is polymorphic - type info is written per element
Ok(())
}
- fn fory_read_type_info(fory: &$crate::fory::Fory, _context: &mut $crate::resolver::context::ReadContext, _is_field: bool) -> Result<(), $crate::error::Error> {
+ fn fory_read_type_info(_context: &mut $crate::resolver::context::ReadContext, _is_field: bool) -> Result<(), $crate::error::Error> {
// Box<dyn Trait> is polymorphic - type info is read per element
Ok(())
}
- fn fory_read(fory: &$crate::fory::Fory, context: &mut $crate::resolver::context::ReadContext, is_field: bool) -> Result<Self, $crate::error::Error> {
+ fn fory_read(context: &mut $crate::resolver::context::ReadContext, is_field: bool) -> Result<Self, $crate::error::Error> {
context.inc_depth()?;
- let fory_type_id = $crate::serializer::trait_object::read_trait_object_headers(fory, context)?;
+ let fory_type_id = $crate::serializer::trait_object::read_trait_object_headers(context)?;
let result = $crate::resolve_and_deserialize!(
- fory_type_id, fory, context, is_field,
+ fory_type_id, context, is_field,
|obj| Box::new(obj) as Box<dyn $trait_name>,
$trait_name, $($impl_type),+
);
@@ -251,13 +250,13 @@ macro_rules! register_trait_type {
result
}
- fn fory_read_data(fory: &$crate::fory::Fory, _context: &mut $crate::resolver::context::ReadContext, _is_field: bool) -> Result<Self, $crate::error::Error> {
+ fn fory_read_data(_context: &mut $crate::resolver::context::ReadContext, _is_field: bool) -> Result<Self, $crate::error::Error> {
// This should not be called for polymorphic types like Box<dyn Trait>
// The fory_read method handles the polymorphic dispatch
panic!("fory_read_data should not be called directly on polymorphic Box<dyn {}> trait object", stringify!($trait_name));
}
- fn fory_get_type_id(_fory: &$crate::fory::Fory) -> Result<u32, $crate::error::Error> {
+ fn fory_get_type_id(_type_resolver: &$crate::resolver::type_resolver::TypeResolver) -> Result<u32, $crate::error::Error> {
Ok($crate::types::TypeId::STRUCT as u32)
}
@@ -406,23 +405,23 @@ macro_rules! generate_smart_pointer_wrapper {
macro_rules! impl_smart_pointer_serializer {
($wrapper_name:ident, $pointer_type:ty, $constructor_expr:expr, $trait_name:ident, $try_write_ref:ident, $get_ref:ident, $store_ref:ident, $($impl_type:ty),+) => {
impl $crate::serializer::Serializer for $wrapper_name {
- fn fory_write(&self, fory: &$crate::fory::Fory, context: &mut $crate::resolver::context::WriteContext, is_field: bool) -> Result<(), $crate::error::Error> {
+ fn fory_write(&self, context: &mut $crate::resolver::context::WriteContext, is_field: bool) -> Result<(), $crate::error::Error> {
if !context.ref_writer.$try_write_ref(&mut context.writer, &self.0) {
let any_obj = <dyn $trait_name as $crate::serializer::Serializer>::as_any(&*self.0);
let concrete_type_id = any_obj.type_id();
- let harness = context.write_any_typeinfo(fory, concrete_type_id)?;
+ let harness = context.write_any_typeinfo(concrete_type_id)?;
let serializer_fn = harness.get_write_data_fn();
- serializer_fn(any_obj, fory, context, is_field)?;
+ serializer_fn(any_obj, context, is_field)?;
}
Ok(())
}
- fn fory_write_data(&self, fory: &$crate::fory::Fory, context: &mut $crate::resolver::context::WriteContext, is_field: bool) -> Result<(), $crate::error::Error> {
+ fn fory_write_data(&self, context: &mut $crate::resolver::context::WriteContext, is_field: bool) -> Result<(), $crate::error::Error> {
let any_obj = <dyn $trait_name as $crate::serializer::Serializer>::as_any(&*self.0);
- $crate::downcast_and_serialize!(any_obj, fory, context, is_field, $trait_name, $($impl_type),+)
+ $crate::downcast_and_serialize!(any_obj, context, is_field, $trait_name, $($impl_type),+)
}
- fn fory_read(fory: &$crate::fory::Fory, context: &mut $crate::resolver::context::ReadContext, is_field: bool) -> Result<Self, $crate::error::Error> {
+ fn fory_read(context: &mut $crate::resolver::context::ReadContext, is_field: bool) -> Result<Self, $crate::error::Error> {
use $crate::types::RefFlag;
let ref_flag = context.ref_reader.read_ref_flag(&mut context.reader)?;
@@ -441,9 +440,9 @@ macro_rules! impl_smart_pointer_serializer {
}
RefFlag::NotNullValue => {
context.inc_depth()?;
- let harness = context.read_any_typeinfo(fory)?;
+ let harness = context.read_any_typeinfo()?;
let deserializer_fn = harness.get_read_data_fn();
- let boxed_any = deserializer_fn(fory, context, is_field)?;
+ let boxed_any = deserializer_fn(context, is_field)?;
context.dec_depth();
$(
@@ -461,9 +460,9 @@ macro_rules! impl_smart_pointer_serializer {
}
RefFlag::RefValue => {
context.inc_depth()?;
- let harness = context.read_any_typeinfo(fory)?;
+ let harness = context.read_any_typeinfo()?;
let deserializer_fn = harness.get_read_data_fn();
- let boxed_any = deserializer_fn(fory, context, is_field)?;
+ let boxed_any = deserializer_fn(context, is_field)?;
context.dec_depth();
$(
@@ -482,10 +481,10 @@ macro_rules! impl_smart_pointer_serializer {
}
}
}
- fn fory_read_data(fory: &$crate::fory::Fory, context: &mut $crate::resolver::context::ReadContext, is_field: bool) -> Result<Self, $crate::error::Error> {
+ fn fory_read_data(context: &mut $crate::resolver::context::ReadContext, is_field: bool) -> Result<Self, $crate::error::Error> {
let concrete_fory_type_id = context.reader.read_varuint32()?;
$crate::resolve_and_deserialize!(
- concrete_fory_type_id, fory, context, is_field,
+ concrete_fory_type_id, context, is_field,
|obj| {
let pointer = $constructor_expr(obj) as $pointer_type;
Self::from(pointer)
@@ -494,15 +493,15 @@ macro_rules! impl_smart_pointer_serializer {
)
}
- fn fory_get_type_id(_fory: &$crate::fory::Fory) -> Result<u32, $crate::error::Error> {
+ fn fory_get_type_id(_type_resolver: &$crate::resolver::type_resolver::TypeResolver) -> Result<u32, $crate::error::Error> {
Ok($crate::types::TypeId::STRUCT as u32)
}
- fn fory_write_type_info(_fory: &$crate::fory::Fory, _context: &mut $crate::resolver::context::WriteContext, _is_field: bool) -> Result<(), $crate::error::Error> {
+ fn fory_write_type_info(_context: &mut $crate::resolver::context::WriteContext, _is_field: bool) -> Result<(), $crate::error::Error> {
Ok(())
}
- fn fory_read_type_info(fory: &$crate::fory::Fory, _context: &mut $crate::resolver::context::ReadContext, _is_field: bool) -> Result<(), $crate::error::Error> {
+ fn fory_read_type_info(_context: &mut $crate::resolver::context::ReadContext, _is_field: bool) -> Result<(), $crate::error::Error> {
Ok(())
}
@@ -510,10 +509,10 @@ macro_rules! impl_smart_pointer_serializer {
true
}
- fn fory_type_id_dyn(&self, fory: &$crate::fory::Fory) -> Result<u32, $crate::error::Error> {
+ fn fory_type_id_dyn(&self, type_resolver: &$crate::resolver::type_resolver::TypeResolver) -> Result<u32, $crate::error::Error> {
let any_obj = <dyn $trait_name as $crate::serializer::Serializer>::as_any(&*self.0);
let concrete_type_id = any_obj.type_id();
- fory.get_type_resolver()
+ type_resolver
.get_fory_type_id(concrete_type_id)
.ok_or_else(|| $crate::error::Error::TypeError("Type not registered for trait object".into()))
}
@@ -543,30 +542,20 @@ impl ForyDefault for Box<dyn Serializer> {
}
impl Serializer for Box<dyn Serializer> {
- fn fory_write(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- let fory_type_id = (**self).fory_type_id_dyn(fory)?;
+ fn fory_write(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ let fory_type_id = (**self).fory_type_id_dyn(context.get_type_resolver())?;
let concrete_type_id = (**self).fory_concrete_type_id();
- write_trait_object_headers(fory, context, fory_type_id, concrete_type_id)?;
- (**self).fory_write_data(fory, context, is_field)
+ write_trait_object_headers(context, fory_type_id, concrete_type_id)?;
+ (**self).fory_write_data(context, is_field)
}
- fn fory_write_data(
- &self,
- _fory: &Fory,
- _context: &mut WriteContext,
- _is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_data(&self, _context: &mut WriteContext, _is_field: bool) -> Result<(), Error> {
panic!("fory_write_data should not be called directly on Box<dyn Serializer>");
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error> {
- (**self).fory_type_id_dyn(fory)
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
+ (**self).fory_type_id_dyn(type_resolver)
}
fn as_any(&self) -> &dyn std::any::Any {
@@ -577,33 +566,25 @@ impl Serializer for Box<dyn Serializer> {
true
}
- fn fory_write_type_info(
- _fory: &Fory,
- _context: &mut WriteContext,
- _is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write_type_info(_context: &mut WriteContext, _is_field: bool) -> Result<(), Error> {
// Box<dyn Serializer> is polymorphic - type info is written per element
Ok(())
}
- fn fory_read_type_info(
- _fory: &Fory,
- _context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_read_type_info(_context: &mut ReadContext, _is_field: bool) -> Result<(), Error> {
// Box<dyn Serializer> is polymorphic - type info is read per element
Ok(())
}
- fn fory_read(fory: &Fory, context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
- let fory_type_id = read_trait_object_headers(fory, context)?;
+ fn fory_read(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
+ let fory_type_id = read_trait_object_headers(context)?;
context.inc_depth()?;
- let type_resolver = fory.get_type_resolver();
+ let type_resolver = context.get_type_resolver();
if let Some(harness) = type_resolver.get_harness(fory_type_id) {
let deserializer_fn = harness.get_read_fn();
let to_serializer_fn = harness.get_to_serializer();
- let boxed_any = deserializer_fn(fory, context, is_field, true)?;
+ let boxed_any = deserializer_fn(context, is_field, true)?;
let trait_object = to_serializer_fn(boxed_any)?;
context.dec_depth();
Ok(trait_object)
@@ -635,11 +616,7 @@ impl Serializer for Box<dyn Serializer> {
}
}
}
- fn fory_read_data(
- _fory: &Fory,
- _context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(_context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
panic!("fory_read_data should not be called directly on Box<dyn Serializer>");
}
}
diff --git a/rust/fory-core/src/serializer/weak.rs b/rust/fory-core/src/serializer/weak.rs
index 54fc3304f..c04735901 100644
--- a/rust/fory-core/src/serializer/weak.rs
+++ b/rust/fory-core/src/serializer/weak.rs
@@ -122,8 +122,8 @@
//! once the strong pointer becomes available.
use crate::error::Error;
-use crate::fory::Fory;
use crate::resolver::context::{ReadContext, WriteContext};
+use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{ForyDefault, Serializer};
use crate::types::RefFlag;
use std::cell::UnsafeCell;
@@ -312,12 +312,7 @@ impl<T: Serializer + ForyDefault + 'static> Serializer for RcWeak<T> {
true
}
- fn fory_write(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
if let Some(rc) = self.upgrade() {
if context
.ref_writer
@@ -325,38 +320,29 @@ impl<T: Serializer + ForyDefault + 'static> Serializer for RcWeak<T> {
{
return Ok(());
}
- T::fory_write_data(&*rc, fory, context, is_field)?;
+ T::fory_write_data(&*rc, context, is_field)?;
} else {
context.writer.write_i8(RefFlag::Null as i8);
}
Ok(())
}
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- self.fory_write(fory, context, is_field)
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ self.fory_write(context, is_field)
}
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_write_type_info(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ T::fory_write_type_info(context, is_field)
}
- fn fory_read(fory: &Fory, context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
+ fn fory_read(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
let ref_flag = context.ref_reader.read_ref_flag(&mut context.reader)?;
match ref_flag {
RefFlag::Null => Ok(RcWeak::new()),
RefFlag::RefValue => {
context.inc_depth()?;
- let data = T::fory_read_data(fory, context, is_field)?;
+ let data = T::fory_read_data(context, is_field)?;
context.dec_depth();
let rc = Rc::new(data);
let ref_id = context.ref_reader.store_rc_ref(rc);
@@ -387,20 +373,12 @@ impl<T: Serializer + ForyDefault + 'static> Serializer for RcWeak<T> {
}
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
- Self::fory_read(fory, context, is_field)
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
+ Self::fory_read(context, is_field)
}
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_read_type_info(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ T::fory_read_type_info(context, is_field)
}
fn fory_reserved_space() -> usize {
@@ -408,15 +386,15 @@ impl<T: Serializer + ForyDefault + 'static> Serializer for RcWeak<T> {
4
}
- fn fory_get_type_id(fory: &Fory) -> Result<u32, Error> {
- T::fory_get_type_id(fory)
+ fn fory_get_type_id(type_resolver: &TypeResolver) -> Result<u32, Error> {
+ T::fory_get_type_id(type_resolver)
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
if let Some(rc) = self.upgrade() {
- (*rc).fory_type_id_dyn(fory)
+ (*rc).fory_type_id_dyn(type_resolver)
} else {
- T::fory_get_type_id(fory)
+ T::fory_get_type_id(type_resolver)
}
}
@@ -436,12 +414,7 @@ impl<T: Serializer + ForyDefault + Send + Sync + 'static> Serializer for ArcWeak
true
}
- fn fory_write(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
+ fn fory_write(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
if let Some(arc) = self.upgrade() {
// IMPORTANT: If the target Arc was serialized already, just write a ref
if context
@@ -452,38 +425,29 @@ impl<T: Serializer + ForyDefault + Send + Sync + 'static> Serializer for ArcWeak
return Ok(());
}
// First time seeing this object, write RefValue and then its data
- T::fory_write_data(&*arc, fory, context, is_field)?;
+ T::fory_write_data(&*arc, context, is_field)?;
} else {
context.writer.write_i8(RefFlag::Null as i8);
}
Ok(())
}
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- self.fory_write(fory, context, is_field)
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ self.fory_write(context, is_field)
}
- fn fory_write_type_info(
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_write_type_info(fory, context, is_field)
+ fn fory_write_type_info(context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ T::fory_write_type_info(context, is_field)
}
- fn fory_read(fory: &Fory, context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
+ fn fory_read(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
let ref_flag = context.ref_reader.read_ref_flag(&mut context.reader)?;
match ref_flag {
RefFlag::Null => Ok(ArcWeak::new()),
RefFlag::RefValue => {
context.inc_depth()?;
- let data = T::fory_read_data(fory, context, _is_field)?;
+ let data = T::fory_read_data(context, _is_field)?;
context.dec_depth();
let arc = Arc::new(data);
let ref_id = context.ref_reader.store_arc_ref(arc);
@@ -515,20 +479,12 @@ impl<T: Serializer + ForyDefault + Send + Sync + 'static> Serializer for ArcWeak
)),
}
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
- Self::fory_read(fory, context, is_field)
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
+ Self::fory_read(context, is_field)
}
- fn fory_read_type_info(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<(), Error> {
- T::fory_read_type_info(fory, context, is_field)
+ fn fory_read_type_info(context: &mut ReadContext, is_field: bool) -> Result<(), Error> {
+ T::fory_read_type_info(context, is_field)
}
fn fory_reserved_space() -> usize {
@@ -536,15 +492,15 @@ impl<T: Serializer + ForyDefault + Send + Sync + 'static> Serializer for ArcWeak
4
}
- fn fory_get_type_id(fory: &Fory) -> Result<u32, Error> {
- T::fory_get_type_id(fory)
+ fn fory_get_type_id(type_resolver: &TypeResolver) -> Result<u32, Error> {
+ T::fory_get_type_id(type_resolver)
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error> {
+ fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
if let Some(arc) = self.upgrade() {
- (*arc).fory_type_id_dyn(fory)
+ (*arc).fory_type_id_dyn(type_resolver)
} else {
- T::fory_get_type_id(fory)
+ T::fory_get_type_id(type_resolver)
}
}
diff --git a/rust/fory-derive/src/object/derive_enum.rs b/rust/fory-derive/src/object/derive_enum.rs
index 7221241c9..61f7c0234 100644
--- a/rust/fory-derive/src/object/derive_enum.rs
+++ b/rust/fory-derive/src/object/derive_enum.rs
@@ -25,9 +25,9 @@ pub fn gen_actual_type_id() -> TokenStream {
}
}
-pub fn gen_type_def(_data_enum: &DataEnum) -> TokenStream {
+pub fn gen_field_fields_info(_data_enum: &DataEnum) -> TokenStream {
quote! {
- Ok(fory_core::serializer::enum_::type_def(fory, type_id, namespace, type_name, register_by_name))
+ Ok(Vec::new())
}
}
@@ -39,13 +39,13 @@ pub fn gen_reserved_space() -> TokenStream {
pub fn gen_write_type_info() -> TokenStream {
quote! {
- fory_core::serializer::enum_::write_type_info::<Self>(fory, context, is_field)
+ fory_core::serializer::enum_::write_type_info::<Self>(context, is_field)
}
}
pub fn gen_read_type_info() -> TokenStream {
quote! {
- fory_core::serializer::enum_::read_type_info::<Self>(fory, context, is_field)
+ fory_core::serializer::enum_::read_type_info::<Self>(context, is_field)
}
}
@@ -79,18 +79,18 @@ pub fn gen_read_data(data_enum: &DataEnum) -> TokenStream {
pub fn gen_read_compatible() -> TokenStream {
quote! {
- fory_core::serializer::enum_::read_compatible::<Self>(fory, context)
+ fory_core::serializer::enum_::read_compatible::<Self>(context)
}
}
pub fn gen_write(_data_enum: &DataEnum) -> TokenStream {
quote! {
- fory_core::serializer::enum_::write::<Self>(self, fory, context, is_field)
+ fory_core::serializer::enum_::write::<Self>(self, context, is_field)
}
}
pub fn gen_read(_data_enum: &DataEnum) -> TokenStream {
quote! {
- fory_core::serializer::enum_::read::<Self>(fory, context, is_field)
+ fory_core::serializer::enum_::read::<Self>(context, is_field)
}
}
diff --git a/rust/fory-derive/src/object/misc.rs b/rust/fory-derive/src/object/misc.rs
index 4bb522cad..f122198c8 100644
--- a/rust/fory-derive/src/object/misc.rs
+++ b/rust/fory-derive/src/object/misc.rs
@@ -71,7 +71,7 @@ pub fn gen_get_sorted_field_names(fields: &[&Field]) -> TokenStream {
}
}
-pub fn gen_type_def(fields: &[&Field]) -> TokenStream {
+pub fn gen_field_fields_info(fields: &[&Field]) -> TokenStream {
let field_infos = fields.iter().map(|field| {
let ty = &field.ty;
let name = format!("{}", field.ident.as_ref().expect("should be field name"));
@@ -127,6 +127,6 @@ pub fn gen_type_def(fields: &[&Field]) -> TokenStream {
});
quote! {
let field_infos: Vec<fory_core::meta::FieldInfo> = vec![#(#field_infos),*];
- Ok(fory_core::serializer::struct_::type_def::<Self>(fory, type_id, namespace, type_name, register_by_name, field_infos))
+ Ok(field_infos)
}
}
diff --git a/rust/fory-derive/src/object/read.rs b/rust/fory-derive/src/object/read.rs
index 2a18bda71..e72ff3eed 100644
--- a/rust/fory-derive/src/object/read.rs
+++ b/rust/fory-derive/src/object/read.rs
@@ -115,12 +115,12 @@ fn gen_read_field(field: &Field, private_ident: &Ident) -> TokenStream {
let fory_type_id = context.reader.read_varuint32()?;
- let harness = fory.get_type_resolver()
+ let harness = context.get_type_resolver()
.get_harness(fory_type_id)
.ok_or_else(|| Error::TypeError("Type not registered for trait object field".into()))?;
let deserializer_fn = harness.get_read_fn();
- let any_box = deserializer_fn(fory, context, true, false)?;
+ let any_box = deserializer_fn(context, true, false)?;
let base_type_id = fory_type_id >> 8;
let #private_ident = #helper_mod::#from_any_fn(any_box, base_type_id)?;
@@ -132,7 +132,7 @@ fn gen_read_field(field: &Field, private_ident: &Ident) -> TokenStream {
let wrapper_ty = types.wrapper_ty;
let trait_ident = types.trait_ident;
quote! {
- let wrapper = <#wrapper_ty as fory_core::serializer::Serializer>::fory_read(fory, context, true)?;
+ let wrapper = <#wrapper_ty as fory_core::serializer::Serializer>::fory_read(context, true)?;
let #private_ident = std::rc::Rc::<dyn #trait_ident>::from(wrapper);
}
}
@@ -141,7 +141,7 @@ fn gen_read_field(field: &Field, private_ident: &Ident) -> TokenStream {
let wrapper_ty = types.wrapper_ty;
let trait_ident = types.trait_ident;
quote! {
- let wrapper = <#wrapper_ty as fory_core::serializer::Serializer>::fory_read(fory, context, true)?;
+ let wrapper = <#wrapper_ty as fory_core::serializer::Serializer>::fory_read(context, true)?;
let #private_ident = std::sync::Arc::<dyn #trait_ident>::from(wrapper);
}
}
@@ -150,7 +150,7 @@ fn gen_read_field(field: &Field, private_ident: &Ident) -> TokenStream {
let wrapper_ty = types.wrapper_ty;
let trait_ident = types.trait_ident;
quote! {
- let wrapper_vec = <Vec<#wrapper_ty> as fory_core::serializer::Serializer>::fory_read(fory, context, true)?;
+ let wrapper_vec = <Vec<#wrapper_ty> as fory_core::serializer::Serializer>::fory_read(context, true)?;
let #private_ident = wrapper_vec.into_iter()
.map(|w| std::rc::Rc::<dyn #trait_ident>::from(w))
.collect();
@@ -161,7 +161,7 @@ fn gen_read_field(field: &Field, private_ident: &Ident) -> TokenStream {
let wrapper_ty = types.wrapper_ty;
let trait_ident = types.trait_ident;
quote! {
- let wrapper_vec = <Vec<#wrapper_ty> as fory_core::serializer::Serializer>::fory_read(fory, context, true)?;
+ let wrapper_vec = <Vec<#wrapper_ty> as fory_core::serializer::Serializer>::fory_read(context, true)?;
let #private_ident = wrapper_vec.into_iter()
.map(|w| std::sync::Arc::<dyn #trait_ident>::from(w))
.collect();
@@ -172,7 +172,7 @@ fn gen_read_field(field: &Field, private_ident: &Ident) -> TokenStream {
let wrapper_ty = types.wrapper_ty;
let trait_ident = types.trait_ident;
quote! {
- let wrapper_map = <std::collections::HashMap<#key_ty, #wrapper_ty> as fory_core::serializer::Serializer>::fory_read(fory, context, true)?;
+ let wrapper_map = <std::collections::HashMap<#key_ty, #wrapper_ty> as fory_core::serializer::Serializer>::fory_read(context, true)?;
let #private_ident = wrapper_map.into_iter()
.map(|(k, v)| (k, std::rc::Rc::<dyn #trait_ident>::from(v)))
.collect();
@@ -183,7 +183,7 @@ fn gen_read_field(field: &Field, private_ident: &Ident) -> TokenStream {
let wrapper_ty = types.wrapper_ty;
let trait_ident = types.trait_ident;
quote! {
- let wrapper_map = <std::collections::HashMap<#key_ty, #wrapper_ty> as fory_core::serializer::Serializer>::fory_read(fory, context, true)?;
+ let wrapper_map = <std::collections::HashMap<#key_ty, #wrapper_ty> as fory_core::serializer::Serializer>::fory_read(context, true)?;
let #private_ident = wrapper_map.into_iter()
.map(|(k, v)| (k, std::sync::Arc::<dyn #trait_ident>::from(v)))
.collect();
@@ -191,13 +191,13 @@ fn gen_read_field(field: &Field, private_ident: &Ident) -> TokenStream {
}
StructField::Forward => {
quote! {
- let #private_ident = fory_core::serializer::Serializer::fory_read(fory, context, true)?;
+ let #private_ident = fory_core::serializer::Serializer::fory_read(context, true)?;
}
}
_ => {
let skip_ref_flag = skip_ref_flag(ty);
quote! {
- let #private_ident = fory_core::serializer::read_ref_info_data::<#ty>(fory, context, true, #skip_ref_flag, false)?;
+ let #private_ident = fory_core::serializer::read_ref_info_data::<#ty>(context, true, #skip_ref_flag, false)?;
}
}
}
@@ -205,7 +205,7 @@ fn gen_read_field(field: &Field, private_ident: &Ident) -> TokenStream {
pub fn gen_read_type_info() -> TokenStream {
quote! {
- fory_core::serializer::struct_::read_type_info::<Self>(fory, context, is_field)
+ fory_core::serializer::struct_::read_type_info::<Self>(context, is_field)
}
}
@@ -259,11 +259,11 @@ fn gen_read_compatible_match_arm_body(field: &Field, var_name: &Ident) -> TokenS
return Err(Error::InvalidRef("Expected NotNullValue for trait object field".into()));
}
let fory_type_id = context.reader.read_varuint32()?;
- let harness = fory.get_type_resolver()
+ let harness = context.get_type_resolver()
.get_harness(fory_type_id)
.ok_or_else(|| Error::TypeError("Type not registered for trait object field".into()))?;
let deserializer_fn = harness.get_read_fn();
- let any_box = deserializer_fn(fory, context, true, false)?;
+ let any_box = deserializer_fn(context, true, false)?;
let base_type_id = fory_type_id >> 8;
#var_name = #helper_mod::#from_any_fn(any_box, base_type_id)?;
}
@@ -273,7 +273,7 @@ fn gen_read_compatible_match_arm_body(field: &Field, var_name: &Ident) -> TokenS
let wrapper_ty = types.wrapper_ty;
let trait_ident = types.trait_ident;
quote! {
- let wrapper = <#wrapper_ty as fory_core::serializer::Serializer>::fory_read(fory, context, true)?;
+ let wrapper = <#wrapper_ty as fory_core::serializer::Serializer>::fory_read(context, true)?;
#var_name = Some(std::rc::Rc::<dyn #trait_ident>::from(wrapper));
}
}
@@ -282,7 +282,7 @@ fn gen_read_compatible_match_arm_body(field: &Field, var_name: &Ident) -> TokenS
let wrapper_ty = types.wrapper_ty;
let trait_ident = types.trait_ident;
quote! {
- let wrapper = <#wrapper_ty as fory_core::serializer::Serializer>::fory_read(fory, context, true)?;
+ let wrapper = <#wrapper_ty as fory_core::serializer::Serializer>::fory_read(context, true)?;
#var_name = Some(std::sync::Arc::<dyn #trait_ident>::from(wrapper));
}
}
@@ -291,7 +291,7 @@ fn gen_read_compatible_match_arm_body(field: &Field, var_name: &Ident) -> TokenS
let wrapper_ty = types.wrapper_ty;
let trait_ident = types.trait_ident;
quote! {
- let wrapper_vec = <Vec<#wrapper_ty> as fory_core::serializer::Serializer>::fory_read(fory, context, true)?;
+ let wrapper_vec = <Vec<#wrapper_ty> as fory_core::serializer::Serializer>::fory_read(context, true)?;
#var_name = Some(wrapper_vec.into_iter()
.map(|w| std::rc::Rc::<dyn #trait_ident>::from(w))
.collect());
@@ -302,7 +302,7 @@ fn gen_read_compatible_match_arm_body(field: &Field, var_name: &Ident) -> TokenS
let wrapper_ty = types.wrapper_ty;
let trait_ident = types.trait_ident;
quote! {
- let wrapper_vec = <Vec<#wrapper_ty> as fory_core::serializer::Serializer>::fory_read(fory, context, true)?;
+ let wrapper_vec = <Vec<#wrapper_ty> as fory_core::serializer::Serializer>::fory_read(context, true)?;
#var_name = Some(wrapper_vec.into_iter()
.map(|w| std::sync::Arc::<dyn #trait_ident>::from(w))
.collect());
@@ -313,7 +313,7 @@ fn gen_read_compatible_match_arm_body(field: &Field, var_name: &Ident) -> TokenS
let wrapper_ty = types.wrapper_ty;
let trait_ident = types.trait_ident;
quote! {
- let wrapper_map = <std::collections::HashMap<#key_ty, #wrapper_ty> as fory_core::serializer::Serializer>::fory_read(fory, context, true)?;
+ let wrapper_map = <std::collections::HashMap<#key_ty, #wrapper_ty> as fory_core::serializer::Serializer>::fory_read(context, true)?;
#var_name = Some(wrapper_map.into_iter()
.map(|(k, v)| (k, std::rc::Rc::<dyn #trait_ident>::from(v)))
.collect());
@@ -324,7 +324,7 @@ fn gen_read_compatible_match_arm_body(field: &Field, var_name: &Ident) -> TokenS
let wrapper_ty = types.wrapper_ty;
let trait_ident = types.trait_ident;
quote! {
- let wrapper_map = <std::collections::HashMap<#key_ty, #wrapper_ty> as fory_core::serializer::Serializer>::fory_read(fory, context, true)?;
+ let wrapper_map = <std::collections::HashMap<#key_ty, #wrapper_ty> as fory_core::serializer::Serializer>::fory_read(context, true)?;
#var_name = Some(wrapper_map.into_iter()
.map(|(k, v)| (k, std::sync::Arc::<dyn #trait_ident>::from(v)))
.collect());
@@ -332,13 +332,13 @@ fn gen_read_compatible_match_arm_body(field: &Field, var_name: &Ident) -> TokenS
}
StructField::ContainsTraitObject => {
quote! {
- let skip_ref_flag = fory_core::serializer::get_skip_ref_flag::<#ty>(fory);
- #var_name = Some(fory_core::serializer::read_ref_info_data::<#ty>(fory, context, true, skip_ref_flag, false)?);
+ let skip_ref_flag = fory_core::serializer::get_skip_ref_flag::<#ty>(context.get_type_resolver());
+ #var_name = Some(fory_core::serializer::read_ref_info_data::<#ty>(context, true, skip_ref_flag, false)?);
}
}
StructField::Forward => {
quote! {
- #var_name = Some(fory_core::serializer::Serializer::fory_read(fory, context, true)?);
+ #var_name = Some(fory_core::serializer::Serializer::fory_read(context, true)?);
}
}
StructField::None => {
@@ -351,10 +351,10 @@ fn gen_read_compatible_match_arm_body(field: &Field, var_name: &Ident) -> TokenS
if local_nullable {
quote! {
if _field.field_type.nullable {
- #var_name = Some(fory_core::serializer::read_ref_info_data::<#ty>(fory, context, true, false, false)?);
+ #var_name = Some(fory_core::serializer::read_ref_info_data::<#ty>(context, true, false, false)?);
} else {
#var_name = Some(
- fory_core::serializer::read_ref_info_data::<#ty>(fory, context, true, true, false)?
+ fory_core::serializer::read_ref_info_data::<#ty>(context, true, true, false)?
);
}
}
@@ -363,21 +363,21 @@ fn gen_read_compatible_match_arm_body(field: &Field, var_name: &Ident) -> TokenS
if dec_by_option {
quote! {
if !_field.field_type.nullable {
- #var_name = Some(fory_core::serializer::read_ref_info_data::<#ty>(fory, context, true, true, false)?);
+ #var_name = Some(fory_core::serializer::read_ref_info_data::<#ty>(context, true, true, false)?);
} else {
- #var_name = fory_core::serializer::read_ref_info_data::<Option<#ty>>(fory, context, true, false, false)?
+ #var_name = fory_core::serializer::read_ref_info_data::<Option<#ty>>(context, true, false, false)?
}
}
} else {
let null_flag = RefFlag::Null as i8;
quote! {
if !_field.field_type.nullable {
- #var_name = fory_core::serializer::read_ref_info_data::<#ty>(fory, context, true, true, false)?;
+ #var_name = fory_core::serializer::read_ref_info_data::<#ty>(context, true, true, false)?;
} else {
if context.reader.read_i8()? == #null_flag {
#var_name = <#ty as fory_core::serializer::ForyDefault>::fory_default();
} else {
- #var_name = fory_core::serializer::read_ref_info_data::<#ty>(fory, context, true, true, false)?;
+ #var_name = fory_core::serializer::read_ref_info_data::<#ty>(context, true, true, false)?;
}
}
}
@@ -391,11 +391,11 @@ pub fn gen_read(struct_ident: &Ident) -> TokenStream {
quote! {
let ref_flag = context.reader.read_i8()?;
if ref_flag == (fory_core::types::RefFlag::NotNullValue as i8) || ref_flag == (fory_core::types::RefFlag::RefValue as i8) {
- if fory.is_compatible() {
- <#struct_ident as fory_core::serializer::Serializer>::fory_read_compatible(fory, context)
+ if context.is_compatible() {
+ <#struct_ident as fory_core::serializer::Serializer>::fory_read_compatible(context)
} else {
- <Self as fory_core::serializer::Serializer>::fory_read_type_info(fory, context, false)?;
- <Self as fory_core::serializer::Serializer>::fory_read_data(fory, context, false)
+ <Self as fory_core::serializer::Serializer>::fory_read_type_info(context, false)?;
+ <Self as fory_core::serializer::Serializer>::fory_read_data(context, false)
}
} else if ref_flag == (fory_core::types::RefFlag::Null as i8) {
Ok(<Self as fory_core::serializer::ForyDefault>::fory_default())
@@ -437,9 +437,9 @@ pub fn gen_read_compatible(fields: &[&Field]) -> TokenStream {
};
#(#declare_ts)*
- let local_type_hash = fory.get_type_resolver().get_type_info(std::any::TypeId::of::<Self>())?.get_type_meta().get_hash();
+ let local_type_hash = context.get_type_resolver().get_type_info(std::any::TypeId::of::<Self>())?.get_type_meta().get_hash();
if meta.get_hash() == local_type_hash {
- <Self as fory_core::serializer::Serializer>::fory_read_data(fory, context, false)
+ <Self as fory_core::serializer::Serializer>::fory_read_data(context, false)
} else {
for _field in fields.iter() {
match _field.field_id {
@@ -447,7 +447,7 @@ pub fn gen_read_compatible(fields: &[&Field]) -> TokenStream {
_ => {
let field_type = &_field.field_type;
let read_ref_flag = fory_core::serializer::skip::get_read_ref_flag(&field_type);
- fory_core::serializer::skip::skip_field_value(fory, context, &field_type, read_ref_flag)?;
+ fory_core::serializer::skip::skip_field_value(context, &field_type, read_ref_flag)?;
}
}
}
diff --git a/rust/fory-derive/src/object/serializer.rs b/rust/fory-derive/src/object/serializer.rs
index 23f911452..2ba9b9513 100644
--- a/rust/fory-derive/src/object/serializer.rs
+++ b/rust/fory-derive/src/object/serializer.rs
@@ -50,21 +50,21 @@ pub fn derive_serializer(ast: &syn::DeriveInput) -> TokenStream {
};
// StructSerializer
- let (actual_type_id_ts, get_sorted_field_names_ts, type_def_ts, read_compatible_ts) =
+ let (actual_type_id_ts, get_sorted_field_names_ts, fields_info_ts, read_compatible_ts) =
match &ast.data {
syn::Data::Struct(s) => {
let fields = sorted_fields(&s.fields);
(
misc::gen_actual_type_id(),
misc::gen_get_sorted_field_names(&fields),
- misc::gen_type_def(&fields),
+ misc::gen_field_fields_info(&fields),
read::gen_read_compatible(&fields),
)
}
syn::Data::Enum(s) => (
derive_enum::gen_actual_type_id(),
- quote! { unreachable!() },
- derive_enum::gen_type_def(s),
+ quote! { &[] },
+ derive_enum::gen_field_fields_info(s),
derive_enum::gen_read_compatible(),
),
syn::Data::Union(_) => {
@@ -124,21 +124,21 @@ pub fn derive_serializer(ast: &syn::DeriveInput) -> TokenStream {
#actual_type_id_ts
}
- fn fory_get_sorted_field_names(_fory: &fory_core::fory::Fory) -> &'static [&'static str] {
+ fn fory_get_sorted_field_names() -> &'static [&'static str] {
#get_sorted_field_names_ts
}
- fn fory_type_def(fory: &fory_core::fory::Fory, type_id: u32, namespace: fory_core::meta::MetaString, type_name: fory_core::meta::MetaString, register_by_name: bool) -> Result<(Vec<u8>, fory_core::meta::TypeMeta), fory_core::error::Error> {
- #type_def_ts
+ fn fory_fields_info(type_resolver: &fory_core::resolver::type_resolver::TypeResolver) -> Result<Vec<fory_core::meta::FieldInfo>, fory_core::error::Error> {
+ #fields_info_ts
}
}
impl fory_core::serializer::Serializer for #name {
- fn fory_get_type_id(fory: &fory_core::fory::Fory) -> Result<u32, fory_core::error::Error> {
- fory.get_type_resolver().get_type_id(&std::any::TypeId::of::<Self>(), #type_idx)
+ fn fory_get_type_id(type_resolver: &fory_core::resolver::type_resolver::TypeResolver) -> Result<u32, fory_core::error::Error> {
+ type_resolver.get_type_id(&std::any::TypeId::of::<Self>(), #type_idx)
}
- fn fory_type_id_dyn(&self, fory: &fory_core::fory::Fory) -> Result<u32, fory_core::error::Error> {
- Self::fory_get_type_id(fory)
+ fn fory_type_id_dyn(&self, type_resolver: &fory_core::resolver::type_resolver::TypeResolver) -> Result<u32, fory_core::error::Error> {
+ Self::fory_get_type_id(type_resolver)
}
fn as_any(&self) -> &dyn std::any::Any {
@@ -149,31 +149,31 @@ pub fn derive_serializer(ast: &syn::DeriveInput) -> TokenStream {
#reserved_space_ts
}
- fn fory_write_type_info(fory: &fory_core::fory::Fory, context: &mut fory_core::resolver::context::WriteContext, is_field: bool) -> Result<(), fory_core::error::Error> {
+ fn fory_write_type_info(context: &mut fory_core::resolver::context::WriteContext, is_field: bool) -> Result<(), fory_core::error::Error> {
#write_type_info_ts
}
- fn fory_read_type_info(fory: &fory_core::fory::Fory, context: &mut fory_core::resolver::context::ReadContext, is_field: bool) -> Result<(), fory_core::error::Error> {
+ fn fory_read_type_info(context: &mut fory_core::resolver::context::ReadContext, is_field: bool) -> Result<(), fory_core::error::Error> {
#read_type_info_ts
}
- fn fory_write_data(&self, fory: &fory_core::fory::Fory, context: &mut fory_core::resolver::context::WriteContext, is_field: bool) -> Result<(), fory_core::error::Error> {
+ fn fory_write_data(&self, context: &mut fory_core::resolver::context::WriteContext, is_field: bool) -> Result<(), fory_core::error::Error> {
#write_data_ts
}
- fn fory_read_data(fory: &fory_core::fory::Fory, context: &mut fory_core::resolver::context::ReadContext, is_field: bool) -> Result<Self, fory_core::error::Error> {
+ fn fory_read_data( context: &mut fory_core::resolver::context::ReadContext, is_field: bool) -> Result<Self, fory_core::error::Error> {
#read_data_ts
}
- fn fory_write(&self, fory: &fory_core::fory::Fory, context: &mut fory_core::resolver::context::WriteContext, is_field: bool) -> Result<(), fory_core::error::Error> {
+ fn fory_write(&self, context: &mut fory_core::resolver::context::WriteContext, is_field: bool) -> Result<(), fory_core::error::Error> {
#write_ts
}
- fn fory_read(fory: &fory_core::fory::Fory, context: &mut fory_core::resolver::context::ReadContext, is_field: bool) -> Result<Self, fory_core::error::Error> {
+ fn fory_read(context: &mut fory_core::resolver::context::ReadContext, is_field: bool) -> Result<Self, fory_core::error::Error> {
#read_ts
}
- fn fory_read_compatible(fory: &fory_core::fory::Fory, context: &mut fory_core::resolver::context::ReadContext) -> Result<Self, fory_core::error::Error> {
+ fn fory_read_compatible(context: &mut fory_core::resolver::context::ReadContext) -> Result<Self, fory_core::error::Error> {
#read_compatible_ts
}
}
diff --git a/rust/fory-derive/src/object/util.rs b/rust/fory-derive/src/object/util.rs
index 6f7ca8ef6..ee5e0a585 100644
--- a/rust/fory-derive/src/object/util.rs
+++ b/rust/fory-derive/src/object/util.rs
@@ -354,7 +354,7 @@ pub(super) fn generic_tree_to_tokens(node: &TypeNode) -> TokenStream {
ts
} else {
quote! {
- <#ty as fory_core::serializer::Serializer>::fory_get_type_id(fory)?
+ <#ty as fory_core::serializer::Serializer>::fory_get_type_id(type_resolver)?
}
};
diff --git a/rust/fory-derive/src/object/write.rs b/rust/fory-derive/src/object/write.rs
index 18cee31ee..035562ecd 100644
--- a/rust/fory-derive/src/object/write.rs
+++ b/rust/fory-derive/src/object/write.rs
@@ -95,7 +95,7 @@ pub fn gen_reserved_space(fields: &[&Field]) -> TokenStream {
pub fn gen_write_type_info() -> TokenStream {
quote! {
- fory_core::serializer::struct_::write_type_info::<Self>(fory, context, is_field)
+ fory_core::serializer::struct_::write_type_info::<Self>(context, is_field)
}
}
@@ -108,20 +108,20 @@ fn gen_write_field(field: &Field) -> TokenStream {
{
let any_ref = self.#ident.as_any();
let concrete_type_id = any_ref.type_id();
- let fory_type_id = fory.get_type_resolver()
+ let fory_type_id = context.get_type_resolver()
.get_fory_type_id(concrete_type_id)
.ok_or_else(|| fory_core::error::Error::TypeError("Type not registered for trait object field".into()))?;
context.writer.write_i8(fory_core::types::RefFlag::NotNullValue as i8)?;
context.writer.write_varuint32(fory_type_id);
- let harness = fory
+ let harness = context
.get_type_resolver()
.get_harness(fory_type_id)
.ok_or_else(|| fory_core::error::Error::TypeError("Harness not found for trait object field".into()))?;
let serializer_fn = harness.get_write_fn();
- serializer_fn(any_ref, fory, context, true)?;
+ serializer_fn(any_ref, context, true)?;
}
}
}
@@ -132,7 +132,7 @@ fn gen_write_field(field: &Field) -> TokenStream {
quote! {
{
let wrapper = #wrapper_ty::from(self.#ident.clone() as std::rc::Rc<dyn #trait_ident>);
- fory_core::serializer::Serializer::fory_write(&wrapper, fory, context, true)?;
+ fory_core::serializer::Serializer::fory_write(&wrapper, context, true)?;
}
}
}
@@ -143,7 +143,7 @@ fn gen_write_field(field: &Field) -> TokenStream {
quote! {
{
let wrapper = #wrapper_ty::from(self.#ident.clone() as std::sync::Arc<dyn #trait_ident>);
- fory_core::serializer::Serializer::fory_write(&wrapper, fory, context, true)?;
+ fory_core::serializer::Serializer::fory_write(&wrapper, context, true)?;
}
}
}
@@ -156,7 +156,7 @@ fn gen_write_field(field: &Field) -> TokenStream {
let wrapper_vec: Vec<#wrapper_ty> = self.#ident.iter()
.map(|item| #wrapper_ty::from(item.clone() as std::rc::Rc<dyn #trait_ident>))
.collect();
- fory_core::serializer::Serializer::fory_write(&wrapper_vec, fory, context, true)?;
+ fory_core::serializer::Serializer::fory_write(&wrapper_vec, context, true)?;
}
}
}
@@ -169,7 +169,7 @@ fn gen_write_field(field: &Field) -> TokenStream {
let wrapper_vec: Vec<#wrapper_ty> = self.#ident.iter()
.map(|item| #wrapper_ty::from(item.clone() as std::sync::Arc<dyn #trait_ident>))
.collect();
- fory_core::serializer::Serializer::fory_write(&wrapper_vec, fory, context, true)?;
+ fory_core::serializer::Serializer::fory_write(&wrapper_vec, context, true)?;
}
}
}
@@ -182,7 +182,7 @@ fn gen_write_field(field: &Field) -> TokenStream {
let wrapper_map: std::collections::HashMap<#key_ty, #wrapper_ty> = self.#ident.iter()
.map(|(k, v)| (k.clone(), #wrapper_ty::from(v.clone() as std::rc::Rc<dyn #trait_ident>)))
.collect();
- fory_core::serializer::Serializer::fory_write(&wrapper_map, fory, context, true)?;
+ fory_core::serializer::Serializer::fory_write(&wrapper_map, context, true)?;
}
}
}
@@ -195,21 +195,21 @@ fn gen_write_field(field: &Field) -> TokenStream {
let wrapper_map: std::collections::HashMap<#key_ty, #wrapper_ty> = self.#ident.iter()
.map(|(k, v)| (k.clone(), #wrapper_ty::from(v.clone() as std::sync::Arc<dyn #trait_ident>)))
.collect();
- fory_core::serializer::Serializer::fory_write(&wrapper_map, fory, context, true)?;
+ fory_core::serializer::Serializer::fory_write(&wrapper_map, context, true)?;
}
}
}
StructField::Forward => {
quote! {
{
- fory_core::serializer::Serializer::fory_write(&self.#ident, fory, context, true)?;
+ fory_core::serializer::Serializer::fory_write(&self.#ident, context, true)?;
}
}
}
_ => {
let skip_ref_flag = skip_ref_flag(ty);
quote! {
- fory_core::serializer::write_ref_info_data::<#ty>(&self.#ident, fory, context, true, #skip_ref_flag, false)?;
+ fory_core::serializer::write_ref_info_data::<#ty>(&self.#ident, context, true, #skip_ref_flag, false)?;
}
}
}
@@ -225,6 +225,6 @@ pub fn gen_write_data(fields: &[&Field]) -> TokenStream {
pub fn gen_write() -> TokenStream {
quote! {
- fory_core::serializer::struct_::write::<Self>(self, fory, context, is_field)
+ fory_core::serializer::struct_::write::<Self>(self, context, is_field)
}
}
diff --git a/rust/fory/src/lib.rs b/rust/fory/src/lib.rs
index 10cd983b2..b8e6c538f 100644
--- a/rust/fory/src/lib.rs
+++ b/rust/fory/src/lib.rs
@@ -707,7 +707,7 @@
//! the binary buffer.
//!
//! ```rust
-//! use fory::{Fory, ReadContext, WriteContext, Serializer, ForyDefault, Error};
+//! use fory::{Fory, TypeResolver, ReadContext, WriteContext, Serializer, ForyDefault, Error};
//! use std::any::Any;
//!
//! #[derive(Debug, PartialEq, Default)]
@@ -717,22 +717,22 @@
//! }
//!
//! impl Serializer for CustomType {
-//! fn fory_write_data(&self, fory: &Fory, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+//! fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
//! context.writer.write_i32(self.value);
//! context.writer.write_varuint32(self.name.len() as u32);
//! context.writer.write_utf8_string(&self.name);
//! Ok(())
//! }
//!
-//! fn fory_read_data(fory: &Fory, context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
+//! fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
//! let value = context.reader.read_i32()?;
//! let len = context.reader.read_varuint32()? as usize;
//! let name = context.reader.read_utf8_string(len)?;
//! Ok(Self { value, name })
//! }
//!
-//! fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, Error> {
-//! Self::fory_get_type_id(fory)
+//! fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
+//! Self::fory_get_type_id(type_resolver)
//! }
//!
//! fn as_any(&self) -> &dyn Any {
@@ -1048,6 +1048,6 @@
pub use fory_core::{
error::Error, fory::Fory, register_trait_type, row::from_row, row::to_row, types::TypeId,
- ArcWeak, ForyDefault, RcWeak, ReadContext, Serializer, WriteContext,
+ ArcWeak, ForyDefault, RcWeak, ReadContext, Serializer, TypeResolver, WriteContext,
};
pub use fory_derive::{ForyObject, ForyRow};
diff --git a/rust/tests/tests/compatible/test_basic_type.rs b/rust/tests/tests/compatible/test_basic_type.rs
index 0ae571fcf..9c1d008c6 100644
--- a/rust/tests/tests/compatible/test_basic_type.rs
+++ b/rust/tests/tests/compatible/test_basic_type.rs
@@ -482,12 +482,12 @@ fn basic() {
let fory = Fory::default().compatible(true);
// serialize
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
serialize_non_null(&fory, &mut write_context);
// deserialize
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context = ReadContext::new(reader, 5);
+ let mut read_context = ReadContext::new_from_fory(reader, &fory);
deserialize_non_null(&fory, &mut read_context, false, true);
}
@@ -497,12 +497,12 @@ fn basic_nullable() {
let fory = Fory::default().compatible(true);
// serialize
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
serialize_nullable(&fory, &mut write_context);
// deserialize
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context = ReadContext::new(reader, 5);
+ let mut read_context = ReadContext::new_from_fory(reader, &fory);
deserialize_nullable(&fory, &mut read_context, false, true);
}
@@ -512,20 +512,20 @@ fn auto_conv() {
let fory = Fory::default().compatible(true);
// serialize_non-null
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
serialize_non_null(&fory, &mut write_context);
// deserialize_nullable
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context: ReadContext = ReadContext::new(reader, 5);
+ let mut read_context: ReadContext = ReadContext::new_from_fory(reader, &fory);
deserialize_nullable(&fory, &mut read_context, true, true);
// serialize_nullable
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
serialize_nullable(&fory, &mut write_context);
// deserialize_non-null
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context = ReadContext::new(reader, 5);
+ let mut read_context = ReadContext::new_from_fory(reader, &fory);
deserialize_non_null(&fory, &mut read_context, true, true);
}
diff --git a/rust/tests/tests/compatible/test_container.rs b/rust/tests/tests/compatible/test_container.rs
index 0dec8d01a..9fa1969a5 100644
--- a/rust/tests/tests/compatible/test_container.rs
+++ b/rust/tests/tests/compatible/test_container.rs
@@ -223,7 +223,7 @@ fn container_outer_auto_conv() {
let fory = Fory::default().compatible(true);
// serialize_outer_non-null
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
fory.serialize_with_context(&basic_list(), &mut write_context)
.unwrap();
fory.serialize_with_context(&basic_set(), &mut write_context)
@@ -233,7 +233,7 @@ fn container_outer_auto_conv() {
// deserialize_outer_nullable
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context = ReadContext::new(reader, 5);
+ let mut read_context = ReadContext::new_from_fory(reader, &fory);
assert_eq!(
Some(basic_list()),
fory.deserialize_with_context::<Option<Vec<String>>>(&mut read_context)
@@ -252,7 +252,7 @@ fn container_outer_auto_conv() {
assert_eq!(read_context.reader.slice_after_cursor().len(), 0);
// serialize_outer_nullable
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
fory.serialize_with_context(&Some(basic_list()), &mut write_context)
.unwrap();
fory.serialize_with_context(&Some(basic_set()), &mut write_context)
@@ -268,7 +268,7 @@ fn container_outer_auto_conv() {
// deserialize_outer_non-null
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context = ReadContext::new(reader, 5);
+ let mut read_context = ReadContext::new_from_fory(reader, &fory);
assert_eq!(
basic_list(),
fory.deserialize_with_context::<Vec<String>>(&mut read_context)
@@ -311,7 +311,7 @@ fn collection_inner() {
for fory in [fory1, fory2] {
// serialize
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
fory.serialize_with_context(&basic_list(), &mut write_context)
.unwrap();
fory.serialize_with_context(&item_list(), &mut write_context)
@@ -331,7 +331,7 @@ fn collection_inner() {
// deserialize
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context = ReadContext::new(reader, 5);
+ let mut read_context = ReadContext::new_from_fory(reader, &fory);
assert_eq!(
basic_list(),
fory.deserialize_with_context::<Vec<String>>(&mut read_context)
@@ -383,9 +383,9 @@ fn collection_inner_auto_conv() {
let mut fory2 = Fory::default().compatible(true);
fory2.register_by_name::<Item>("item").unwrap();
for fory in [fory1, fory2] {
- // serialize_non-null
+ // serialize_non_null
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
fory.serialize_with_context(&basic_list(), &mut write_context)
.unwrap();
fory.serialize_with_context(&item_list(), &mut write_context)
@@ -397,7 +397,7 @@ fn collection_inner_auto_conv() {
// deserialize_nullable
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context = ReadContext::new(reader, 5);
+ let mut read_context = ReadContext::new_from_fory(reader, &fory);
assert_eq!(
nullable_basic_list(true),
fory.deserialize_with_context::<Vec<Option<String>>>(&mut read_context)
@@ -421,7 +421,7 @@ fn collection_inner_auto_conv() {
assert_eq!(read_context.reader.slice_after_cursor().len(), 0);
// serialize_nullable
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
fory.serialize_with_context(&nullable_basic_list(false), &mut write_context)
.unwrap();
fory.serialize_with_context(&nullable_item_list(false), &mut write_context)
@@ -433,7 +433,7 @@ fn collection_inner_auto_conv() {
// deserialize_non-null
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context = ReadContext::new(reader, 5);
+ let mut read_context = ReadContext::new_from_fory(reader, &fory);
assert_eq!(
basic_list(),
fory.deserialize_with_context::<Vec<String>>(&mut read_context)
@@ -467,7 +467,7 @@ fn map_inner() {
for fory in [fory1, fory2] {
// serialize
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
fory.serialize_with_context(&basic_map(), &mut write_context)
.unwrap();
fory.serialize_with_context(&item_map(), &mut write_context)
@@ -479,7 +479,7 @@ fn map_inner() {
// deserialize
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context = ReadContext::new(reader, 5);
+ let mut read_context = ReadContext::new_from_fory(reader, &fory);
assert_eq!(
basic_map(),
fory.deserialize_with_context::<HashMap<String, String>>(&mut read_context)
@@ -513,9 +513,9 @@ fn map_inner_auto_conv() {
let mut fory2 = Fory::default().compatible(true);
fory2.register_by_name::<Item>("item").unwrap();
for fory in [fory1, fory2] {
- // serialize_non-null
+ // serialize_non_null
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
fory.serialize_with_context(&basic_map(), &mut write_context)
.unwrap();
fory.serialize_with_context(&item_map(), &mut write_context)
@@ -523,7 +523,7 @@ fn map_inner_auto_conv() {
// deserialize_nullable
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context = ReadContext::new(reader, 5);
+ let mut read_context = ReadContext::new_from_fory(reader, &fory);
assert_eq!(
nullable_basic_map(true),
fory.deserialize_with_context::<HashMap<Option<String>, Option<String>>>(
@@ -539,7 +539,7 @@ fn map_inner_auto_conv() {
assert_eq!(read_context.reader.slice_after_cursor().len(), 0);
// serialize_nullable
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
fory.serialize_with_context(&nullable_basic_map(false), &mut write_context)
.unwrap();
fory.serialize_with_context(&nullable_item_map(false), &mut write_context)
@@ -547,7 +547,7 @@ fn map_inner_auto_conv() {
// deserialize_non-null
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context = ReadContext::new(reader, 5);
+ let mut read_context = ReadContext::new_from_fory(reader, &fory);
assert_eq!(
basic_map(),
fory.deserialize_with_context::<HashMap<String, String>>(&mut read_context)
@@ -570,7 +570,7 @@ fn complex() {
fory2.register_by_name::<Item>("item").unwrap();
for fory in [fory1, fory2] {
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
fory.serialize_with_context(&nested_collection(), &mut write_context)
.unwrap();
fory.serialize_with_context(&complex_container1(), &mut write_context)
@@ -579,7 +579,7 @@ fn complex() {
.unwrap();
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context = ReadContext::new(reader, 5);
+ let mut read_context = ReadContext::new_from_fory(reader, &fory);
assert_eq!(
nested_collection(),
fory.deserialize_with_context::<Vec<HashSet<Item>>>(&mut read_context)
diff --git a/rust/tests/tests/compatible/test_struct_enum.rs b/rust/tests/tests/compatible/test_struct_enum.rs
index 39bd8241f..ca25a0aba 100644
--- a/rust/tests/tests/compatible/test_struct_enum.rs
+++ b/rust/tests/tests/compatible/test_struct_enum.rs
@@ -21,6 +21,7 @@ use fory_core::error::Error;
use fory_core::fory::{read_data, write_data, Fory};
use fory_core::resolver::context::{ReadContext, WriteContext};
use fory_core::serializer::{ForyDefault, Serializer};
+use fory_core::TypeResolver;
use fory_derive::ForyObject;
use std::collections::{HashMap, HashSet};
@@ -91,7 +92,7 @@ fn basic() {
fory2.register_by_name::<Person>("person").unwrap();
for fory in [fory1, fory2] {
let writer = Writer::default();
- let mut write_context = WriteContext::new(writer);
+ let mut write_context = WriteContext::new_from_fory(writer, &fory);
let person = Person::default();
fory.serialize_with_context(&person, &mut write_context)
.unwrap();
@@ -99,7 +100,7 @@ fn basic() {
.unwrap();
let bytes = write_context.writer.dump();
let reader = Reader::new(bytes.as_slice());
- let mut read_context = ReadContext::new(reader, 5);
+ let mut read_context = ReadContext::new_from_fory(reader, &fory);
assert_eq!(
person,
fory.deserialize_with_context::<Person>(&mut read_context)
@@ -400,24 +401,22 @@ fn ext() {
impl Serializer for ExtItem {
fn fory_write_data(
&self,
- fory: &Fory,
context: &mut WriteContext,
is_field: bool,
) -> Result<(), fory_core::error::Error> {
- write_data(&self.id, fory, context, is_field)
+ write_data(&self.id, context, is_field)
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
Ok(Self {
- id: read_data(fory, context, is_field)?,
+ id: read_data(context, is_field)?,
})
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, fory_core::error::Error> {
- Self::fory_get_type_id(fory)
+ fn fory_type_id_dyn(
+ &self,
+ type_resolver: &TypeResolver,
+ ) -> Result<u32, fory_core::error::Error> {
+ Self::fory_get_type_id(type_resolver)
}
fn as_any(&self) -> &dyn std::any::Any {
@@ -457,24 +456,22 @@ fn skip_ext() {
impl Serializer for ExtItem {
fn fory_write_data(
&self,
- fory: &Fory,
context: &mut WriteContext,
is_field: bool,
) -> Result<(), fory_core::error::Error> {
- write_data(&self.id, fory, context, is_field)
+ write_data(&self.id, context, is_field)
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
Ok(Self {
- id: read_data(fory, context, is_field)?,
+ id: read_data(context, is_field)?,
})
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, fory_core::error::Error> {
- Self::fory_get_type_id(fory)
+ fn fory_type_id_dyn(
+ &self,
+ type_resolver: &TypeResolver,
+ ) -> Result<u32, fory_core::error::Error> {
+ Self::fory_get_type_id(type_resolver)
}
fn as_any(&self) -> &dyn std::any::Any {
@@ -529,23 +526,21 @@ fn compatible_ext() {
impl Serializer for ExtItem {
fn fory_write_data(
&self,
- fory: &Fory,
context: &mut WriteContext,
is_field: bool,
) -> Result<(), fory_core::error::Error> {
- write_data(&self.id, fory, context, is_field)
+ write_data(&self.id, context, is_field)
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
Ok(Self {
- id: read_data(fory, context, is_field)?,
+ id: read_data(context, is_field)?,
})
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, fory_core::error::Error> {
- Self::fory_get_type_id(fory)
+ fn fory_type_id_dyn(
+ &self,
+ type_resolver: &TypeResolver,
+ ) -> Result<u32, fory_core::error::Error> {
+ Self::fory_get_type_id(type_resolver)
}
fn as_any(&self) -> &dyn std::any::Any {
diff --git a/rust/tests/tests/test_cross_language.rs b/rust/tests/tests/test_cross_language.rs
index 274ea803d..f6bfdc408 100644
--- a/rust/tests/tests/test_cross_language.rs
+++ b/rust/tests/tests/test_cross_language.rs
@@ -22,6 +22,7 @@ use fory_core::fory::{read_data, write_data, Fory};
use fory_core::meta::murmurhash3_x64_128;
use fory_core::resolver::context::{ReadContext, WriteContext};
use fory_core::serializer::{ForyDefault, Serializer};
+use fory_core::TypeResolver;
use fory_derive::ForyObject;
use std::collections::{HashMap, HashSet};
use std::{fs, vec};
@@ -228,13 +229,13 @@ fn test_string_serializer() {
.compatible(true)
.xlang(true)
.compress_string(false);
- let mut context = ReadContext::new(reader, 5);
+ let mut context = ReadContext::new_from_fory(reader, &fory);
let reader_compress = Reader::new(bytes.as_slice());
let fory_compress = Fory::default()
.compatible(true)
.xlang(true)
.compress_string(true);
- let mut context_compress = ReadContext::new(reader_compress, 5);
+ let mut context_compress = ReadContext::new_from_fory(reader_compress, &fory_compress);
let test_strings: Vec<String> = vec![
// Latin1
"ab".to_string(),
@@ -249,20 +250,17 @@ fn test_string_serializer() {
];
for s in &test_strings {
// make is_field=true to skip read/write type_id
+ assert_eq!(*s, String::fory_read_data(&mut context, true).unwrap());
assert_eq!(
*s,
- String::fory_read_data(&fory, &mut context, true).unwrap()
- );
- assert_eq!(
- *s,
- String::fory_read_data(&fory_compress, &mut context_compress, true).unwrap()
+ String::fory_read_data(&mut context_compress, true).unwrap()
);
}
let writer = Writer::default();
let fory = Fory::default().compatible(true).xlang(true);
- let mut context = WriteContext::new(writer);
+ let mut context = WriteContext::new_from_fory(writer, &fory);
for s in &test_strings {
- s.fory_write_data(&fory, &mut context, true).unwrap();
+ s.fory_write_data(&mut context, true).unwrap();
}
fs::write(&data_file_path, context.writer.dump()).unwrap();
}
@@ -293,7 +291,7 @@ fn test_cross_language_serializer() {
let reader = Reader::new(bytes.as_slice());
let mut fory = Fory::default().compatible(true).xlang(true);
fory.register::<Color>(101).unwrap();
- let mut context = ReadContext::new(reader, 5);
+ let mut context = ReadContext::new_from_fory(reader, &fory);
assert_de!(fory, context, bool, true);
assert_de!(fory, context, bool, false);
assert_de!(fory, context, i32, -1);
@@ -322,7 +320,7 @@ fn test_cross_language_serializer() {
assert_de!(fory, context, Color, color);
let writer = Writer::default();
- let mut context = WriteContext::new(writer);
+ let mut context = WriteContext::new_from_fory(writer, &fory);
fory.serialize_with_context(&true, &mut context).unwrap();
fory.serialize_with_context(&false, &mut context).unwrap();
fory.serialize_with_context(&-1, &mut context).unwrap();
@@ -439,7 +437,7 @@ fn test_list() {
let mut fory = Fory::default().compatible(true);
fory.register::<Item>(102).unwrap();
let reader = Reader::new(bytes.as_slice());
- let mut context = ReadContext::new(reader, 5);
+ let mut context = ReadContext::new_from_fory(reader, &fory);
let str_list = vec![Some("a".to_string()), Some("b".to_string())];
let str_list2 = vec![None, Some("b".to_string())];
@@ -466,7 +464,7 @@ fn test_list() {
assert_eq!(remote_item_list2, item_list2);
let writer = Writer::default();
- let mut context = WriteContext::new(writer);
+ let mut context = WriteContext::new_from_fory(writer, &fory);
fory.serialize_with_context(&remote_str_list, &mut context)
.unwrap();
fory.serialize_with_context(&remote_str_list2, &mut context)
@@ -488,7 +486,7 @@ fn test_map() {
let mut fory = Fory::default().compatible(true);
fory.register::<Item>(102).unwrap();
let reader = Reader::new(bytes.as_slice());
- let mut context = ReadContext::new(reader, 5);
+ let mut context = ReadContext::new_from_fory(reader, &fory);
let str_map = HashMap::from([
(Some("k1".to_string()), Some("v1".to_string())),
@@ -557,8 +555,7 @@ fn test_integer() {
let mut fory = Fory::default().compatible(true);
fory.register::<Item2>(101).unwrap();
let reader = Reader::new(bytes.as_slice());
-
- let mut context = ReadContext::new(reader, 5);
+ let mut context = ReadContext::new_from_fory(reader, &fory);
let f1 = 1;
let f2 = Some(2);
let f3 = Some(3);
@@ -590,7 +587,7 @@ fn test_integer() {
assert_eq!(remote_f6, f6);
let writer = Writer::default();
- let mut context = WriteContext::new(writer);
+ let mut context = WriteContext::new_from_fory(writer, &fory);
fory.serialize_with_context(&remote_item2, &mut context)
.unwrap();
fory.serialize_with_context(&remote_f1, &mut context)
@@ -619,27 +616,25 @@ struct MyExt {
impl Serializer for MyExt {
fn fory_write_data(
&self,
- fory: &Fory,
context: &mut WriteContext,
_is_field: bool,
) -> Result<(), fory_core::error::Error> {
// set is_field=false to write type_id like in java
- write_data(&self.id, fory, context, false)
+ write_data(&self.id, context, false)
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- _is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, _is_field: bool) -> Result<Self, Error> {
Ok(Self {
// set is_field=false to write type_id like in java
- id: read_data(fory, context, false)?,
+ id: read_data(context, false)?,
})
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, fory_core::error::Error> {
- Self::fory_get_type_id(fory)
+ fn fory_type_id_dyn(
+ &self,
+ type_resolver: &TypeResolver,
+ ) -> Result<u32, fory_core::error::Error> {
+ Self::fory_get_type_id(type_resolver)
}
fn as_any(&self) -> &dyn std::any::Any {
@@ -740,7 +735,7 @@ fn test_consistent_named() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
let reader = Reader::new(bytes.as_slice());
- let mut context = ReadContext::new(reader, 5);
+ let mut context = ReadContext::new_from_fory(reader, &fory);
assert_eq!(
fory.deserialize_with_context::<Color>(&mut context)
@@ -775,7 +770,7 @@ fn test_consistent_named() {
);
let writer = Writer::default();
- let mut context = WriteContext::new(writer);
+ let mut context = WriteContext::new_from_fory(writer, &fory);
fory.serialize_with_context(&color, &mut context).unwrap();
fory.serialize_with_context(&color, &mut context).unwrap();
fory.serialize_with_context(&color, &mut context).unwrap();
diff --git a/rust/tests/tests/test_ext.rs b/rust/tests/tests/test_ext.rs
index 7fa202439..3e023622a 100644
--- a/rust/tests/tests/test_ext.rs
+++ b/rust/tests/tests/test_ext.rs
@@ -19,6 +19,7 @@ use fory_core::error::Error;
use fory_core::fory::Fory;
use fory_core::resolver::context::{ReadContext, WriteContext};
use fory_core::serializer::{ForyDefault, Serializer};
+use fory_core::TypeResolver;
use fory_derive::ForyObject;
#[test]
@@ -59,28 +60,22 @@ fn test_use() {
}
impl Serializer for Item {
- fn fory_write_data(
- &self,
- fory: &Fory,
- context: &mut WriteContext,
- is_field: bool,
- ) -> Result<(), Error> {
- write_data(&self.f1, fory, context, is_field)
+ fn fory_write_data(&self, context: &mut WriteContext, is_field: bool) -> Result<(), Error> {
+ write_data(&self.f1, context, is_field)
}
- fn fory_read_data(
- fory: &Fory,
- context: &mut ReadContext,
- is_field: bool,
- ) -> Result<Self, Error> {
+ fn fory_read_data(context: &mut ReadContext, is_field: bool) -> Result<Self, Error> {
Ok(Self {
- f1: read_data(fory, context, is_field)?,
+ f1: read_data(context, is_field)?,
f2: 0,
})
}
- fn fory_type_id_dyn(&self, fory: &Fory) -> Result<u32, fory_core::error::Error> {
- Self::fory_get_type_id(fory)
+ fn fory_type_id_dyn(
+ &self,
+ type_resolver: &TypeResolver,
+ ) -> Result<u32, fory_core::error::Error> {
+ Self::fory_get_type_id(type_resolver)
}
fn as_any(&self) -> &dyn std::any::Any {
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@fory.apache.org
For additional commands, e-mail: commits-help@fory.apache.org