Enum fbthrift::compact_protocol::CompactProtocol

pub enum CompactProtocol<F = Bytes> {
    __Phantom(CompactProtocol<F>),
    CompactProtocol,
}

An efficient, dense encoding that uses variable-length integers and squeezes data into unused bits wherever possible.

let protocol = CompactProtocol;
let transport = HttpClient::new(ENDPOINT)?;
let client = BuckGraphService::new(protocol, transport);

The type parameter is the Framing expected by the transport on which this protocol is operating. Usually by convention the transport itself serves as the Framing impl, so for example in the case of HttpClient above, the compiler has inferred F = HttpClient.

Where the compiler reports that a Framing can't be inferred, one can be specified explicitly:

let protocol = CompactProtocol::<SRHeaderTransport>;

Variants

__Phantom(CompactProtocol<F>)

CompactProtocol

Trait Implementations

impl<F> Clone for CompactProtocol<F>

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F> Copy for CompactProtocol<F>

impl<F> Protocol for CompactProtocol<F> where
    F: Framing + 'static, 

type Frame = F

Type of the framing implementation

type Sizer = CompactProtocolSerializer<SizeCounter>

Compute the size of a frame for a given protocol. This can be exact or too large, but must not be too small.

type Serializer = CompactProtocolSerializer<F::EncBuf>

Serialize into a buffer. The buffer is allocated with the size computed by Sizer, so it must be large enough.

type Deserializer = CompactProtocolDeserializer<F::DecBuf>

Set up a deserializer from a frame's buffer.

pub const PROTOCOL_ID: ProtocolID

pub fn serializer<SZ, SER>(
    size: SZ,
    ser: SER
) -> <Self::Serializer as ProtocolWriter>::Final where
    SZ: FnOnce(&mut Self::Sizer),
    SER: FnOnce(&mut Self::Serializer), 

pub fn deserializer(buf: F::DecBuf) -> Self::Deserializer

pub fn into_buffer(deser: Self::Deserializer) -> F::DecBuf