Enum jomini::binary::Token

pub enum Token<'a> {
    Open,
    Close,
    Equal,
    U32(u32),
    U64(u64),
    I32(i32),
    Bool(bool),
    Quoted(Scalar<'a>),
    Unquoted(Scalar<'a>),
    F32([u8; 4]),
    F64([u8; 8]),
    Rgb(Rgb),
    I64(i64),
    Id(u16),
}

Binary token, the raw form of BinaryToken

This binary token contains the yielded raw tokens, and won’t match open and close tokens together, nor does it make a determination if open and close represents an array, object, or both.

Variants

Open

‘{’

Close

‘}’

Equal

‘=’

U32(u32)

32bit unsigned integer

U64(u64)

64bit unsigned integer

I32(i32)

32bit signed integer

Bool(bool)

boolean

Quoted(Scalar<'a>)

quoted text

Unquoted(Scalar<'a>)

text that is not quoted

F32([u8; 4])

32bits of floating point data

F64([u8; 8])

64bits of floating point data

Rgb(Rgb)

Rgb data

I64(i64)

64bit signed integer

Id(u16)

token id that can be resolved to a string via a TokenResolver

Implementations

impl<'a> Token<'a>

pub fn write(&self, wtr: impl Write) -> Result<(), Error>

Write the binary representation of a token to a writer

use jomini::binary::Token;
let out = Vec::new();
let mut cursor = std::io::Cursor::new(out);
for token in &[Token::Id(0x00e1), Token::Equal, Token::U32(10)] {
    token.write(&mut cursor)?;
}

assert_eq!(&cursor.into_inner(), &[0xe1, 0x00, 0x01, 0x00, 0x14, 0x00, 0x0a, 0x00, 0x00, 0x00]);

Trait Implementations

impl<'a> Clone for Token<'a>

fn clone(&self) -> Token<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Token<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Token<'a>

fn eq(&self, other: &Token<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Copy for Token<'a>

impl<'a> Eq for Token<'a>

impl<'a> StructuralPartialEq for Token<'a>