Enum SnapshotMarker 

#[non_exhaustive]
pub enum SnapshotMarker {
    Begin,
    End(u64),
    Ping(FeedPosition),
}

Decoded snapshot marker, returned by decode_snapshot_marker.

use kevy_replicate::wire::{SnapshotMarker, decode_snapshot_marker, encode_snapshot_end};

let (marker, _) = decode_snapshot_marker(&encode_snapshot_end(12))?.expect("a marker line");
let next_live_offset = match marker {
    SnapshotMarker::End(ack) => ack,
    other => panic!("unexpected {other:?}"),
};
assert_eq!(next_live_offset, 12);

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.

Begin

+SNAPSHOT\r\n — primary is about to stream snapshot chunks.

use kevy_replicate::wire::{SnapshotMarker, decode_snapshot_marker};

assert_eq!(decode_snapshot_marker(b"+SNAPSHOT\r\n")?, Some((SnapshotMarker::Begin, 11)));

End(u64)

+SNAPSHOT_END <ack_offset>\r\n — end of snapshot; the next live frame’s offset will equal ack_offset.

use kevy_replicate::wire::{SnapshotMarker, decode_snapshot_marker};

let line = b"+SNAPSHOT_END 42\r\n";
assert_eq!(decode_snapshot_marker(line)?, Some((SnapshotMarker::End(42), line.len())));

Ping(FeedPosition)

+PING <generation> <next_offset>\r\n — in-stream heartbeat: the primary’s current feed generation + next_offset, sent every ~1s so a replica can compute its own lag (applied vs primary) and judge link liveness without a request/response round trip. Out-of-band: occupies no offset space.

The generation lets REPL.TOKEN / REPL.WAIT compare token generations against the replica’s last-seen upstream generation. A legacy one-number +PING <next_offset>\r\n line still decodes — generation reads as 0, the “unknown” value no real feed ever serves (feed generations start at 1).

use kevy_replicate::feed::FeedPosition;
use kevy_replicate::wire::{SnapshotMarker, decode_snapshot_marker};

let (ping, _) = decode_snapshot_marker(b"+PING 3 120\r\n")?.expect("a marker line");
assert_eq!(ping, SnapshotMarker::Ping(FeedPosition::new(3, 120)));
let (legacy, _) = decode_snapshot_marker(b"+PING 120\r\n")?.expect("a marker line");
assert_eq!(legacy, SnapshotMarker::Ping(FeedPosition::new(0, 120))); // generation unknown

Trait Implementations

impl Clone for SnapshotMarker

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 SnapshotMarker

impl Debug for SnapshotMarker

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

Formats the value using the given formatter.

impl Eq for SnapshotMarker

impl Hash for SnapshotMarker

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 SnapshotMarker

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SnapshotMarker