Struct ReadonlyRefgetStore 

pub struct ReadonlyRefgetStore { /* private fields */ }

Core refget store with &self read methods, suitable for Arc sharing in servers.

Mutating methods are used during the setup/loading phase; once wrapped in Arc, only &self reads are accessible, making concurrent access thread-safe.

Holds a global sequence_store with all sequences (across collections) deduplicated. This allows lookup by sequence digest directly (bypassing collection information). Also holds a collections hashmap, to provide lookup by collection+name.

Implementations

impl ReadonlyRefgetStore

pub fn set_quiet(&mut self, quiet: bool)

Set whether to suppress progress output.

pub fn is_quiet(&self) -> bool

Returns whether the store is in quiet mode.

pub fn store_exists<P: AsRef<Path>>(path: P) -> bool

Check whether a valid RefgetStore exists at the given path.

pub fn set_encoding_mode(&mut self, new_mode: StorageMode)

Change the storage mode, re-encoding/decoding existing sequences as needed.

pub fn enable_encoding(&mut self)

Enable 2-bit encoding for space efficiency.

pub fn disable_encoding(&mut self)

Disable encoding, use raw byte storage.

pub fn enable_persistence<P: AsRef<Path>>(&mut self, path: P) -> Result<()>

Enable disk persistence for this store.

pub fn disable_persistence(&mut self)

Disable disk persistence for this store.

pub fn is_persisting(&self) -> bool

Check if persistence to disk is enabled.

pub fn add_sequence<T: Into<Option<[u8; 48]>>>( &mut self, sequence_record: SequenceRecord, collection_digest: T, force: bool, ) -> Result<()>

Adds a sequence to the Store

pub fn add_sequence_collection( &mut self, collection: SequenceCollection, ) -> Result<()>

Adds a collection, and all sequences in it, to the store.

pub fn add_sequence_collection_force( &mut self, collection: SequenceCollection, ) -> Result<()>

Adds a collection, overwriting existing data.

pub fn add_sequence_record( &mut self, sr: SequenceRecord, force: bool, ) -> Result<()>

Adds a SequenceRecord directly to the store without collection association.

pub fn sequence_digests(&self) -> impl Iterator<Item = [u8; 48]> + '_

Returns an iterator over all sequence digests in the store

pub fn sequence_metadata(&self) -> impl Iterator<Item = &SequenceMetadata> + '_

Returns an iterator over sequence metadata for all sequences in the store.

pub fn total_disk_size(&self) -> usize

Calculate the total disk size of all sequences in the store

pub fn actual_disk_usage(&self) -> usize

Returns the actual disk usage of the store directory.

pub fn list_collections( &self, page: usize, page_size: usize, filters: &[(&str, &str)], ) -> Result<PagedResult<SequenceCollectionMetadata>>

List collections with pagination and optional attribute filtering.

pub fn get_collection_metadata<K: AsRef<[u8]>>( &self, collection_digest: K, ) -> Option<&SequenceCollectionMetadata>

Get metadata for a single collection by digest (no sequence data).

pub fn get_collection( &self, collection_digest: &str, ) -> Result<SequenceCollection>

Get a collection with all its sequences loaded.

pub fn remove_collection( &mut self, digest: &str, remove_orphan_sequences: bool, ) -> Result<bool>

Remove a collection from the store.

pub fn import_collection( &mut self, source: &ReadonlyRefgetStore, digest: &str, ) -> Result<()>

Import a single collection (with all its sequences, aliases, and FHR metadata) from another store into this store.

The source store must have the collection loaded (call load_collection() or load_all_collections() first).

pub fn list_sequences(&self) -> Vec<SequenceMetadata>

List all sequences in the store (metadata only, no sequence data).

pub fn get_sequence_metadata<K: AsRef<[u8]>>( &self, seq_digest: K, ) -> Option<&SequenceMetadata>

Get metadata for a single sequence by digest (no sequence data).

pub fn get_sequence<K: AsRef<[u8]>>( &self, seq_digest: K, ) -> Result<&SequenceRecord>

Get a sequence by its SHA512t24u digest.

pub fn ensure_decoded<K: AsRef<[u8]>>(&mut self, seq_digest: K) -> Result<()>

Ensure a sequence is loaded and decoded into the decoded cache.

pub fn clear_decoded_cache(&mut self)

Clear the decoded sequence cache to reclaim memory.

pub fn clear(&mut self)

Clear sequence data from the store to free memory.

pub fn sequence_bytes<K: AsRef<[u8]>>(&self, seq_digest: K) -> Option<&[u8]>

Get decoded sequence bytes from the cache.

pub fn get_sequence_by_name<K: AsRef<[u8]>>( &self, collection_digest: K, sequence_name: &str, ) -> Result<&SequenceRecord>

Get a sequence by collection digest and name.

pub fn load_all_collections(&mut self) -> Result<()>

Eagerly load all Stub collections to Full.

pub fn load_all_sequences(&mut self) -> Result<()>

Eagerly load all Stub sequences to Full.

pub fn load_collection(&mut self, digest: &str) -> Result<()>

Load a single collection by digest.

pub fn load_sequence(&mut self, digest: &str) -> Result<()>

Load a single sequence by digest.

pub fn iter_collections(&self) -> impl Iterator<Item = SequenceCollection> + '_

Iterate over all collections with their sequences loaded.

pub fn iter_sequences(&self) -> impl Iterator<Item = SequenceRecord> + '_

Iterate over all sequences with their data loaded.

pub fn is_collection_loaded<K: AsRef<[u8]>>(&self, collection_digest: K) -> bool

Check if a collection is fully loaded.

pub fn local_path(&self) -> Option<&PathBuf>

Returns the local path where the store is located (if any)

pub fn remote_source(&self) -> Option<&str>

Returns the remote source URL (if any)

pub fn storage_mode(&self) -> StorageMode

Returns the storage mode used by this store

pub fn get_substring<K: AsRef<[u8]>>( &self, sha512_digest: K, start: usize, end: usize, ) -> Result<String>

Retrieves a substring from an encoded sequence by its SHA512t24u digest.

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

Write the store using its configured paths.

pub fn write_store_to_dir<P: AsRef<Path>>( &self, root_path: P, seqdata_path_template: Option<&str>, ) -> Result<()>

Write a RefgetStore object to a directory

pub fn stats(&self) -> StoreStats

Returns statistics about the store

pub fn available_alias_namespaces(&self) -> AvailableAliases<'_>

List alias namespaces available on this store (from manifest).

impl ReadonlyRefgetStore

pub fn add_sequence_alias( &mut self, namespace: &str, alias: &str, digest: &str, ) -> Result<()>

Add a sequence alias and persist to disk if applicable.

pub fn get_sequence_metadata_by_alias( &self, namespace: &str, alias: &str, ) -> Option<&SequenceMetadata>

Resolve a sequence alias to sequence metadata (no data loading).

pub fn get_sequence_by_alias( &self, namespace: &str, alias: &str, ) -> Result<&SequenceRecord>

Resolve a sequence alias and return the loaded sequence record.

pub fn get_aliases_for_sequence(&self, digest: &str) -> Vec<(String, String)>

Reverse lookup: find all aliases pointing to this sequence digest.

pub fn list_sequence_alias_namespaces(&self) -> Vec<String>

List all sequence alias namespaces.

pub fn list_sequence_aliases(&self, namespace: &str) -> Option<Vec<String>>

List all aliases in a sequence alias namespace.

pub fn remove_sequence_alias( &mut self, namespace: &str, alias: &str, ) -> Result<bool>

Remove a single sequence alias.

pub fn load_sequence_aliases( &mut self, namespace: &str, path: &str, ) -> Result<usize>

Load sequence aliases from a TSV file into a namespace.

pub fn add_collection_alias( &mut self, namespace: &str, alias: &str, digest: &str, ) -> Result<()>

Add a collection alias and persist to disk if applicable.

pub fn get_collection_metadata_by_alias( &self, namespace: &str, alias: &str, ) -> Option<&SequenceCollectionMetadata>

Resolve a collection alias to collection metadata.

pub fn get_collection_by_alias( &self, namespace: &str, alias: &str, ) -> Result<SequenceCollection>

Resolve a collection alias and return the loaded collection.

pub fn get_aliases_for_collection(&self, digest: &str) -> Vec<(String, String)>

Reverse lookup: find all aliases pointing to this collection digest.

pub fn list_collection_alias_namespaces(&self) -> Vec<String>

List all collection alias namespaces.

pub fn list_collection_aliases(&self, namespace: &str) -> Option<Vec<String>>

List all aliases in a collection alias namespace.

pub fn remove_collection_alias( &mut self, namespace: &str, alias: &str, ) -> Result<bool>

Remove a single collection alias.

pub fn load_collection_aliases( &mut self, namespace: &str, path: &str, ) -> Result<usize>

Load collection aliases from a TSV file into a namespace.

impl ReadonlyRefgetStore

pub fn set_fhr_metadata( &mut self, collection_digest: &str, metadata: FhrMetadata, ) -> Result<()>

Set FHR metadata for a collection.

pub fn get_fhr_metadata(&self, collection_digest: &str) -> Option<&FhrMetadata>

Get FHR metadata for a collection. Returns None if missing.

pub fn remove_fhr_metadata(&mut self, collection_digest: &str) -> bool

Remove FHR metadata for a collection.

pub fn list_fhr_metadata(&self) -> Vec<String>

List all collection digests that have FHR metadata.

pub fn load_fhr_metadata( &mut self, collection_digest: &str, path: &str, ) -> Result<()>

Load FHR metadata from a JSON file and attach it to a collection.

impl ReadonlyRefgetStore

pub fn add_sequence_collection_from_fasta<P: AsRef<Path>>( &mut self, file_path: P, opts: FastaImportOptions<'_>, ) -> Result<(SequenceCollectionMetadata, bool)>

Import a FASTA file into the store using a multithreaded pipeline.

After the pipeline finishes, computes collection metadata, registers the collection, and inserts all sequences.

impl ReadonlyRefgetStore

pub fn write_sequences_rgsi<P: AsRef<Path>>(&self, file_path: P) -> Result<()>

Write all sequence metadata to an RGSI file.

pub fn store_metadata(&self) -> Result<HashMap<String, String>>

Read the store metadata from rgstore.json, returning state digests and timestamp.

Returns a HashMap with keys: modified, collections_digest, sequences_digest, aliases_digest, fhr_digest. Missing values are omitted from the map.

impl ReadonlyRefgetStore

pub fn substrings_from_regions<'a, K: AsRef<[u8]>>( &'a self, collection_digest: K, bed_file_path: &str, ) -> Result<SubstringsFromRegions<'a, K>>

Get an iterator over substrings defined by BED file regions.

pub fn export_fasta_from_regions<K: AsRef<[u8]>>( &self, collection_digest: K, bed_file_path: &str, output_file_path: &str, ) -> Result<()>

Export sequences from BED file regions to a FASTA file.

pub fn export_fasta<K: AsRef<[u8]>, P: AsRef<Path>>( &self, collection_digest: K, output_path: P, sequence_names: Option<Vec<&str>>, line_width: Option<usize>, ) -> Result<()>

Export sequences from a collection to a FASTA file.

pub fn export_fasta_by_digests<P: AsRef<Path>>( &self, seq_digests: Vec<&str>, output_path: P, line_width: Option<usize>, ) -> Result<()>

Export sequences by their sequence digests to a FASTA file.

impl ReadonlyRefgetStore

pub fn enable_ancillary_digests(&mut self)

Enable computation and storage of ancillary digests (nlp, snlp, sorted_sequences).

pub fn disable_ancillary_digests(&mut self)

Disable computation and storage of ancillary digests.

pub fn has_ancillary_digests(&self) -> bool

Returns whether ancillary digests are enabled.

pub fn has_attribute_index(&self) -> bool

Returns whether the on-disk attribute index is enabled.

pub fn get_collection_level1(&self, digest: &str) -> Result<CollectionLevel1>

Get collection at level 1 representation (attribute digests with spec field names). This is a lightweight operation that only reads metadata, no loading needed.

pub fn get_collection_level2(&self, digest: &str) -> Result<CollectionLevel2>

Get collection at level 2 representation (full arrays, spec format). May need to load the collection from disk/remote.

pub fn compare( &self, digest_a: &str, digest_b: &str, ) -> Result<SeqColComparison>

Compare two collections by digest. Both must be preloaded.

pub fn compare_with_level2( &self, digest_a: &str, external: &CollectionLevel2, ) -> Result<SeqColComparison>

Compare a stored collection (by digest) against an externally-provided level-2 body.

Used for the seqcol spec POST /comparison/:digest1 endpoint where the client submits a local collection as JSON rather than referencing a stored digest.

The returned SeqColComparison has digests.a set to the stored collection’s digest and digests.b set to None because the external collection has no server-side digest.

pub fn find_collections_by_attribute( &self, attr_name: &str, attr_digest: &str, ) -> Result<Vec<String>>

Find all collections with a specific attribute digest.

Dispatches to indexed lookup (if attribute_index enabled) or brute-force metadata scan (default).

Supported attr_name values: “names”, “lengths”, “sequences”, “name_length_pairs”, “sorted_name_length_pairs”, “sorted_sequences”

pub fn get_attribute( &self, attr_name: &str, attr_digest: &str, ) -> Result<Option<Value>>

Get the raw attribute array for a given attribute digest. Finds a collection with this attribute (via search), loads it, and extracts the array.

Supported attr_name values: “names”, “lengths”, “sequences”, “name_length_pairs”, “sorted_name_length_pairs”, “sorted_sequences”

Returns the array as a serde_json::Value (array of strings or numbers). Returns Ok(None) if no collection has this attribute digest.

pub fn enable_attribute_index(&mut self)

Enable indexed attribute lookup (not yet implemented).

Note: The indexed lookup feature is planned for a future release. Enabling this will cause find_collections_by_attribute() to return a “not implemented” error until the feature is complete.

pub fn disable_attribute_index(&mut self)

Disable indexed attribute lookup, using brute-force scan instead.

pub fn collection_count(&self) -> usize

Total number of collections in the store.

Trait Implementations

impl Debug for ReadonlyRefgetStore

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

Formats the value using the given formatter.

impl Display for ReadonlyRefgetStore

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

Formats the value using the given formatter.

impl SeqColService for ReadonlyRefgetStore

fn get_collection_level1(&self, digest: &str) -> Result<CollectionLevel1>

Level 1: attribute digests only.

fn get_collection_level2(&self, digest: &str) -> Result<CollectionLevel2>

Level 2: full arrays with values.

fn compare(&self, digest_a: &str, digest_b: &str) -> Result<SeqColComparison>

Compare two collections by digest.

fn compare_with_level2( &self, digest_a: &str, external: &CollectionLevel2, ) -> Result<SeqColComparison>

Compare a stored collection against an externally-provided level-2 body.

fn find_collections_by_attribute( &self, attr_name: &str, attr_digest: &str, ) -> Result<Vec<String>>

Find collections sharing an attribute digest.

fn get_attribute( &self, attr_name: &str, attr_digest: &str, ) -> Result<Option<Value>>

Get the raw attribute array for a given attribute digest.

fn list_collections( &self, page: usize, page_size: usize, filters: &[(&str, &str)], ) -> Result<PagedResult<SequenceCollectionMetadata>>

List collections with pagination and optional attribute filters.

fn collection_count(&self) -> usize

Total number of collections in the store.