Struct Reader 

struct Reader {

    version: u32,
    logged: Rows,
    indexed: bool,
    arrived: Rows,
    backlog: Rows,
    newest_at: i64,
    since: i64,
    started: i64,
    total_texts: u64,
    total_media: u64,
    measured: i64,
    done_texts: u64,
    done_media: u64,
    looked: i64,
    behind: bool,
    left: bool,
}

The reader’s state and the import’s measures, private to the phone (texts/reader.json in the state folder): the rows its log holds, those still to read, when the import began, what the phone holds and how much has gone.

Fields

version: u32

READER_VERSION; 0, the first version’s (30 days, before the archive); 2, marks of the ids read, oldest first; 3, ranges of the ids read, newest first. Both knew a row by its id alone, which the plain texts’ table gives again to the next text once the newest one was deleted: such a text was never read. Version 4 knows each row by its id and its date (texts::Row).

logged: Rows

The rows this phone’s log holds (texts deleted on the phone among them), made from the log itself when indexed is false (a reader of an older version, or one lost), and again at each day’s look.

indexed: bool

arrived: Rows

Rows that appeared since a step and are not read yet: read at the next steps, on the battery too.

backlog: Rows

The history still to read (a first import, or a block of old texts put at once): the newest first by date, all of it while the phone charges, its newest meanwhile.

newest_at: i64

The newest text read (ms): on the battery, the history is read only above it.

since: i64

When the history was found (ms): a block of old texts, or what the log of a reader of an older version lacked; for a first import, started. On the battery, nothing older than a day before it is read.

started: i64

total_texts: u64

What the phone holds, as last measured (texts; media bytes), and when.

total_media: u64

measured: i64

done_texts: u64

What has gone to your computers: the texts the log holds, the media bytes put in the sharing.

done_media: u64

looked: i64

When the deletions were last looked for.

behind: bool

A history waits (backlog): all of it only while the phone charges (import_now), its newest meanwhile (recent_now).

left: bool

Rows that came wait still (arrived: their media over a step’s share): the next step reads on, on the battery too.

Implementations

impl Reader

fn path() -> PathBuf

fn load() -> Reader

fn load_at(path: &Path) -> Reader

fn save(&self) -> Result<(), String>

fn save_at(&self, path: &Path) -> Result<(), String>

fn measure(&mut self, answer: &Value, now: i64)

What texts-ids measured: how many texts, how many media bytes.

fn index(&mut self, log: &[Text])

What the log holds, read from the log itself: its rows, its newest text, how many texts and media bytes have gone (never a count a step cut short left behind).

Trait Implementations

impl Clone for Reader

fn clone(&self) -> Reader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Reader

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

Formats the value using the given formatter.

impl Default for Reader

fn default() -> Reader

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Reader

where Reader: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Reader

fn eq(&self, other: &Reader) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Reader

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Reader