Struct RecordReader 

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

What: A field reader over one untrusted record object, naming the record in failures. Why: The incumbent’s createRecordReader: each accessor fails closed with “Transaction record has a malformed field.”

In TS you’d write (pseudocode):

type RecordReader = { string(key): string; ... };

Implementations

impl<'a> RecordReader<'a>

Typed accessors, each failing closed with the field named.

pub fn new(name: &str, map: &'a Map<String, Value>) -> Self

What: A reader over a parsed object. Why: Nested objects get their own reader with a #-joined name.

In TS you’d write (pseudocode):

createRecordReader({ name, value })

pub fn malformed(&self, key: &str) -> RecoveryError

What: The malformed-field failure. Why: Every accessor reports the same sentence.

In TS you’d write (pseudocode):

malformed(key)

pub fn string(&self, key: &str) -> Result<String, RecoveryError>

What: A required text field; any text, empty included, as typeof === 'string'. Why: The incumbent’s readString.

In TS you’d write (pseudocode):

read.string(key)

pub fn optional_string( &self, key: &str, ) -> Result<Option<String>, RecoveryError>

What: An optional text field: absent is None, present must be text. Why: The incumbent’s optionalString (key in value).

In TS you’d write (pseudocode):

read.optionalString(key)

pub fn boolean(&self, key: &str) -> Result<bool, RecoveryError>

What: A required boolean field. Why: The incumbent’s boolean.

In TS you’d write (pseudocode):

read.boolean(key)

pub fn positive_integer(&self, key: &str) -> Result<i64, RecoveryError>

What: A required safe integer of at least 1. Why: The incumbent’s positiveInteger.

In TS you’d write (pseudocode):

read.positiveInteger(key)

pub fn strings(&self, key: &str) -> Result<Vec<String>, RecoveryError>

What: A required array of text. Why: The incumbent’s strings.

In TS you’d write (pseudocode):

read.strings(key)

pub fn object(&self, key: &str) -> Result<RecordReader<'a>, RecoveryError>

What: A required nested object, as its own reader. Why: The incumbent’s object; arrays and null are not objects here.

In TS you’d write (pseudocode):

read.object(key)

pub fn base(&self, key: &str) -> Result<Base, RecoveryError>

What: A required base. Why: The incumbent’s base: unborn, or commit with an oid.

In TS you’d write (pseudocode):

read.base(key)

pub fn identity(&self, key: &str) -> Result<FileIdentity, RecoveryError>

What: A required file identity. Why: The incumbent’s identity.

In TS you’d write (pseudocode):

read.identity(key)

pub fn lock(&self, key: &str) -> Result<LockIdentity, RecoveryError>

What: A required lock identity. Why: The incumbent’s lock.

In TS you’d write (pseudocode):

read.lock(key)

pub fn added_paths(&self, key: &str) -> Result<Vec<AddedPath>, RecoveryError>

What: A required list of added-path records. Why: The incumbent’s addedPaths: each item an object with a regular or executable mode.

In TS you’d write (pseudocode):

read.addedPaths(key)