Struct sppparse::SparseRefRaw

pub struct SparseRefRaw<S> { /* fields omitted */ }

A raw dynamic ref

SparseRefRaw will render the pointed value.

It uses a SparseState to render itself in order to limit the IO calls at a minimum. It will deserialize into the desired type at creation.

If the SparseStateFile used to render the object changes, SparseRefRaw will deserialize it again in order to always be up to date.

Implementations

impl<S> SparseRefRaw<S>

pub fn val(&self) -> &SparsePointedValue<S>

The inner value

pub fn raw_pointer(&self) -> &String

The raw JSON pointer, as it is deserialized

pub fn base_path(&self) -> &PathBuf

The path of the file in which originates this pointer, if any

impl<S> SparseRefRaw<S>

pub fn base_path_mut(&mut self) -> &mut PathBuf

The path of the file in which originates this pointer, if any

impl<S> SparseRefRaw<S> where
    S: DeserializeOwned + Serialize + SparsableTrait, 

pub fn new(raw_pointer: String) -> Self

Trait Implementations

impl<S: Clone> Clone for SparseRefRaw<S>

fn clone(&self) -> SparseRefRaw<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for SparseRefRaw<S>

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

Formats the value using the given formatter.

impl<'de, S> Deserialize<'de> for SparseRefRaw<S>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<S: PartialEq> PartialEq<SparseRefRaw<S>> for SparseRefRaw<S>

fn eq(&self, other: &SparseRefRaw<S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &SparseRefRaw<S>) -> bool

This method tests for !=.

impl<S> Serialize for SparseRefRaw<S>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<S> Sparsable for SparseRefRaw<S> where
    S: DeserializeOwned + Serialize + SparsableTrait, 

fn sparse_init<'a>(
    &mut self,
    state: &mut SparseState,
    metadata: &SparseMetadata,
    depth: u32
) -> Result<(), SparseError>

Initialize recusively a Sparsable pointer

fn sparse_updt<'a>(
    &mut self,
    state: &mut SparseState,
    metadata: &SparseMetadata,
    depth: u32
) -> Result<(), SparseError>

Update recusively a Sparsable pointer

fn check_depth(&self, depth: u32) -> Result<(), SparseError>

Check if the current depth isn't too much. This is the cyclic pointer protection mechanism

impl<S> SparsePointerRaw<S> for SparseRefRaw<S> where
    S: DeserializeOwned + Serialize + SparsableTrait, 

fn check_version(&self, state: &SparseState) -> Result<(), SparseError>

Check that the inner version doesn't mismatch with the SparseState

fn get<'a>(
    &'a self,
    metadata: Option<&'a SparseMetadata>
) -> Result<SparseValue<'a, S>, SparseError>

Get the inner value, deserializing the pointed value

fn get_mut<'a>(
    &'a mut self,
    state_cell: Rc<RefCell<SparseState>>,
    metadata: Option<&'a SparseMetadata>
) -> Result<SparseValueMut<'a, S>, SparseError>

Get the inner value of the pointer (mutable)

fn self_reset<'a>(
    &mut self,
    state: &mut SparseState,
    metadata: &SparseMetadata,
    depth: u32
) -> Result<(), SparseError>

Reset the inner value and parse it again from the state

impl<S> StructuralPartialEq for SparseRefRaw<S>