Struct dodo::storage::Directory

pub struct Directory { /* fields omitted */ }

Storage backed by a folder.

Locking strategy

This storage locks entries while they are being read or writen to. Thus, readers and writers should be dropped as soon as possible to prevent resource starvation. Note that multiple readers are allowed at once on the same entry, like a RwLock does.

Nothing prevents other programs from tempering with the files while they are locked, as the locks are only advisory locks. This storage will always check for locks before doing anything though.

Errors

All files in the folder are considered part of this storage. Thus, any unexpected event (denied permission, interrupted, ...) in the folder will result in an error.

It is expected that the folder remains valid as long a the storage exists. Tempering with the folder in any way (deleting it, moving it, removing permissions, ...) will result in an error.

Panics

A panic will occur if a file can't be locked or unlocked by this storage.

Methods

impl Directory

pub fn new<P>(path: P) -> Result<Self> where
    P: AsRef<Path>, 

Create a new directory storage, or open it if it already exist. Folders are created recursively if needed.

Examples

use dodo::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let directory = Directory::new(&path)?;
    Ok(())
}

Errors

This will return an error in the following situations :

• Folders didn't exists, and storage wasn't able to create it.
• Path points at a file, not a folder.
• Other IO specific errors (permission denied, invalid path, ...).

Trait Implementations

impl Clone for Directory

fn clone(&self) -> Directory

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Directory

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

Formats the value using the given formatter.

impl Storage for Directory

type Read = File

Reader.

type Write = File

Writer.

type Iterator = Iter

Iterator.

fn new(&mut self) -> Result<(Uuid, Self::Write)>

Create a new entry in this storage, returning his id and a writer.

fn read(&self, entry: Uuid) -> Result<Self::Read>

Provide a reader to an entry, if it exists.

fn write(&mut self, entry: Uuid) -> Result<Self::Write>

Provide a writer to an entry. If it exists, this writer overrides (and truncates) the bytes. If it doesn't exists, a new entry is created.

fn overwrite(&mut self, entry: Uuid) -> Result<Self::Write>

Provide a writer to an entry, only if it exists. This writer override (and truncates) the bytes.

fn delete(&mut self, entry: Uuid) -> Result<()>

Delete an entry.

fn clear(&mut self) -> Result<()>

Empties this storage.

fn iter(&self) -> Result<Self::Iterator>

Provide an iterator listing the entries currently in this storage.