Struct RcRecursive 

#[repr(transparent)]
pub struct RcRecursive<T>(pub Rc<RefCell<Option<T>>>);

The parent (origin) anchor definition that may have recursive references to it. This type provides the value for the references and must be placed where the original value is defined. Fields that reference this value (possibly recursively) must be wrapped in RcRecursion.

use std::cell::Ref;
use serde::{Deserialize, Serialize};
use serde_saphyr::{RcRecursion, RcRecursive};
#[derive(Deserialize, Serialize)]
struct King {
    name: String,
    coronator: RcRecursion<King>, // who crowned this king
}

#[derive(Deserialize, Serialize)]
struct Kingdom {
    king: RcRecursive<King>,
}
    let yaml = r#"
king: &root
  name: "Aurelian I"
  coronator: *root # this king crowned himself
"#;

let kingdom_data: Kingdom = serde_saphyr::from_str(yaml).unwrap();
    let king: Ref<King> = kingdom_data.king.borrow();
    let coronator = king
        .coronator
        .upgrade().expect("coronator always exists");
    let coronator_name = &coronator.borrow().name;
    assert_eq!(coronator_name, "Aurelian I");

Tuple Fields

0: Rc<RefCell<Option<T>>>

Implementations

impl<T> RcRecursive<T>

pub fn wrapping(x: T) -> Self

Create a new recursive anchor with an initialized value.

pub fn borrow(&self) -> Ref<'_, T>

Borrow the inner value

Trait Implementations

impl<T: Clone> Clone for RcRecursive<T>

fn clone(&self) -> RcRecursive<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for RcRecursive<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default> Default for RcRecursive<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for RcRecursive<T>

type Target = Rc<RefCell<Option<T>>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de, T> Deserialize<'de> for RcRecursive<T>

where T: Deserialize<'de> + 'static,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<&RcRecursive<T>> for RcRecursion<T>

fn from(rca: &RcRecursive<T>) -> Self

Converts to this type from the input type.

impl<T> PartialEq for RcRecursive<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Serialize> Serialize for RcRecursive<T>

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<T> Eq for RcRecursive<T>