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 path(&self, key: &str, bytes_key: &str) -> Result<Vec<u8>, RecoveryError>

What: A required text field that names a path, with the exact bytes from bytes_key when the record has them. Why: A name that is not UTF-8 is stored as its readable text and, beside it, the base64 of its bytes; a record written by the incumbent has only the text, which is then the exact name. Bytes whose readable text differs from the text field are a damaged record.

In TS you’d write (pseudocode):

read.path(key, bytesKey)

pub fn paths( &self, key: &str, bytes_key: &str, ) -> Result<Vec<Vec<u8>>, RecoveryError>

What: A required array of text that names paths, with the exact bytes of every path from bytes_key when the record has them. Why: See path; the two arrays line up entry for entry.

In TS you’d write (pseudocode):

read.paths(key, bytesKey)

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 optional_digest( &self, key: &str, ) -> Result<Option<ContentDigest>, RecoveryError>

What: An optional content digest of an index snapshot: absent is None, present must be { "length": <whole number>, "fnv1a64": <16 lowercase hexadecimal digits> }. Why: Records written before the digests existed have none and keep their old trust in the artifact identity; a digest that is present but misspelled is a damaged record and never read as absent.

In TS you’d write (pseudocode):

read.optionalDigest(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)