Struct Chat 

pub struct Chat {
    pub rowid: i32,
    pub chat_identifier: String,
    pub service_name: Option<String>,
    pub display_name: Option<String>,
}

Represents a single row in the chat table.

Fields

rowid: i32

The unique identifier for the chat in the database

chat_identifier: String

The identifier for the chat, typically a phone number, email, or group chat ID

service_name: Option<String>

The service the chat used, i.e. iMessage, SMS, IRC, etc.

display_name: Option<String>

Optional custom name created created for the chat

Implementations

impl Chat

pub fn name(&self) -> &str

Generate a name for a chat, falling back to the default if a custom one is not set

pub fn display_name(&self) -> Option<&str>

Get the current display name for the chat, if it exists.

pub fn service(&self) -> Service<'_>

Get the service used by the chat, i.e. iMessage, SMS, IRC, etc.

pub fn properties(&self, db: &Connection) -> Option<Properties>

Get the Properties for the chat, if they exist

Calling this hits the database, so it is expensive and should only get invoked when needed.

Trait Implementations

impl Cacheable for Chat

fn cache(db: &Connection) -> Result<HashMap<Self::K, Self::V>, TableError>

Generate a hashmap containing each chatroom’s ID pointing to the chatroom’s metadata.

These chatroom ID’s contain duplicates and must be deduped later once we have all of the participants parsed out. On its own this data is not useful.

Example:

use imessage_database::util::dirs::default_db_path;
use imessage_database::tables::table::{Cacheable, get_connection};
use imessage_database::tables::chat::Chat;

let db_path = default_db_path();
let conn = get_connection(&db_path).unwrap();
let chatrooms = Chat::cache(&conn);

type K = i32

The key type for the cache HashMap

type V = Chat

The value type for the cache HashMap

impl Debug for Chat

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

Formats the value using the given formatter.

impl Table for Chat

fn from_row(row: &Row<'_>) -> Result<Chat>

Deserialize a single row into Self, returning a rusqlite::Result

fn get(db: &Connection) -> Result<CachedStatement<'_>, TableError>

Prepare SELECT * statement

fn extract(chat: Result<Result<Self, Error>, Error>) -> Result<Self, TableError>

Map a rusqlite::Result<Self> into our TableError

fn stream<F, E>(db: &Connection, callback: F) -> Result<(), TableError>

where F: FnMut(Result<Self, TableError>) -> Result<(), E>,

Process all rows from the table using a callback. This is the most memory-efficient approach for large tables.

fn get_blob<'a>( &self, db: &'a Connection, table: &str, column: &str, rowid: i64, ) -> Option<Blob<'a>>

Get a BLOB from the table

fn has_blob( &self, db: &Connection, table: &str, column: &str, rowid: i64, ) -> bool

Check if a BLOB exists in the table