Struct jmap_client::event_source::Changes

pub struct Changes { /* private fields */ }

Implementations

impl Changes

pub fn new( id: Option<String>, changes: AHashMap<String, AHashMap<TypeState, String>> ) -> Self

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

Examples found in repository

examples/eventsource.rs (line 51)

async fn event_source() {
    // Connect to the JMAP server using Basic authentication
    let client = Client::new()
        .credentials(("john@example.org", "secret"))
        .connect("https://jmap.example.org")
        .await
        .unwrap();

    // Open EventSource connection
    let mut stream = client
        .event_source(
            [
                TypeState::Email,
                TypeState::EmailDelivery,
                TypeState::Mailbox,
                TypeState::EmailSubmission,
                TypeState::Identity,
            ]
            .into(),
            false,
            60.into(),
            None,
        )
        .await
        .unwrap();

    // Consume events
    while let Some(event) = stream.next().await {
        let changes = event.unwrap();
        println!("-> Change id: {:?}", changes.id());
        for account_id in changes.changed_accounts() {
            println!(" Account {} has changes:", account_id);
            if let Some(account_changes) = changes.changes(account_id) {
                for (type_state, state_id) in account_changes {
                    println!("   Type {:?} has a new state {}.", type_state, state_id);
                }
            }
        }
    }
}

pub fn account_changes( &mut self, account_id: &str ) -> Option<AHashMap<TypeState, String>>

pub fn changed_accounts(&self) -> impl Iterator<Item = &String>

Examples found in repository

examples/eventsource.rs (line 52)

async fn event_source() {
    // Connect to the JMAP server using Basic authentication
    let client = Client::new()
        .credentials(("john@example.org", "secret"))
        .connect("https://jmap.example.org")
        .await
        .unwrap();

    // Open EventSource connection
    let mut stream = client
        .event_source(
            [
                TypeState::Email,
                TypeState::EmailDelivery,
                TypeState::Mailbox,
                TypeState::EmailSubmission,
                TypeState::Identity,
            ]
            .into(),
            false,
            60.into(),
            None,
        )
        .await
        .unwrap();

    // Consume events
    while let Some(event) = stream.next().await {
        let changes = event.unwrap();
        println!("-> Change id: {:?}", changes.id());
        for account_id in changes.changed_accounts() {
            println!(" Account {} has changes:", account_id);
            if let Some(account_changes) = changes.changes(account_id) {
                for (type_state, state_id) in account_changes {
                    println!("   Type {:?} has a new state {}.", type_state, state_id);
                }
            }
        }
    }
}

pub fn changes( &self, account_id: &str ) -> Option<impl Iterator<Item = (&TypeState, &String)>>

Examples found in repository

examples/eventsource.rs (line 54)

async fn event_source() {
    // Connect to the JMAP server using Basic authentication
    let client = Client::new()
        .credentials(("john@example.org", "secret"))
        .connect("https://jmap.example.org")
        .await
        .unwrap();

    // Open EventSource connection
    let mut stream = client
        .event_source(
            [
                TypeState::Email,
                TypeState::EmailDelivery,
                TypeState::Mailbox,
                TypeState::EmailSubmission,
                TypeState::Identity,
            ]
            .into(),
            false,
            60.into(),
            None,
        )
        .await
        .unwrap();

    // Consume events
    while let Some(event) = stream.next().await {
        let changes = event.unwrap();
        println!("-> Change id: {:?}", changes.id());
        for account_id in changes.changed_accounts() {
            println!(" Account {} has changes:", account_id);
            if let Some(account_changes) = changes.changes(account_id) {
                for (type_state, state_id) in account_changes {
                    println!("   Type {:?} has a new state {}.", type_state, state_id);
                }
            }
        }
    }
}

pub fn has_type(&self, type_: TypeState) -> bool

pub fn into_inner(self) -> AHashMap<String, AHashMap<TypeState, String>>

pub fn is_empty(&self) -> bool

Trait Implementations

impl Clone for Changes

fn clone(&self) -> Changes

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Changes

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Changes

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Changes

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Changes

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Changes

impl StructuralEq for Changes

impl StructuralPartialEq for Changes