Struct MatrixRequest

pub struct MatrixRequest<'a, T, U = ClientApi> {
    pub meth: Method,
    pub endpoint: Cow<'a, str>,
    pub params: HashMap<Cow<'a, str>, Cow<'a, str>>,
    pub body: T,
    pub typ: U,
}

A arbitrary request to an endpoint in the Matrix API.

To actually determine what URL is used for the request, two things are consulted: the request type, and the request endpoint. The request type specifies what Matrix API is being used (for example, the client-server API revision 0, under /_matrix/client/r0), while the endpoint determines what method is being called on that API.

This type has Super Cow Powers.

Fields

meth: Method

Request method (exported in the http module)

endpoint: Cow<'a, str>

API endpoint (e.g. /sync)

params: HashMap<Cow<'a, str>, Cow<'a, str>>

Query-string parameters.

body: T

Request body (some type implementing Serialize).

If this is empty (serialises to {}), it will not be sent. Therefore, requests with no body should use () here.

typ: U

Request type.

Implementations

impl<'a, T, U> MatrixRequest<'a, T, U>

where T: Serialize, U: ApiType,

pub fn new<S: Into<Cow<'a, str>>>( meth: Method, endpoint: S, body: T, typ: U, ) -> Self

Make a new MatrixRequest, specifying all possible options.

impl<'a> MatrixRequest<'a, ()>

pub fn new_basic<S: Into<Cow<'a, str>>>(meth: Method, endpoint: S) -> Self

Makes a MatrixRequest with the following defaults:

• meth and endpoint specified
• params set to an empty hashmap
• body set to ()
• typ set to apis::r0::ClientApi

impl<'a, 'b, 'c> MatrixRequest<'a, HashMap<Cow<'b, str>, Cow<'c, str>>>

pub fn new_with_body<S, T, U, V>(meth: Method, endpoint: S, body: V) -> Self

where S: Into<Cow<'a, str>>, T: Into<Cow<'b, str>>, U: Into<Cow<'c, str>>, V: IntoIterator<Item = (T, U)>,

Makes a MatrixRequest with the following defaults:

• meth and endpoint specified
• body converted from an iterator over (T, U) where T & U implement Into<Cow<str>>
• params set to an empty hashmap
• typ set to apis::r0::ClientApi

impl<'a, T> MatrixRequest<'a, T>

where T: Serialize,

pub fn new_with_body_ser<S>(meth: Method, endpoint: S, body: T) -> Self

where S: Into<Cow<'a, str>>,

Like new_with_body, but takes a serializable object for body.

impl<'a, T, U> MatrixRequest<'a, T, U>

where T: Serialize, U: ApiType,

pub fn make_request<C>(&self, client: &C) -> MatrixResult<Request<Vec<u8>>>

where C: MatrixRequestable,

Make this MatrixRequest into a HTTP request.

pub fn send<C, R>( &self, mxc: &mut C, ) -> impl Future<Item = R, Error = MatrixError> + 'static

where R: DeserializeOwned + 'static, C: MatrixRequestable,

Sends this request to a Matrix homeserver, expecting a deserializable R return type.

A helpful mix of make_hyper() and MatrixClient::send_request().

pub fn discarding_send<'x, 'y, C>( &'x self, mxc: &'y mut C, ) -> impl Future<Item = (), Error = MatrixError> + 'static

where C: MatrixRequestable,

Like send(), but uses MatrixClient::send_discarding_request().