Enum cdp::CdpOutgoing

pub enum CdpOutgoing<'a> {
    Result {
        id: u64,
        result: Result<Map<String, Value>, CdpError<'a>>,
    },
    Event {
        name: Cow<'a, str>,
        params: Map<String, Value>,
    },
    Error(CdpError<'a>),
}

Variants

Result

Fields of Result

id: u64
result: Result<Map<String, Value>, CdpError<'a>>

Event

Fields of Event

name: Cow<'a, str>
params: Map<String, Value>

Error(CdpError<'a>)

Methods

impl<'a> CdpOutgoing<'a>

pub fn serialize_result<S, R>(
    serializer: S,
    id: u64,
    result: Result<&R, &CdpError>
) -> Result<S::Ok, S::Error> where
    S: Serializer,
    R: Serialize, 

pub fn serialize_result_to_writer<W, R>(
    writer: W,
    id: u64,
    result: Result<&R, &CdpError>
) -> Result<(), Error> where
    W: Write,
    R: Serialize, 

pub fn serialize_result_to_string<R>(
    string: &mut String,
    id: u64,
    result: Result<&R, &CdpError>
) -> Result<(), Error> where
    R: Serialize, 

pub fn serialize_response<S, R>(
    serializer: S,
    id: u64,
    response: &R
) -> Result<S::Ok, S::Error> where
    S: Serializer,
    R: Serialize, 

pub fn serialize_response_to_writer<W, R>(
    writer: W,
    id: u64,
    response: &R
) -> Result<(), Error> where
    W: Write,
    R: Serialize, 

pub fn serialize_response_to_string<R>(
    string: &mut String,
    id: u64,
    response: &R
) -> Result<(), Error> where
    R: Serialize, 

pub fn serialize_error<S>(
    serializer: S,
    maybe_id: Option<u64>,
    error: &CdpError
) -> Result<S::Ok, S::Error> where
    S: Serializer, 

pub fn serialize_error_to_writer<W>(
    writer: W,
    maybe_id: Option<u64>,
    error: &CdpError
) -> Result<(), Error> where
    W: Write, 

pub fn serialize_error_to_string(
    string: &mut String,
    maybe_id: Option<u64>,
    error: &CdpError
) -> Result<(), Error>

pub fn serialize_event<E, S>(
    serializer: S,
    event: &E
) -> Result<S::Ok, S::Error> where
    S: Serializer,
    E: SerializeCdpEvent, 

pub fn serialize_event_to_writer<W, E>(
    writer: W,
    event: &E
) -> Result<(), Error> where
    W: Write,
    E: SerializeCdpEvent, 

pub fn serialize_event_to_string<E>(
    string: &mut String,
    event: &E
) -> Result<(), Error> where
    E: SerializeCdpEvent, 

Trait Implementations

impl<'a> Clone for CdpOutgoing<'a>

fn clone(&self) -> CdpOutgoing<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for CdpOutgoing<'a>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a> PartialEq for CdpOutgoing<'a>

fn eq(&self, __arg_0: &CdpOutgoing<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &CdpOutgoing<'a>) -> bool

This method tests for !=.

impl<'a> Serialize for CdpOutgoing<'a>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de, 'a> Deserialize<'de> for CdpOutgoing<'a>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'a> From<CdpOutgoingImpl<'a>> for CdpOutgoing<'a>

fn from(message: CdpOutgoingImpl<'a>) -> Self

Performs the conversion.