Struct TryData 

pub struct TryData<T>(pub Result<T, ParserError>);

An Extractor that returns the deserialized incoming data or a deserialization error.

Deserializing to a generic type (e.g. Data<serde_json::Value>).

Deserialization to a generic type is possible (note that it will be less performant/memory efficient). However if you have binary data in you message. It is recommended to use rmpv::Value rather than serde_json::Value. This is because rmpv::Value has a binary data variant contrary to serde_json::Value. If you still use serde_json::Value with binary data, it will be converted to a sequence of numbers which is less efficient than a binary blob.

Alternatively if your binary fields are at the top level of your object you can deserialize to a type with a dynamic type in it: (serde_json::Value, Bytes, Bytes) or

struct MyData {
    data: serde_json::Value,
    binary1: bytes::Bytes,
    binary2: bytes::Bytes,
}

Tuple Fields

0: Result<T, ParserError>

Methods from Deref<Target = Result<T, ParserError>>

pub fn is_ok(&self) -> bool

Returns true if the result is Ok.

Examples

let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);

pub fn is_err(&self) -> bool

Returns true if the result is Err.

Examples

let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);

pub fn as_ref(&self) -> Result<&T, &E>

Converts from &Result<T, E> to Result<&T, &E>.

Produces a new Result, containing a reference into the original, leaving the original in place.

Examples

let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));

pub fn as_mut(&mut self) -> Result<&mut T, &mut E>

Converts from &mut Result<T, E> to Result<&mut T, &mut E>.

Examples

fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);

pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>

where T: Deref,

Converts from Result<T, E> (or &Result<T, E>) to Result<&<T as Deref>::Target, &E>.

Coerces the Ok variant of the original Result via Deref and returns the new Result.

Examples

let x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&str, &u32> = Ok("hello");
assert_eq!(x.as_deref(), y);

let x: Result<String, u32> = Err(42);
let y: Result<&str, &u32> = Err(&42);
assert_eq!(x.as_deref(), y);

pub fn as_deref_mut(&mut self) -> Result<&mut <T as Deref>::Target, &mut E>

where T: DerefMut,

Converts from Result<T, E> (or &mut Result<T, E>) to Result<&mut <T as DerefMut>::Target, &mut E>.

Coerces the Ok variant of the original Result via DerefMut and returns the new Result.

Examples

let mut s = "HELLO".to_string();
let mut x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&mut str, &mut u32> = Ok(&mut s);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);

let mut i = 42;
let mut x: Result<String, u32> = Err(42);
let y: Result<&mut str, &mut u32> = Err(&mut i);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

The iterator yields one value if the result is Result::Ok, otherwise none.

Examples

let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a mutable iterator over the possibly contained value.

The iterator yields one value if the result is Result::Ok, otherwise none.

Examples

let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {},
}
assert_eq!(x, Ok(40));

let mut x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter_mut().next(), None);

Trait Implementations

impl<T> Deref for TryData<T>

type Target = Result<T, ParserError>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for TryData<T>

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

Mutably dereferences the value.

impl<T, A> FromConnectParts<A> for TryData<T>

where T: DeserializeOwned, A: Adapter,

type Error = Infallible

The error type returned by the extractor

fn from_connect_parts( s: &Arc<Socket<A>>, auth: &Option<Value>, ) -> Result<Self, Infallible>

Extract the arguments from the connect event. If it fails, the handler is not called

impl<T, A> FromMessageParts<A> for TryData<T>

where T: DeserializeOwned, A: Adapter,

type Error = Infallible

The error type returned by the extractor

fn from_message_parts( s: &Arc<Socket<A>>, v: &mut Value, _: &Option<i64>, ) -> Result<Self, Infallible>

Extract the arguments from the message event. If it fails, the handler is not called.