Here is an example:

pub struct WriteContext<'se> {
    pub writer: &'se mut Writer,
    meta_resolver: MetaWriterResolver<'se>,
    pub ref_writer: RefWriter,
}
pub struct ReadContext<'de, 'bf: 'de> {
    pub reader: Reader<'bf>,
    pub meta_resolver: MetaReaderResolver,
    pub ref_reader: RefReader,
    max_dyn_depth: u32,
    current_depth: u32,
}

Serializer:

pub trait Serializer: 'static {
    /// Entry point of the serialization.
    fn fory_write(&self, fory: &Fory, context: &mut WriteContext, is_field: bool)
    where
        Self: Sized,
    {
        write_ref_info_data(self, fory: &Fory, context, is_field, false, false);
    }

    fn fory_read(context: fory: &Fory, &mut ReadContext, is_field: bool) -> Result<Self, Error>
    where
        Self: Sized + ForyDefault,
    {
        read_ref_info_data(fory, context, is_field, false, false)
    }

    fn fory_get_type_id(fory: &Fory) -> u32
    where
        Self: Sized,
    {
        fory.get_type_resolver()
            .get_type_info(std::any::TypeId::of::<Self>())
            .get_type_id()
    }

    fn fory_type_id_dyn(&self, fory: &Fory) -> u32;

    fn fory_write_type_info(fory: &Fory, context: &mut WriteContext, _is_field: bool)
    where
        Self: Sized,
    {
    }

    fn fory_read_type_info(fory: &Fory, context: &mut ReadContext, _is_field: bool)
    where
        Self: Sized,
    {

    }

    // only used by struct/enum/ext
    fn fory_read_compatible(fory: &Fory, context: &mut ReadContext) -> Result<Self, Error>
    where
        Self: Sized,
    {

    }

    /// Write/Read the data into the buffer. Need to be implemented.
    fn fory_write_data(&self,fory: &Fory,  context: &mut WriteContext, is_field: bool);

    fn fory_read_data(fory: &Fory, context: &mut ReadContext, is_field: bool) -> Result<Self, Error>
    where
        Self: Sized + ForyDefault;

}

Fory:

pub struct Fory {
    mode: Mode,
    xlang: bool,
    share_meta: bool,
    type_resolver: TypeResolver,
    metastring_resolver: Rc<RefCell<MetaStringResolver>>,
    compress_string: bool,
    max_dyn_depth: u32,
    write_context_pool: RefCell<Pool<WriteContext>>,
    read_context_pool: RefCell<Pool<ReadContext>>,
}

impl Fory {
    pub fn serialize<T: Serializer>(&self, record: &T) -> Vec<u8> {
        let mut &writer = self.write_context_pool.borrow_ref();
        let mut context: WriteContext<'_> = WriteContext::new(self, &mut writer);
        self.serialize_with_context(record, &mut context)
        context.clear();
        self.write_context_pool.return_ref(context)
    }

    pub fn deserialize<T: Serializer + ForyDefault>(&self, bf: &[u8]) -> Result<T, Error> {
        let reader = Reader::new(bf);
        let mut &context = self.read_context_pool.borrow_ref();
        let result = self.deserialize_with_context(&mut context);
        if result.is_ok() {
            assert_eq!(context.reader.slice_after_cursor().len(), 0);
        }
        context.clear();
        self.read_context_pool.return_ref(context)
        result
    }
}

The Pool needs be thread safe, and you can use a mutux to protect it.
context must be clear before return to pool

[Rust] reuse context to manage reduce object allocation #2717

Description

Feature Request

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions