Skip to main content

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::buffer::{Reader, Writer};
19use crate::context::{ReadContext, WriteContext};
20use crate::error::Error;
21use crate::serializer::util::read_basic_type_info;
22use crate::serializer::Serializer;
23use crate::type_id::TypeId;
24use crate::types::bfloat16::bfloat16;
25use crate::types::float16::float16;
26use std::sync::Arc;
27
28macro_rules! impl_num_serializer {
29    (
30        $ty:ty,
31        $writer:expr,
32        $reader:expr,
33        $type_id:expr,
34        $default:expr
35    ) => {
36        impl Serializer for $ty {
37            type Target = Self;
38
39            const READ_DATA_ALWAYS_ADVANCES: bool = true;
40
41            #[inline(always)]
42            fn write_data(value: &Self, context: &mut WriteContext) -> Result<(), Error> {
43                $writer(&mut context.writer, *value);
44                Ok(())
45            }
46
47            #[inline(always)]
48            fn read_data(context: &mut ReadContext) -> Result<Self, Error> {
49                $reader(&mut context.reader)
50            }
51
52            #[inline(always)]
53            fn default_value(_: &mut ReadContext) -> Result<Self, Error> {
54                Ok($default)
55            }
56
57            #[inline(always)]
58            fn read_arc_any(
59                context: &mut ReadContext,
60            ) -> Result<Arc<dyn std::any::Any + Send + Sync>, Error> {
61                Ok(Arc::new(Self::read_data(context)?))
62            }
63
64            #[inline(always)]
65            fn reserved_space() -> usize {
66                std::mem::size_of::<Self>()
67            }
68
69            #[inline(always)]
70            fn static_type_id() -> TypeId {
71                $type_id
72            }
73
74            #[inline(always)]
75            fn write_type_info(context: &mut WriteContext) -> Result<(), Error> {
76                context.writer.write_var_u32($type_id as u32);
77                Ok(())
78            }
79
80            #[inline(always)]
81            fn read_type_info(context: &mut ReadContext) -> Result<(), Error> {
82                read_basic_type_info::<Self>(context)
83            }
84        }
85    };
86}
87
88impl_num_serializer!(i8, Writer::write_i8, Reader::read_i8, TypeId::INT8, 0);
89impl_num_serializer!(i16, Writer::write_i16, Reader::read_i16, TypeId::INT16, 0);
90impl_num_serializer!(
91    i32,
92    Writer::write_var_i32,
93    Reader::read_var_i32,
94    TypeId::VARINT32,
95    0
96);
97impl_num_serializer!(
98    i64,
99    Writer::write_var_i64,
100    Reader::read_var_i64,
101    TypeId::VARINT64,
102    0
103);
104impl_num_serializer!(
105    f32,
106    Writer::write_f32,
107    Reader::read_f32,
108    TypeId::FLOAT32,
109    0.0
110);
111impl_num_serializer!(
112    f64,
113    Writer::write_f64,
114    Reader::read_f64,
115    TypeId::FLOAT64,
116    0.0
117);
118impl_num_serializer!(
119    float16,
120    Writer::write_f16,
121    Reader::read_f16,
122    TypeId::FLOAT16,
123    float16::ZERO
124);
125impl_num_serializer!(
126    bfloat16,
127    Writer::write_bf16,
128    Reader::read_bf16,
129    TypeId::BFLOAT16,
130    bfloat16::ZERO
131);
132impl_num_serializer!(
133    i128,
134    Writer::write_i128,
135    Reader::read_i128,
136    TypeId::INT128,
137    0
138);
139impl_num_serializer!(
140    isize,
141    Writer::write_isize,
142    Reader::read_isize,
143    TypeId::ISIZE,
144    0
145);