Struct melib::backends::jmap::rfc8620::QueryChangesResponse

pub struct QueryChangesResponse<OBJ: Object> {
    pub account_id: Id<Account>,
    pub old_query_state: String,
    pub new_query_state: String,
    pub total: Option<usize>,
    pub removed: Vec<Id<OBJ>>,
    pub added: Vec<AddedItem<OBJ>>,
}

Fields

account_id: Id<Account>

The id of the account used for the call.

old_query_state: String

This is the "sinceQueryState" argument echoed back; that is, the state from which the server is returning changes.

new_query_state: String

This is the state the query will be in after applying the set of changes to the old state.

total: Option<usize>

The total number of Foos in the results (given the "filter"). This argument MUST be omitted if the "calculateTotal" request argument is not true.

removed: Vec<Id<OBJ>>

The "id" for every Foo that was in the query results in the old state and that is not in the results in the new state. If the server cannot calculate this exactly, the server MAY return the ids of extra Foos in addition that may have been in the old results but are not in the new results. If the sort and filter are both only on immutable properties and an "upToId" is supplied and exists in the results, any ids that were removed but have a higher index than "upToId" SHOULD be omitted. If the "filter" or "sort" includes a mutable property, the server MUST include all Foos in the current results for which this property may have changed. The position of these may have moved in the results, so they must be reinserted by the client to ensure its query cache is correct.

added: Vec<AddedItem<OBJ>>

The id and index in the query results (in the new state) for every Foo that has been added to the results since the old state AND every Foo in the current results that was included in the "removed" array (due to a filter or sort based upon a mutable property). If the sort and filter are both only on immutable properties and an "upToId" is supplied and exists in the results, any ids that were added but have a higher index than "upToId" SHOULD be omitted. The array MUST be sorted in order of index, with the lowest index first. An AddedItem object has the following properties:

• id: "Id"
• index: "UnsignedInt" The result of this is that if the client has a cached sparse array of Foo ids corresponding to the results in the old state, then: fooIds = [ "id1", "id2", null, null, "id3", "id4", null, null, null ] If it splices out all ids in the removed array that it has in its cached results, then: removed = [ "id2", "id31", ... ]; fooIds => [ "id1", null, null, "id3", "id4", null, null, null ] and splices in (one by one in order, starting with the lowest index) all of the ids in the added array: added = [{ id: "id5", index: 0, ... }]; fooIds => [ "id5", "id1", null, null, "id3", "id4", null, null, null ] and truncates or extends to the new total length, then the results will now be in the new state. Note: splicing in adds the item at the given index, incrementing the index of all items previously at that or a higher index. Splicing out is the inverse, removing the item and decrementing the index of every item after it in the array.

Trait Implementations

impl<OBJ: Debug + Object> Debug for QueryChangesResponse<OBJ>

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

Formats the value using the given formatter.

impl<'de, OBJ: Object> Deserialize<'de> for QueryChangesResponse<OBJ> where
    OBJ: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<OBJ: Object> Serialize for QueryChangesResponse<OBJ> where
    OBJ: Serialize, 

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

Serialize this value into the given Serde serializer.