Struct DeferredRead 

pub struct DeferredRead<'a, T, Vfs: VfsCore = FsVfs, const CHECK_ON_READ: bool = false>(pub <<Vfs as VfsCore>::Path as PathType>::OwnedPath, _, _);

A wrapper that defers the reading of a file until it is actually needed.

The only thing you can do with a DeferredRead is to call DeferredRead::perform_read, which will read the file and return the value.

See the DeferredRead::perform_read method for more details.

For a version that also caches the read value, see DeferredReadOrOwn.

Tuple Fields

0: <<Vfs as VfsCore>::Path as PathType>::OwnedPath

Implementations

impl<'a, const CHECK_ON_READ: bool, T, Vfs: Vfs<'a, Path = P>, P: PathType + ?Sized + 'a> DeferredRead<'a, T, Vfs, CHECK_ON_READ>

where T: ReadFrom<'a, Vfs>,

pub fn perform_read(&self) -> VfsResult<T, Vfs>

Performs the read and returns the value.

If the value changed on disk since the DeferredRead was created, then the new value will be read from disk and returned.

For a cached version see DeferredReadOrOwn.

Examples

use std::path::Path;
use std::pin::Pin;
use dir_structure::traits::sync::DirStructureItem;
use dir_structure::deferred_read::DeferredRead;
use dir_structure::prelude::*;

#[derive(dir_structure::DirStructure)]
struct Dir<'vfs, Vfs: VfsCore> {
    #[dir_structure(path = "f.txt")]
    f: DeferredRead<'vfs, String, Vfs>,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let d = Path::new("dir");

    std::fs::create_dir_all(&d)?;
    std::fs::write(d.join("f.txt"), "Hello, world!")?;

    let dir = Dir::read(&d)?;
    assert_eq!(dir.f.perform_read()?, "Hello, world!");

    std::fs::write(d.join("f.txt"), "Goodbye, world!")?;
    assert_eq!(dir.f.perform_read()?, "Goodbye, world!");

    Ok(())
}

impl<'a, const CHECK_ON_READ: bool, T, Vfs: VfsAsync<Path = P> + 'a, P: PathType + ?Sized + 'a> DeferredRead<'a, T, Vfs, CHECK_ON_READ>

where T: ReadFromAsync<'a, Vfs> + Send + 'static,

pub async fn perform_read_async(&self) -> VfsResult<T, Vfs>

Available on crate feature async only.

Performs the read asynchronously and returns the value.

If the value changed on disk since the DeferredRead was created, then the new value will be read from disk and returned.

For a cached version see DeferredReadOrOwn.

Asynchronous version of DeferredRead::perform_read.

Trait Implementations

impl<'a, T, Vfs: VfsCore, const CHECK_ON_READ: bool> AssertEq for DeferredRead<'a, T, Vfs, CHECK_ON_READ>

where for<'__trivial> <<Vfs as VfsCore>::Path as PathType>::OwnedPath: AssertEq<<<Vfs as VfsCore>::Path as PathType>::OwnedPath> + Debug,

fn assert_eq( &self, other: &Self, path: &mut AssertPath, init_left: &impl Display, init_right: &impl Display, )

Asserts that self is equal to other, panicking if they are not equal.

impl<'a, T: Clone, Vfs: Clone + VfsCore, const CHECK_ON_READ: bool> Clone for DeferredRead<'a, T, Vfs, CHECK_ON_READ>

fn clone(&self) -> DeferredRead<'a, T, Vfs, CHECK_ON_READ>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, const CHECK_ON_READ: bool, T, Vfs: VfsCore<Path = P>, P> Debug for DeferredRead<'a, T, Vfs, CHECK_ON_READ>

where T: Debug, P: PathType + ?Sized, P::OwnedPath: Debug,

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

Formats the value using the given formatter.

impl<const CHECK_ON_READ: bool, T, Vfs: VfsCore> DynamicHasField for DeferredRead<'_, T, Vfs, CHECK_ON_READ>

where T: DynamicHasField,

Available on crate feature resolve-path only.

type Inner = <T as DynamicHasField>::Inner

The type of the field.

fn resolve_path<P: OwnedPathType>(p: P, name: &str) -> P

How to resolve the path for the field, from the path of Self, given the name passed into the resolve_path! macro.

impl<const CHECK_ON_READ: bool, const NAME: [char; 32], T, Vfs: VfsCore> HasField<NAME> for DeferredRead<'_, T, Vfs, CHECK_ON_READ>

where T: HasField<NAME>,

Available on crate feature resolve-path only.

type Inner = <T as HasField<NAME>>::Inner

The type of the field.

fn resolve_path<P: OwnedPathType>(p: P) -> P

How to resolve the path for the field, from the path of Self.

impl<'a, const CHECK_ON_READ: bool, T, Vfs: VfsCore> Hash for DeferredRead<'a, T, Vfs, CHECK_ON_READ>

where T: Hash, <Vfs::Path as PathType>::OwnedPath: Hash,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, const CHECK_ON_READ: bool, T, Vfs: Vfs<'a>> ReadFrom<'a, Vfs> for DeferredRead<'a, T, Vfs, CHECK_ON_READ>

where T: ReadFrom<'a, Vfs>,

fn read_from(path: &Vfs::Path, vfs: Pin<&'a Vfs>) -> VfsResult<Self, Vfs>

where Self: Sized,

Reads the structure from the specified path, which can be either a file or a directory.

impl<'a, const CHECK_ON_READ: bool, T, Vfs: VfsAsync<Path = P> + 'static, P: PathType + ?Sized + 'a> ReadFromAsync<'a, Vfs> for DeferredRead<'a, T, Vfs, CHECK_ON_READ>

where T: Send + ReadFromAsync<'a, Vfs> + 'static,

Available on crate feature async only.

type Future = Pin<Box<dyn Future<Output = Result<DeferredRead<'a, T, Vfs, CHECK_ON_READ>, Error<<<Vfs as VfsCore>::Path as PathType>::OwnedPath>>> + Send + 'a>> where Self: 'a

The future type returned by the async read function.

fn read_from_async(path: P::OwnedPath, vfs: Pin<&'a Vfs>) -> Self::Future

Asynchronously reads the structure from the specified path, which can be either a file or a directory.

impl<'a, 't, const CHECK_ON_READ: bool, T, P: PathType + ?Sized + 'a, SelfVfs: Vfs<'a, Path = P>, TargetVfs: WriteSupportingVfs<'t, Path = P>> WriteTo<'t, TargetVfs> for DeferredRead<'a, T, SelfVfs, CHECK_ON_READ>

where T: ReadFrom<'a, SelfVfs> + WriteTo<'t, TargetVfs>,

fn write_to( &self, path: &P, vfs: Pin<&'t TargetVfs>, ) -> Result<(), P::OwnedPath>

Writes the structure to the specified path.

impl<'f, const CHECK_ON_READ: bool, T, P: PathType + ?Sized + 'f, SelfVfs: VfsAsync<Path = P> + 'f, TargetVfs: WriteSupportingVfsAsync<Path = P> + 'f> WriteToAsync<'f, TargetVfs> for DeferredRead<'f, T, SelfVfs, CHECK_ON_READ>

where T: for<'a> ReadFromAsync<'a, SelfVfs> + for<'a> WriteToAsync<'a, TargetVfs> + Send + 'static, for<'a> <T as ReadFromAsync<'a, SelfVfs>>::Future: Future<Output = VfsResult<T, SelfVfs>> + Unpin + 'a, for<'a> <T as WriteToAsync<'a, TargetVfs>>::Future: Future<Output = VfsResult<(), TargetVfs>> + Unpin + 'a,

Available on crate feature async only.

type Future = DeferredReadWriteFuture<'f, T, P, SelfVfs, TargetVfs>

The future type returned by the async write function.

fn write_to_async( self, path: P::OwnedPath, vfs: Pin<&'f TargetVfs>, ) -> Self::Future

Asynchronously writes the structure to the specified path.

impl<'f, const CHECK_ON_READ: bool, T, P: PathType + ?Sized + 'f, SelfVfs: VfsAsync<Path = P> + 'f, TargetVfs: WriteSupportingVfsAsync<Path = P> + 'f> WriteToAsyncRef<'f, TargetVfs> for DeferredRead<'f, T, SelfVfs, CHECK_ON_READ>

where for<'a> T: ReadFromAsync<'a, SelfVfs> + WriteToAsync<'a, TargetVfs> + Send + 'a, for<'a> <T as ReadFromAsync<'a, SelfVfs>>::Future: Future<Output = VfsResult<T, SelfVfs>> + Unpin + 'a, for<'a> <T as WriteToAsync<'a, TargetVfs>>::Future: Future<Output = VfsResult<(), TargetVfs>> + Unpin + 'a,

Available on crate feature async only.

type Future<'a> = DeferredReadWriteFuture<'a, T, P, SelfVfs, TargetVfs> where Self: 'a, 'f: 'a

The future type returned by the async write function.

fn write_to_async_ref<'a>( &'a self, path: P::OwnedPath, vfs: Pin<&'a TargetVfs>, ) -> Self::Future<'a>

where 'f: 'a,

Asynchronously writes the structure to the specified path.