Enum Token 

pub enum Token<'a> {
    ILLEGAL(&'a str),
    EOF,
    IDENT(&'a str, Option<SocketPlug>),
    VALUE(Value<'a>),
    TAG(Option<u8>, Option<TagConstraint<'a>>),
    ASSIGN,
    OPTIONAL,
    ASTERISK,
    ONEORMORE,
    UNWRAP,
    COMMA,
    COLON,
    COMMENT(&'a str),
    TCHOICE,
    GCHOICE,
    TCHOICEALT,
    GCHOICEALT,
    ARROWMAP,
    CUT,
    RANGEOP(bool),
    RANGE(RangeValue<'a>, RangeValue<'a>, bool),
    LPAREN,
    RPAREN,
    LBRACE,
    RBRACE,
    LBRACKET,
    RBRACKET,
    LANGLEBRACKET,
    RANGLEBRACKET,
    ControlOperator(ControlOperator),
    GTOCHOICE,
    FALSE,
    TRUE,
    BOOL,
    NIL,
    NULL,
    UINT,
    NINT,
    INT,
    FLOAT16,
    FLOAT32,
    FLOAT64,
    FLOAT1632,
    FLOAT3264,
    FLOAT,
    BSTR,
    TSTR,
    ANY,
    BYTES,
    TEXT,
    TDATE,
    TIME,
    NUMBER,
    BIGUINT,
    BIGNINT,
    BIGINT,
    INTEGER,
    UNSIGNED,
    DECFRAC,
    BIGFLOAT,
    EB64URL,
    EB64LEGACY,
    EB16,
    ENCODEDCBOR,
    URI,
    B64URL,
    B64LEGACY,
    REGEXP,
    MIMEMESSAGE,
    CBORANY,
    UNDEFINED,
    NEWLINE,
}

Token which represents a valid CDDL character or sequence

Variants

ILLEGAL(&'a str)

Illegal sequence of characters

EOF

End of file

IDENT(&'a str, Option<SocketPlug>)

Identifier

Tuple Fields

0: &'a str

Identifier

1: Option<SocketPlug>

Socket/plug

VALUE(Value<'a>)

Value

TAG(Option<u8>, Option<TagConstraint<'a>>)

CBOR tag ‘#’

Tuple Fields

0: Option<u8>

Major type

1: Option<TagConstraint<'a>>

Optional constraint - either a literal number or a type expression

ASSIGN

Assignment operator ‘=’

OPTIONAL

Optional occurrence indicator ‘?’

ASTERISK

Zero or more occurrence indicator ‘*’

ONEORMORE

One or more occurrence indicator ‘+’

UNWRAP

Unwrap operator ‘~’

COMMA

Comma ‘,’

COLON

Colon ‘:’

COMMENT(&'a str)

Comment text

TCHOICE

Type choice indicator ‘/’

GCHOICE

Group choice indicator ‘//’

TCHOICEALT

Type choice alternative ‘/=’

GCHOICEALT

Group choice alternative ‘//=’

ARROWMAP

Arrow map ‘=>’

CUT

Cut ‘^’

RANGEOP(bool)

Range operator. Inclusive ‘..’ if true, otherwise exclusive ’…’s

RANGE(RangeValue<'a>, RangeValue<'a>, bool)

Range

Tuple Fields

0: RangeValue<'a>

Lower bound

1: RangeValue<'a>

Upper bound

2: bool

Inclusive

LPAREN

Left opening parend

RPAREN

Right closing parend

LBRACE

Left opening brace

RBRACE

Right closing brace

LBRACKET

Left opening bracket

RBRACKET

Right closing bracket

LANGLEBRACKET

Left opening angle bracket

RANGLEBRACKET

Right closing angle bracket

ControlOperator(ControlOperator)

Control operator token

GTOCHOICE

group to choice enumeration ‘&’

FALSE

false

TRUE

true

BOOL

bool

NIL

nil

NULL

null

UINT

uint

NINT

nint

INT

int

FLOAT16

float16

FLOAT32

float32

FLOAT64

float64

FLOAT1632

float16-32

FLOAT3264

float32-64

FLOAT

float

BSTR

bstr

TSTR

tstr

ANY

any

BYTES

bytes

TEXT

text

TDATE

tdate

TIME

time

NUMBER

number

BIGUINT

biguint

BIGNINT

bignint

BIGINT

bigint

INTEGER

integer

UNSIGNED

unsigned

DECFRAC

decfrac

BIGFLOAT

bigfloat

EB64URL

eb64url

EB64LEGACY

eb64legacy

EB16

eb16k

ENCODEDCBOR

encoded-cbor

URI

uri

B64URL

b64url

B64LEGACY

b64legacy

REGEXP

regexp

MIMEMESSAGE

mime-message

CBORANY

cbor-any

UNDEFINED

undefined

NEWLINE

newline (used only for comment formatting when compiled with the “lsp” feature)

Implementations

impl Token<'_>

pub fn in_standard_prelude(&self) -> Option<&'static str>

Returns optional string literal of token if it is in the standard prelude

Example

use cddl::token::Token;

let t = Token::ANY;
assert_eq!(t.in_standard_prelude(), Some("any"));

Trait Implementations

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

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

Returns a duplicate 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 Display for Token<'_>

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

Formats the value using the given formatter.

impl<'a> From<Token<'a>> for Identifier<'a>

fn from(token: Token<'_>) -> Self

Converts to this type from the input type.

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

fn eq(&self, other: &Token<'a>) -> 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<'a> TryFrom<Token<'a>> for RangeValue<'a>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(t: Token<'a>) -> Result<Self, Self::Error>

Performs the conversion.

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