Struct ServerTaskVariantFull 

pub struct ServerTaskVariantFull<T, R, P, E>
where
    T: Send + 'static,
    R: Send + 'static,
    P: Send + 'static,
    E: RpcErrCodec,
{
    pub seq: u64,
    pub action: RpcActionOwned,
    pub req: R,
    pub req_blob: Option<Buffer>,
    pub resp: Option<P>,
    pub resp_blob: Option<Buffer>,
    pub res: Option<Result<(), E>>,
    /* private fields */
}

A container that impl ServerTaskResp to show an example, presuming you have a type to carry both Request and Response. You can write your customize version.

Fields

seq: u64

action: RpcActionOwned

req: R

req_blob: Option<Buffer>

resp: Option<P>

resp_blob: Option<Buffer>

res: Option<Result<(), E>>

Trait Implementations

impl<T, R, P, E> Debug for ServerTaskVariantFull<T, R, P, E>

where T: Send + 'static, R: Send + 'static + Debug, P: Send + 'static, E: RpcErrCodec + Display,

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

Formats the value using the given formatter.

impl<T, R, P, E> ServerTaskAction for ServerTaskVariantFull<T, R, P, E>

where T: Send + 'static, R: Send + 'static, P: Send + 'static, E: RpcErrCodec,

fn get_action<'a>(&'a self) -> RpcAction<'a>

impl<T, R, P, E> ServerTaskDecode<T> for ServerTaskVariantFull<T, R, P, E>

where T: Send + 'static, R: for<'b> Deserialize<'b> + Send + 'static, P: Send + 'static, E: RpcErrCodec,

fn decode_req<'a, C: Codec>( codec: &'a C, action: RpcAction<'a>, seq: u64, msg: &'a [u8], blob: Option<Buffer>, noti: RespNoti<T>, ) -> Result<Self, ()>

impl<T, R, P, E> ServerTaskDone<T, E> for ServerTaskVariantFull<T, R, P, E>

where T: Send + 'static, R: Send + 'static, P: Send + 'static, E: RpcErrCodec,

fn _set_result(&mut self, res: Result<(), E>) -> RespNoti<T>

Should implement for enum delegation, not intended for user call

fn set_result(self, res: Result<(), E>)

where T: From<Self>,

For users, set the result in the task and send it back

impl<T, R, P, E> ServerTaskEncode for ServerTaskVariantFull<T, R, P, E>

where T: Send + 'static, R: Send + 'static, P: Send + 'static + Serialize, E: RpcErrCodec,

fn encode_resp<'a, 'b, C: Codec>( &'a mut self, codec: &'b C, buf: &'b mut Vec<u8>, ) -> (u64, Result<(usize, Option<&'a [u8]>), EncodedErr>)