Struct Storage 

pub struct Storage { /* private fields */ }

Handles file system paths for reading from and writing to data storage.

The Storage struct provides a way to manage file paths used for storing data in different locations. It simplifies the process of accessing and modifying data by providing methods for these operations.

Example

use rusty_store::{Storage, StoreHandle, Storing};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Default, Storing)]
pub struct MyStore {
    pub count: u32,
}

impl MyStore {
    fn increment_count(&mut self) {
        self.count += 1;
    }
}


// Initialize the Storage with the defaults
let storage = Storage::new("APP_ID");

// Create a handle for managing the store data.
let mut handle = StoreHandle::<MyStore>::new("my_store_id");

// Read existing store from storage
storage
    .read(&mut handle)
    .expect("Failed to read from storage");

// Modify the store data
let counter = handle.get_store_mut();

counter.increment_count();
counter.increment_count();
counter.increment_count();

// Write changes to disk
storage
    .write(&mut handle)
    .expect("Failed to write to storage");

let counter = handle.get_store();

println!("Count: {}", counter.count);

Implementations

impl Storage

pub fn cache_dir(&self) -> &Path

Get the cache directory

pub fn data_dir(&self) -> &Path

Get the data directory

pub fn config_dir(&self) -> &Path

Get the config directory

pub fn new(app_id: &str) -> Self

Creates a new Storage instance by obtaining the paths for cache, data, and configuration directories.

Panics

• Panics if the cache directory, data directory, or configuration directory path cannot be determined.

Examples found in repository

examples/minimal/main.rs (line 21)

fn main() {
    // Initialize the Storage and create a new manager
    let mut counter: StoreManager<MyStore> = Storage::new("com.github.mazynoah.storage")
        .new_manager("manager")
        .expect("Failed to create StoreManager");

    counter
        .increment_count()
        .expect("Could not increment count");

    println!("Count: {}", counter.get_store().count);
}

examples/manager_trait/main.rs (line 21)

fn main() {
    // Initialize the Storage with the defaults
    let storage = Storage::new("com.github.mazynoah.storage");

    // Use `StoreManager` to manage the store.
    let mut manager =
        StoreManager::new(&storage, "manager_trait").expect("Failed to create StoreManager");

    // Modify and save the data using `StoreManager`.
    manager
        .increment_count()
        .expect("Failed to increment count");

    let counter = manager.get_store();

    println!("Count: {}", counter.count);
}

examples/manager_uncommitted/main.rs (line 21)

fn main() {
    // Initialize the Storage with the defaults
    let storage = Storage::new("com.github.mazynoah.storage");

    // Use `StoreManager` to manage the store.
    let mut manager =
        StoreManager::new(&storage, "manager_uncommitted").expect("Failed to create StoreManager");

    // Modify the data without saving the changes to disk.
    manager.increment_count();
    manager.increment_count();
    manager.increment_count();

    // Save the data to the storage
    manager.save().expect("Failed to save count to storage");

    let counter = manager.get_store();

    println!("Count: {}", counter.count);
}

examples/handle/main.rs (line 17)

fn main() {
    // Initialize the Storage with the defaults
    let storage = Storage::new("com.github.mazynoah.storage");

    // Create a handle for managing the store data.
    let mut handle = StoreHandle::<MyStore>::new("handle");

    // Read existing store from storage
    storage
        .read(&mut handle)
        .expect("Failed to read from storage");

    // Modify the store data
    let counter = handle.get_store_mut();

    counter.increment_count();
    counter.increment_count();
    counter.increment_count();

    // Write changes to disk
    storage
        .write(&mut handle)
        .expect("Failed to write to storage");

    let counter = handle.get_store();

    println!("Count: {}", counter.count);
}

examples/manager/main.rs (line 17)

fn main() {
    // Initialize the Storage with the defaults
    let storage = Storage::new("com.github.mazynoah.storage");

    // Create a StoreManager for managing the store data
    let mut counter_manager = storage
        .new_manager::<MyStore>("manager")
        .expect("Failed to create StoreManager");

    // Alternatively:
    let mut counter_manager =
        StoreManager::<MyStore>::new(&storage, "manager").expect("Failed to create StoreManager");

    // Get a mutable reference to the store
    let counter = counter_manager.get_store_mut();

    counter.count = 75;
    counter.increment_count();

    // Save the data to the storage
    counter_manager
        .save()
        .expect("Failed to save count to storage");

    let counter = counter_manager.get_store();

    println!("Count: {}", counter.count);
}

examples/custom_location/main.rs (line 23)

fn main() {
    // Initialize the Storage with the defaults
    let storage = Storage::new("com.github.mazynoah.storage");

    // Create a StoreManager for managing the store data
    let mut counter_manager = storage
        .new_manager::<MyStore>("custom_location")
        .expect("Failed to create StoreManager");

    // Alternatively:
    let mut counter_manager = StoreManager::<MyStore>::new(&storage, "custom_location")
        .expect("Failed to create StoreManager");

    // Get a mutable reference to the store
    let counter = counter_manager.get_store_mut();

    counter.count = 75;
    counter.increment_count();

    // Save the data to the storage
    counter_manager
        .save()
        .expect("Failed to save count to storage");

    let counter = counter_manager.get_store();

    println!("Count: {}", counter.count);
}

pub fn from_dirs( cache_dir: PathBuf, data_dir: PathBuf, config_dir: PathBuf, ) -> Self

Creates a new Storage instance with specific cache, data, and config paths.

Arguments

• cache_dir - A PathBuf representing the cache directory path.
• data_dir - A PathBuf representing the data directory path.
• config_dir - A PathBuf representing the configuration directory path.

Returns

A new Storage instance with the specified cache, data, and config paths.

Example

use std::path::PathBuf;
use rusty_store::Storage;

let cache_dir = PathBuf::from("/path/to/cache");
let data_dir = PathBuf::from("/path/to/data");
let config_dir = PathBuf::from("/path/to/config");

let storage = Storage::from_dirs(cache_dir, data_dir, config_dir);

pub fn new_manager<T: Storing>( &self, store_id: &str, ) -> Result<StoreManager<T>, StoreError>

Returns a new StoreManager of type T with the given store_id

Examples found in repository

examples/minimal/main.rs (line 22)

fn main() {
    // Initialize the Storage and create a new manager
    let mut counter: StoreManager<MyStore> = Storage::new("com.github.mazynoah.storage")
        .new_manager("manager")
        .expect("Failed to create StoreManager");

    counter
        .increment_count()
        .expect("Could not increment count");

    println!("Count: {}", counter.get_store().count);
}

examples/manager/main.rs (line 21)

fn main() {
    // Initialize the Storage with the defaults
    let storage = Storage::new("com.github.mazynoah.storage");

    // Create a StoreManager for managing the store data
    let mut counter_manager = storage
        .new_manager::<MyStore>("manager")
        .expect("Failed to create StoreManager");

    // Alternatively:
    let mut counter_manager =
        StoreManager::<MyStore>::new(&storage, "manager").expect("Failed to create StoreManager");

    // Get a mutable reference to the store
    let counter = counter_manager.get_store_mut();

    counter.count = 75;
    counter.increment_count();

    // Save the data to the storage
    counter_manager
        .save()
        .expect("Failed to save count to storage");

    let counter = counter_manager.get_store();

    println!("Count: {}", counter.count);
}

examples/custom_location/main.rs (line 27)

fn main() {
    // Initialize the Storage with the defaults
    let storage = Storage::new("com.github.mazynoah.storage");

    // Create a StoreManager for managing the store data
    let mut counter_manager = storage
        .new_manager::<MyStore>("custom_location")
        .expect("Failed to create StoreManager");

    // Alternatively:
    let mut counter_manager = StoreManager::<MyStore>::new(&storage, "custom_location")
        .expect("Failed to create StoreManager");

    // Get a mutable reference to the store
    let counter = counter_manager.get_store_mut();

    counter.count = 75;
    counter.increment_count();

    // Save the data to the storage
    counter_manager
        .save()
        .expect("Failed to save count to storage");

    let counter = counter_manager.get_store();

    println!("Count: {}", counter.count);
}

pub fn new_handle<T: Storing>(&self, store_id: &str) -> StoreHandle<T>

Returns a new Handle of type T with the given store_id

pub fn read<T: Storing>( &self, handle: &mut StoreHandle<T>, ) -> Result<(), StoreError>

Reads the store from a file and updates the provided StoreHandle. If the file does not exist, it creates a default store if a default is available.

Example

use rusty_store::{Storage, StoreHandle, Storing};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Default, Storing)]
pub struct MyStore {
    pub count: u32,
}

impl MyStore {
    fn increment_count(&mut self) {
        self.count += 1;
    }
}

let storage = Storage::new("APP_ID");
let mut handle: StoreHandle<MyStore> = StoreHandle::new("my_store_id");

storage.read(&mut handle).expect("Failed to read store");

Examples found in repository

examples/handle/main.rs (line 24)

fn main() {
    // Initialize the Storage with the defaults
    let storage = Storage::new("com.github.mazynoah.storage");

    // Create a handle for managing the store data.
    let mut handle = StoreHandle::<MyStore>::new("handle");

    // Read existing store from storage
    storage
        .read(&mut handle)
        .expect("Failed to read from storage");

    // Modify the store data
    let counter = handle.get_store_mut();

    counter.increment_count();
    counter.increment_count();
    counter.increment_count();

    // Write changes to disk
    storage
        .write(&mut handle)
        .expect("Failed to write to storage");

    let counter = handle.get_store();

    println!("Count: {}", counter.count);
}

pub fn write<T: Storing>( &self, handle: &mut StoreHandle<T>, ) -> Result<(), StoreError>

Writes the current store T from the provided StoreHandle to a file. If the file does not exist, it creates a default store if a default is available.

Example

use rusty_store::{Storage, StoreHandle, Storing};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Default, Storing)]
pub struct MyStore {
    pub count: u32,
}

impl MyStore {
    fn increment_count(&mut self) {
        self.count += 1;
    }
}

let storage = Storage::new("APP_ID");
let mut handle: StoreHandle<MyStore> = StoreHandle::new("my_store_id");

storage.write(&mut handle).expect("Failed to read store");

Examples found in repository

examples/handle/main.rs (line 36)

fn main() {
    // Initialize the Storage with the defaults
    let storage = Storage::new("com.github.mazynoah.storage");

    // Create a handle for managing the store data.
    let mut handle = StoreHandle::<MyStore>::new("handle");

    // Read existing store from storage
    storage
        .read(&mut handle)
        .expect("Failed to read from storage");

    // Modify the store data
    let counter = handle.get_store_mut();

    counter.increment_count();
    counter.increment_count();
    counter.increment_count();

    // Write changes to disk
    storage
        .write(&mut handle)
        .expect("Failed to write to storage");

    let counter = handle.get_store();

    println!("Count: {}", counter.count);
}

Trait Implementations

impl Clone for Storage

fn clone(&self) -> Storage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Storage

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Storage

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Storage

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

where __S: Serializer,

Serialize this value into the given Serde serializer.