Enum silx_core::utils::RecFiled

pub enum RecFiled<T: Filable> {
    unloaded {
        path: PathBuf,
    },
    partially_loaded {
        path: PathBuf,
        data: T,
    },
}

Recursive filed data type

• T: Filable : Partially unfiled data type associated to the filed data type
  • This partially unfiled data type is not an unfiled data type
  • Indeed, the unloading process is recursive for this structure

Variants

unloaded

Fields

path: PathBuf

File path for serialized data

Unloaded variant

partially_loaded

Fields

path: PathBuf

File path for serialized data

data: T

Partially unfiled data

Partially loaded variant

Implementations

impl<T: Filable> RecFiled<T>

pub fn new_unloaded<P: AsRef<Path>>(path: P) -> Self

Builder for unloaded variant

• path: P : path of serialization file
• P: AsRef<Path> : type of the path
• Output: the variant

pub fn new_partially_loaded<P: AsRef<Path>>(path: P, data: T) -> Self

Builder for partially loaded variant

• path: P : path of serialization file
• data: T : partially unfiled data
• P: AsRef<Path> : type of the path
• Output: the variant

Trait Implementations

impl<T: Clone + Filable> Clone for RecFiled<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Filable> Debug for RecFiled<T>

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

Formats the value using the given formatter.

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

where T: Deserialize<'de> + Filable,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Filable for RecFiled<T>

where T: Filable + Serialize + DeserializeOwned,

type Unfiled = <T as Filable>::Unfiled

Type of the unfiled data type

fn load<P: AsRef<Path>>(&mut self, prefix: P) -> Result<bool, String>

Load all missing data from files; bool indicates if already loaded (false) or not

fn unload(&mut self, opath: Option<&Path>) -> Result<Self::Unfiled, String>

Optionally serialize all data on disk (filed data needs to be fully loaded) while unloading into the associated unfiled data type

fn unwrap(self) -> Result<Self::Unfiled, String>

where Self: Sized,

Unload all data (filed data needs to be fully loaded) into the associated unfiled data type

impl<T> Serialize for RecFiled<T>

where T: Serialize + Filable,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.