Enum ServiceReply 

pub enum ServiceReply<T: Serialize, E> {
    Ok {
        result: T,
    },
    Err {
        reason: String,
        msg: Option<String>,
        _e: E,
    },
}

Variants

Ok

Fields

result: T

Err

Fields

reason: String

msg: Option<String>

_e: E

Trait Implementations

impl<T, E> From<E> for ServiceReply<T, E>

where T: Serialize, E: Debug + Error,

fn from(e: E) -> ServiceReply<T, E>

Converts to this type from the input type.

impl<T, E> From<Result<T, E>> for ServiceReply<T, E>

where T: Serialize, E: Debug + Error,

fn from(res: Result<T, E>) -> ServiceReply<T, E>

Converts to this type from the input type.

impl<T, E> Reply<T, E> for ServiceReply<T, E>

where T: Serialize + 'static, E: From<Error> + Debug + Error + 'static,

fn reply(&self, status: StatusCode) -> HyperFuture

write reply body

fn serv_state<F, S, Req>(state: S, f: F) -> HyperService

where Self: 'static, F: for<'a> Fn(&'a S, Req) -> Box<dyn Future<Item = T, Error = E>> + 'static, S: 'static, Req: for<'de> Deserialize<'de> + 'static,

serv_state build HyperService with given function F and state S.

fn serv<F, Req>(f: F) -> HyperService

where Self: 'static, F: Fn(Req) -> Box<dyn Future<Item = T, Error = E>> + 'static, Req: for<'de> Deserialize<'de> + 'static,

service builds HyperService with given function F.

fn serv_state_sync<F, S, Req>(state: S, f: F) -> HyperService

where Self: 'static, F: for<'a> Fn(&'a S, Req) -> Result<T, E> + 'static, S: 'static, Req: for<'de> Deserialize<'de> + 'static,

serv_state builds HyperService with given function F and state S.

fn serv_sync<F, Req>(f: F) -> HyperService

where Self: 'static, F: Fn(Req) -> Result<T, E> + 'static, Req: for<'de> Deserialize<'de> + 'static,

serv build HyperService with given function F.

impl<T, E> Serialize for ServiceReply<T, E>

where T: Serialize + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.