Struct FilesystemSource

pub struct FilesystemSource { /* private fields */ }

A Source that loads packages from the filesystem. This is a good source to use for development, or if you don’t care about packaging your data files into an archive.

Implementations

impl FilesystemSource

pub fn new(directory: &str, trust: TrustLevel) -> FilesystemSource

Creates a new FilesystemSource using the given directory to look for packages in

Examples found in repository

examples/basic.rs (line 44)

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!("");
    }
}

Trait Implementations

impl Source for FilesystemSource

fn get_uri(&self) -> &str

The path that this Source originates from. Only used for debug purposes.

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

Returns true if the Source has a package of the given name, otherwise returns false

fn list_packages(&mut self) -> Vec<String>

Returns a list of all packages available in this Source. Do not call this repeatedly!

fn read_file<'a>( &'a mut self, package_name: &str, pathname: &str, ) -> Result<Box<dyn ReadSeek + 'a>, PackageError>

Returns a Read + Seek for the file at the given pathname, if one exists.

fn write_file<'a>( &'a mut self, package_name: &str, pathname: &str, ) -> Result<Box<dyn Write + 'a>, PackageError>

Returns a Write for the file at the given pathname.

fn iter_entries<'a>( &'a mut self, package_name: &str, type_folder: &str, ) -> Box<dyn Iterator<Item = Result<String, PackageError>> + 'a>

Returns an iterator through the items in a given package, if the Source has said package

fn trust_level(&self, _package_name: &str) -> TrustLevel

Returns the source’s trust level for the given package. Trusted sources are able to load resource types marked as requiring trust.