Struct VarLong 

pub struct VarLong(pub i64);

A variable-length encoded 64-bit signed integer, occupying 1 to 10 bytes.

VarLong uses the same MSB continuation bit encoding as VarInt but for 64-bit values. It is used in the protocol for large values like entity UUIDs in some contexts, timestamps, and world seed. Negative values use two’s complement and always require 10 bytes.

Tuple Fields

0: i64

Implementations

impl VarLong

pub const MAX_BYTES: usize = 10

Maximum number of bytes a VarLong can occupy on the wire.

Trait Implementations

impl Clone for VarLong

fn clone(&self) -> VarLong

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for VarLong

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

Formats the value using the given formatter.

impl Decode for VarLong

Decodes a VarLong by reading 1-10 bytes from the buffer.

Same algorithm as VarInt decoding but allowing up to 10 bytes (64 bits). Returns Error::VarIntTooLarge if more than 10 bytes carry continuation bits, Error::BufferUnderflow if the buffer ends mid-value.

fn decode(buf: &mut &[u8]) -> Result<Self>

impl Encode for VarLong

Encodes the VarLong as 1-10 bytes using MSB continuation bit encoding.

Same algorithm as VarInt but operating on 64-bit values. Negative values are encoded as their unsigned two’s complement representation and always produce 10 bytes.

fn encode(&self, buf: &mut Vec<u8>) -> Result<()>

impl EncodedSize for VarLong

Computes the number of bytes this VarLong will occupy when encoded.

Returns 1-10 based on the unsigned magnitude. Small positive values (0-127) take 1 byte, i64::MAX takes 9, and negative values always take 10 bytes.

fn encoded_size(&self) -> usize

impl From<VarLong> for i64

Extracts the inner i64 value from a VarLong.

fn from(value: VarLong) -> Self

Converts to this type from the input type.

impl From<i64> for VarLong

Wraps a raw i64 into a VarLong for protocol encoding.

fn from(value: i64) -> Self

Converts to this type from the input type.

impl Hash for VarLong

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 PartialEq for VarLong

fn eq(&self, other: &VarLong) -> 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 Copy for VarLong

impl Eq for VarLong

impl StructuralPartialEq for VarLong