Enum ParserNode 

pub enum ParserNode {
    LexerToken(Token),
    Ability {
        ability: Ability,
    },
    AbilityTree {
        tree: AbilityTree,
    },
    Condition {
        condition: Condition,
    },
    ContinuousEffect {
        effect: ContinuousEffect,
    },
    Colors {
        colors: Colors,
    },
    Cost {
        cost: Cost,
    },
    CostModification {
        cost_modification: CostModification,
    },
    CostModificationEffect {
        cost_modification: CostModificationEffect,
    },
    CountSpecifier {
        count: CountSpecifier,
    },
    CreatedTokenKind {
        kind: CreatedTokenKind,
    },
    CreatureAction {
        action: CreatureAction,
    },
    CreatureSubtypeList {
        list: ArrayVec<CreatureSubtype, 24>,
    },
    Event {
        event: Event,
    },
    EventReplacement {
        replacement: EventReplacement,
    },
    EventSource {
        source: EventSource,
    },
    EventSourceReference {
        source: EventSourceReference,
    },
    ExileFollowUp {
        follow_up: ExileFollowUp,
    },
    Imperative {
        imperative: Imperative,
    },
    ImperativeList {
        imperatives: ImperativeList,
    },
    ImperativeChoices {
        choices: HeapArrayVec<SpellAbility, 23>,
    },
    KeywordAbility {
        ability: KeywordAbility,
    },
    ManaCost {
        mana_cost: ManaCost,
    },
    Number {
        number: Number,
    },
    ObjectReference {
        reference: ObjectReference,
    },
    ObjectSpecifier {
        specifier: ObjectSpecifier,
    },
    ObjectSpecifiers {
        specifiers: ObjectSpecifiers,
    },
    Player {
        player: PlayerSpecifier,
    },
    PlayerAction {
        action: PlayerAction,
    },
    PreviouslyMentionnedObject {
        object: PreviouslyMentionnedObject,
    },
    PutCounterKind {
        kind: CounterKind,
    },
    SpellAbility {
        ability: SpellAbility,
    },
    Statement {
        statement: Statement,
    },
    StaticAbilityKind {
        kind: StaticAbilityKind,
    },
    TokenDefinition {
        token: TokenLayout,
    },
    TriggerCondition {
        condition: TriggerCondition,
    },
    AbilityKind {
        ability: AbilityKind,
    },
    ZoneReference {
        zone: ZoneReference,
    },
}

Since this can carry entire ability trees, we need to box the biggest variants. Otherwise, this can easily blow up the stack when attempting to store multiple of them. Current size is 112 bytes, let’s try to keep it around here ?

Variants

LexerToken(Token)

Ability

Fields

ability: Ability

AbilityTree

Fields

tree: AbilityTree

Condition

Fields

condition: Condition

ContinuousEffect

Fields

effect: ContinuousEffect

Colors

Fields

colors: Colors

Cost

Fields

cost: Cost

CostModification

Fields

cost_modification: CostModification

CostModificationEffect

Fields

cost_modification: CostModificationEffect

CountSpecifier

Fields

count: CountSpecifier

CreatedTokenKind

Fields

kind: CreatedTokenKind

CreatureAction

Fields

action: CreatureAction

CreatureSubtypeList

Fields

list: ArrayVec<CreatureSubtype, 24>

Event

Fields

event: Event

EventReplacement

Fields

replacement: EventReplacement

EventSource

Fields

source: EventSource

EventSourceReference

Fields

source: EventSourceReference

ExileFollowUp

Fields

follow_up: ExileFollowUp

Imperative

Fields

imperative: Imperative

ImperativeList

Fields

imperatives: ImperativeList

ImperativeChoices

Fields

choices: HeapArrayVec<SpellAbility, 23>

KeywordAbility

Fields

ability: KeywordAbility

ManaCost

Fields

mana_cost: ManaCost

Number

Fields

number: Number

ObjectReference

Fields

reference: ObjectReference

ObjectSpecifier

Fields

specifier: ObjectSpecifier

ObjectSpecifiers

Fields

specifiers: ObjectSpecifiers

Player

Fields

player: PlayerSpecifier

PlayerAction

Fields

action: PlayerAction

PreviouslyMentionnedObject

Fields

object: PreviouslyMentionnedObject

PutCounterKind

Fields

kind: CounterKind

SpellAbility

Fields

ability: SpellAbility

Statement

Fields

statement: Statement

StaticAbilityKind

Fields

kind: StaticAbilityKind

TokenDefinition

Fields

token: TokenLayout

TriggerCondition

Fields

condition: TriggerCondition

AbilityKind

Fields

ability: AbilityKind

ZoneReference

Fields

zone: ZoneReference

Trait Implementations

impl Clone for ParserNode

fn clone(&self) -> ParserNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParserNode

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

Formats the value using the given formatter.

impl From<Token> for ParserNode

fn from(token: Token) -> Self

Converts to this type from the input type.

impl Idris for ParserNode

const COUNT: usize

fn id(&self) -> usize

fn name_from_id(id: usize) -> &'static str

impl PartialEq for ParserNode

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

impl StructuralPartialEq for ParserNode