Enum Message 

pub enum Message {
    Query {
        query_id: Int256,
        query: LiteQuery,
    },
    Answer {
        query_id: Int256,
        answer: Response,
    },
    Ping {
        random_id: u64,
    },
    Pong {
        random_id: u64,
    },
}

Variants

Query

adnl.message.query query_id:int256 query:bytes = adnl.Message;

Fields

query_id: Int256

query: LiteQuery

Answer

adnl.message.answer query_id:int256 answer:bytes = adnl.Message;

Fields

query_id: Int256

answer: Response

Ping

tcp.ping random_id:long = tcp.Pong;

Fields

random_id: u64

Pong

tcp.pong random_id:long = tcp.Pong;

Fields

random_id: u64

Implementations

impl<'tl> Message

pub const TL_ID_QUERY: u32 = 3_029_072_250u32

pub const TL_ID_ANSWER: u32 = 262_964_246u32

pub const TL_ID_PING: u32 = 1_292_381_082u32

pub const TL_ID_PONG: u32 = 3_697_933_059u32

Trait Implementations

impl Clone for Message

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl PartialEq for Message

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S> Service<Message> for UnwrapService<S>

where S: LiteService, S::Future: Send + 'static,

type Response = Message

Responses given by the service.

type Error = LiteError

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<Message, LiteError>> + Send>>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, request: Message) -> Self::Future

Process the request and return the response asynchronously.

impl<T> Sink<Message> for LitePeer<T>

where T: Sink<Bytes, Error = AdnlError>,

type Error = LiteError

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: Message) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<T> TagStore<Message, Message> for LitePeer<T>

type Tag = LiteTag

The type used for tags.

fn assign_tag(self: Pin<&mut Self>, r: &mut Message) -> Self::Tag

Assign a fresh tag to the given Request, and return that tag.

fn finish_tag(self: Pin<&mut Self>, r: &Message) -> Self::Tag

Retire and return the tag contained in the given Response.

impl<'tl> TlRead<'tl> for Message

type Repr = Boxed

Serialized object representation.

fn read_from(__packet: &'tl [u8], __offset: &mut usize) -> TlResult<Self>

Tries to read itself from bytes at the specified offset, incrementing that offset.

impl TlWrite for Message

type Repr = Boxed

Serialized object representation.

fn max_size_hint(&self) -> usize

Max required number of bytes.

fn write_to<P_>(&self, __packet: &mut P_)

where P_: TlPacket,

Writes itself to the specified TlPacket.