fory_core/serializer/
number.rs

1// Licensed to the Apache Software Foundation (ASF) under one
2// or more contributor license agreements.  See the NOTICE file
3// distributed with this work for additional information
4// regarding copyright ownership.  The ASF licenses this file
5// to you under the Apache License, Version 2.0 (the
6// "License"); you may not use this file except in compliance
7// with the License.  You may obtain a copy of the License at
8//
9//   http://www.apache.org/licenses/LICENSE-2.0
10//
11// Unless required by applicable law or agreed to in writing,
12// software distributed under the License is distributed on an
13// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14// KIND, either express or implied.  See the License for the
15// specific language governing permissions and limitations
16// under the License.
17
18use crate::types::bfloat16::bfloat16;
19use crate::types::float16::float16;
20
21use crate::buffer::{Reader, Writer};
22use crate::context::ReadContext;
23use crate::context::WriteContext;
24use crate::error::Error;
25use crate::resolver::TypeResolver;
26use crate::serializer::util::read_basic_type_info;
27use crate::serializer::{ForyDefault, Serializer};
28use crate::type_id::TypeId;
29
30macro_rules! impl_num_serializer {
31    ($ty:ty, $writer:expr, $reader:expr, $field_type:expr) => {
32        impl Serializer for $ty {
33            #[inline(always)]
34            fn fory_write_data(&self, context: &mut WriteContext) -> Result<(), Error> {
35                $writer(&mut context.writer, *self);
36                Ok(())
37            }
38
39            #[inline(always)]
40            fn fory_read_data(context: &mut ReadContext) -> Result<Self, Error> {
41                $reader(&mut context.reader)
42            }
43            #[inline]
44            fn fory_read_data_as_send_sync_any(
45                context: &mut ReadContext,
46            ) -> Result<Box<dyn std::any::Any + Send + Sync>, Error>
47            where
48                Self: Sized + ForyDefault,
49            {
50                Ok(crate::serializer::box_send_sync(Self::fory_read_data(
51                    context,
52                )?))
53            }
54
55            #[inline(always)]
56            fn fory_reserved_space() -> usize {
57                std::mem::size_of::<$ty>()
58            }
59
60            #[inline(always)]
61            fn fory_get_type_id(_: &TypeResolver) -> Result<TypeId, Error> {
62                Ok($field_type)
63            }
64
65            #[inline(always)]
66            fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<TypeId, Error> {
67                Ok($field_type)
68            }
69
70            #[inline(always)]
71            fn fory_static_type_id() -> TypeId {
72                $field_type
73            }
74
75            #[inline(always)]
76            fn as_any(&self) -> &dyn std::any::Any {
77                self
78            }
79
80            #[inline(always)]
81            fn fory_write_type_info(context: &mut WriteContext) -> Result<(), Error> {
82                context.writer.write_var_u32($field_type as u32);
83                Ok(())
84            }
85
86            #[inline(always)]
87            fn fory_read_type_info(context: &mut ReadContext) -> Result<(), Error> {
88                read_basic_type_info::<Self>(context)
89            }
90        }
91        impl ForyDefault for $ty {
92            #[inline(always)]
93            fn fory_default() -> Self {
94                0 as $ty
95            }
96        }
97    };
98}
99
100impl_num_serializer!(i8, Writer::write_i8, Reader::read_i8, TypeId::INT8);
101impl_num_serializer!(i16, Writer::write_i16, Reader::read_i16, TypeId::INT16);
102impl_num_serializer!(
103    i32,
104    Writer::write_var_i32,
105    Reader::read_var_i32,
106    TypeId::VARINT32
107);
108impl_num_serializer!(
109    i64,
110    Writer::write_var_i64,
111    Reader::read_var_i64,
112    TypeId::VARINT64
113);
114impl_num_serializer!(f32, Writer::write_f32, Reader::read_f32, TypeId::FLOAT32);
115impl_num_serializer!(f64, Writer::write_f64, Reader::read_f64, TypeId::FLOAT64);
116
117// Custom implementation for float16 (cannot use 0 as float16)
118impl Serializer for float16 {
119    #[inline(always)]
120    fn fory_write_data(&self, context: &mut WriteContext) -> Result<(), Error> {
121        Writer::write_f16(&mut context.writer, *self);
122        Ok(())
123    }
124    #[inline(always)]
125    fn fory_read_data(context: &mut ReadContext) -> Result<Self, Error> {
126        Reader::read_f16(&mut context.reader)
127    }
128    #[inline]
129    fn fory_read_data_as_send_sync_any(
130        context: &mut ReadContext,
131    ) -> Result<Box<dyn std::any::Any + Send + Sync>, Error>
132    where
133        Self: Sized + ForyDefault,
134    {
135        Ok(crate::serializer::box_send_sync(Self::fory_read_data(
136            context,
137        )?))
138    }
139    #[inline(always)]
140    fn fory_reserved_space() -> usize {
141        std::mem::size_of::<float16>()
142    }
143    #[inline(always)]
144    fn fory_get_type_id(_: &TypeResolver) -> Result<TypeId, Error> {
145        Ok(TypeId::FLOAT16)
146    }
147    #[inline(always)]
148    fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<TypeId, Error> {
149        Ok(TypeId::FLOAT16)
150    }
151    #[inline(always)]
152    fn fory_static_type_id() -> TypeId {
153        TypeId::FLOAT16
154    }
155    #[inline(always)]
156    fn as_any(&self) -> &dyn std::any::Any {
157        self
158    }
159    #[inline(always)]
160    fn fory_write_type_info(context: &mut WriteContext) -> Result<(), Error> {
161        context.writer.write_var_u32(TypeId::FLOAT16 as u32);
162        Ok(())
163    }
164    #[inline(always)]
165    fn fory_read_type_info(context: &mut ReadContext) -> Result<(), Error> {
166        read_basic_type_info::<Self>(context)
167    }
168}
169
170impl ForyDefault for float16 {
171    #[inline(always)]
172    fn fory_default() -> Self {
173        float16::ZERO
174    }
175}
176
177impl Serializer for bfloat16 {
178    #[inline(always)]
179    fn fory_write_data(&self, context: &mut WriteContext) -> Result<(), Error> {
180        Writer::write_bf16(&mut context.writer, *self);
181        Ok(())
182    }
183    #[inline(always)]
184    fn fory_read_data(context: &mut ReadContext) -> Result<Self, Error> {
185        Reader::read_bf16(&mut context.reader)
186    }
187    #[inline]
188    fn fory_read_data_as_send_sync_any(
189        context: &mut ReadContext,
190    ) -> Result<Box<dyn std::any::Any + Send + Sync>, Error>
191    where
192        Self: Sized + ForyDefault,
193    {
194        Ok(crate::serializer::box_send_sync(Self::fory_read_data(
195            context,
196        )?))
197    }
198    #[inline(always)]
199    fn fory_reserved_space() -> usize {
200        std::mem::size_of::<bfloat16>()
201    }
202    #[inline(always)]
203    fn fory_get_type_id(_: &TypeResolver) -> Result<TypeId, Error> {
204        Ok(TypeId::BFLOAT16)
205    }
206    #[inline(always)]
207    fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<TypeId, Error> {
208        Ok(TypeId::BFLOAT16)
209    }
210    #[inline(always)]
211    fn fory_static_type_id() -> TypeId {
212        TypeId::BFLOAT16
213    }
214    #[inline(always)]
215    fn as_any(&self) -> &dyn std::any::Any {
216        self
217    }
218    #[inline(always)]
219    fn fory_write_type_info(context: &mut WriteContext) -> Result<(), Error> {
220        context.writer.write_var_u32(TypeId::BFLOAT16 as u32);
221        Ok(())
222    }
223    #[inline(always)]
224    fn fory_read_type_info(context: &mut ReadContext) -> Result<(), Error> {
225        read_basic_type_info::<Self>(context)
226    }
227}
228
229impl ForyDefault for bfloat16 {
230    #[inline(always)]
231    fn fory_default() -> Self {
232        bfloat16::ZERO
233    }
234}
235impl_num_serializer!(i128, Writer::write_i128, Reader::read_i128, TypeId::INT128);
236impl_num_serializer!(
237    isize,
238    Writer::write_isize,
239    Reader::read_isize,
240    TypeId::ISIZE
241);
fory_core/serializer/number.rs

fory_core/serializer/
number.rs
