Struct CascStorage 

pub struct CascStorage { /* private fields */ }

Main CASC storage implementation

Implementations

impl CascStorage

pub fn new(config: CascConfig) -> Result<Self>

Create a new CASC storage instance

pub fn load_indices(&self) -> Result<()>

Load indices from disk

pub async fn new_async(config: CascConfig) -> Result<Self>

Create new CASC storage asynchronously (recommended for async contexts)

pub async fn load_indices_parallel(&self) -> Result<()>

Load indices from disk with parallel processing (3-5x faster)

pub fn load_indices_sequential(&self) -> Result<()>

Load indices from disk (sequential fallback)

pub fn load_archives(&self) -> Result<()>

Load archive files

pub fn read_arc(&self, ekey: &EKey) -> Result<Arc<Vec<u8>>>

Read a file by its encoding key (zero-copy when cached)

pub fn read(&self, ekey: &EKey) -> Result<Vec<u8>>

Read a file by its encoding key (compatibility method, always clones)

pub fn write(&self, ekey: &EKey, data: &[u8]) -> Result<()>

Write a file with the given encoding key

pub fn verify(&self) -> Result<Vec<EKey>>

Verify storage integrity

pub fn rebuild_indices(&self) -> Result<()>

Build indices from scratch by scanning archives

pub fn stats(&self) -> StorageStats

Get storage statistics

pub fn enumerate_files_vec(&self) -> Vec<(EKey, ArchiveLocation)>

Enumerate all files in the storage Returns a vector of (EKey, ArchiveLocation) pairs

pub fn enumerate_files( &self, ) -> impl Iterator<Item = (EKey, ArchiveLocation)> + '_

Enumerate all files in the storage Returns an iterator over (EKey, ArchiveLocation) pairs

pub fn get_all_ekeys(&self) -> Vec<EKey>

Get all EKeys in the storage

pub fn test_ekey_lookup(&self) -> Result<()>

Test function to verify EKey lookup is working

pub fn files_per_archive(&self) -> HashMap<u16, usize>

Count files per archive

pub fn clear_cache(&self)

Clear the cache

pub fn flush(&self) -> Result<()>

Flush any pending writes

pub fn init_tact_manifests(&mut self, config: ManifestConfig)

Initialize TACT manifest support with configuration

pub fn load_root_manifest(&self, data: Vec<u8>) -> Result<()>

Load root manifest from raw data

pub fn load_encoding_manifest(&self, data: Vec<u8>) -> Result<()>

Load encoding manifest from raw data

pub fn load_root_manifest_from_file(&self, path: &Path) -> Result<()>

Load root manifest from file

pub fn load_encoding_manifest_from_file(&self, path: &Path) -> Result<()>

Load encoding manifest from file

pub fn load_listfile(&self, path: &Path) -> Result<usize>

Load a community listfile for filename resolution

pub fn read_by_fdid(&self, fdid: u32) -> Result<Vec<u8>>

Read a file by FileDataID

pub fn read_by_filename(&self, filename: &str) -> Result<Vec<u8>>

Read a file by filename (requires loaded listfile or root manifest)

pub fn get_fdid_for_filename(&self, filename: &str) -> Option<u32>

Get FileDataID for a filename (if known)

pub fn get_all_fdids(&self) -> Result<Vec<u32>>

Get all known FileDataIDs

pub fn tact_manifests_loaded(&self) -> bool

Check if TACT manifests are loaded and ready

pub fn get_file_mapping(&self, fdid: u32) -> Result<FileMapping>

Get file mapping information for a FileDataID

pub fn clear_manifest_cache(&self)

Clear TACT manifest caches

pub async fn init_async_indices(&mut self) -> Result<()>

Initialize async index manager for parallel operations

pub async fn lookup_async(&self, ekey: &EKey) -> Option<ArchiveLocation>

Perform async lookup using the async index manager

pub async fn lookup_batch_async( &self, ekeys: &[EKey], ) -> Vec<Option<ArchiveLocation>>

Batch lookup for multiple keys using async operations

pub async fn start_index_background_updates(&self, interval: Duration)

Start background index updates with specified interval

pub async fn stop_index_background_updates(&self)

Stop background index updates

pub async fn get_async_index_stats(&self) -> Option<AsyncIndexStats>

Get async index statistics

pub async fn clear_async_index_cache(&self)

Clear async index cache

pub fn init_progressive_loading(&mut self, config: ProgressiveConfig)

Initialize progressive file loading with configuration

pub async fn read_progressive( &self, ekey: &EKey, size_hint: SizeHint, ) -> Result<Arc<ProgressiveFile>>

Read a file progressively with size hints

pub async fn read_by_fdid_progressive( &self, fdid: u32, ) -> Result<Arc<ProgressiveFile>>

Read a file by FileDataID progressively with size hints from manifest

pub fn get_size_hint_for_ekey(&self, ekey: &EKey) -> SizeHint

Get size hint for an EKey from archive location

pub fn has_progressive_loading(&self) -> bool

Check if progressive loading is available

pub async fn cleanup_progressive_files(&self)

Cleanup inactive progressive files

pub async fn get_progressive_stats(&self) -> Vec<(EKey, LoadingStats)>

Get progressive loading statistics