Struct DataStore

pub struct DataStore<T: DataObject + 'static> { /* private fields */ }

Storage that allows lookup and access of DataObjects of a given type

Implementations

impl<T: DataObject + 'static> DataStore<T>

pub fn new(source_manager: Rc<RefCell<SourceManager>>) -> DataStore<T>

Constructs a new DataStore that gets its Sources from the given SourceManager

Examples found in repository

examples/basic.rs (line 61)

fn main()
{
    println!("Listing items in mypackage/text:");
    
    let mut source = FilesystemSource::new("examples", TrustLevel::TrustedSource);
    let iter = source.iter_entries("mypackage", "text");
    
    for entry in iter
    {
        match entry
        {
            Ok(pathname) => println!("{}", pathname),
            Err(error) => println!("Error: {}", error)
        }
    }
    
    println!("Loading files from mypackage/text...");
    
    let source_manager = Rc::new(RefCell::new(SourceManager::new()));
    source_manager.borrow_mut().add_source(Box::new(source));
    
    let mut store = DataStore::<TextData>::new(source_manager);
    
    store.load_package("mypackage").expect("Failed to load package.");
    
    for name in &["emoji.txt", "missingfile.txt", "loremipsum.txt"]
    {
        match store.get_id("mypackage", name)
        {
            Ok(id) =>
            {
                println!("Contents of {}:", name);
                match store.get(id)
                {
                    Some(data) => println!("{}", data.text),
                    None => println!("(not found)"),
                }
            }
            Err(error) =>
            {
                println!("Error for {}:\n{}", name, error);
            }
        }
        
        println!("");
    }
}

pub fn load_package( &mut self, package_name: &str, ) -> Result<DataStoreOk, DataError>

Loads the package by the given name if it is not already loaded.

Examples found in repository

examples/basic.rs (line 63)

fn main()
{
    println!("Listing items in mypackage/text:");
    
    let mut source = FilesystemSource::new("examples", TrustLevel::TrustedSource);
    let iter = source.iter_entries("mypackage", "text");
    
    for entry in iter
    {
        match entry
        {
            Ok(pathname) => println!("{}", pathname),
            Err(error) => println!("Error: {}", error)
        }
    }
    
    println!("Loading files from mypackage/text...");
    
    let source_manager = Rc::new(RefCell::new(SourceManager::new()));
    source_manager.borrow_mut().add_source(Box::new(source));
    
    let mut store = DataStore::<TextData>::new(source_manager);
    
    store.load_package("mypackage").expect("Failed to load package.");
    
    for name in &["emoji.txt", "missingfile.txt", "loremipsum.txt"]
    {
        match store.get_id("mypackage", name)
        {
            Ok(id) =>
            {
                println!("Contents of {}:", name);
                match store.get(id)
                {
                    Some(data) => println!("{}", data.text),
                    None => println!("(not found)"),
                }
            }
            Err(error) =>
            {
                println!("Error for {}:\n{}", name, error);
            }
        }
        
        println!("");
    }
}

pub fn get_id( &self, package_name: &str, pathname: &str, ) -> Result<DataId<T>, DataError>

Gets the numeric ID of the DataObject from the given package at the given pathname.

Examples found in repository

examples/basic.rs (line 67)

fn main()
{
    println!("Listing items in mypackage/text:");
    
    let mut source = FilesystemSource::new("examples", TrustLevel::TrustedSource);
    let iter = source.iter_entries("mypackage", "text");
    
    for entry in iter
    {
        match entry
        {
            Ok(pathname) => println!("{}", pathname),
            Err(error) => println!("Error: {}", error)
        }
    }
    
    println!("Loading files from mypackage/text...");
    
    let source_manager = Rc::new(RefCell::new(SourceManager::new()));
    source_manager.borrow_mut().add_source(Box::new(source));
    
    let mut store = DataStore::<TextData>::new(source_manager);
    
    store.load_package("mypackage").expect("Failed to load package.");
    
    for name in &["emoji.txt", "missingfile.txt", "loremipsum.txt"]
    {
        match store.get_id("mypackage", name)
        {
            Ok(id) =>
            {
                println!("Contents of {}:", name);
                match store.get(id)
                {
                    Some(data) => println!("{}", data.text),
                    None => println!("(not found)"),
                }
            }
            Err(error) =>
            {
                println!("Error for {}:\n{}", name, error);
            }
        }
        
        println!("");
    }
}

pub fn get_id_mut( &mut self, package_name: &str, pathname: &str, ) -> Result<DataId<T>, DataError>

Gets the numeric ID of the DataObject from the given package at the given pathname. If the package is not loaded, it will be loaded automatically.

pub fn get(&self, id: DataId<T>) -> Option<&T>

Returns a reference to the DataObject by the given DataId, if one exists. Otherwise returns None.

Examples found in repository

examples/basic.rs (line 72)

fn main()
{
    println!("Listing items in mypackage/text:");
    
    let mut source = FilesystemSource::new("examples", TrustLevel::TrustedSource);
    let iter = source.iter_entries("mypackage", "text");
    
    for entry in iter
    {
        match entry
        {
            Ok(pathname) => println!("{}", pathname),
            Err(error) => println!("Error: {}", error)
        }
    }
    
    println!("Loading files from mypackage/text...");
    
    let source_manager = Rc::new(RefCell::new(SourceManager::new()));
    source_manager.borrow_mut().add_source(Box::new(source));
    
    let mut store = DataStore::<TextData>::new(source_manager);
    
    store.load_package("mypackage").expect("Failed to load package.");
    
    for name in &["emoji.txt", "missingfile.txt", "loremipsum.txt"]
    {
        match store.get_id("mypackage", name)
        {
            Ok(id) =>
            {
                println!("Contents of {}:", name);
                match store.get(id)
                {
                    Some(data) => println!("{}", data.text),
                    None => println!("(not found)"),
                }
            }
            Err(error) =>
            {
                println!("Error for {}:\n{}", name, error);
            }
        }
        
        println!("");
    }
}

pub fn get_mut(&mut self, id: DataId<T>) -> Option<&mut T>

Returns a mutable reference to the DataObject by the given DataId, if one exists. Otherwise returns None.

pub fn list_package_contents(&self, package_name: &str) -> Vec<String>

Returns a string list of the names of each DataObject in the given package. The package will need to have been loaded or this will return an empty list. Please do not call this repeatedly.

pub fn unload_package(&mut self, package_name: &str) -> bool

Unloads the given package from memory. Any DataObjects will be dropped, but pathname-id mappings will be retained in memory so that existing references will not be invalidated. Returns true if the package was loaded.

pub fn unload_all(&mut self)

Unloads all packages from memory. Any DataObjects will be dropped, but pathname-id mappings will be retained in memory so that existing references will not be invalidated. Returns true if the package was loaded.

pub fn unload_unused(&mut self)

Unloads all packages that do not have an active PackageUseToken.

pub fn package_loaded(&self, package_name: &str) -> bool

Returns true if the given package is loaded.

pub fn package_use_token( &self, package_name: &str, ) -> Option<PackageUseToken<T>>

Returns a PackageUseToken that can be used to keep the given package from being unloaded automatically.

pub fn save( &mut self, package_name: &str, pathname: &str, source_id: SourceId, ) -> Result<(), DataError>

Saves the indicated item using the Source given by SourceId.

pub fn reprepare(&mut self, id: DataId<T>) -> bool

Marks the DataObject by the given DataId as needing to be “reprepared”. Use this, for example, when data has been changed and it needs to be reflected in a backend via the PreparedStore. Returns true if the data was marked for reprepare, otherwise false.

pub fn reload( &mut self, package_name: &str, pathname: &str, ) -> Result<(), DataError>

Reloads an already-loaded resource by the given name.

pub fn load_direct( &self, package_name: &str, pathname: &str, source_id: SourceId, ) -> Result<T, DataError>

Loads a single DataObject from the given source and returns it. This function does not index, cache, or track the loaded object in any way. Loading the object through here will result in a separate copy in memory even if it was previously loaded through the usual package loading mechanism. For most cases you should use load_package() or get_id_mut() instead.