Struct TypedReader 

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

A Document bound to its QuillConfig for typed reads. Construct with Quill::reader. Reads target the main card; use card for a composable card. The read twin of TypedWriter.

Implementations

impl<'a> TypedReader<'a>

pub fn new(config: &'a QuillConfig, doc: &'a Document) -> TypedReader<'a>

Bind doc to config. Prefer Quill::reader.

pub fn get(&self, name: &str) -> Result<Option<ReadValue>, EditError>

Read a main-card field, interpreted by its declared type: richtext to markdown (ReadValue::Markdown), plaintext to literal text (ReadValue::Plaintext), every other type verbatim (ReadValue::Value). Ok(None) when the field is absent; EditError::UnknownField for a name the schema does not declare (a typo, as on the write side); EditError::FieldDecode when a content field holds a value that does not decode (a scalar an opaque store_field wrote).

pub fn get_content(&self, name: &str) -> Result<Option<Content>, EditError>

Read a main-card content field as its Content, decoded through the codec its declared type names: the Content twin of get, which returns a projection. Total over the storage form, so a field the writer committed as a canonical content object and one a markdown parse left as an authored string both read back as a Content, and which lane built the document stops being the caller’s business.

Ok(None) when the field is absent; EditError::UnknownField for a name the schema does not declare; EditError::FieldNotContent for a declared type that is not a content leaf (an integer has no Content even when it holds a string, and an array<richtext> carries content without having one Content); EditError::FieldDecode when the stored value decodes under neither encoding.

The codec is the schema’s to name, which is why this read is here and not on Document: a richtext string is markdown, a plaintext string is literal text, and a quill-free read would have to guess.

pub fn body_markdown(&self) -> String

The main body’s markdown projection, the quill-free body read (Card::body_markdown). A body’s type is a format fact, not a schema fact, so this consults no schema and never raises; the body is never absent.

pub fn card(&self, index: usize) -> Result<CardReader<'_>, EditError>

A schema-bound reader for the composable card at index. The card’s $kind resolves its CardSchema; an unknown kind carries no schema, so every field name on it is undeclared and reads with EditError::UnknownField (read such a card verbatim through Card::payload). EditError::IndexOutOfRange when index is out of range: a boundary error, not an absent field, as the card write verbs treat it.