Struct FeOxDbBackend 

pub struct FeOxDbBackend<S = JsonFormat, C = PassthroughCompressor>
where
    S: Format,
    C: Compressor,
{ /* private fields */ }

Disk-based cache backend using FeOxDB.

Use this when cache data must survive restarts or doesn’t fit in memory. For pure speed without persistence, prefer MokaBackend.

use hitbox_feoxdb::FeOxDbBackend;

// Persistent cache with defaults
let backend = FeOxDbBackend::builder()
    .path("/var/cache/myapp")
    .build()?;

// With resource limits
let backend = FeOxDbBackend::builder()
    .path("/var/cache/myapp")
    .max_file_size(10 * 1024 * 1024 * 1024)  // 10 GB
    .max_memory(256 * 1024 * 1024)           // 256 MB
    .build()?;

Cloning is cheap — clones share the same underlying database.

Implementations

impl<S, C> FeOxDbBackend<S, C>

where S: Format, C: Compressor,

pub fn flush(&self)

Forces pending writes to disk.

FeOxDB buffers writes in memory and flushes them periodically (~100ms). Call this when you need to ensure data is persisted before proceeding, or in tests to verify disk behavior synchronously.

No-op in memory-only mode.

impl FeOxDbBackend<JsonFormat, PassthroughCompressor>

pub fn builder() -> FeOxDbBackendBuilder<JsonFormat, PassthroughCompressor>

Starts building a new backend.

pub fn in_memory() -> Result<Self, FeOxDbError>

In-memory backend for tests.

Data is lost when dropped. Equivalent to builder().build().

use hitbox_feoxdb::FeOxDbBackend;

let backend = FeOxDbBackend::in_memory()
    .expect("Failed to create in-memory backend");

Trait Implementations

impl<S, C> Backend for FeOxDbBackend<S, C>

where S: Format + Send + Sync, C: Compressor + Send + Sync,

fn read<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 CacheKey, ) -> Pin<Box<dyn Future<Output = BackendResult<Option<CacheValue<Raw>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read raw cached data by key.

fn write<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 CacheKey, value: CacheValue<Raw>, ) -> Pin<Box<dyn Future<Output = BackendResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Write raw data to cache.

fn remove<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 CacheKey, ) -> Pin<Box<dyn Future<Output = BackendResult<DeleteStatus>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove data from cache.

fn value_format(&self) -> &dyn Format

Serialization format for cached values. Default: BincodeFormat.

fn key_format(&self) -> &CacheKeyFormat

Key serialization format. Default: CacheKeyFormat::Bitcode.

fn compressor(&self) -> &dyn Compressor

Compressor for cached values. Default: PassthroughCompressor.

fn label(&self) -> BackendLabel

Backend label for metrics and source path composition.

impl<S, C> CacheBackend for FeOxDbBackend<S, C>

where S: Format + Send + Sync, C: Compressor + Send + Sync,

fn get<T>( &self, key: &CacheKey, ctx: &mut SmallBox<dyn Context, S4>, ) -> impl Future<Output = Result<Option<CacheValue<<T as CacheableResponse>::Cached>>, BackendError>> + Send

where T: CacheableResponse, <T as CacheableResponse>::Cached: Cacheable,

Retrieve a typed value from cache.

fn set<T>( &self, key: &CacheKey, value: &CacheValue<<T as CacheableResponse>::Cached>, ctx: &mut SmallBox<dyn Context, S4>, ) -> impl Future<Output = Result<(), BackendError>> + Send

where T: CacheableResponse, <T as CacheableResponse>::Cached: Cacheable,

Store a typed value in cache.

fn delete( &self, key: &CacheKey, _ctx: &mut SmallBox<dyn Context, S4>, ) -> impl Future<Output = Result<DeleteStatus, BackendError>> + Send

Delete a value from cache.

impl<S, C> Clone for FeOxDbBackend<S, C>

where S: Format + Clone, C: Compressor + Clone,

fn clone(&self) -> FeOxDbBackend<S, C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.