[][src]Trait tantivy::Directory

pub trait Directory: DirectoryClone + Debug + Send + Sync + 'static {
    fn open_read(&self, path: &Path) -> Result<ReadOnlySource, OpenReadError>;
fn delete(&self, path: &Path) -> Result<(), DeleteError>;
fn exists(&self, path: &Path) -> bool;
fn open_write(&mut self, path: &Path) -> Result<WritePtr, OpenWriteError>;
fn atomic_read(&self, path: &Path) -> Result<Vec<u8>, OpenReadError>;
fn atomic_write(&mut self, path: &Path, data: &[u8]) -> Result<()>;
fn watch(&self, watch_callback: WatchCallback) -> Result<WatchHandle>; fn acquire_lock(&self, lock: &Lock) -> Result<DirectoryLock, LockError> { ... } }

Write-once read many (WORM) abstraction for where tantivy's data should be stored.

There are currently two implementations of Directory

Required methods

fn open_read(&self, path: &Path) -> Result<ReadOnlySource, OpenReadError>

Opens a virtual file for read.

Once a virtual file is open, its data may not change.

Specifically, subsequent writes or flushes should have no effect on the returned ReadOnlySource object.

fn delete(&self, path: &Path) -> Result<(), DeleteError>

Removes a file

Removing a file will not affect an eventual existing ReadOnlySource pointing to it.

Removing a nonexistent file, yields a DeleteError::DoesNotExist.

fn exists(&self, path: &Path) -> bool

Returns true iff the file exists

fn open_write(&mut self, path: &Path) -> Result<WritePtr, OpenWriteError>

Opens a writer for the virtual file associated with a Path.

Right after this call, the file should be created and any subsequent call to open_read for the same path should return a ReadOnlySource.

Write operations may be aggressively buffered. The client of this trait is responsible for calling flush to ensure that subsequent read operations will take into account preceding write operations.

Flush operation should also be persistent.

The user shall not rely on Drop triggering flush. Note that RAMDirectory will panic! if flush was not called.

The file may not previously exist.

fn atomic_read(&self, path: &Path) -> Result<Vec<u8>, OpenReadError>

Reads the full content file that has been written using atomic_write.

This should only be used for small files.

fn atomic_write(&mut self, path: &Path, data: &[u8]) -> Result<()>

Atomically replace the content of a file with data.

This calls ensure that reads can never observe a partially written file.

The file may or may not previously exist.

fn watch(&self, watch_callback: WatchCallback) -> Result<WatchHandle>

Registers a callback that will be called whenever a change on the meta.json using the atomic_write API is detected.

The behavior when using .watch() on a file using .open_write(...) is, on the other hand, undefined.

The file will be watched for the lifetime of the returned WatchHandle. The caller is required to keep it. It does not override previous callbacks. When the file is modified, all callback that are registered (and whose WatchHandle is still alive) are triggered.

Internally, tantivy only uses this API to detect new commits to implement the OnCommit ReloadPolicy. Not implementing watch in a Directory only prevents the OnCommit ReloadPolicy to work properly.

Loading content...

Provided methods

fn acquire_lock(&self, lock: &Lock) -> Result<DirectoryLock, LockError>

Acquire a lock in the given directory.

The method is blocking or not depending on the Lock object.

Loading content...


impl Directory for ManagedDirectory[src]

impl Directory for MmapDirectory[src]

fn delete(&self, path: &Path) -> Result<(), DeleteError>[src]

Any entry associated to the path in the mmap will be removed before the file is deleted.

impl Directory for RAMDirectory[src]

Loading content...