Struct Response 

pub struct Response<T> {
    pub rate_limit_status: RateLimit,
    pub response: T,
}

A helper struct to wrap response data with accompanying rate limit information.

This is returned by any function that calls a rate-limited method on Twitter, to allow for inline checking of the rate-limit information without an extra call to service::rate_limit_info.

As this implements Deref and DerefMut, you can transparently use the contained response’s methods as if they were methods on this struct.

Fields

rate_limit_status: RateLimit

The latest rate-limit information returned with the request.

response: T

The decoded response from the request.

Implementations

impl<T> Response<T>

pub fn new(rate_limit_status: RateLimit, response: T) -> Response<T>

impl<T> Response<T>

pub fn map<F, U>(src: Response<T>, fun: F) -> Response<U>

where F: FnOnce(T) -> U,

Convert a Response<T> to a Response<U> by running its contained response through the given function. This preserves its rate-limit information.

Note that this is not a member function, so as to not conflict with potential methods on the contained T.

pub fn try_map<F, U, E>(src: Response<T>, fun: F) -> Result<Response<U>, E>

where F: FnOnce(T) -> Result<U, E>,

Attempt to convert a Response<T> into a Response<U> by running its contained response through the given function, preserving its rate-limit information. If the conversion function fails, an error is returned instead.

Note that this is not a member function, so as to not conflict with potential methods on the contained T.

pub fn into<U>(src: Self) -> Response<U>

where T: Into<U>,

Converts a Response<T> into a Response<U> using the Into trait.

This is implemented as a type function instead of the From/Into trait due to implementation conflicts with the From<T> for T implementation in the standard library. It is also implemented as a function directly on the Response type instead of as a member function to not clash with the into() function that would be available on the contained T.

Trait Implementations

impl<T: Debug> Debug for Response<T>

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

Formats the value using the given formatter.

impl<T> DerefMut for Response<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, T> Deserialize<'de> for Response<T>

where T: Deserialize<'de> + Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: IntoIterator> IntoIterator for Response<T>

type IntoIter = ResponseIter<<T as IntoIterator>::IntoIter>

Which kind of iterator are we turning this into?

type Item = Response<<T as IntoIterator>::Item>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> Deref for Response<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.