fory-core 1.0.0-rc.1

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

//! Serialization support for [`crate::types::weak::RcWeak`] and [`crate::types::weak::ArcWeak`].

use crate::context::{ReadContext, WriteContext};
use crate::error::Error;
use crate::resolver::{RefFlag, RefMode};
use crate::resolver::{TypeInfo, TypeResolver};
use crate::serializer::{ForyDefault, Serializer};
use crate::type_id::TypeId;
use crate::types::{ArcWeak, RcWeak};
use std::rc::Rc;
use std::sync::Arc;

impl<T: Serializer + ForyDefault + 'static> Serializer for RcWeak<T> {
    fn fory_is_shared_ref() -> bool {
        true
    }

    fn fory_write(
        &self,
        context: &mut WriteContext,
        ref_mode: RefMode,
        write_type_info: bool,
        has_generics: bool,
    ) -> Result<(), Error> {
        // Weak pointers require track_ref to be enabled on the Fory instance
        if !context.is_track_ref() {
            return Err(Error::invalid_ref(
                "RcWeak requires track_ref to be enabled. Use Fory::builder().track_ref(true).build()",
            ));
        }
        // Weak MUST use ref tracking - otherwise read value will be lost
        if ref_mode != RefMode::Tracking {
            return Err(Error::invalid_ref(
                "RcWeak requires RefMode::Tracking for serialization",
            ));
        }
        if let Some(rc) = self.upgrade() {
            if !context
                .ref_writer
                .try_write_rc_ref(&mut context.writer, &rc)
            {
                if write_type_info {
                    T::fory_write_type_info(context)?;
                }
                T::fory_write_data_generic(&*rc, context, has_generics)?;
            }
        } else {
            context.writer.write_i8(RefFlag::Null as i8);
        }
        Ok(())
    }

    fn fory_write_data_generic(&self, _: &mut WriteContext, _: bool) -> Result<(), Error> {
        Err(Error::not_allowed(
            "RcWeak<T> should be written using `fory_write` to handle reference tracking properly",
        ))
    }

    fn fory_write_data(&self, _: &mut WriteContext) -> Result<(), Error> {
        Err(Error::not_allowed(
            "RcWeak<T> should be written using `fory_write` to handle reference tracking properly",
        ))
    }

    fn fory_write_type_info(context: &mut WriteContext) -> Result<(), Error> {
        T::fory_write_type_info(context)
    }

    fn fory_read(
        context: &mut ReadContext,
        ref_mode: RefMode,
        read_type_info: bool,
    ) -> Result<Self, Error> {
        // Weak MUST track refs
        debug_assert!(
            ref_mode == RefMode::Tracking,
            "RcWeak requires RefMode::Tracking"
        );
        read_rc_weak::<T>(context, read_type_info, None)
    }

    fn fory_read_with_type_info(
        context: &mut ReadContext,
        ref_mode: RefMode,
        typeinfo: Rc<TypeInfo>,
    ) -> Result<Self, Error> {
        debug_assert!(
            ref_mode == RefMode::Tracking,
            "RcWeak requires RefMode::Tracking"
        );
        read_rc_weak::<T>(context, false, Some(typeinfo))
    }

    fn fory_read_data(_: &mut ReadContext) -> Result<Self, Error> {
        Err(Error::not_allowed("RcWeak<T> should be written using `fory_read/fory_read_with_type_info` to handle reference tracking properly"))
    }

    fn fory_read_type_info(context: &mut ReadContext) -> Result<(), Error> {
        T::fory_read_type_info(context)
    }

    fn fory_reserved_space() -> usize {
        // RcWeak is a shared ref, return a const to avoid infinite recursion
        4
    }

    fn fory_get_type_id(type_resolver: &TypeResolver) -> Result<TypeId, Error> {
        T::fory_get_type_id(type_resolver)
    }

    fn fory_get_type_info(type_resolver: &TypeResolver) -> Result<Rc<TypeInfo>, Error> {
        T::fory_get_type_info(type_resolver)
    }

    fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<TypeId, Error> {
        if let Some(rc) = self.upgrade() {
            (*rc).fory_type_id_dyn(type_resolver)
        } else {
            T::fory_get_type_id(type_resolver)
        }
    }

    fn fory_static_type_id() -> TypeId {
        T::fory_static_type_id()
    }

    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
}

fn read_rc_weak<T: Serializer + ForyDefault + 'static>(
    context: &mut ReadContext,
    read_type_info: bool,
    type_info: Option<Rc<TypeInfo>>,
) -> Result<RcWeak<T>, Error> {
    // Always read ref flag - Weak requires tracking
    let ref_flag = context.ref_reader.read_ref_flag(&mut context.reader)?;
    match ref_flag {
        RefFlag::Null => Ok(RcWeak::new()),
        RefFlag::RefValue => {
            context.inc_depth()?;
            let data = if let Some(type_info) = type_info {
                T::fory_read_with_type_info(context, RefMode::None, type_info)?
            } else {
                if read_type_info {
                    context.read_any_type_info()?;
                }
                T::fory_read_data(context)?
            };
            context.dec_depth();
            let rc = Rc::new(data);
            let ref_id = context.ref_reader.store_rc_ref(rc);
            let rc = context.ref_reader.get_rc_ref::<T>(ref_id).unwrap();
            Ok(RcWeak::from(&rc))
        }
        RefFlag::Ref => {
            let ref_id = context.ref_reader.read_ref_id(&mut context.reader)?;
            if let Some(rc) = context.ref_reader.get_rc_ref::<T>(ref_id) {
                Ok(RcWeak::from(&rc))
            } else {
                let result_weak = RcWeak::new();
                let callback_weak = result_weak.clone();
                context.ref_reader.add_callback(Box::new(move |ref_reader| {
                    if let Some(rc) = ref_reader.get_rc_ref::<T>(ref_id) {
                        callback_weak.update(Rc::downgrade(&rc));
                    }
                }));

                Ok(result_weak)
            }
        }
        RefFlag::NotNullValue => Err(Error::invalid_ref("RcWeak can't hold a strong ref value")),
    }
}

impl<T: ForyDefault> ForyDefault for RcWeak<T> {
    fn fory_default() -> Self {
        RcWeak::new()
    }
}

impl<T: Serializer + ForyDefault + Send + Sync + 'static> Serializer for ArcWeak<T> {
    fn fory_is_shared_ref() -> bool {
        true
    }

    fn fory_write(
        &self,
        context: &mut WriteContext,
        ref_mode: RefMode,
        write_type_info: bool,
        has_generics: bool,
    ) -> Result<(), Error> {
        // Weak pointers require track_ref to be enabled on the Fory instance
        if !context.is_track_ref() {
            return Err(Error::invalid_ref(
                "ArcWeak requires track_ref to be enabled. Use Fory::builder().track_ref(true).build()",
            ));
        }
        // Weak MUST use ref tracking - otherwise read value will be lost
        if ref_mode != RefMode::Tracking {
            return Err(Error::invalid_ref(
                "ArcWeak requires RefMode::Tracking for serialization",
            ));
        }
        if let Some(arc) = self.upgrade() {
            if !context
                .ref_writer
                .try_write_arc_ref(&mut context.writer, &arc)
            {
                if write_type_info {
                    T::fory_write_type_info(context)?;
                }
                T::fory_write_data_generic(&*arc, context, has_generics)?;
            }
        } else {
            context.writer.write_i8(RefFlag::Null as i8);
        }
        Ok(())
    }

    fn fory_write_data_generic(&self, _: &mut WriteContext, _: bool) -> Result<(), Error> {
        Err(Error::not_allowed(
            "ArcWeak<T> should be written using `fory_write` to handle reference tracking properly",
        ))
    }

    fn fory_write_data(&self, _: &mut WriteContext) -> Result<(), Error> {
        Err(Error::not_allowed(
            "ArcWeak<T> should be written using `fory_write` to handle reference tracking properly",
        ))
    }

    fn fory_write_type_info(context: &mut WriteContext) -> Result<(), Error> {
        T::fory_write_type_info(context)
    }

    fn fory_read(
        context: &mut ReadContext,
        ref_mode: RefMode,
        read_type_info: bool,
    ) -> Result<Self, Error> {
        // Weak MUST track refs
        debug_assert!(
            ref_mode == RefMode::Tracking,
            "ArcWeak requires RefMode::Tracking"
        );
        read_arc_weak(context, read_type_info, None)
    }

    fn fory_read_with_type_info(
        context: &mut ReadContext,
        ref_mode: RefMode,
        typeinfo: Rc<TypeInfo>,
    ) -> Result<Self, Error> {
        debug_assert!(
            ref_mode == RefMode::Tracking,
            "ArcWeak requires RefMode::Tracking"
        );
        read_arc_weak::<T>(context, false, Some(typeinfo))
    }

    fn fory_read_data(_: &mut ReadContext) -> Result<Self, Error> {
        Err(Error::not_allowed("ArcWeak<T> should be written using `fory_read/fory_read_with_type_info` to handle reference tracking properly"))
    }

    fn fory_read_type_info(context: &mut ReadContext) -> Result<(), Error> {
        T::fory_read_type_info(context)
    }

    fn fory_reserved_space() -> usize {
        // ArcWeak is a shared ref, return a const to avoid infinite recursion
        4
    }

    fn fory_get_type_id(type_resolver: &TypeResolver) -> Result<TypeId, Error> {
        T::fory_get_type_id(type_resolver)
    }

    fn fory_get_type_info(type_resolver: &TypeResolver) -> Result<Rc<TypeInfo>, Error> {
        T::fory_get_type_info(type_resolver)
    }

    fn fory_type_id_dyn(&self, type_resolver: &TypeResolver) -> Result<TypeId, Error> {
        if let Some(arc) = self.upgrade() {
            (*arc).fory_type_id_dyn(type_resolver)
        } else {
            T::fory_get_type_id(type_resolver)
        }
    }

    fn fory_static_type_id() -> TypeId {
        T::fory_static_type_id()
    }

    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
}

fn read_arc_weak<T: Serializer + ForyDefault + 'static>(
    context: &mut ReadContext,
    read_type_info: bool,
    type_info: Option<Rc<TypeInfo>>,
) -> Result<ArcWeak<T>, Error> {
    // Always read ref flag - Weak requires tracking
    let ref_flag = context.ref_reader.read_ref_flag(&mut context.reader)?;
    match ref_flag {
        RefFlag::Null => Ok(ArcWeak::new()),
        RefFlag::RefValue => {
            context.inc_depth()?;
            let data = if let Some(type_info) = type_info {
                T::fory_read_with_type_info(context, RefMode::None, type_info)?
            } else {
                if read_type_info {
                    context.read_any_type_info()?;
                }
                T::fory_read_data(context)?
            };
            context.dec_depth();
            let arc = Arc::new(data);
            let ref_id = context.ref_reader.store_arc_ref(arc);
            let arc = context.ref_reader.get_arc_ref::<T>(ref_id).unwrap();
            let weak = ArcWeak::from(&arc);
            Ok(weak)
        }
        RefFlag::Ref => {
            let ref_id = context.ref_reader.read_ref_id(&mut context.reader)?;
            let weak = ArcWeak::new();

            if let Some(arc) = context.ref_reader.get_arc_ref::<T>(ref_id) {
                weak.update(Arc::downgrade(&arc));
            } else {
                let callback_weak = weak.clone();
                context.ref_reader.add_callback(Box::new(move |ref_reader| {
                    if let Some(arc) = ref_reader.get_arc_ref::<T>(ref_id) {
                        callback_weak.update(Arc::downgrade(&arc));
                    }
                }));
            }
            Ok(weak)
        }
        RefFlag::NotNullValue => Err(Error::invalid_ref("ArcWeak can't hold a strong ref value")),
    }
}

impl<T: ForyDefault> ForyDefault for ArcWeak<T> {
    fn fory_default() -> Self {
        ArcWeak::new()
    }
}