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