Struct sppparse::SparseRefRaw

pub struct SparseRefRaw<S: DeserializeOwned + Serialize + SparsableTrait> { /* 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: DeserializeOwned + Serialize + SparsableTrait> SparseRefRaw<S>

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: DeserializeOwned + Serialize + SparsableTrait> 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 + DeserializeOwned + Serialize + SparsableTrait> Clone for SparseRefRaw<S>

pub 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 + DeserializeOwned + Serialize + SparsableTrait> Debug for SparseRefRaw<S>

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

Formats the value using the given formatter.

impl<'de, S: DeserializeOwned + Serialize + SparsableTrait> Deserialize<'de> for SparseRefRaw<S> where
    S: DeserializeOwned + Serialize + SparsableTrait, 

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

Deserialize this value from the given Serde deserializer.

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

pub 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, 

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

Initialize recusively a Sparsable pointer

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

Update recusively a Sparsable pointer

pub fn check_depth(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, 

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

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

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

Get the inner value, deserializing the pointed value

pub 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)

pub 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