Struct VersionedHash 

pub struct VersionedHash<T: Hash, P: PathType + ?Sized = Path, H: Hasher + Default = DefaultHasher> { /* private fields */ }

A value with a hash to determine if it has changed.

You can use any hasher that implements std::hash::Hasher and std::default::Default. By default, it uses std::collections::hash_map::DefaultHasher.

To access the inner value, you can use Deref / DerefMut or the into_inner method.

Examples

use std::path::PathBuf;
use dir_structure::versioned_hash::VersionedHash;

let mut vh = VersionedHash::<String>::new_clean(PathBuf::from("test.txt"), "Hello, world!".to_owned());
assert!(vh.is_clean());

vh.push_str(" Modified.");
assert!(vh.is_dirty());
assert!(!vh.is_clean());

Implementations

impl<T: Hash, P: PathType + ?Sized, H: Hasher + Default> VersionedHash<T, P, H>

pub fn into_inner(self) -> T

Get the inner value. You can also use Deref / DerefMut to get references to the inner value.

Examples

use std::path::PathBuf;
use dir_structure::versioned_hash::VersionedHash;

let vh = VersionedHash::<String>::new_clean(PathBuf::from("test.txt"), "Hello, world!".to_owned());
assert_eq!(vh.into_inner(), "Hello, world!".to_owned());

let vh = VersionedHash::<String>::new_dirty(PathBuf::from("test.txt"), "Hello, world!".to_owned());
assert_eq!(vh.into_inner(), "Hello, world!".to_owned());

pub fn new_clean(path: P::OwnedPath, value: T) -> Self

Create a new clean value.

Examples

use std::path::PathBuf;
use dir_structure::versioned_hash::VersionedHash;

let vh = VersionedHash::<String>::new_clean(PathBuf::from("test.txt"), "Hello, world!".to_owned());
assert!(vh.is_clean());
assert!(!vh.is_dirty());

pub fn new_dirty(path: P::OwnedPath, value: T) -> Self

Create a new dirty value.

Examples

use std::path::PathBuf;
use dir_structure::versioned_hash::VersionedHash;

let vh = VersionedHash::<String>::new_dirty(PathBuf::from("test.txt"), "Hello, world!".to_owned());
assert!(!vh.is_clean());
assert!(vh.is_dirty());

pub fn is_clean(&self) -> bool

Checks if the value has been modified since being read. Returns true if the value is clean (i.e., has not been modified). Returns false if the value is dirty (i.e., has been modified).

Examples

use std::path::PathBuf;
use dir_structure::versioned_hash::VersionedHash;

let vh = VersionedHash::<String>::new_clean(PathBuf::from("test.txt"), "Hello, world!".to_owned());
assert!(vh.is_clean());

let vh = VersionedHash::<String>::new_dirty(PathBuf::from("test.txt"), "Hello, world!".to_owned());
assert!(!vh.is_clean());

pub fn is_dirty(&self) -> bool

Checks if the value has been modified since being read. Returns true if the value is dirty (i.e., has been modified). Returns false if the value is clean (i.e., has not been modified).

Examples

use std::path::PathBuf;
use dir_structure::versioned_hash::VersionedHash;

let vh = VersionedHash::<String>::new_clean(PathBuf::from("test.txt"), "Hello, world!".to_owned());
assert!(!vh.is_dirty());

let vh = VersionedHash::<String>::new_dirty(PathBuf::from("test.txt"), "Hello, world!".to_owned());
assert!(vh.is_dirty());

pub unsafe fn reset(&mut self)

Resets the hash to the current value’s hash.

Safety

This function is unsafe because it can lead to changes not being written if the value has changed. Ideally this function should only be called after writing the value to disk.

Examples

use std::path::PathBuf;
use dir_structure::versioned_hash::VersionedHash;

let mut vh = VersionedHash::<String>::new_clean(PathBuf::from("test.txt"), "Hello, world!".to_owned());
assert!(vh.is_clean());

vh.push_str(" Modified.");
assert!(vh.is_dirty());
assert!(!vh.is_clean());

unsafe {
  vh.reset();
}
assert!(vh.is_clean());
assert!(!vh.is_dirty());

Trait Implementations

impl<T, P: PathType + ?Sized, H: Hasher + Default> AssertEq for VersionedHash<T, P, H>

where for<'__trivial> T: AssertEq<T> + Debug + Hash, for<'__trivial> u64: AssertEq<u64> + Debug, for<'__trivial> P::OwnedPath: AssertEq<P::OwnedPath> + Debug, for<'__trivial> PhantomData<H>: AssertEq<PhantomData<H>> + 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<T: Hash, P: PathType + ?Sized, H: Hasher + Default> Deref for VersionedHash<T, P, H>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Hash, P: PathType + ?Sized, H: Hasher + Default> DerefMut for VersionedHash<T, P, H>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, T, H, Vfs: Vfs<'a>> ReadFrom<'a, Vfs> for VersionedHash<T, Vfs::Path, H>

where T: ReadFrom<'a, Vfs> + Hash + 'a, H: Hasher + Default + 'a,

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

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

impl<'a, T, H, Vfs: VfsAsync + 'a> ReadFromAsync<'a, Vfs> for VersionedHash<T, Vfs::Path, H>

where T: ReadFromAsync<'a, Vfs> + Hash + 'a, H: Hasher + Default + 'a,

Available on crate feature async only.

type Future = Pin<Box<dyn Future<Output = Result<VersionedHash<T, <Vfs as VfsCore>::Path, H>, 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: <<Vfs as VfsCore>::Path as PathType>::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, H, Vfs: WriteSupportingVfs<'a>> WriteTo<'a, Vfs> for VersionedHash<T, Vfs::Path, H>

where T: WriteTo<'a, Vfs> + Hash, Vfs::Path: PartialEq, H: Hasher + Default,

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

Writes the structure to the specified path.

impl<'a, T, P, H, Vfs: WriteSupportingVfsAsync<Path = P> + 'a> WriteToAsync<'a, Vfs> for VersionedHash<T, P, H>

where T: WriteToAsync<'a, Vfs> + Hash + 'a, P: PathType + ?Sized + PartialEq + 'a, H: Hasher + Default + 'a,

Available on crate feature async only.

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

The future type returned by the async write function.

fn write_to_async( self, path: <<Vfs as VfsCore>::Path as PathType>::OwnedPath, vfs: Pin<&'a Vfs>, ) -> Self::Future

Asynchronously writes the structure to the specified path.

impl<'a, T, H, Vfs: WriteSupportingVfsAsync + 'a> WriteToAsyncRef<'a, Vfs> for VersionedHash<T, Vfs::Path, H>

where T: WriteToAsyncRef<'a, Vfs> + Hash + 'a, H: Hasher + Default + 'a,

Available on crate feature async only.

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

The future type returned by the async write function.

fn write_to_async_ref<'f>( &'f self, path: <<Vfs as VfsCore>::Path as PathType>::OwnedPath, vfs: Pin<&'f Vfs>, ) -> Self::Future<'f>

where 'a: 'f,

Asynchronously writes the structure to the specified path.