Struct MessageFlags 

pub struct MessageFlags(/* private fields */);

Per-message flags packed into a bitfield byte on the wire.

Wire encoding

Flags are encoded a little strangely, it’s easiest to explain by explaining the history. The first flag we added was to indicate that the other end supported “v2” sync protocol messages - sync messages in which the entire document state is sent in a single message. This flag was forward compatibly encoded by taking advantage of the fact that the original parser would ignore any bytes after the end of the sync message. We thus encoded new flags as length prefixed set of flags at the end of the message. I.e. it looked a bit like this:

| message length | < sync message > | number of flags | flags |

The idea was that this allows us to forward compatibly add new flags to the protocol by just sending a longer list of flags. The problem with this approach is that it usees a byte per flag, which becomes much more wasteful as the number of flags grows. Thus, we now encode flags as bitfields. We want to stay backwards compatible for implementations unaware of the bitfields though. To do this we take advantage of the fact that there was only ever one flag sent - the old MessageV2 flag. This means that the only flags ever sent were:

| 0x01 | 0x02 |

Where 0x01 is the length prefix byte and 0x02 is the old MessageV2 flag. To stay backwards compatible we encode the old MessageV2 flag as a single byte and then all the remaining flags as a byte with the high bit set. The old code thus sees a bunch of unknown bytes after the old MessageV2 flag and ignores them, the new code reads every bit and parses any byte with it’s high bit set as a bitfield of flags. This scheme allows us to forward compatibly add as many flags as we need (by increasing the length prefix) without breaking old implementations.

The final encoding then is

| length prefix | old MessageV2 flag | bitfield byte (0x80 set) |

When parsing messages from old implementations (all bytes < 0x80), the old individual byte values are mapped to the corresponding flag bits.

Implementations

impl MessageFlags

pub const SYNC_RESET: u8

Signals the remote peer should clear its sent_hashes and perform a fresh sync. Used when switching from read-only to read-write mode.

pub const READ_ONLY: u8

Indicates the sender is in read-only mode and will not apply incoming changes.

pub const SUPPORTS_SYNC_RESET: u8

Advertises that the sender understands the SYNC_RESET flag and will clear sent_hashes when it receives one.

pub fn new() -> MessageFlags

pub fn contains(self, flag: u8) -> bool

pub fn set(&mut self, flag: u8)

Trait Implementations

impl Clone for MessageFlags

fn clone(&self) -> MessageFlags

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MessageFlags

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

Formats the value using the given formatter.

impl Default for MessageFlags

fn default() -> MessageFlags

Returns the “default value” for a type.

impl Hash for MessageFlags

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

where __H: Hasher,

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 MessageFlags

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for MessageFlags

impl Eq for MessageFlags

impl StructuralPartialEq for MessageFlags