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 901680898 feat(rust): use rc instead of arc for type meta for faster
performance (#2782)
901680898 is described below
commit 90168089809180b7457d63e459e3bc7ff2567114
Author: Shawn Yang <[email protected]>
AuthorDate: Mon Oct 20 14:06:38 2025 +0800
feat(rust): use rc instead of arc for type meta for faster performance
(#2782)
## Why?
<!-- Describe the purpose of this PR. -->
## What does this PR do?
use rc instead of arc for type meta for faster performance
## Related issues
<!--
Is there any related issue? If this PR closes them you say say
fix/closes:
- #xxxx0
- #xxxx1
- Fixes #xxxx2
-->
## 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/fory-core/src/resolver/context.rs | 33 +++++++++---
rust/fory-core/src/resolver/meta_resolver.rs | 12 ++---
rust/fory-core/src/resolver/type_resolver.rs | 74 +++++++++++++++------------
rust/fory-core/src/serializer/any.rs | 12 ++---
rust/fory-core/src/serializer/arc.rs | 7 +--
rust/fory-core/src/serializer/core.rs | 6 +--
rust/fory-core/src/serializer/map.rs | 10 ++--
rust/fory-core/src/serializer/mutex.rs | 4 +-
rust/fory-core/src/serializer/option.rs | 3 +-
rust/fory-core/src/serializer/rc.rs | 7 ++-
rust/fory-core/src/serializer/refcell.rs | 4 +-
rust/fory-core/src/serializer/trait_object.rs | 11 ++--
rust/fory-core/src/serializer/weak.rs | 8 +--
rust/fory-derive/src/object/read.rs | 2 +-
rust/fory-derive/src/object/serializer.rs | 4 +-
15 files changed, 111 insertions(+), 86 deletions(-)
diff --git a/rust/fory-core/src/resolver/context.rs
b/rust/fory-core/src/resolver/context.rs
index 714f7dda8..64dca6bd0 100644
--- a/rust/fory-core/src/resolver/context.rs
+++ b/rust/fory-core/src/resolver/context.rs
@@ -27,8 +27,11 @@ use crate::resolver::metastring_resolver::{
use crate::resolver::ref_resolver::{RefReader, RefWriter};
use crate::resolver::type_resolver::{TypeInfo, TypeResolver};
use crate::types;
-use std::sync::{Arc, Mutex};
+use std::rc::Rc;
+use std::sync::Mutex;
+/// Serialization state container used on a single thread at a time.
+/// Sharing the same instance across threads simultaneously causes undefined
behavior.
pub struct WriteContext {
// Replicated environment fields (direct access, no Arc indirection for
flags)
type_resolver: TypeResolver,
@@ -87,7 +90,7 @@ impl WriteContext {
}
#[inline(always)]
- pub fn get_type_info(&self, type_id: &std::any::TypeId) ->
Result<Arc<TypeInfo>, Error> {
+ pub fn get_type_info(&self, type_id: &std::any::TypeId) ->
Result<Rc<TypeInfo>, Error> {
self.type_resolver.get_type_info(type_id)
}
@@ -138,7 +141,7 @@ impl WriteContext {
&mut self,
fory_type_id: u32,
concrete_type_id: std::any::TypeId,
- ) -> Result<Arc<TypeInfo>, Error> {
+ ) -> Result<Rc<TypeInfo>, Error> {
if types::is_internal_type(fory_type_id) {
self.writer.write_varuint32(fory_type_id);
return self
@@ -192,6 +195,15 @@ impl WriteContext {
}
}
+// Safety: WriteContext is only shared across threads via higher-level pooling
code that
+// ensures single-threaded access while the context is in use. Users must
never hold the same
+// instance on multiple threads simultaneously; that would violate the
invariants and result in
+// undefined behavior. Under that assumption, marking it Send/Sync is sound.
+unsafe impl Send for WriteContext {}
+unsafe impl Sync for WriteContext {}
+
+/// Deserialization state container used on a single thread at a time.
+/// Sharing the same instance across threads simultaneously causes undefined
behavior.
pub struct ReadContext {
// Replicated environment fields (direct access, no Arc indirection for
flags)
type_resolver: TypeResolver,
@@ -208,6 +220,13 @@ pub struct ReadContext {
current_depth: u32,
}
+// Safety: ReadContext follows the same invariants as WriteContext—external
orchestrators ensure
+// single-threaded use. Concurrent access to the same instance across threads
is forbidden and
+// would result in undefined behavior. With exclusive use guaranteed, the
Send/Sync markers are safe
+// even though Rc is used internally.
+unsafe impl Send for ReadContext {}
+unsafe impl Sync for ReadContext {}
+
impl ReadContext {
pub fn new(
reader: Reader,
@@ -284,7 +303,7 @@ impl ReadContext {
}
#[inline(always)]
- pub fn get_meta(&self, type_index: usize) -> Result<&Arc<TypeMeta>, Error>
{
+ pub fn get_meta(&self, type_index: usize) -> Result<&Rc<TypeMeta>, Error> {
self.meta_resolver.get(type_index).ok_or_else(|| {
Error::type_error(format!("Meta not found for type index: {}",
type_index))
})
@@ -298,7 +317,7 @@ impl ReadContext {
)
}
- pub fn read_any_typeinfo(&mut self) -> Result<Arc<TypeInfo>, Error> {
+ pub fn read_any_typeinfo(&mut self) -> Result<Rc<TypeInfo>, Error> {
let fory_type_id = self.reader.read_varuint32()?;
// should be compiled to jump table generation
match fory_type_id & 0xff {
@@ -311,7 +330,7 @@ impl ReadContext {
.ok_or_else(|| Error::type_error("ID harness not found"))?;
// Create a new TypeInfo with remote metadata but local harness
// TODO: make self.get_meta return type info
- Ok(Arc::new(local_type_info.with_remote_meta(remote_meta)))
+ Ok(Rc::new(local_type_info.with_remote_meta(remote_meta)))
}
types::NAMED_ENUM | types::NAMED_EXT | types::NAMED_STRUCT => {
if self.is_share_meta() {
@@ -336,7 +355,7 @@ impl ReadContext {
}
#[inline(always)]
- pub fn get_type_info(&self, type_id: &std::any::TypeId) ->
Result<Arc<TypeInfo>, Error> {
+ pub fn get_type_info(&self, type_id: &std::any::TypeId) ->
Result<Rc<TypeInfo>, Error> {
self.type_resolver.get_type_info(type_id)
}
diff --git a/rust/fory-core/src/resolver/meta_resolver.rs
b/rust/fory-core/src/resolver/meta_resolver.rs
index 4cb8b4d90..525caf702 100644
--- a/rust/fory-core/src/resolver/meta_resolver.rs
+++ b/rust/fory-core/src/resolver/meta_resolver.rs
@@ -20,11 +20,11 @@ use crate::error::Error;
use crate::meta::{Encoding, MetaString, TypeMeta, NAMESPACE_DECODER};
use crate::TypeResolver;
use std::collections::HashMap;
-use std::sync::Arc;
+use std::rc::Rc;
#[derive(Default)]
pub struct MetaWriterResolver {
- type_defs: Vec<Arc<Vec<u8>>>,
+ type_defs: Vec<Rc<Vec<u8>>>,
type_id_index_map: HashMap<std::any::TypeId, usize>,
}
@@ -68,12 +68,12 @@ impl MetaWriterResolver {
#[derive(Default)]
pub struct MetaReaderResolver {
- pub reading_type_defs: Vec<Arc<TypeMeta>>,
- parsed_type_defs: HashMap<i64, Arc<TypeMeta>>,
+ pub reading_type_defs: Vec<Rc<TypeMeta>>,
+ parsed_type_defs: HashMap<i64, Rc<TypeMeta>>,
}
impl MetaReaderResolver {
- pub fn get(&self, index: usize) -> Option<&Arc<TypeMeta>> {
+ pub fn get(&self, index: usize) -> Option<&Rc<TypeMeta>> {
self.reading_type_defs.get(index)
}
@@ -90,7 +90,7 @@ impl MetaReaderResolver {
self.reading_type_defs.push(type_meta.clone());
TypeMeta::skip_bytes(reader, meta_header)?;
} else {
- let type_meta = Arc::new(TypeMeta::from_bytes_with_header(
+ let type_meta = Rc::new(TypeMeta::from_bytes_with_header(
reader,
type_resolver,
meta_header,
diff --git a/rust/fory-core/src/resolver/type_resolver.rs
b/rust/fory-core/src/resolver/type_resolver.rs
index 0fdd8fda5..46c676bcd 100644
--- a/rust/fory-core/src/resolver/type_resolver.rs
+++ b/rust/fory-core/src/resolver/type_resolver.rs
@@ -25,7 +25,7 @@ use crate::serializer::{ForyDefault, Serializer,
StructSerializer};
use crate::util::get_ext_actual_type_id;
use crate::{Reader, TypeId};
use std::collections::{HashSet, LinkedList};
-use std::sync::Arc;
+use std::rc::Rc;
use std::{any::Any, collections::HashMap};
type WriteFn = fn(
@@ -92,8 +92,8 @@ impl Harness {
#[derive(Clone, Debug)]
pub struct TypeInfo {
- type_def: Arc<Vec<u8>>,
- type_meta: Arc<TypeMeta>,
+ type_def: Rc<Vec<u8>>,
+ type_meta: Rc<TypeMeta>,
type_id: u32,
namespace: MetaString,
type_name: MetaString,
@@ -135,7 +135,7 @@ impl TypeInfo {
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(
+ let type_meta = Rc::new(TypeMeta::from_fields(
type_id,
namespace_metastring.clone(),
type_name_metastring.clone(),
@@ -144,7 +144,7 @@ impl TypeInfo {
));
let type_def_bytes = type_meta.to_bytes()?;
Ok(TypeInfo {
- type_def: Arc::from(type_def_bytes),
+ type_def: Rc::from(type_def_bytes),
type_meta,
type_id,
namespace: namespace_metastring,
@@ -176,8 +176,8 @@ impl TypeInfo {
let type_def = meta.to_bytes()?;
let meta = TypeMeta::from_bytes(&mut Reader::new(&type_def),
type_resolver)?;
Ok(TypeInfo {
- type_def: Arc::from(type_def),
- type_meta: Arc::new(meta),
+ type_def: Rc::from(type_def),
+ type_meta: Rc::new(meta),
type_id,
namespace: namespace_metastring,
type_name: type_name_metastring,
@@ -198,11 +198,11 @@ impl TypeInfo {
&self.type_name
}
- pub fn get_type_def(&self) -> Arc<Vec<u8>> {
+ pub fn get_type_def(&self) -> Rc<Vec<u8>> {
self.type_def.clone()
}
- pub fn get_type_meta(&self) -> Arc<TypeMeta> {
+ pub fn get_type_meta(&self) -> Rc<TypeMeta> {
self.type_meta.clone()
}
@@ -217,7 +217,7 @@ impl TypeInfo {
/// Create a new TypeInfo with the same properties but different type_meta.
/// This is used during deserialization to create a TypeInfo with remote
metadata
/// while keeping the local harness for deserialization functions.
- pub fn with_remote_meta(&self, remote_meta: Arc<TypeMeta>) -> TypeInfo {
+ pub fn with_remote_meta(&self, remote_meta: Rc<TypeMeta>) -> TypeInfo {
TypeInfo {
type_def: self.type_def.clone(),
type_meta: remote_meta,
@@ -233,15 +233,21 @@ impl TypeInfo {
/// TypeResolver is a resolver for fast type/serializer dispatch.
#[derive(Clone)]
pub struct TypeResolver {
- type_info_map_by_id: HashMap<u32, Arc<TypeInfo>>,
- type_info_map: HashMap<std::any::TypeId, Arc<TypeInfo>>,
- type_info_map_by_name: HashMap<(String, String), Arc<TypeInfo>>,
- type_info_map_by_ms_name: HashMap<(MetaString, MetaString), Arc<TypeInfo>>,
+ type_info_map_by_id: HashMap<u32, Rc<TypeInfo>>,
+ type_info_map: HashMap<std::any::TypeId, Rc<TypeInfo>>,
+ type_info_map_by_name: HashMap<(String, String), Rc<TypeInfo>>,
+ type_info_map_by_ms_name: HashMap<(MetaString, MetaString), Rc<TypeInfo>>,
// Fast lookup by numeric ID for common types
type_id_index: Vec<u32>,
compatible: bool,
}
+// Safety: TypeResolver instances are only shared through higher-level
synchronization that
+// guarantees thread confinement for mutations, so marking them Send/Sync
preserves existing
+// invariants despite internal Rc usage.
+unsafe impl Send for TypeResolver {}
+unsafe impl Sync for TypeResolver {}
+
const NO_TYPE_ID: u32 = 1000000000;
impl Default for TypeResolver {
@@ -260,7 +266,7 @@ impl Default for TypeResolver {
}
impl TypeResolver {
- pub fn get_type_info(&self, type_id: &std::any::TypeId) ->
Result<Arc<TypeInfo>, Error> {
+ pub fn get_type_info(&self, type_id: &std::any::TypeId) ->
Result<Rc<TypeInfo>, Error> {
self.type_info_map.get(type_id)
.ok_or_else(|| {
Error::type_error(format!(
@@ -271,11 +277,11 @@ impl TypeResolver {
.cloned()
}
- pub fn get_type_info_by_id(&self, id: u32) -> Option<Arc<TypeInfo>> {
+ pub fn get_type_info_by_id(&self, id: u32) -> Option<Rc<TypeInfo>> {
self.type_info_map_by_id.get(&id).cloned()
}
- pub fn get_type_info_by_name(&self, namespace: &str, type_name: &str) ->
Option<Arc<TypeInfo>> {
+ pub fn get_type_info_by_name(&self, namespace: &str, type_name: &str) ->
Option<Rc<TypeInfo>> {
self.type_info_map_by_name
.get(&(namespace.to_owned(), type_name.to_owned()))
.cloned()
@@ -285,7 +291,7 @@ impl TypeResolver {
&self,
namespace: &MetaString,
type_name: &MetaString,
- ) -> Option<Arc<TypeInfo>> {
+ ) -> Option<Rc<TypeInfo>> {
self.type_info_map_by_ms_name
.get(&(namespace.clone(), type_name.clone()))
.cloned()
@@ -306,27 +312,27 @@ impl TypeResolver {
)))
}
- pub fn get_harness(&self, id: u32) -> Option<Arc<Harness>> {
+ pub fn get_harness(&self, id: u32) -> Option<Rc<Harness>> {
self.type_info_map_by_id
.get(&id)
- .map(|info| Arc::new(info.get_harness().clone()))
+ .map(|info| Rc::new(info.get_harness().clone()))
}
pub fn get_name_harness(
&self,
namespace: &MetaString,
type_name: &MetaString,
- ) -> Option<Arc<Harness>> {
+ ) -> Option<Rc<Harness>> {
let key = (namespace.clone(), type_name.clone());
self.type_info_map_by_ms_name
.get(&key)
- .map(|info| Arc::new(info.get_harness().clone()))
+ .map(|info| Rc::new(info.get_harness().clone()))
}
- pub fn get_ext_harness(&self, id: u32) -> Result<Arc<Harness>, Error> {
+ pub fn get_ext_harness(&self, id: u32) -> Result<Rc<Harness>, Error> {
self.type_info_map_by_id
.get(&id)
- .map(|info| Arc::new(info.get_harness().clone()))
+ .map(|info| Rc::new(info.get_harness().clone()))
.ok_or_else(|| Error::type_error("ext type must be registered in
both peers"))
}
@@ -334,11 +340,11 @@ impl TypeResolver {
&self,
namespace: &MetaString,
type_name: &MetaString,
- ) -> Result<Arc<Harness>, Error> {
+ ) -> Result<Rc<Harness>, Error> {
let key = (namespace.clone(), type_name.clone());
self.type_info_map_by_ms_name
.get(&key)
- .map(|info| Arc::new(info.get_harness().clone()))
+ .map(|info| Rc::new(info.get_harness().clone()))
.ok_or_else(|| Error::type_error("named_ext type must be
registered in both peers"))
}
@@ -495,11 +501,11 @@ impl TypeResolver {
// Store in main map
self.type_info_map
- .insert(rs_type_id, Arc::new(type_info.clone()));
+ .insert(rs_type_id, Rc::new(type_info.clone()));
// Store by ID
self.type_info_map_by_id
- .insert(type_info.type_id, Arc::new(type_info.clone()));
+ .insert(type_info.type_id, Rc::new(type_info.clone()));
// Update type_id_index for fast lookup
let index = T::fory_type_index() as usize;
@@ -525,10 +531,10 @@ impl TypeResolver {
)));
}
self.type_info_map_by_ms_name
- .insert(ms_key, Arc::new(type_info.clone()));
+ .insert(ms_key, Rc::new(type_info.clone()));
let string_key = (namespace.original.clone(),
type_name.original.clone());
self.type_info_map_by_name
- .insert(string_key, Arc::new(type_info));
+ .insert(string_key, Rc::new(type_info));
}
Ok(())
}
@@ -671,11 +677,11 @@ impl TypeResolver {
// Store in main map
self.type_info_map
- .insert(rs_type_id, Arc::new(type_info.clone()));
+ .insert(rs_type_id, Rc::new(type_info.clone()));
// Store by ID
self.type_info_map_by_id
- .insert(type_info.type_id, Arc::new(type_info.clone()));
+ .insert(type_info.type_id, Rc::new(type_info.clone()));
// Store by name if registered by name
if type_info.register_by_name {
@@ -689,10 +695,10 @@ impl TypeResolver {
)));
}
self.type_info_map_by_ms_name
- .insert(ms_key, Arc::new(type_info.clone()));
+ .insert(ms_key, Rc::new(type_info.clone()));
let string_key = (namespace.original.clone(),
type_name.original.clone());
self.type_info_map_by_name
- .insert(string_key, Arc::new(type_info));
+ .insert(string_key, Rc::new(type_info));
}
Ok(())
}
diff --git a/rust/fory-core/src/serializer/any.rs
b/rust/fory-core/src/serializer/any.rs
index 615d86f4e..80e3f2355 100644
--- a/rust/fory-core/src/serializer/any.rs
+++ b/rust/fory-core/src/serializer/any.rs
@@ -90,7 +90,7 @@ impl Serializer for Box<dyn Any> {
fn fory_read_with_type_info(
context: &mut ReadContext,
read_ref_info: bool,
- type_info: Arc<TypeInfo>,
+ type_info: Rc<TypeInfo>,
) -> Result<Self, Error>
where
Self: Sized + ForyDefault,
@@ -172,7 +172,7 @@ pub fn read_box_any(
context: &mut ReadContext,
read_ref_info: bool,
read_type_info: bool,
- type_info: Option<Arc<TypeInfo>>,
+ type_info: Option<Rc<TypeInfo>>,
) -> Result<Box<dyn Any>, Error> {
context.inc_depth()?;
let ref_flag = if read_ref_info {
@@ -258,7 +258,7 @@ impl Serializer for Rc<dyn Any> {
fn fory_read_with_type_info(
context: &mut ReadContext,
read_ref_info: bool,
- type_info: Arc<TypeInfo>,
+ type_info: Rc<TypeInfo>,
) -> Result<Self, Error>
where
Self: Sized + ForyDefault,
@@ -321,7 +321,7 @@ pub fn read_rc_any(
context: &mut ReadContext,
read_ref_info: bool,
read_type_info: bool,
- type_info: Option<Arc<TypeInfo>>,
+ type_info: Option<Rc<TypeInfo>>,
) -> Result<Rc<dyn Any>, Error> {
let ref_flag = if read_ref_info {
context.ref_reader.read_ref_flag(&mut context.reader)?
@@ -427,7 +427,7 @@ impl Serializer for Arc<dyn Any> {
fn fory_read_with_type_info(
context: &mut ReadContext,
read_ref_info: bool,
- type_info: Arc<TypeInfo>,
+ type_info: Rc<TypeInfo>,
) -> Result<Self, Error>
where
Self: Sized + ForyDefault,
@@ -490,7 +490,7 @@ pub fn read_arc_any(
context: &mut ReadContext,
read_ref_info: bool,
read_type_info: bool,
- type_info: Option<Arc<TypeInfo>>,
+ type_info: Option<Rc<TypeInfo>>,
) -> Result<Arc<dyn Any>, Error> {
let ref_flag = if read_ref_info {
context.ref_reader.read_ref_flag(&mut context.reader)?
diff --git a/rust/fory-core/src/serializer/arc.rs
b/rust/fory-core/src/serializer/arc.rs
index 33eddff2c..ea221dcfa 100644
--- a/rust/fory-core/src/serializer/arc.rs
+++ b/rust/fory-core/src/serializer/arc.rs
@@ -21,6 +21,7 @@ use crate::resolver::type_resolver::{TypeInfo, TypeResolver};
use crate::serializer::{ForyDefault, Serializer};
use crate::types::RefFlag;
use crate::types::TypeId;
+use std::rc::Rc;
use std::sync::Arc;
impl<T: Serializer + ForyDefault + Send + Sync + 'static> Serializer for
Arc<T> {
@@ -83,7 +84,7 @@ impl<T: Serializer + ForyDefault + Send + Sync + 'static>
Serializer for Arc<T>
fn fory_read_with_type_info(
context: &mut ReadContext,
read_ref_info: bool,
- typeinfo: Arc<TypeInfo>,
+ typeinfo: Rc<TypeInfo>,
) -> Result<Self, Error>
where
Self: Sized + ForyDefault,
@@ -126,7 +127,7 @@ fn read_arc<T: Serializer + ForyDefault + 'static>(
context: &mut ReadContext,
read_ref_info: bool,
read_type_info: bool,
- typeinfo: Option<Arc<TypeInfo>>,
+ typeinfo: Option<Rc<TypeInfo>>,
) -> Result<Arc<T>, Error> {
let ref_flag = if read_ref_info {
context.ref_reader.read_ref_flag(&mut context.reader)?
@@ -159,7 +160,7 @@ fn read_arc<T: Serializer + ForyDefault + 'static>(
fn read_arc_inner<T: Serializer + ForyDefault + 'static>(
context: &mut ReadContext,
read_type_info: bool,
- typeinfo: Option<Arc<TypeInfo>>,
+ typeinfo: Option<Rc<TypeInfo>>,
) -> Result<T, Error> {
if let Some(typeinfo) = typeinfo {
let inner_read_ref = T::fory_is_shared_ref();
diff --git a/rust/fory-core/src/serializer/core.rs
b/rust/fory-core/src/serializer/core.rs
index f2ac8f7a6..1723b86ba 100644
--- a/rust/fory-core/src/serializer/core.rs
+++ b/rust/fory-core/src/serializer/core.rs
@@ -23,7 +23,7 @@ use crate::serializer::{bool, struct_};
use crate::types::{RefFlag, TypeId};
use crate::TypeResolver;
use std::any::Any;
-use std::sync::Arc;
+use std::rc::Rc;
pub trait ForyDefault: Sized {
fn fory_default() -> Self;
@@ -155,7 +155,7 @@ pub trait Serializer: 'static {
fn fory_read_with_type_info(
context: &mut ReadContext,
read_ref_info: bool,
- type_info: Arc<TypeInfo>,
+ type_info: Rc<TypeInfo>,
) -> Result<Self, Error>
where
Self: Sized + ForyDefault,
@@ -269,7 +269,7 @@ pub trait StructSerializer: Serializer + 'static {
// only used by struct
fn fory_read_compatible(
context: &mut ReadContext,
- type_info: Arc<TypeInfo>,
+ type_info: Rc<TypeInfo>,
) -> Result<Self, Error>
where
Self: Sized;
diff --git a/rust/fory-core/src/serializer/map.rs
b/rust/fory-core/src/serializer/map.rs
index 37a075b8e..876a0980a 100644
--- a/rust/fory-core/src/serializer/map.rs
+++ b/rust/fory-core/src/serializer/map.rs
@@ -23,7 +23,7 @@ use crate::serializer::util::read_basic_type_info;
use crate::serializer::{ForyDefault, Serializer};
use crate::types::{need_to_write_type_for_field, TypeId, SIZE_OF_REF_AND_TYPE};
use std::collections::{BTreeMap, HashMap};
-use std::sync::Arc;
+use std::rc::Rc;
const MAX_CHUNK_SIZE: u8 = 255;
@@ -380,7 +380,7 @@ macro_rules! impl_read_map_dyn_ref {
let track_value_ref = (header & TRACKING_VALUE_REF) != 0;
// Determine value type info (if any)
- let value_type_info: Option<Arc<TypeInfo>> = if
!value_declared {
+ let value_type_info: Option<Rc<TypeInfo>> = if
!value_declared {
if val_is_polymorphic {
Some(context.read_any_typeinfo()?)
} else {
@@ -411,7 +411,7 @@ macro_rules! impl_read_map_dyn_ref {
let key_declared = (header & DECL_KEY_TYPE) != 0;
let track_key_ref = (header & TRACKING_KEY_REF) != 0;
- let key_type_info: Option<Arc<TypeInfo>> = if
!key_declared {
+ let key_type_info: Option<Rc<TypeInfo>> = if !key_declared
{
if key_is_polymorphic {
Some(context.read_any_typeinfo()?)
} else {
@@ -443,7 +443,7 @@ macro_rules! impl_read_map_dyn_ref {
let track_key_ref = (header & TRACKING_KEY_REF) != 0;
let track_value_ref = (header & TRACKING_VALUE_REF) != 0;
- let key_type_info: Option<Arc<TypeInfo>> = if !key_declared {
+ let key_type_info: Option<Rc<TypeInfo>> = if !key_declared {
if key_is_polymorphic {
Some(context.read_any_typeinfo()?)
} else {
@@ -453,7 +453,7 @@ macro_rules! impl_read_map_dyn_ref {
} else {
None
};
- let value_type_info: Option<Arc<TypeInfo>> = if
!value_declared {
+ let value_type_info: Option<Rc<TypeInfo>> = if !value_declared
{
if val_is_polymorphic {
Some(context.read_any_typeinfo()?)
} else {
diff --git a/rust/fory-core/src/serializer/mutex.rs
b/rust/fory-core/src/serializer/mutex.rs
index f6fcc3452..fd9c7e788 100644
--- a/rust/fory-core/src/serializer/mutex.rs
+++ b/rust/fory-core/src/serializer/mutex.rs
@@ -46,7 +46,7 @@ use crate::resolver::context::{ReadContext, WriteContext};
use crate::resolver::type_resolver::{TypeInfo, TypeResolver};
use crate::serializer::{ForyDefault, Serializer};
use crate::types::TypeId;
-use std::sync::Arc;
+use std::rc::Rc;
use std::sync::Mutex;
/// `Serializer` impl for `Mutex<T>`
@@ -114,7 +114,7 @@ impl<T: Serializer + ForyDefault> Serializer for Mutex<T> {
fn fory_read_with_type_info(
context: &mut ReadContext,
read_ref_info: bool,
- type_info: Arc<TypeInfo>,
+ type_info: Rc<TypeInfo>,
) -> Result<Self, Error>
where
Self: Sized + ForyDefault,
diff --git a/rust/fory-core/src/serializer/option.rs
b/rust/fory-core/src/serializer/option.rs
index 52c0dc138..ea888e8e8 100644
--- a/rust/fory-core/src/serializer/option.rs
+++ b/rust/fory-core/src/serializer/option.rs
@@ -21,6 +21,7 @@ use crate::resolver::context::WriteContext;
use crate::resolver::type_resolver::TypeResolver;
use crate::serializer::{ForyDefault, Serializer};
use crate::types::{RefFlag, TypeId};
+use std::rc::Rc;
impl<T: Serializer + ForyDefault> Serializer for Option<T> {
#[inline(always)]
@@ -83,7 +84,7 @@ impl<T: Serializer + ForyDefault> Serializer for Option<T> {
fn fory_read_with_type_info(
context: &mut ReadContext,
read_ref_info: bool,
- type_info: std::sync::Arc<crate::TypeInfo>,
+ type_info: Rc<crate::TypeInfo>,
) -> Result<Self, Error>
where
Self: Sized + ForyDefault,
diff --git a/rust/fory-core/src/serializer/rc.rs
b/rust/fory-core/src/serializer/rc.rs
index 7114e85bd..2d9ff4ec2 100644
--- a/rust/fory-core/src/serializer/rc.rs
+++ b/rust/fory-core/src/serializer/rc.rs
@@ -22,7 +22,6 @@ use crate::serializer::{ForyDefault, Serializer};
use crate::types::RefFlag;
use crate::types::TypeId;
use std::rc::Rc;
-use std::sync::Arc;
impl<T: Serializer + ForyDefault + 'static> Serializer for Rc<T> {
fn fory_is_shared_ref() -> bool {
@@ -83,7 +82,7 @@ impl<T: Serializer + ForyDefault + 'static> Serializer for
Rc<T> {
fn fory_read_with_type_info(
context: &mut ReadContext,
read_ref_info: bool,
- typeinfo: Arc<TypeInfo>,
+ typeinfo: Rc<TypeInfo>,
) -> Result<Self, Error>
where
Self: Sized + ForyDefault,
@@ -126,7 +125,7 @@ fn read_rc<T: Serializer + ForyDefault + 'static>(
context: &mut ReadContext,
read_ref_info: bool,
read_type_info: bool,
- typeinfo: Option<Arc<TypeInfo>>,
+ typeinfo: Option<Rc<TypeInfo>>,
) -> Result<Rc<T>, Error> {
let ref_flag = if read_ref_info {
context.ref_reader.read_ref_flag(&mut context.reader)?
@@ -159,7 +158,7 @@ fn read_rc<T: Serializer + ForyDefault + 'static>(
fn read_rc_inner<T: Serializer + ForyDefault + 'static>(
context: &mut ReadContext,
read_type_info: bool,
- typeinfo: Option<Arc<TypeInfo>>,
+ typeinfo: Option<Rc<TypeInfo>>,
) -> Result<T, Error> {
if let Some(typeinfo) = typeinfo {
let inner_read_ref = T::fory_is_shared_ref();
diff --git a/rust/fory-core/src/serializer/refcell.rs
b/rust/fory-core/src/serializer/refcell.rs
index 67d69cb2f..0012fffe8 100644
--- a/rust/fory-core/src/serializer/refcell.rs
+++ b/rust/fory-core/src/serializer/refcell.rs
@@ -38,7 +38,7 @@ use crate::resolver::type_resolver::{TypeInfo, TypeResolver};
use crate::serializer::{ForyDefault, Serializer};
use crate::types::TypeId;
use std::cell::RefCell;
-use std::sync::Arc;
+use std::rc::Rc;
/// `Serializer` impl for `RefCell<T>`
///
@@ -63,7 +63,7 @@ impl<T: Serializer + ForyDefault> Serializer for RefCell<T> {
fn fory_read_with_type_info(
context: &mut ReadContext,
read_ref_info: bool,
- type_info: Arc<TypeInfo>,
+ type_info: Rc<TypeInfo>,
) -> Result<Self, Error>
where
Self: Sized + ForyDefault,
diff --git a/rust/fory-core/src/serializer/trait_object.rs
b/rust/fory-core/src/serializer/trait_object.rs
index 97195b3ea..00aeb975c 100644
--- a/rust/fory-core/src/serializer/trait_object.rs
+++ b/rust/fory-core/src/serializer/trait_object.rs
@@ -24,7 +24,7 @@ use crate::resolver::context::{ReadContext, WriteContext};
use crate::resolver::type_resolver::{TypeInfo, TypeResolver};
use crate::serializer::{ForyDefault, Serializer};
use crate::RefFlag;
-use std::sync::Arc;
+use std::rc::Rc;
/// Helper macro for common type resolution and downcasting pattern
#[macro_export]
@@ -68,7 +68,6 @@ macro_rules! resolve_and_deserialize {
/// either you use the wrapper types or use the `Rc<dyn Any>` or `Arc<dyn
Any>` instead if it's not
/// inside struct fields. For struct fields, you can use the `Rc<dyn Trait>`,
`Arc<dyn Trait>` directly,
/// fory will generate converters for `Rc<dyn Trait>` and `Arc<dyn Trait>` to
convert to wrapper for
-/// serialization/ deserialization automatically.
///
/// The macro generates:
/// - `Serializer` implementation for `Box<dyn Trait>`
@@ -213,7 +212,7 @@ macro_rules! register_trait_type {
fn fory_read_with_type_info(
context: &mut fory_core::ReadContext,
read_ref_info: bool,
- type_info: std::sync::Arc<fory_core::TypeInfo>,
+ type_info: std::rc::Rc<fory_core::TypeInfo>,
) -> Result<Self, fory_core::Error>
where
Self: Sized + fory_core::ForyDefault,
@@ -468,7 +467,7 @@ macro_rules! impl_smart_pointer_serializer {
)
}
- fn fory_read_with_type_info(context: &mut fory_core::ReadContext,
read_ref_info: bool, type_info: std::sync::Arc<fory_core::TypeInfo>) ->
Result<Self, fory_core::Error> {
+ fn fory_read_with_type_info(context: &mut fory_core::ReadContext,
read_ref_info: bool, type_info: std::rc::Rc<fory_core::TypeInfo>) ->
Result<Self, fory_core::Error> {
$crate::read_ptr_trait_object!(
context,
read_ref_info,
@@ -650,7 +649,7 @@ impl Serializer for Box<dyn Serializer> {
fn fory_read_with_type_info(
context: &mut ReadContext,
read_ref_info: bool,
- type_info: Arc<TypeInfo>,
+ type_info: Rc<TypeInfo>,
) -> Result<Self, Error>
where
Self: Sized + ForyDefault,
@@ -667,7 +666,7 @@ fn read_box_seralizer(
context: &mut ReadContext,
read_ref_info: bool,
read_type_info: bool,
- type_info: Option<Arc<TypeInfo>>,
+ type_info: Option<Rc<TypeInfo>>,
) -> Result<Box<dyn Serializer>, Error> {
context.inc_depth()?;
let ref_flag = if read_ref_info {
diff --git a/rust/fory-core/src/serializer/weak.rs
b/rust/fory-core/src/serializer/weak.rs
index d88f68a87..29d3009a8 100644
--- a/rust/fory-core/src/serializer/weak.rs
+++ b/rust/fory-core/src/serializer/weak.rs
@@ -367,7 +367,7 @@ impl<T: Serializer + ForyDefault + 'static> Serializer for
RcWeak<T> {
fn fory_read_with_type_info(
context: &mut ReadContext,
read_ref_info: bool,
- typeinfo: Arc<TypeInfo>,
+ typeinfo: Rc<TypeInfo>,
) -> Result<Self, Error> {
read_rc_weak::<T>(context, read_ref_info, false, Some(typeinfo))
}
@@ -410,7 +410,7 @@ fn read_rc_weak<T: Serializer + ForyDefault + 'static>(
context: &mut ReadContext,
read_ref_info: bool,
read_type_info: bool,
- type_info: Option<Arc<TypeInfo>>,
+ type_info: Option<Rc<TypeInfo>>,
) -> Result<RcWeak<T>, Error> {
let ref_flag = if read_ref_info {
context.ref_reader.read_ref_flag(&mut context.reader)?
@@ -526,7 +526,7 @@ impl<T: Serializer + ForyDefault + Send + Sync + 'static>
Serializer for ArcWeak
fn fory_read_with_type_info(
context: &mut ReadContext,
read_ref_info: bool,
- typeinfo: Arc<TypeInfo>,
+ typeinfo: Rc<TypeInfo>,
) -> Result<Self, Error> {
read_arc_weak::<T>(context, read_ref_info, false, Some(typeinfo))
}
@@ -569,7 +569,7 @@ fn read_arc_weak<T: Serializer + ForyDefault + 'static>(
context: &mut ReadContext,
read_ref_info: bool,
read_type_info: bool,
- type_info: Option<Arc<TypeInfo>>,
+ type_info: Option<Rc<TypeInfo>>,
) -> Result<ArcWeak<T>, Error> {
let ref_flag = if read_ref_info {
context.ref_reader.read_ref_flag(&mut context.reader)?
diff --git a/rust/fory-derive/src/object/read.rs
b/rust/fory-derive/src/object/read.rs
index 03755e1fe..b288e0ecd 100644
--- a/rust/fory-derive/src/object/read.rs
+++ b/rust/fory-derive/src/object/read.rs
@@ -472,7 +472,7 @@ pub fn gen_read_with_type_info(struct_ident: &Ident) ->
TokenStream {
// fn fory_read_with_type_info(
// context: &mut ReadContext,
// read_ref_info: bool,
- // type_info: Arc<TypeInfo>,
+ // type_info: Rc<TypeInfo>,
// ) -> Result<Self, Error>
quote! {
let ref_flag = if read_ref_info {
diff --git a/rust/fory-derive/src/object/serializer.rs
b/rust/fory-derive/src/object/serializer.rs
index 51a1ae131..20893654c 100644
--- a/rust/fory-derive/src/object/serializer.rs
+++ b/rust/fory-derive/src/object/serializer.rs
@@ -141,7 +141,7 @@ pub fn derive_serializer(ast: &syn::DeriveInput,
debug_enabled: bool) -> TokenSt
#fields_info_ts
}
- fn fory_read_compatible(context: &mut
fory_core::resolver::context::ReadContext, type_info:
std::sync::Arc<fory_core::TypeInfo>) -> Result<Self, fory_core::error::Error> {
+ fn fory_read_compatible(context: &mut
fory_core::resolver::context::ReadContext, type_info:
std::rc::Rc<fory_core::TypeInfo>) -> Result<Self, fory_core::error::Error> {
#read_compatible_ts
}
}
@@ -186,7 +186,7 @@ pub fn derive_serializer(ast: &syn::DeriveInput,
debug_enabled: bool) -> TokenSt
#read_ts
}
- fn fory_read_with_type_info(context: &mut
fory_core::resolver::context::ReadContext, read_ref_info: bool, type_info:
std::sync::Arc<fory_core::TypeInfo>) -> Result<Self, fory_core::error::Error> {
+ fn fory_read_with_type_info(context: &mut
fory_core::resolver::context::ReadContext, read_ref_info: bool, type_info:
std::rc::Rc<fory_core::TypeInfo>) -> Result<Self, fory_core::error::Error> {
#read_with_type_info_ts
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
