Enum Either 

pub enum Either<X, Y> {
    X(X),
    Y(Y),
}

A boolean-selected value of protocol type X or Y.

The wire representation begins with a Boolean. A true marker is followed by an X value, while a false marker is followed by a Y value:

0x01 + X
0x00 + Y

Both branch types must implement TypeCodec. The enum variant binds the marker to the matching payload, so an in-memory marker/payload mismatch cannot be represented.

Examples

use mcproto_types::{Either, TypeCodec, UnsignedByte, VarInt};

let x = Either::<UnsignedByte, VarInt>::X(UnsignedByte(0xab));
let mut encoded = Vec::new();
x.encode(&mut encoded)?;
assert_eq!(encoded, [0x01, 0xab]);
assert_eq!(Either::decode(&mut encoded.as_slice())?, x);

let y = Either::<UnsignedByte, VarInt>::Y(VarInt(25565));
let mut encoded = Vec::new();
y.encode(&mut encoded)?;
assert_eq!(encoded, [0x00, 0xdd, 0xc7, 0x01]);

See the official Either X or Y protocol documentation.

Variants

X(X)

An X payload, prefixed by a true boolean.

Y(Y)

A Y payload, prefixed by a false boolean.

Implementations

impl<X, Y> Either<X, Y>

pub const fn is_x(&self) -> bool

Returns whether this value contains an X payload.

pub const fn is_y(&self) -> bool

Returns whether this value contains a Y payload.

pub const fn as_ref(&self) -> Either<&X, &Y>

Borrows the selected payload while retaining its branch.

pub fn into_x(self) -> Option<X>

Extracts the X payload, returning None for the Y branch.

pub fn into_y(self) -> Option<Y>

Extracts the Y payload, returning None for the X branch.

Trait Implementations

impl<X: Clone, Y: Clone> Clone for Either<X, Y>

fn clone(&self) -> Either<X, Y>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<X: Copy, Y: Copy> Copy for Either<X, Y>

impl<X: Debug, Y: Debug> Debug for Either<X, Y>

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

Formats the value using the given formatter.

impl<X: Eq, Y: Eq> Eq for Either<X, Y>

impl<X: Hash, Y: Hash> Hash for Either<X, Y>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<X: PartialEq, Y: PartialEq> PartialEq for Either<X, Y>

fn eq(&self, other: &Either<X, Y>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<X: PartialEq, Y: PartialEq> StructuralPartialEq for Either<X, Y>

impl<X, Y> TypeCodec for Either<X, Y>

where X: TypeCodec, Y: TypeCodec,

fn encode(&self, writer: &mut impl Write) -> Result<(), CodecError>

Encodes this value to the writer.

fn decode(reader: &mut impl Read) -> Result<Self, CodecError>

Decodes this value from the reader.