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
44            #[inline(always)]
45            fn fory_reserved_space() -> usize {
46                std::mem::size_of::<$ty>()
47            }
48
49            #[inline(always)]
50            fn fory_get_type_id(_: &TypeResolver) -> Result<TypeId, Error> {
51                Ok($field_type)
52            }
53
54            #[inline(always)]
55            fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<TypeId, Error> {
56                Ok($field_type)
57            }
58
59            #[inline(always)]
60            fn fory_static_type_id() -> TypeId {
61                $field_type
62            }
63
64            #[inline(always)]
65            fn as_any(&self) -> &dyn std::any::Any {
66                self
67            }
68
69            #[inline(always)]
70            fn fory_write_type_info(context: &mut WriteContext) -> Result<(), Error> {
71                context.writer.write_var_u32($field_type as u32);
72                Ok(())
73            }
74
75            #[inline(always)]
76            fn fory_read_type_info(context: &mut ReadContext) -> Result<(), Error> {
77                read_basic_type_info::<Self>(context)
78            }
79        }
80        impl ForyDefault for $ty {
81            #[inline(always)]
82            fn fory_default() -> Self {
83                0 as $ty
84            }
85        }
86    };
87}
88
89impl_num_serializer!(i8, Writer::write_i8, Reader::read_i8, TypeId::INT8);
90impl_num_serializer!(i16, Writer::write_i16, Reader::read_i16, TypeId::INT16);
91impl_num_serializer!(
92    i32,
93    Writer::write_var_i32,
94    Reader::read_var_i32,
95    TypeId::VARINT32
96);
97impl_num_serializer!(
98    i64,
99    Writer::write_var_i64,
100    Reader::read_var_i64,
101    TypeId::VARINT64
102);
103impl_num_serializer!(f32, Writer::write_f32, Reader::read_f32, TypeId::FLOAT32);
104impl_num_serializer!(f64, Writer::write_f64, Reader::read_f64, TypeId::FLOAT64);
105
106// Custom implementation for float16 (cannot use 0 as float16)
107impl Serializer for float16 {
108    #[inline(always)]
109    fn fory_write_data(&self, context: &mut WriteContext) -> Result<(), Error> {
110        Writer::write_f16(&mut context.writer, *self);
111        Ok(())
112    }
113    #[inline(always)]
114    fn fory_read_data(context: &mut ReadContext) -> Result<Self, Error> {
115        Reader::read_f16(&mut context.reader)
116    }
117    #[inline(always)]
118    fn fory_reserved_space() -> usize {
119        std::mem::size_of::<float16>()
120    }
121    #[inline(always)]
122    fn fory_get_type_id(_: &TypeResolver) -> Result<TypeId, Error> {
123        Ok(TypeId::FLOAT16)
124    }
125    #[inline(always)]
126    fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<TypeId, Error> {
127        Ok(TypeId::FLOAT16)
128    }
129    #[inline(always)]
130    fn fory_static_type_id() -> TypeId {
131        TypeId::FLOAT16
132    }
133    #[inline(always)]
134    fn as_any(&self) -> &dyn std::any::Any {
135        self
136    }
137    #[inline(always)]
138    fn fory_write_type_info(context: &mut WriteContext) -> Result<(), Error> {
139        context.writer.write_var_u32(TypeId::FLOAT16 as u32);
140        Ok(())
141    }
142    #[inline(always)]
143    fn fory_read_type_info(context: &mut ReadContext) -> Result<(), Error> {
144        read_basic_type_info::<Self>(context)
145    }
146}
147
148impl ForyDefault for float16 {
149    #[inline(always)]
150    fn fory_default() -> Self {
151        float16::ZERO
152    }
153}
154
155impl Serializer for bfloat16 {
156    #[inline(always)]
157    fn fory_write_data(&self, context: &mut WriteContext) -> Result<(), Error> {
158        Writer::write_bf16(&mut context.writer, *self);
159        Ok(())
160    }
161    #[inline(always)]
162    fn fory_read_data(context: &mut ReadContext) -> Result<Self, Error> {
163        Reader::read_bf16(&mut context.reader)
164    }
165    #[inline(always)]
166    fn fory_reserved_space() -> usize {
167        std::mem::size_of::<bfloat16>()
168    }
169    #[inline(always)]
170    fn fory_get_type_id(_: &TypeResolver) -> Result<TypeId, Error> {
171        Ok(TypeId::BFLOAT16)
172    }
173    #[inline(always)]
174    fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<TypeId, Error> {
175        Ok(TypeId::BFLOAT16)
176    }
177    #[inline(always)]
178    fn fory_static_type_id() -> TypeId {
179        TypeId::BFLOAT16
180    }
181    #[inline(always)]
182    fn as_any(&self) -> &dyn std::any::Any {
183        self
184    }
185    #[inline(always)]
186    fn fory_write_type_info(context: &mut WriteContext) -> Result<(), Error> {
187        context.writer.write_var_u32(TypeId::BFLOAT16 as u32);
188        Ok(())
189    }
190    #[inline(always)]
191    fn fory_read_type_info(context: &mut ReadContext) -> Result<(), Error> {
192        read_basic_type_info::<Self>(context)
193    }
194}
195
196impl ForyDefault for bfloat16 {
197    #[inline(always)]
198    fn fory_default() -> Self {
199        bfloat16::ZERO
200    }
201}
202impl_num_serializer!(i128, Writer::write_i128, Reader::read_i128, TypeId::INT128);
203impl_num_serializer!(
204    isize,
205    Writer::write_isize,
206    Reader::read_isize,
207    TypeId::ISIZE
208);
fory_core/serializer/number.rs

fory_core/serializer/
number.rs
