fory_core/serializer/
any.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::ensure;
19use crate::error::Error;
20use crate::resolver::context::{ReadContext, WriteContext};
21use crate::resolver::type_resolver::{TypeInfo, TypeResolver};
22use crate::serializer::util::write_dyn_data_generic;
23use crate::serializer::{ForyDefault, Serializer};
24use crate::types::RefFlag;
25use crate::types::TypeId;
26use std::any::Any;
27use std::rc::Rc;
28use std::sync::Arc;
29
30/// Helper function to deserialize to `Box<dyn Any>`
31pub fn deserialize_any_box(context: &mut ReadContext) -> Result<Box<dyn Any>, Error> {
32    context.inc_depth()?;
33    let ref_flag = context.reader.read_i8()?;
34    if ref_flag != RefFlag::NotNullValue as i8 {
35        return Err(Error::invalid_ref("Expected NotNullValue for Box<dyn Any>"));
36    }
37    let typeinfo = context.read_any_typeinfo()?;
38    let deserializer_fn = typeinfo.get_harness().get_read_data_fn();
39    let result = deserializer_fn(context);
40    context.dec_depth();
41    result
42}
43
44impl ForyDefault for Box<dyn Any> {
45    fn fory_default() -> Self {
46        Box::new(())
47    }
48}
49
50impl Serializer for Box<dyn Any> {
51    fn fory_write(
52        &self,
53        context: &mut WriteContext,
54        write_ref_info: bool,
55        write_typeinfo: bool,
56        has_generics: bool,
57    ) -> Result<(), Error> {
58        write_box_any(
59            self.as_ref(),
60            context,
61            write_ref_info,
62            write_typeinfo,
63            has_generics,
64        )
65    }
66
67    fn fory_write_data_generic(
68        &self,
69        context: &mut WriteContext,
70        has_generics: bool,
71    ) -> Result<(), Error> {
72        let concrete_type_id = (**self).type_id();
73        let typeinfo = context.get_type_info(&concrete_type_id)?;
74        let serializer_fn = typeinfo.get_harness().get_write_data_fn();
75        serializer_fn(&**self, context, has_generics)
76    }
77
78    fn fory_write_data(&self, context: &mut WriteContext) -> Result<(), Error> {
79        self.fory_write_data_generic(context, false)
80    }
81
82    fn fory_read(
83        context: &mut ReadContext,
84        read_ref_info: bool,
85        read_type_info: bool,
86    ) -> Result<Self, Error> {
87        read_box_any(context, read_ref_info, read_type_info, None)
88    }
89
90    fn fory_read_with_type_info(
91        context: &mut ReadContext,
92        read_ref_info: bool,
93        type_info: Rc<TypeInfo>,
94    ) -> Result<Self, Error>
95    where
96        Self: Sized + ForyDefault,
97    {
98        read_box_any(context, read_ref_info, false, Some(type_info))
99    }
100
101    fn fory_read_data(_: &mut ReadContext) -> Result<Self, Error> {
102        Err(Error::not_allowed(
103            "fory_read_data should not be called directly on polymorphic Rc<dyn Any> trait object",
104        ))
105    }
106
107    fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
108        Err(Error::type_error(
109            "Box<dyn Any> has no static type ID - use fory_type_id_dyn",
110        ))
111    }
112
113    fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
114        let concrete_type_id = (**self).type_id();
115        type_resolver
116            .get_fory_type_id(concrete_type_id)
117            .ok_or_else(|| Error::type_error("Type not registered"))
118    }
119
120    fn fory_concrete_type_id(&self) -> std::any::TypeId {
121        (**self).type_id()
122    }
123
124    fn fory_is_polymorphic() -> bool {
125        true
126    }
127
128    fn fory_is_shared_ref() -> bool {
129        false
130    }
131
132    fn fory_static_type_id() -> TypeId {
133        TypeId::UNKNOWN
134    }
135
136    fn fory_write_type_info(_context: &mut WriteContext) -> Result<(), Error> {
137        // Box<dyn Any> is polymorphic - type info is written per element
138        Ok(())
139    }
140
141    fn fory_read_type_info(_context: &mut ReadContext) -> Result<(), Error> {
142        // Box<dyn Any> is polymorphic - type info is read per element
143        Ok(())
144    }
145
146    fn as_any(&self) -> &dyn Any {
147        &**self
148    }
149}
150
151pub fn write_box_any(
152    value: &dyn Any,
153    context: &mut WriteContext,
154    write_ref_info: bool,
155    write_typeinfo: bool,
156    has_generics: bool,
157) -> Result<(), Error> {
158    if write_ref_info {
159        context.writer.write_i8(RefFlag::NotNullValue as i8);
160    }
161    let concrete_type_id = value.type_id();
162    let typeinfo = if write_typeinfo {
163        context.write_any_typeinfo(TypeId::UNKNOWN as u32, concrete_type_id)?
164    } else {
165        context.get_type_info(&concrete_type_id)?
166    };
167    let serializer_fn = typeinfo.get_harness().get_write_data_fn();
168    serializer_fn(value, context, has_generics)
169}
170
171pub fn read_box_any(
172    context: &mut ReadContext,
173    read_ref_info: bool,
174    read_type_info: bool,
175    type_info: Option<Rc<TypeInfo>>,
176) -> Result<Box<dyn Any>, Error> {
177    context.inc_depth()?;
178    let ref_flag = if read_ref_info {
179        context.reader.read_i8()?
180    } else {
181        RefFlag::NotNullValue as i8
182    };
183    if ref_flag != RefFlag::NotNullValue as i8 {
184        return Err(Error::invalid_data(
185            "Expected NotNullValue for Box<dyn Any>",
186        ));
187    }
188    let typeinfo = if let Some(type_info) = type_info {
189        type_info
190    } else {
191        ensure!(
192            read_type_info,
193            Error::invalid_data("Type info must be read for Box<dyn Any>")
194        );
195        context.read_any_typeinfo()?
196    };
197    let deserializer_fn = typeinfo.get_harness().get_read_data_fn();
198    let result = deserializer_fn(context);
199    context.dec_depth();
200    result
201}
202
203impl ForyDefault for Rc<dyn Any> {
204    fn fory_default() -> Self {
205        Rc::new(())
206    }
207}
208
209impl Serializer for Rc<dyn Any> {
210    fn fory_write(
211        &self,
212        context: &mut WriteContext,
213        write_ref_info: bool,
214        write_type_info: bool,
215        has_generics: bool,
216    ) -> Result<(), Error> {
217        if !write_ref_info
218            || !context
219                .ref_writer
220                .try_write_rc_ref(&mut context.writer, self)
221        {
222            let concrete_type_id: std::any::TypeId = (**self).type_id();
223            let write_data_fn = if write_type_info {
224                let typeinfo =
225                    context.write_any_typeinfo(TypeId::UNKNOWN as u32, concrete_type_id)?;
226                typeinfo.get_harness().get_write_data_fn()
227            } else {
228                context
229                    .get_type_info(&concrete_type_id)?
230                    .get_harness()
231                    .get_write_data_fn()
232            };
233            write_data_fn(&**self, context, has_generics)?;
234        }
235        Ok(())
236    }
237
238    fn fory_write_data(&self, context: &mut WriteContext) -> Result<(), Error> {
239        write_dyn_data_generic(self, context, false)
240    }
241
242    fn fory_write_data_generic(
243        &self,
244        context: &mut WriteContext,
245        has_generics: bool,
246    ) -> Result<(), Error> {
247        write_dyn_data_generic(self, context, has_generics)
248    }
249
250    fn fory_read(
251        context: &mut ReadContext,
252        read_ref_info: bool,
253        read_type_info: bool,
254    ) -> Result<Self, Error> {
255        read_rc_any(context, read_ref_info, read_type_info, None)
256    }
257
258    fn fory_read_with_type_info(
259        context: &mut ReadContext,
260        read_ref_info: bool,
261        type_info: Rc<TypeInfo>,
262    ) -> Result<Self, Error>
263    where
264        Self: Sized + ForyDefault,
265    {
266        read_rc_any(context, read_ref_info, false, Some(type_info))
267    }
268
269    fn fory_read_data(_: &mut ReadContext) -> Result<Self, Error> {
270        Err(Error::not_allowed(format!(
271            "fory_read_data should not be called directly on polymorphic Rc<dyn {}> trait object",
272            stringify!($trait_name)
273        )))
274    }
275
276    fn fory_get_type_id(_: &TypeResolver) -> Result<u32, Error> {
277        Err(Error::type_error(
278            "Rc<dyn Any> has no static type ID - use fory_type_id_dyn",
279        ))
280    }
281
282    fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
283        let concrete_type_id = (**self).type_id();
284        type_resolver
285            .get_fory_type_id(concrete_type_id)
286            .ok_or_else(|| Error::type_error("Type not registered"))
287    }
288
289    fn fory_concrete_type_id(&self) -> std::any::TypeId {
290        (**self).type_id()
291    }
292
293    fn fory_is_shared_ref() -> bool {
294        true
295    }
296
297    fn fory_is_polymorphic() -> bool {
298        true
299    }
300
301    fn fory_static_type_id() -> TypeId {
302        TypeId::UNKNOWN
303    }
304
305    fn fory_write_type_info(_context: &mut WriteContext) -> Result<(), Error> {
306        // Rc<dyn Any> is polymorphic - type info is written per element
307        Ok(())
308    }
309
310    fn fory_read_type_info(_context: &mut ReadContext) -> Result<(), Error> {
311        // Rc<dyn Any> is polymorphic - type info is read per element
312        Ok(())
313    }
314
315    fn as_any(&self) -> &dyn Any {
316        &**self
317    }
318}
319
320pub fn read_rc_any(
321    context: &mut ReadContext,
322    read_ref_info: bool,
323    read_type_info: bool,
324    type_info: Option<Rc<TypeInfo>>,
325) -> Result<Rc<dyn Any>, Error> {
326    let ref_flag = if read_ref_info {
327        context.ref_reader.read_ref_flag(&mut context.reader)?
328    } else {
329        RefFlag::NotNullValue
330    };
331    match ref_flag {
332        RefFlag::Null => Err(Error::invalid_ref("Rc<dyn Any> cannot be null")),
333        RefFlag::Ref => {
334            let ref_id = context.ref_reader.read_ref_id(&mut context.reader)?;
335            context
336                .ref_reader
337                .get_rc_ref::<dyn Any>(ref_id)
338                .ok_or_else(|| {
339                    Error::invalid_data(format!("Rc<dyn Any> reference {} not found", ref_id))
340                })
341        }
342        RefFlag::NotNullValue => {
343            context.inc_depth()?;
344            let typeinfo = if read_type_info {
345                context.read_any_typeinfo()?
346            } else {
347                type_info.ok_or_else(|| Error::type_error("No type info found for read"))?
348            };
349            let read_data_fn = typeinfo.get_harness().get_read_data_fn();
350            let boxed = read_data_fn(context)?;
351            context.dec_depth();
352            Ok(Rc::<dyn Any>::from(boxed))
353        }
354        RefFlag::RefValue => {
355            context.inc_depth()?;
356            let typeinfo = if read_type_info {
357                context.read_any_typeinfo()?
358            } else {
359                type_info.ok_or_else(|| Error::type_error("No type info found for read"))?
360            };
361            let read_data_fn = typeinfo.get_harness().get_read_data_fn();
362            let boxed = read_data_fn(context)?;
363            context.dec_depth();
364            let rc: Rc<dyn Any> = Rc::from(boxed);
365            context.ref_reader.store_rc_ref(rc.clone());
366            Ok(rc)
367        }
368    }
369}
370
371impl ForyDefault for Arc<dyn Any> {
372    fn fory_default() -> Self {
373        Arc::new(())
374    }
375}
376
377impl Serializer for Arc<dyn Any> {
378    fn fory_write(
379        &self,
380        context: &mut WriteContext,
381        write_ref_info: bool,
382        write_type_info: bool,
383        has_generics: bool,
384    ) -> Result<(), Error> {
385        if !write_ref_info
386            || !context
387                .ref_writer
388                .try_write_arc_ref(&mut context.writer, self)
389        {
390            let concrete_type_id: std::any::TypeId = (**self).type_id();
391            if write_type_info {
392                let typeinfo =
393                    context.write_any_typeinfo(TypeId::UNKNOWN as u32, concrete_type_id)?;
394                let serializer_fn = typeinfo.get_harness().get_write_data_fn();
395                serializer_fn(&**self, context, has_generics)?;
396            } else {
397                let serializer_fn = context
398                    .get_type_info(&concrete_type_id)?
399                    .get_harness()
400                    .get_write_data_fn();
401                serializer_fn(&**self, context, has_generics)?;
402            }
403        }
404        Ok(())
405    }
406
407    fn fory_write_data(&self, context: &mut WriteContext) -> Result<(), Error> {
408        write_dyn_data_generic(self, context, false)
409    }
410
411    fn fory_write_data_generic(
412        &self,
413        context: &mut WriteContext,
414        has_generics: bool,
415    ) -> Result<(), Error> {
416        write_dyn_data_generic(self, context, has_generics)
417    }
418
419    fn fory_read(
420        context: &mut ReadContext,
421        read_ref_info: bool,
422        read_type_info: bool,
423    ) -> Result<Self, Error> {
424        read_arc_any(context, read_ref_info, read_type_info, None)
425    }
426
427    fn fory_read_with_type_info(
428        context: &mut ReadContext,
429        read_ref_info: bool,
430        type_info: Rc<TypeInfo>,
431    ) -> Result<Self, Error>
432    where
433        Self: Sized + ForyDefault,
434    {
435        read_arc_any(context, read_ref_info, false, Some(type_info))
436    }
437
438    fn fory_read_data(_: &mut ReadContext) -> Result<Self, Error> {
439        Err(Error::not_allowed(format!(
440            "fory_read_data should not be called directly on polymorphic Rc<dyn {}> trait object",
441            stringify!($trait_name)
442        )))
443    }
444
445    fn fory_get_type_id(_type_resolver: &TypeResolver) -> Result<u32, Error> {
446        Err(Error::type_error(
447            "Arc<dyn Any> has no static type ID - use fory_type_id_dyn",
448        ))
449    }
450
451    fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<u32, Error> {
452        let concrete_type_id = (**self).type_id();
453        type_resolver
454            .get_fory_type_id(concrete_type_id)
455            .ok_or_else(|| Error::type_error("Type not registered"))
456    }
457
458    fn fory_concrete_type_id(&self) -> std::any::TypeId {
459        (**self).type_id()
460    }
461
462    fn fory_is_polymorphic() -> bool {
463        true
464    }
465
466    fn fory_is_shared_ref() -> bool {
467        true
468    }
469
470    fn fory_static_type_id() -> TypeId {
471        TypeId::UNKNOWN
472    }
473
474    fn fory_write_type_info(_context: &mut WriteContext) -> Result<(), Error> {
475        // Arc<dyn Any> is polymorphic - type info is written per element
476        Ok(())
477    }
478
479    fn fory_read_type_info(_context: &mut ReadContext) -> Result<(), Error> {
480        // Arc<dyn Any> is polymorphic - type info is read per element
481        Ok(())
482    }
483
484    fn as_any(&self) -> &dyn Any {
485        &**self
486    }
487}
488
489pub fn read_arc_any(
490    context: &mut ReadContext,
491    read_ref_info: bool,
492    read_type_info: bool,
493    type_info: Option<Rc<TypeInfo>>,
494) -> Result<Arc<dyn Any>, Error> {
495    let ref_flag = if read_ref_info {
496        context.ref_reader.read_ref_flag(&mut context.reader)?
497    } else {
498        RefFlag::NotNullValue
499    };
500    match ref_flag {
501        RefFlag::Null => Err(Error::invalid_ref("Arc<dyn Any> cannot be null")),
502        RefFlag::Ref => {
503            let ref_id = context.ref_reader.read_ref_id(&mut context.reader)?;
504            context
505                .ref_reader
506                .get_arc_ref::<dyn Any>(ref_id)
507                .ok_or_else(|| {
508                    Error::invalid_data(format!("Arc<dyn Any> reference {} not found", ref_id))
509                })
510        }
511        RefFlag::NotNullValue => {
512            context.inc_depth()?;
513            let typeinfo = if read_type_info {
514                context.read_any_typeinfo()?
515            } else {
516                type_info
517                    .ok_or_else(|| Error::type_error("No type info found for read Arc<dyn Any>"))?
518            };
519            let read_data_fn = typeinfo.get_harness().get_read_data_fn();
520            let boxed = read_data_fn(context)?;
521            context.dec_depth();
522            Ok(Arc::<dyn Any>::from(boxed))
523        }
524        RefFlag::RefValue => {
525            context.inc_depth()?;
526            let typeinfo = if read_type_info {
527                context.read_any_typeinfo()?
528            } else {
529                type_info
530                    .ok_or_else(|| Error::type_error("No type info found for read Arc<dyn Any>"))?
531            };
532            let read_data_fn = typeinfo.get_harness().get_read_data_fn();
533            let boxed = read_data_fn(context)?;
534            context.dec_depth();
535            let arc: Arc<dyn Any> = Arc::from(boxed);
536            context.ref_reader.store_arc_ref(arc.clone());
537            Ok(arc)
538        }
539    }
540}
fory_core/serializer/any.rs

fory_core/serializer/
any.rs
