Enum Filed

pub enum Filed<T> {
    unloaded {
        path: PathBuf,
    },
    loaded {
        path: PathBuf,
        data: T,
    },
}

Filed data type

• T : unfiled data type associated to the filed data type

Variants

unloaded

Unloaded variant

Fields

path: PathBuf

File path for serialized data

loaded

Loaded variant

Fields

path: PathBuf

File path for serialized data

data: T

Unfiled data

Implementations

impl<T> Filed<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_loaded<P: AsRef<Path>>(path: P, data: T) -> Self

Builder for loaded variant

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

Trait Implementations

impl<T: Clone> Clone for Filed<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Filed<T>

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

Formats the value using the given formatter.

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

where T: Deserialize<'de>,

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 Filed<T>

where T: Serialize + DeserializeOwned,

type Unfiled = T

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<T, 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 Filed<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.