Struct melib::backends::jmap::rfc8620::Set

pub struct Set<OBJ: Object> where
    OBJ: Debug + Serialize,  {
    pub account_id: Id<Account>,
    pub if_in_state: Option<State<OBJ>>,
    pub create: Option<HashMap<Id<OBJ>, OBJ>>,
    pub update: Option<HashMap<Id<OBJ>, Value>>,
    pub destroy: Option<Vec<Id<OBJ>>>,
}

#set

Modifying the state of Foo objects on the server is done via the "Foo/set" method. This encompasses creating, updating, and destroying Foo records. This allows the server to sort out ordering and dependencies that may exist if doing multiple operations at once (for example, to ensure there is always a minimum number of a certain record type).

Fields

account_id: Id<Account>

o accountId: "Id"

The id of the account to use.

if_in_state: Option<State<OBJ>>

o ifInState: "String|null"

This is a state string as returned by the "Foo/get" method (representing the state of all objects of this type in the account). If supplied, the string must match the current state; otherwise, the method will be aborted and a "stateMismatch" error returned. If null, any changes will be applied to the current state.

create: Option<HashMap<Id<OBJ>, OBJ>>

o create: "Id[Foo]|null"

A map of a creation id (a temporary id set by the client) to Foo objects, or null if no objects are to be created.

The Foo object type definition may define default values for properties. Any such property may be omitted by the client.

The client MUST omit any properties that may only be set by the server (for example, the "id" property on most object types).

update: Option<HashMap<Id<OBJ>, Value>>

o update: "Id[PatchObject]|null"

A map of an id to a Patch object to apply to the current Foo object with that id, or null if no objects are to be updated.

A PatchObject is of type "String[*]" and represents an unordered set of patches. The keys are a path in JSON Pointer format [RFC6901], with an implicit leading "/" (i.e., prefix each key with "/" before applying the JSON Pointer evaluation algorithm).

All paths MUST also conform to the following restrictions; if there is any violation, the update MUST be rejected with an "invalidPatch" error:

• The pointer MUST NOT reference inside an array (i.e., you MUST NOT insert/delete from an array; the array MUST be replaced in its entirety instead).

• All parts prior to the last (i.e., the value after the final slash) MUST already exist on the object being patched.

• There MUST NOT be two patches in the PatchObject where the pointer of one is the prefix of the pointer of the other, e.g., "alerts/1/offset" and "alerts".

The value associated with each pointer determines how to apply that patch:

• If null, set to the default value if specified for this property; otherwise, remove the property from the patched object. If the key is not present in the parent, this a no-op.

• Anything else: The value to set for this property (this may be a replacement or addition to the object being patched).

Any server-set properties MAY be included in the patch if their value is identical to the current server value (before applying the patches to the object). Otherwise, the update MUST be rejected with an "invalidProperties" SetError.

This patch definition is designed such that an entire Foo object is also a valid PatchObject. The client may choose to optimise network usage by just sending the diff or may send the whole object; the server processes it the same either way.

destroy: Option<Vec<Id<OBJ>>>

o destroy: "Id[]|null"

A list of ids for Foo objects to permanently delete, or null if no objects are to be destroyed.

Implementations

impl<OBJ: Object> Set<OBJ> where
    OBJ: Debug + Serialize, 

pub fn new() -> Self

pub fn account_id(self, new_val: Id<Account>) -> Self

pub fn if_in_state(self, new_val: Option<State<OBJ>>) -> Self

o ifInState: "String|null"

This is a state string as returned by the "Foo/get" method (representing the state of all objects of this type in the account). If supplied, the string must match the current state; otherwise, the method will be aborted and a "stateMismatch" error returned. If null, any changes will be applied to the current state.

pub fn update(self, new_val: Option<HashMap<Id<OBJ>, Value>>) -> Self

Trait Implementations

impl<OBJ: Debug + Object> Debug for Set<OBJ> where
    OBJ: Debug + Serialize, 

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

Formats the value using the given formatter.

impl<'de, OBJ: Object> Deserialize<'de> for Set<OBJ> where
    OBJ: Debug + Serialize,
    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 Set<OBJ> where
    OBJ: Debug + Serialize,
    OBJ: Serialize, 

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

Serialize this value into the given Serde serializer.