Struct ProfileReader 

pub struct ProfileReader { /* private fields */ }

Implementations

impl ProfileReader

pub fn cached_image( &self, id: &SourceMessageId, quality: ImageQuality, ) -> Result<CachedImage>

Resolve one exact local message through its advertised original hash and hardlink namespace. Ambiguous groups are rejected. Standard/Thumbnail require the exact resource basename/type/status/encoded-size join. A suffix alone is not a quality proof; Original also requires the XML content MD5.

impl ProfileReader

pub fn cached_hardlink_file( &self, kind: HardlinkKind, md5: &str, ) -> Result<CachedBytes>

File/video hardlinks use one month directory and the observed zero second directory sentinel. Every candidate is content-MD5 verified; ambiguous bytes or unknown path layouts are refused rather than guessed.

impl ProfileReader

pub fn peer_metadata( &self, peers: &[String], ) -> Result<BTreeMap<String, PeerMetadata>>

Read one page’s saved metadata without refreshing contacts or catalogs. Missing peers are omitted. A malformed extra buffer affects only its peer; an incompatible database schema remains an error.

impl ProfileReader

pub fn thread_pinned( &self, threads: &[String], ) -> Result<BTreeMap<String, Option<bool>>>

Read the saved pin bit for ordinary contacts and active groups in one query. Incomplete identities and unsupported built-in peers stay unknown.

pub fn thread_muted( &self, threads: &[String], ) -> Result<BTreeMap<String, Option<bool>>>

Derive notification preferences for a page without refreshing contacts. Direct contacts and groups use different official fields; incomplete identities and unexpected values remain unknown.

pub fn group_avatar_members( &self, rooms: &[String], ) -> Result<BTreeMap<String, Vec<GroupMember>>>

Read avatar members for a page of groups with three batched queries. Validate membership against the same official room metadata used by group_members; an inconsistent room does not hide other valid rooms.

impl ProfileReader

pub fn open( location: ProfileLocation, keys: KeyFile, options: ReadOptions, ) -> Result<Self>

Examples found in repository

examples/contacts.rs (lines 11-18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    if args.len() != 3 || args[0] != "--stopped-or-consistent-copy" {
        return Err("usage: contacts --stopped-or-consistent-copy ACCOUNT_ROOT KEYS_FILE".into());
    }
    let location = ProfileLocation::new(&args[1])?;
    let keys = KeyFile::load(&args[2])?;
    let reader = ProfileReader::open(
        location,
        keys,
        ReadOptions {
            stopped_or_consistent_snapshot: true,
            ..Default::default()
        },
    )?;
    println!(
        "{} contacts",
        reader.contacts(&ListQuery::default())?.items.len()
    );
    Ok(())
}

examples/apply_text_fixture.rs (lines 34-41)

fn run() -> Result<()> {
    let a = std::env::args().skip(1).collect::<Vec<_>>();
    if a.len() != 3 {
        return Err(ProfileError::InvalidQuery);
    }
    let location = ProfileLocation::new(&a[0])?;
    let keys = KeyFile::load(&a[1])?;
    let input: IncomingText =
        serde_json::from_slice(&std::fs::read(&a[2])?).map_err(|_| ProfileError::InvalidQuery)?;
    let options = WriteOptions {
        exclusive_ownership_confirmed: true,
        allow_plaintext: false,
        durable_intent_id: "explicit-disposable-fixture-validation".into(),
    };
    let first = apply_incoming_text(&location, &keys, &input, &options)?;
    let retry = apply_incoming_text(&location, &keys, &input, &options)?;
    let read = mark_read_messages(
        &location,
        &keys,
        &input.peer,
        std::slice::from_ref(&first.source_id),
        &options,
    )?;
    let read_retry = mark_read_messages(
        &location,
        &keys,
        &input.peer,
        std::slice::from_ref(&first.source_id),
        &options,
    )?;
    let reader = ProfileReader::open(
        location,
        keys,
        ReadOptions {
            stopped_or_consistent_snapshot: true,
            ..Default::default()
        },
    )?;
    let page = reader.messages(&MessageQuery {
        chat: Some(input.peer),
        limit: Some(200),
        ..Default::default()
    })?;
    let found = page
        .items
        .iter()
        .find(|v| v.id == first.source_id)
        .ok_or(ProfileError::InvalidMetadata)?;
    let exact = found.content.text.as_deref() == Some(input.content.as_str())
        && found.source.text.as_deref() == Some(input.source_xml.as_str())
        && found.server_message_id.as_deref() == Some(input.server_message_id.as_str());
    if !exact || retry.message_inserted || read_retry.removed_unread_rows != 0 {
        return Err(ProfileError::InvalidMetadata);
    }
    println!(
        "{}",
        serde_json::json!({"newTextInserted":first.message_inserted,"retryInsertedDuplicate":retry.message_inserted,"exactBodySourceAndServerIdentity":exact,"removedUnreadRows":read.removed_unread_rows,"readRetryRemovedRows":read_retry.removed_unread_rows,"unreadBefore":read.unread_count_before,"unreadAfter":read.unread_count_after,"crossDatabaseAtomic":first.cross_database_atomic,"networkUsed":false,"officialRuntimeUsed":false})
    );
    Ok(())
}

examples/audit_counts.rs (lines 14-22)

fn run() -> Result<()> {
    let mut args = std::env::args().skip(1);
    let path = args.next().ok_or(ProfileError::InvalidQuery)?;
    let keys = args.next();
    let location = ProfileLocation::new(path)?;
    let (keys, plaintext) = if let Some(path) = keys {
        (KeyFile::load(path)?, false)
    } else {
        (KeyFile::empty(location.account_directory()), true)
    };
    let r = ProfileReader::open(
        location,
        keys,
        ReadOptions {
            stopped_or_consistent_snapshot: true,
            allow_plaintext: plaintext,
            ..Default::default()
        },
    )?;
    let mut contacts = 0;
    let mut avatars = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.contacts(&q)?;
        for c in &p.items {
            if r.avatar(&c.username).is_ok() {
                avatars += 1;
            }
        }
        contacts += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut threads = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.threads(&q)?;
        threads += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut groups = 0;
    let mut members = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.groups(&q)?;
        for g in &p.items {
            let mut mq = ListQuery {
                limit: Some(200),
                ..Default::default()
            };
            loop {
                let mp = r.group_members(&g.username, &mq)?;
                members += mp.items.len();
                mq.cursor = mp.next_cursor;
                if mq.cursor.is_none() {
                    break;
                }
            }
        }
        groups += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut messages = 0;
    let mut unresolved = 0;
    let mut decoded = 0;
    let mut q = MessageQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.messages(&q)?;
        for m in &p.items {
            unresolved += usize::from(m.peer.is_none());
            decoded += usize::from(m.content.text.is_some());
        }
        messages += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    println!(
        "{}",
        serde_json::json!({"databases":r.inventory().len(),"partial":r.coverage().partial,"contacts":contacts,"threads":threads,"groups":groups,"groupMembers":members,"cachedAvatars":avatars,"messages":messages,"decodedBodies":decoded,"unresolvedMessages":unresolved,"writesPerformed":false})
    );
    Ok(())
}

pub fn generation(&self) -> &str

pub fn schemas(&self) -> &[SchemaReport]

pub fn coverage(&self) -> Coverage

Examples found in repository

examples/audit_counts.rs (line 104)

fn run() -> Result<()> {
    let mut args = std::env::args().skip(1);
    let path = args.next().ok_or(ProfileError::InvalidQuery)?;
    let keys = args.next();
    let location = ProfileLocation::new(path)?;
    let (keys, plaintext) = if let Some(path) = keys {
        (KeyFile::load(path)?, false)
    } else {
        (KeyFile::empty(location.account_directory()), true)
    };
    let r = ProfileReader::open(
        location,
        keys,
        ReadOptions {
            stopped_or_consistent_snapshot: true,
            allow_plaintext: plaintext,
            ..Default::default()
        },
    )?;
    let mut contacts = 0;
    let mut avatars = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.contacts(&q)?;
        for c in &p.items {
            if r.avatar(&c.username).is_ok() {
                avatars += 1;
            }
        }
        contacts += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut threads = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.threads(&q)?;
        threads += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut groups = 0;
    let mut members = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.groups(&q)?;
        for g in &p.items {
            let mut mq = ListQuery {
                limit: Some(200),
                ..Default::default()
            };
            loop {
                let mp = r.group_members(&g.username, &mq)?;
                members += mp.items.len();
                mq.cursor = mp.next_cursor;
                if mq.cursor.is_none() {
                    break;
                }
            }
        }
        groups += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut messages = 0;
    let mut unresolved = 0;
    let mut decoded = 0;
    let mut q = MessageQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.messages(&q)?;
        for m in &p.items {
            unresolved += usize::from(m.peer.is_none());
            decoded += usize::from(m.content.text.is_some());
        }
        messages += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    println!(
        "{}",
        serde_json::json!({"databases":r.inventory().len(),"partial":r.coverage().partial,"contacts":contacts,"threads":threads,"groups":groups,"groupMembers":members,"cachedAvatars":avatars,"messages":messages,"decodedBodies":decoded,"unresolvedMessages":unresolved,"writesPerformed":false})
    );
    Ok(())
}

pub fn inventory(&self) -> &[DatabaseInventory]

Examples found in repository

examples/audit_counts.rs (line 104)

fn run() -> Result<()> {
    let mut args = std::env::args().skip(1);
    let path = args.next().ok_or(ProfileError::InvalidQuery)?;
    let keys = args.next();
    let location = ProfileLocation::new(path)?;
    let (keys, plaintext) = if let Some(path) = keys {
        (KeyFile::load(path)?, false)
    } else {
        (KeyFile::empty(location.account_directory()), true)
    };
    let r = ProfileReader::open(
        location,
        keys,
        ReadOptions {
            stopped_or_consistent_snapshot: true,
            allow_plaintext: plaintext,
            ..Default::default()
        },
    )?;
    let mut contacts = 0;
    let mut avatars = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.contacts(&q)?;
        for c in &p.items {
            if r.avatar(&c.username).is_ok() {
                avatars += 1;
            }
        }
        contacts += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut threads = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.threads(&q)?;
        threads += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut groups = 0;
    let mut members = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.groups(&q)?;
        for g in &p.items {
            let mut mq = ListQuery {
                limit: Some(200),
                ..Default::default()
            };
            loop {
                let mp = r.group_members(&g.username, &mq)?;
                members += mp.items.len();
                mq.cursor = mp.next_cursor;
                if mq.cursor.is_none() {
                    break;
                }
            }
        }
        groups += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut messages = 0;
    let mut unresolved = 0;
    let mut decoded = 0;
    let mut q = MessageQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.messages(&q)?;
        for m in &p.items {
            unresolved += usize::from(m.peer.is_none());
            decoded += usize::from(m.content.text.is_some());
        }
        messages += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    println!(
        "{}",
        serde_json::json!({"databases":r.inventory().len(),"partial":r.coverage().partial,"contacts":contacts,"threads":threads,"groups":groups,"groupMembers":members,"cachedAvatars":avatars,"messages":messages,"decodedBodies":decoded,"unresolvedMessages":unresolved,"writesPerformed":false})
    );
    Ok(())
}

pub fn require_writable(&self) -> Result<()>

pub fn contacts(&self, q: &ListQuery) -> Result<Page<Contact>>

Examples found in repository

examples/contacts.rs (line 21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    if args.len() != 3 || args[0] != "--stopped-or-consistent-copy" {
        return Err("usage: contacts --stopped-or-consistent-copy ACCOUNT_ROOT KEYS_FILE".into());
    }
    let location = ProfileLocation::new(&args[1])?;
    let keys = KeyFile::load(&args[2])?;
    let reader = ProfileReader::open(
        location,
        keys,
        ReadOptions {
            stopped_or_consistent_snapshot: true,
            ..Default::default()
        },
    )?;
    println!(
        "{} contacts",
        reader.contacts(&ListQuery::default())?.items.len()
    );
    Ok(())
}

examples/audit_counts.rs (line 30)

fn run() -> Result<()> {
    let mut args = std::env::args().skip(1);
    let path = args.next().ok_or(ProfileError::InvalidQuery)?;
    let keys = args.next();
    let location = ProfileLocation::new(path)?;
    let (keys, plaintext) = if let Some(path) = keys {
        (KeyFile::load(path)?, false)
    } else {
        (KeyFile::empty(location.account_directory()), true)
    };
    let r = ProfileReader::open(
        location,
        keys,
        ReadOptions {
            stopped_or_consistent_snapshot: true,
            allow_plaintext: plaintext,
            ..Default::default()
        },
    )?;
    let mut contacts = 0;
    let mut avatars = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.contacts(&q)?;
        for c in &p.items {
            if r.avatar(&c.username).is_ok() {
                avatars += 1;
            }
        }
        contacts += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut threads = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.threads(&q)?;
        threads += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut groups = 0;
    let mut members = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.groups(&q)?;
        for g in &p.items {
            let mut mq = ListQuery {
                limit: Some(200),
                ..Default::default()
            };
            loop {
                let mp = r.group_members(&g.username, &mq)?;
                members += mp.items.len();
                mq.cursor = mp.next_cursor;
                if mq.cursor.is_none() {
                    break;
                }
            }
        }
        groups += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut messages = 0;
    let mut unresolved = 0;
    let mut decoded = 0;
    let mut q = MessageQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.messages(&q)?;
        for m in &p.items {
            unresolved += usize::from(m.peer.is_none());
            decoded += usize::from(m.content.text.is_some());
        }
        messages += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    println!(
        "{}",
        serde_json::json!({"databases":r.inventory().len(),"partial":r.coverage().partial,"contacts":contacts,"threads":threads,"groups":groups,"groupMembers":members,"cachedAvatars":avatars,"messages":messages,"decodedBodies":decoded,"unresolvedMessages":unresolved,"writesPerformed":false})
    );
    Ok(())
}

pub fn thread_exists(&self, username: &str) -> Result<bool>

pub fn threads(&self, q: &ListQuery) -> Result<Page<Thread>>

Examples found in repository

examples/audit_counts.rs (line 48)

fn run() -> Result<()> {
    let mut args = std::env::args().skip(1);
    let path = args.next().ok_or(ProfileError::InvalidQuery)?;
    let keys = args.next();
    let location = ProfileLocation::new(path)?;
    let (keys, plaintext) = if let Some(path) = keys {
        (KeyFile::load(path)?, false)
    } else {
        (KeyFile::empty(location.account_directory()), true)
    };
    let r = ProfileReader::open(
        location,
        keys,
        ReadOptions {
            stopped_or_consistent_snapshot: true,
            allow_plaintext: plaintext,
            ..Default::default()
        },
    )?;
    let mut contacts = 0;
    let mut avatars = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.contacts(&q)?;
        for c in &p.items {
            if r.avatar(&c.username).is_ok() {
                avatars += 1;
            }
        }
        contacts += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut threads = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.threads(&q)?;
        threads += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut groups = 0;
    let mut members = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.groups(&q)?;
        for g in &p.items {
            let mut mq = ListQuery {
                limit: Some(200),
                ..Default::default()
            };
            loop {
                let mp = r.group_members(&g.username, &mq)?;
                members += mp.items.len();
                mq.cursor = mp.next_cursor;
                if mq.cursor.is_none() {
                    break;
                }
            }
        }
        groups += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut messages = 0;
    let mut unresolved = 0;
    let mut decoded = 0;
    let mut q = MessageQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.messages(&q)?;
        for m in &p.items {
            unresolved += usize::from(m.peer.is_none());
            decoded += usize::from(m.content.text.is_some());
        }
        messages += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    println!(
        "{}",
        serde_json::json!({"databases":r.inventory().len(),"partial":r.coverage().partial,"contacts":contacts,"threads":threads,"groups":groups,"groupMembers":members,"cachedAvatars":avatars,"messages":messages,"decodedBodies":decoded,"unresolvedMessages":unresolved,"writesPerformed":false})
    );
    Ok(())
}

pub fn labels(&self) -> Result<BTreeMap<String, String>>

pub fn message_references( &self, chat: Option<&str>, max_items: usize, ) -> Result<Vec<MessageReference>>

Capture complete history membership in one pass per shard. This reads only IDs/timestamps; callers resolve delivered content with messages_by_ids against this same snapshot. No state is cached across snapshots, and incompatible message tables remain errors.

pub fn latest_messages( &self, chats: &[String], own_username: Option<&str>, ) -> Result<BTreeMap<String, Message>>

Read the latest saved message for each requested conversation in one snapshot. One compound query per shard selects one indexed row per conversation; no point lookups or older-body decoding are needed.

pub fn messages(&self, q: &MessageQuery) -> Result<Page<Message>>

Examples found in repository

examples/apply_text_fixture.rs (lines 42-46)

fn run() -> Result<()> {
    let a = std::env::args().skip(1).collect::<Vec<_>>();
    if a.len() != 3 {
        return Err(ProfileError::InvalidQuery);
    }
    let location = ProfileLocation::new(&a[0])?;
    let keys = KeyFile::load(&a[1])?;
    let input: IncomingText =
        serde_json::from_slice(&std::fs::read(&a[2])?).map_err(|_| ProfileError::InvalidQuery)?;
    let options = WriteOptions {
        exclusive_ownership_confirmed: true,
        allow_plaintext: false,
        durable_intent_id: "explicit-disposable-fixture-validation".into(),
    };
    let first = apply_incoming_text(&location, &keys, &input, &options)?;
    let retry = apply_incoming_text(&location, &keys, &input, &options)?;
    let read = mark_read_messages(
        &location,
        &keys,
        &input.peer,
        std::slice::from_ref(&first.source_id),
        &options,
    )?;
    let read_retry = mark_read_messages(
        &location,
        &keys,
        &input.peer,
        std::slice::from_ref(&first.source_id),
        &options,
    )?;
    let reader = ProfileReader::open(
        location,
        keys,
        ReadOptions {
            stopped_or_consistent_snapshot: true,
            ..Default::default()
        },
    )?;
    let page = reader.messages(&MessageQuery {
        chat: Some(input.peer),
        limit: Some(200),
        ..Default::default()
    })?;
    let found = page
        .items
        .iter()
        .find(|v| v.id == first.source_id)
        .ok_or(ProfileError::InvalidMetadata)?;
    let exact = found.content.text.as_deref() == Some(input.content.as_str())
        && found.source.text.as_deref() == Some(input.source_xml.as_str())
        && found.server_message_id.as_deref() == Some(input.server_message_id.as_str());
    if !exact || retry.message_inserted || read_retry.removed_unread_rows != 0 {
        return Err(ProfileError::InvalidMetadata);
    }
    println!(
        "{}",
        serde_json::json!({"newTextInserted":first.message_inserted,"retryInsertedDuplicate":retry.message_inserted,"exactBodySourceAndServerIdentity":exact,"removedUnreadRows":read.removed_unread_rows,"readRetryRemovedRows":read_retry.removed_unread_rows,"unreadBefore":read.unread_count_before,"unreadAfter":read.unread_count_after,"crossDatabaseAtomic":first.cross_database_atomic,"networkUsed":false,"officialRuntimeUsed":false})
    );
    Ok(())
}

examples/audit_counts.rs (line 91)

fn run() -> Result<()> {
    let mut args = std::env::args().skip(1);
    let path = args.next().ok_or(ProfileError::InvalidQuery)?;
    let keys = args.next();
    let location = ProfileLocation::new(path)?;
    let (keys, plaintext) = if let Some(path) = keys {
        (KeyFile::load(path)?, false)
    } else {
        (KeyFile::empty(location.account_directory()), true)
    };
    let r = ProfileReader::open(
        location,
        keys,
        ReadOptions {
            stopped_or_consistent_snapshot: true,
            allow_plaintext: plaintext,
            ..Default::default()
        },
    )?;
    let mut contacts = 0;
    let mut avatars = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.contacts(&q)?;
        for c in &p.items {
            if r.avatar(&c.username).is_ok() {
                avatars += 1;
            }
        }
        contacts += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut threads = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.threads(&q)?;
        threads += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut groups = 0;
    let mut members = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.groups(&q)?;
        for g in &p.items {
            let mut mq = ListQuery {
                limit: Some(200),
                ..Default::default()
            };
            loop {
                let mp = r.group_members(&g.username, &mq)?;
                members += mp.items.len();
                mq.cursor = mp.next_cursor;
                if mq.cursor.is_none() {
                    break;
                }
            }
        }
        groups += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut messages = 0;
    let mut unresolved = 0;
    let mut decoded = 0;
    let mut q = MessageQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.messages(&q)?;
        for m in &p.items {
            unresolved += usize::from(m.peer.is_none());
            decoded += usize::from(m.content.text.is_some());
        }
        messages += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    println!(
        "{}",
        serde_json::json!({"databases":r.inventory().len(),"partial":r.coverage().partial,"contacts":contacts,"threads":threads,"groups":groups,"groupMembers":members,"cachedAvatars":avatars,"messages":messages,"decodedBodies":decoded,"unresolvedMessages":unresolved,"writesPerformed":false})
    );
    Ok(())
}

pub fn message( &self, id: &SourceMessageId, own_username: Option<&str>, ) -> Result<Message>

Read one source-qualified observation without paging through history. Resolve sender numbers only through this database’s own Name2Id map.

pub fn messages_by_ids( &self, ids: &[SourceMessageId], own_username: Option<&str>, ) -> Result<Vec<Message>>

Resolve at most one page without decoding unrelated history. Missing rows are omitted; unreadable databases and incompatible records remain errors. Source-qualified IDs preserve each shard’s own sender namespace.

pub fn messages_by_server_id( &self, chat: &str, server_id: &str, own_username: Option<&str>, ) -> Result<Vec<Message>>

Resolve an unsigned server ID in one conversation only. Return up to two observations so callers can reject ambiguous IDs across shards.

pub fn visit_messages_by_server_ids<E>( &self, targets: &[(String, String)], own_username: Option<&str>, visit: impl FnMut(Message) -> Result<(), E>, ) -> Result<(), E>

where E: From<ProfileError> + From<Error>,

Read quoted originals for one page from this captured snapshot. Group by conversation/shard, decode only matching rows, and retain at most two observations per identity just like the single-reference lookup. The visitor consumes each row before the next, avoiding a page of large bodies.

pub fn groups(&self, q: &ListQuery) -> Result<Page<Group>>

Examples found in repository

examples/audit_counts.rs (line 62)

fn run() -> Result<()> {
    let mut args = std::env::args().skip(1);
    let path = args.next().ok_or(ProfileError::InvalidQuery)?;
    let keys = args.next();
    let location = ProfileLocation::new(path)?;
    let (keys, plaintext) = if let Some(path) = keys {
        (KeyFile::load(path)?, false)
    } else {
        (KeyFile::empty(location.account_directory()), true)
    };
    let r = ProfileReader::open(
        location,
        keys,
        ReadOptions {
            stopped_or_consistent_snapshot: true,
            allow_plaintext: plaintext,
            ..Default::default()
        },
    )?;
    let mut contacts = 0;
    let mut avatars = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.contacts(&q)?;
        for c in &p.items {
            if r.avatar(&c.username).is_ok() {
                avatars += 1;
            }
        }
        contacts += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut threads = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.threads(&q)?;
        threads += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut groups = 0;
    let mut members = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.groups(&q)?;
        for g in &p.items {
            let mut mq = ListQuery {
                limit: Some(200),
                ..Default::default()
            };
            loop {
                let mp = r.group_members(&g.username, &mq)?;
                members += mp.items.len();
                mq.cursor = mp.next_cursor;
                if mq.cursor.is_none() {
                    break;
                }
            }
        }
        groups += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut messages = 0;
    let mut unresolved = 0;
    let mut decoded = 0;
    let mut q = MessageQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.messages(&q)?;
        for m in &p.items {
            unresolved += usize::from(m.peer.is_none());
            decoded += usize::from(m.content.text.is_some());
        }
        messages += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    println!(
        "{}",
        serde_json::json!({"databases":r.inventory().len(),"partial":r.coverage().partial,"contacts":contacts,"threads":threads,"groups":groups,"groupMembers":members,"cachedAvatars":avatars,"messages":messages,"decodedBodies":decoded,"unresolvedMessages":unresolved,"writesPerformed":false})
    );
    Ok(())
}

pub fn group_mention_permissions( &self, room: &str, own: Option<&str>, ) -> Result<GroupMentionPermissions>

pub fn group_members( &self, room: &str, q: &ListQuery, ) -> Result<Page<GroupMember>>

Examples found in repository

examples/audit_counts.rs (line 69)

fn run() -> Result<()> {
    let mut args = std::env::args().skip(1);
    let path = args.next().ok_or(ProfileError::InvalidQuery)?;
    let keys = args.next();
    let location = ProfileLocation::new(path)?;
    let (keys, plaintext) = if let Some(path) = keys {
        (KeyFile::load(path)?, false)
    } else {
        (KeyFile::empty(location.account_directory()), true)
    };
    let r = ProfileReader::open(
        location,
        keys,
        ReadOptions {
            stopped_or_consistent_snapshot: true,
            allow_plaintext: plaintext,
            ..Default::default()
        },
    )?;
    let mut contacts = 0;
    let mut avatars = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.contacts(&q)?;
        for c in &p.items {
            if r.avatar(&c.username).is_ok() {
                avatars += 1;
            }
        }
        contacts += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut threads = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.threads(&q)?;
        threads += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut groups = 0;
    let mut members = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.groups(&q)?;
        for g in &p.items {
            let mut mq = ListQuery {
                limit: Some(200),
                ..Default::default()
            };
            loop {
                let mp = r.group_members(&g.username, &mq)?;
                members += mp.items.len();
                mq.cursor = mp.next_cursor;
                if mq.cursor.is_none() {
                    break;
                }
            }
        }
        groups += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut messages = 0;
    let mut unresolved = 0;
    let mut decoded = 0;
    let mut q = MessageQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.messages(&q)?;
        for m in &p.items {
            unresolved += usize::from(m.peer.is_none());
            decoded += usize::from(m.content.text.is_some());
        }
        messages += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    println!(
        "{}",
        serde_json::json!({"databases":r.inventory().len(),"partial":r.coverage().partial,"contacts":contacts,"threads":threads,"groups":groups,"groupMembers":members,"cachedAvatars":avatars,"messages":messages,"decodedBodies":decoded,"unresolvedMessages":unresolved,"writesPerformed":false})
    );
    Ok(())
}

pub fn avatar(&self, username: &str) -> Result<CachedBytes>

Examples found in repository

examples/audit_counts.rs (line 32)

fn run() -> Result<()> {
    let mut args = std::env::args().skip(1);
    let path = args.next().ok_or(ProfileError::InvalidQuery)?;
    let keys = args.next();
    let location = ProfileLocation::new(path)?;
    let (keys, plaintext) = if let Some(path) = keys {
        (KeyFile::load(path)?, false)
    } else {
        (KeyFile::empty(location.account_directory()), true)
    };
    let r = ProfileReader::open(
        location,
        keys,
        ReadOptions {
            stopped_or_consistent_snapshot: true,
            allow_plaintext: plaintext,
            ..Default::default()
        },
    )?;
    let mut contacts = 0;
    let mut avatars = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.contacts(&q)?;
        for c in &p.items {
            if r.avatar(&c.username).is_ok() {
                avatars += 1;
            }
        }
        contacts += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut threads = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.threads(&q)?;
        threads += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut groups = 0;
    let mut members = 0;
    let mut q = ListQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.groups(&q)?;
        for g in &p.items {
            let mut mq = ListQuery {
                limit: Some(200),
                ..Default::default()
            };
            loop {
                let mp = r.group_members(&g.username, &mq)?;
                members += mp.items.len();
                mq.cursor = mp.next_cursor;
                if mq.cursor.is_none() {
                    break;
                }
            }
        }
        groups += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    let mut messages = 0;
    let mut unresolved = 0;
    let mut decoded = 0;
    let mut q = MessageQuery {
        limit: Some(200),
        ..Default::default()
    };
    loop {
        let p = r.messages(&q)?;
        for m in &p.items {
            unresolved += usize::from(m.peer.is_none());
            decoded += usize::from(m.content.text.is_some());
        }
        messages += p.items.len();
        q.cursor = p.next_cursor;
        if q.cursor.is_none() {
            break;
        }
    }
    println!(
        "{}",
        serde_json::json!({"databases":r.inventory().len(),"partial":r.coverage().partial,"contacts":contacts,"threads":threads,"groups":groups,"groupMembers":members,"cachedAvatars":avatars,"messages":messages,"decodedBodies":decoded,"unresolvedMessages":unresolved,"writesPerformed":false})
    );
    Ok(())
}

pub fn cached_voice( &self, database: &str, chat: &str, local_id: &str, server_id: Option<&str>, ) -> Result<CachedBytes>

Read one exact cached voice record. The supplied media-shard namespace is explicit; its Name2Id is not interchangeable with the message shard.

pub fn decode_dat(&self, bytes: &[u8]) -> Result<(Vec<u8>, DatLayout)>