Enum FeedRead 

pub enum FeedRead {
    Resync {
        tail: FeedPosition,
    },
    Future,
}

Why a feed read could not be served from the backlog.

use kevy_replicate::feed::{FeedPosition, FeedRead, FeedSource};
use kevy_replicate::source::ReplicationSource;

let feed = FeedSource::new(1, ReplicationSource::new(1 << 20));
match feed.read(FeedPosition::new(2, 0), 10) {
    Err(FeedRead::Resync { tail }) => assert_eq!(tail, FeedPosition::new(1, 0)),
    other => panic!("unexpected {other:?}"),
}

Variants

Resync

Cursor unservable (stale generation or evicted offset): rebuild from a scan, then resume from the carried tail cursor.

use kevy_replicate::feed::{FeedPosition, FeedRead, FeedSource};
use kevy_replicate::source::ReplicationSource;

// a 64-byte backlog keeps only the newest frame
let mut feed = FeedSource::new(1, ReplicationSource::new(64));
let set = kevy_resp::Argv::from(vec![b"SET".to_vec(), b"k".to_vec(), b"v".to_vec()]);
for _ in 0..3 {
    feed.source_mut().push_mutation(&set);
}
let err = feed.read(FeedPosition::new(1, 0), 10).unwrap_err();
assert_eq!(err, FeedRead::Resync { tail: FeedPosition::new(1, 3) });

Fields

tail: FeedPosition

The current generation and the next offset the source will assign: where to resume.

use kevy_replicate::feed::{FeedPosition, FeedRead, FeedSource};
use kevy_replicate::source::ReplicationSource;

let feed = FeedSource::new(4, ReplicationSource::new(1 << 20));
let Err(FeedRead::Resync { tail }) = feed.read(FeedPosition::new(3, 0), 10) else { panic!() };
assert!(feed.read(tail, 10)?.is_empty()); // resuming at the tail is served

Future

Cursor is ahead of the stream (offset > next) in the CURRENT generation — caller bug or epoch confusion; reject the read. (A mismatched generation is Resync, never Future: generations carry no order to be “ahead” in.)

use kevy_replicate::feed::{FeedPosition, FeedRead, FeedSource};
use kevy_replicate::source::ReplicationSource;

let feed = FeedSource::new(1, ReplicationSource::new(1 << 20));
assert_eq!(feed.read(FeedPosition::new(1, 5), 10), Err(FeedRead::Future));

Trait Implementations

impl Clone for FeedRead

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 FeedRead

impl Debug for FeedRead

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

Formats the value using the given formatter.

impl Eq for FeedRead

impl Hash for FeedRead

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 FeedRead

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for FeedRead