Struct LoadOptions 

pub struct LoadOptions<'a> { /* private fields */ }

Implementations

impl<'a> LoadOptions<'a>

pub fn new() -> LoadOptions<'static>

pub fn on_partial_load(self, on_partial_load: OnPartialLoad) -> LoadOptions<'a>

What to do when loading a document partially succeeds

The default is OnPartialLoad::Error

pub fn verification_mode( self, verification_mode: VerificationMode, ) -> LoadOptions<'a>

Whether to verify the head hashes after loading

The default is VerificationMode::Check

pub fn patch_log(self, patch_log: &'a mut PatchLog) -> LoadOptions<'a>

A PatchLog to log the changes required to materialize the current state of the

The default is to not log patches

pub fn migrate_strings(self, migration: StringMigration) -> LoadOptions<'a>

Whether to convert ScalarValue::Strs in the loaded document to ObjType::Text

Until version 2.1.0 of the javascript library strings (as in, the native string of the JS runtime) were represented in the document as ScalarValue::Str and there was a special JS class called Text which users were expected to use for ObjType::Text. In 2.1.0 we changed this so that native strings were represented as ObjType::Text and ScalarValue::Str was represented as a special RawString class. This means that upgrading the application code to use the new API would require either

a) Maintaining two code paths in the application to deal with both string and RawString types b) Writing a migration script to convert all RawString types to string

The latter is logic which is the same for all applications so we implement it in the library for convenience. The way this works is that after loading the document we iterate through all visible ScalarValue::Str values and emit a change which creates a new ObjType::Text at the same path with the same content.

pub fn text_encoding(self, text_encoding: TextEncoding) -> LoadOptions<'a>

pub fn author(self, author: Author<'static>) -> LoadOptions<'a>

pub fn known_change_hashes(self, hashes: &'a [ChangeHash]) -> LoadOptions<'a>

Tilo patch (TILO-PATCH.md): the hash of every change in the document chunk the data starts with, in the order Automerge::change_hashes listed them for the document that saved it. Loading then takes them instead of rebuilding and hashing every change, which is most of the cost of loading a large document.

Pass only hashes this program listed itself for exactly these bytes (keyed by a digest of them): they are not checked against the changes, only for being one per change, distinct, and having the document’s heads as the changes nothing depends on. Hashes that fail that are ignored and the changes rebuilt as usual.

Trait Implementations

impl<'a> Debug for LoadOptions<'a>

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

Formats the value using the given formatter.

impl Default for LoadOptions<'static>

fn default() -> LoadOptions<'static>

Returns the “default value” for a type.