Struct Message 

pub struct Message {
    pub heads: Vec<ChangeHash>,
    pub need: Vec<ChangeHash>,
    pub have: Vec<Have>,
    pub changes: ChunkList,
    pub flags: Option<MessageFlags>,
    pub version: MessageVersion,
}

The sync message to be sent.

Notes about encoding

There are two versions of the sync message, V1 and V2. The V1 message is the original message which automerge shipped with and V2 is an extension which allows for encoding the changes as either a list of changes or as a compressed document format. This makes syncing up for the first time faster.

Encoding this in a backwards compatible way is a bit tricky. The wire format of the v1 message didn’t allow for any forwards compatible changes. In order to accomodate this the first message a peer sends is a V1 message with a length-prefixed Vec<MessageFlag> appended to it. For old implementations this appended data is just ignored but new implementations read it and store the advertised capabilities on the sync state. This allows new implementations to discover if the remote peer supports the V2 message format and if so send a V2 message. The flags also carry transient per-message signals such as read-only mode and sync reset.

Fields

heads: Vec<ChangeHash>

The heads of the sender.

need: Vec<ChangeHash>

The hashes of any changes that are being explicitly requested from the recipient.

have: Vec<Have>

A summary of the changes that the sender already has.

changes: ChunkList

The changes for the recipient to apply.

This is a Vec of bytes which should be passed to Automerge::load_incremental. The reason it is a Vec<Vec<u8>> and not a Vec<u8> is that the V1 message format is a sequence of change chunks, each of which is length delimited. The V2 message format is a single length delimited chunk but we nest it inside a Vec for backwards compatibility.

flags: Option<MessageFlags>

Per-message flags including capability advertisements and transient signals.

version: MessageVersion

What version to encode this message as

Implementations

impl Message

pub fn decode(input: &[u8]) -> Result<Message, ReadMessageError>

pub fn encode(self) -> Vec<u8>

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl PartialEq for Message

fn eq(&self, other: &Message) -> 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 Serialize for Message

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Message