Struct hoard::checkers::history::last_paths::HoardPaths

pub struct HoardPaths {
    pub timestamp: OffsetDateTime,
    pub piles: PilePaths,
}

An entry for the last time a hoard was processed.

Contains the timestamp of the last operation on this hoard and a mapping of every file in each of its piles to the corresponding path outside of the hoard.

Fields

timestamp: OffsetDateTime

The timestamp of the most recent operation on this Hoard.

piles: PilePaths

A mapping of piles to the most recent path used.

Implementations

impl HoardPaths

pub fn time(&self) -> &OffsetDateTime

Get the timestamp of the last operation on this hoard.

pub fn named_pile(&self, name: &NonEmptyPileName) -> Option<&SystemPath>

Get the entries for a pile by name.

Returns None if the named pile is not found or if the hoard contains an anonymous pile.

pub fn anonymous_pile(&self) -> Option<&SystemPath>

Get the entries for the anonymous pile.

Returns None if the hoard contains named piles.

pub fn enforce_old_and_new_piles_are_same( old: &Self, new: &Self ) -> Result<(), Error>

Logs any inconsistencies and returns an error if any are found.

This check basically returns an error if old != new, but does some extra checking to provided better logged warnings depending on what the mismatch is.

Any mismatch is considered an inconsistency because it may mean that one of the following occurs because of an unexpected change in the system configuration:

• Backing up an empty/non-existent directory unintentionally deletes the current backup.
• Restoring to an unexpected directory causes nothing to change in the intended one.
• Files don’t get backed up or restored because the system configuration did not match a pile’s environment string.

Example

I sometimes run a normal Steam installation on a Linux machine, sometimes the flatpak version. If the flatpak install takes priority over the normal install, the following set of events might occur:

• Install flatpak Steam to try it out.
• Realize I should back up my normal Steam saves so I can restore them to the flatpak locations.
  • Alternatively, I told hoard to do this already and assumed it finished, but a different hoard took longer than expected to back up.
  • Either way, a backup happens after installing flatpak Steam.
• Existing backup is erased so the new one is a clean backup.
• The associated directories for flatpak are empty or don’t exist, so nothing gets backed up.
• My backups are all deleted.

There are ways to recover from this, for example by uninstalling flatpak Steam and doing another backup, but the situation gets more complex when considering multiple devices each synchronizing files to each other. It’s much easier to make this check and, if the changes are intended, have the user indicate as much.

Errors

Error::HoardPathsMismatch if there is a difference between old and new.

Trait Implementations

impl Clone for HoardPaths

fn clone(&self) -> HoardPaths

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HoardPaths

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HoardPaths

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

Deserialize this value from the given Serde deserializer.

impl<T> From<T> for HoardPathswhere T: Into<PilePaths>,

fn from(val: T) -> Self

Converts to this type from the input type.

impl PartialEq for HoardPaths

fn eq(&self, other: &HoardPaths) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for HoardPaths

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

Serialize this value into the given Serde serializer.

impl Eq for HoardPaths

impl StructuralEq for HoardPaths

impl StructuralPartialEq for HoardPaths