fast-assets

Easy to use assets manager, that can manage any kind of file by manipulating files as Vec, its made to fit in any software/game/framework.

⚠️ Warning ⚠️

This library is still under development. If you found a missing feature open an issue on GitHub. All unchecked features are planned.

Features

• [X] Search for files
• [X] Index files
• [X] Load assets
• [X] Load compressed assets
• [X] Dependency Checker
• [X] Process-Pass
• [ ] Write files (not compressed only)
• [ ] Streaming assets

Compression Support

• [x] ZIP (.zip)

Load pre-defined index

Used to load files compressed

• [X] From CSV file

Example

rust let mut index = fast_assets::index::Index::new("./", "\\w+\\.rs"); index.add_from_file("index/index.csv"); index.set_csv_separator('/');

csv folder/subfolder/file.txt archives/archive.zip/file.txt

Getting Started

Initialization

```rust // Search all un-compressed files and archives, // using extern index allow to add files compressed, // the manager will automatically manage the decompression let mut index = fastassets::index::Index::new("./", "\w+\.rs"); index.search(); index.addfrom_file("index/index.csv");

// The decompression cache is what will manage your compressed files and their caches. let dc = fastassets::decompressionmanager::DecompressionManager::default();

let mut manager = fast_assets::manager::AssetsManager::new(index, dc); ```

Loading/Unloading a file in memory

Load

```rust // Load a compressed file manager.load("index.json").unwrap(); // Load a not compressed file manager.load("text.csv").unwrap();

// Load a not compressed file using full path manager.load("fr/text.csv").unwrap(); // Load a compressed file using full path manager.load("lang.zip/fr/text.csv").unwrap(); ```

UnLoad

```rust // AssetsManager::unload() need two parameters: // decompression_cache: bool => If the file was compressed and if true it will put the file in the cache. // filename: &str => The file that will be unloaded

// UnLoad and put in cache a compressed file manager.unload("index.json", true); // UnLoad a not compressed file manager.unload("text.csv", false);

// Tips: if you want always keep in cache, set always at true, // it will have no impact on the unloading of a uncompressed file ```

Use Regex

```rust

// Get all the files that matching the regex into a Vec let files = manager.getfilesmatching_regex("\w+\.csv");

// Using it: manager.get(&files[0].filename().unwrap().tostring_lossy());

```

Accessing Data

You must know that two things can fail:

• File not indexed
• File not exists

So you need to pass through them to access the data:

```rust manager.get("text.csv").unwrap().unwrap(); manager.getref("text.csv").unwrap().unwrap(); manager.getmut("text.csv").unwrap().unwrap();

// In the case where you have multiple file with the same name: manager.get("en/text.csv").unwrap(); manager.getref("fr/text.csv").unwrap(); manager.getmut("it/text.csv").unwrap(); ```

If the file was put in the cache and will automatically reload it.

Saving Data

⚠️ This feature encounters io authorizations issues ⚠️

Only saves data of files that are not from compressed files. Return a simple std::io::Result<()> as result. If the file does not exist anymore it will create a new file.

rust manager.save("text.csv").unwrap();

Remove a file reference

In the manager and DecompressionManager each file loaded will have its reference, but they use memory, so to do a complete unload you need to remove them. For the cached files, they will have their cache file removed (based on the trait Drop).

```rust manager.remove("text.csv").unwrap().unwrap();

// Tips: You don't need to unload before excepted if you need to put in cache ```

Dependencie Checker

The dependency checker (DependencieManager), the goal is to search the not indexed files in the manager.

JSON File source

As you can see in the example below, the JSON file defines the dependencies for some files. The organization of the JSON file is not recursive, so you cannot define the dependencies of a file into the dependencies of another file.

json { "text.csv": [ "index.json", "other.csv" ], "index.json": [ "text.csv" ] }

Initialize the dependencies

rust // Create DependencieManager object let mut dependencie_manager = DependencieManager::default(); // Load a file containing the dependencies required dependencie_manager.load_file(&mut manager, "deps.json");

Let's check the dependencies

Now you have to load the dependencies, and to check them you need to call three commands:

• update
• checkifvalid
• getmissingdependencies

```rust

// Take a look in the manager to get if a dependency is missing dependenciemanager.update(&mut manager); // Return true if all dependencies are present dependenciemanager.checkifvalid("text.csv"); // Get all the missing dependencies dependenciemanager.getmissing_dependencies("text.csv"); ```

ProcessPass

This is an easy way to add custom features. It targets to let you add support for new compression formats...

Create a ProcessPass

A ProcessPass is a trait that adds the following functions:

```rust /// Called when loading a file, and return true if continue the existing process fn on_load(&mut self, _: &mut AssetsManager, _: &mut Option) -> bool;

/// Called when unloading a file, and return true if continue the existing process fn on_unload(&mut self, _: &mut AssetsManager, _: &mut &str, _: &mut bool);

/// Called when remove a file reference, and return true if continue the existing process fn on_remove(&mut self, _: &mut AssetsManager, _: &mut &str) -> bool;

/// Called when loading file/files from archive fn on_archive(&mut self, _: &mut DecompressionManager, _: &str); ```

Add it to the AssetsManager

```rust let myprocesspass = MyProcessPass::default();

manager.addprocesspass(Box::new(myprocesspass)); ```