Interface Codec

rust/fory-core/src/serializer/codec.rs:469–599

}

pub trait Codec<T: 'static>: 'static {
    fn field_type(type_resolver: &TypeResolver) -> Result<FieldType, Error>;

    #[inline(always)]
    fn reserved_space() -> usize {
        std::mem::size_of::<T>()
    }

    fn write_field(value: &T, context: &mut WriteContext) -> Result<(), Error>;

    fn read_field(context: &mut ReadContext) -> Result<T, Error>;

    #[inline(always)]
    fn read_compatible(
        context: &mut ReadContext,
        local_field_type: &FieldType,
        remote_field_type: &FieldType,
    ) -> Result<Option<T>, Error> {
        if field_types_compatible(local_field_type, remote_field_type)
            || local_field_type.compatible_shape_match(remote_field_type)
        {
            return Self::read_field_with_type(context, remote_field_type).map(Some);
        }
        super::scalar_conversion::read_scalar_field::<T, Self>(
            context,
            local_field_type,
            remote_field_type,
        )
    }

    fn write_data(value: &T, context: &mut WriteContext) -> Result<(), Error>;

    fn read_data(context: &mut ReadContext) -> Result<T, Error>;

    #[inline(always)]
    fn read_data_with_type(
        context: &mut ReadContext,
        _remote_data_type: &FieldType,
    ) -> Result<T, Error> {
        Self::read_data(context)
    }

    #[inline(always)]
    fn read_data_with_type_info(
        context: &mut ReadContext,
        type_info: &Rc<crate::TypeInfo>,
    ) -> Result<T, Error> {
        Self::read_with_type_info(context, RefMode::None, type_info.clone())
    }

    #[inline(always)]
    fn type_info_exact(
        _context: &ReadContext,
        _type_info: &Rc<crate::TypeInfo>,
    ) -> Result<bool, Error> {
        Ok(false)
    }