Enum jomini::TextToken

pub enum TextToken<'a> {
    Array {
        end: usize,
        mixed: bool,
    },
    Object {
        end: usize,
        mixed: bool,
    },
    MixedContainer,
    Unquoted(Scalar<'a>),
    Quoted(Scalar<'a>),
    Parameter(Scalar<'a>),
    UndefinedParameter(Scalar<'a>),
    Operator(Operator),
    End(usize),
    Header(Scalar<'a>),
}

Represents a valid text value

Variants

Array

Start of an array

Fields

end: usize

The index of the TextToken::End for this array

mixed: bool

If this array contains a MixedContainer token

Object

Start of an object

The value of a property typically immediately follows a key token. However, this is not guaranteed so always check if the end has been reached before trying to decode a value. There are two main situations where this is not guaranteed:

• A non-equal operator (eg: a > b will be parsed to 3 instead of 2 tokens)
• If an object switches to a mixed container that is both an array and object

Fields

end: usize

Index of the TextToken::End that signifies this objects’s termination

mixed: bool

If this object contains a MixedContainer token

MixedContainer

Denotes the start of where a homogenous object or array becomes heterogenous.

Unquoted(Scalar<'a>)

Extracted unquoted scalar value

Quoted(Scalar<'a>)

Extracted quoted scalar value

Parameter(Scalar<'a>)

A parameter scalar

Only seen so far in EU4. From the patch notes:

Scripted triggers or effects now support conditional compilation on arguments provided to them. You can now check for if an argument is defined or not and make the script look entirely different based on that. Syntax is [[var_name] code here ] for if variable is defined

generate_advisor = { [[scaled_skill] if = { } ] }

UndefinedParameter(Scalar<'a>)

An undefined parameter, see Parameter variant for more info.

Syntax for undefined variable:

[[!var_name] code here ]

Operator(Operator)

A present, but non-equal operator token

End(usize)

Index of the start of this object

Header(Scalar<'a>)

The header token of the subsequent scalar. For instance, given

color = rgb { 100 200 50 }

rgb would be a the header followed by a 3 element array

Implementations

impl<'a> TextToken<'a>

pub fn as_scalar(&self) -> Option<Scalar<'a>>

Returns the scalar if the token contains a scalar

use jomini::{Scalar, TextToken};
assert_eq!(TextToken::Unquoted(Scalar::new(b"abc")).as_scalar(), Some(Scalar::new(b"abc")));
assert_eq!(TextToken::Quoted(Scalar::new(b"abc")).as_scalar(), Some(Scalar::new(b"abc")));
assert_eq!(TextToken::Header(Scalar::new(b"rgb")).as_scalar(), Some(Scalar::new(b"rgb")));
assert_eq!((TextToken::Object { end: 2, mixed: false }).as_scalar(), None);

Trait Implementations

impl<'a> Clone for TextToken<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TextToken<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for TextToken<'a>

fn eq(&self, other: &TextToken<'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> Eq for TextToken<'a>

impl<'a> StructuralPartialEq for TextToken<'a>