Enum FeedError 

#[non_exhaustive]
pub enum FeedError {
    Resync {
        tail: FeedPosition,
    },
    Future,
    Disabled,
}

Why a feed read could not be served.

use kevy_embedded::{Config, FeedError, Store};

let store = Store::open(Config::default())?;
assert_eq!(store.changes_tail(), Err(FeedError::Disabled));
assert_eq!(FeedError::Disabled.to_string(), "the store was opened without a change feed");

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Resync

Cursor unservable (stale generation / evicted offsets): rebuild from a scan, then resume from tail.

use kevy_embedded::{Config, FeedError, FeedPosition, Store};

let store = Store::open(Config::default().with_feed(0))?;
let tail = store.changes_tail()?;
let stale = FeedPosition::new(tail.generation - 1, 0); // an older generation
assert_eq!(store.changes_since(stale, 10, &[]), Err(FeedError::Resync { tail }));

Fields

tail: FeedPosition

The current generation and the offset to resume from.

use kevy_embedded::{Config, FeedError, FeedPosition, Store};

let store = Store::open(Config::default().with_feed(0))?;
store.set(b"k", b"v")?;
let Err(FeedError::Resync { tail }) = store.changes_since(FeedPosition::new(0, 0), 10, &[]) else {
    panic!("a generation-0 cursor is stale");
};
// after rebuilding from a scan, reading resumes from `tail`
assert!(store.changes_since(tail, 10, &[])?.changes.is_empty());

Future

Cursor is ahead of the stream — caller bug.

use kevy_embedded::{Config, FeedError, FeedPosition, Store};

let store = Store::open(Config::default().with_feed(0))?;
let tail = store.changes_tail()?;
let ahead = FeedPosition::new(tail.generation, tail.offset + 100);
assert_eq!(store.changes_since(ahead, 10, &[]), Err(FeedError::Future));

Disabled

The store was opened without Config::with_feed.

use kevy_embedded::{Config, FeedError, Store};

assert_eq!(Store::open(Config::default())?.changes_tail(), Err(FeedError::Disabled));
assert!(Store::open(Config::default().with_feed(0))?.changes_tail().is_ok());

Trait Implementations

impl Clone for FeedError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for FeedError

impl Debug for FeedError

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

Formats the value using the given formatter.

impl Display for FeedError

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

Formats the value using the given formatter.

impl Eq for FeedError

impl Error for FeedError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl Hash for FeedError

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for FeedError

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for FeedError