Struct IndexStore 

pub struct IndexStore { /* private fields */ }

The stored indexes of one database.

Implementations

impl IndexStore

pub fn new(dir: PathBuf, writable: bool, database: String, limit: u64) -> Self

The store in dir, of the database database (as notices name it), keeping at most limit bytes. A writable store creates dir on its first write.

pub fn dir(&self) -> &Path

pub fn is_writable(&self) -> bool

pub fn database(&self) -> &str

The database as notices name it.

pub fn limit(&self) -> u64

The most bytes of indexes the store keeps.

pub fn set_limit(&self, limit: u64)

Keep at most limit bytes from now on: the next index stored makes room within it. Nothing is evicted now.

pub fn entries(&self) -> Vec<Entry>

The manifest’s entries, as this process knows them.

pub fn load( &self, key: &IndexKey, notifier: &Notifier, ) -> Option<(Arc<GraphIndex>, u64)>

The stored index for key, if there is one whose full key matches and whose file reads back whole, and the size of its file. Blocking: it reads the file.

pub fn save( self: &Arc<Self>, key: IndexKey, index: Arc<GraphIndex>, graph: &str, notifier: &Notifier, ) -> Saved

Decide whether to store index, built for the graph graph, under key (see the module docs), evict what that takes, and start the write on a background thread. Evictions and a failed write are said with notifier; what was decided is returned for the caller to say.

pub fn flush(&self)

Wait for every write save started, then append to each index file this process stored or loaded the parts of its index built since (the in-adjacency, evaluated weights), within the storage limit.

Trait Implementations

impl Debug for IndexStore

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

Formats the value using the given formatter.

impl Drop for IndexStore

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.