Enum Return 

#[repr(C)]
pub enum Return {
    AuthenticateRequest(AuthenticateRequest),
    Failure,
    SID([u32; 4]),
    CID((CID, Option<[u32; 4]>)),
    Success,
}

Variants

AuthenticateRequest(AuthenticateRequest)

The caller must perform an AuthenticatedLookup using this challenge

Failure

The connection failed for some reason

SID([u32; 4])

A server was successfully created with the given SID

CID((CID, Option<[u32; 4]>))

A connection was successfully made with the given CID; an optional “disconnect token” is provided

Success

Operation requested was otherwise successful (currently only used by disconnect to ack the disconnect)

Trait Implementations

impl Archive for Return

where AuthenticateRequest: Archive, [u32; 4]: Archive, (CID, Option<[u32; 4]>): Archive,

type Archived = ArchivedReturn

The archived representation of this type.

type Resolver = ReturnResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Debug for Return

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<Return, __D> for Archived<Return>

where AuthenticateRequest: Archive, <AuthenticateRequest as Archive>::Archived: Deserialize<AuthenticateRequest, __D>, [u32; 4]: Archive, <[u32; 4] as Archive>::Archived: Deserialize<[u32; 4], __D>, (CID, Option<[u32; 4]>): Archive, <(CID, Option<[u32; 4]>) as Archive>::Archived: Deserialize<(CID, Option<[u32; 4]>), __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Return, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for Return

where AuthenticateRequest: Serialize<__S>, [u32; 4]: Serialize<__S>, (CID, Option<[u32; 4]>): Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.