Enum Value 

pub enum Value {
    Undefined,
    Null,
    Bool(bool),
    Num(f64),
    Str(String),
    List(Vec<Value>),
    Node(Node),
}

A value held by an AST node field.

Every traversal of a value is ITERATIVE: dropping, cloning, comparing, writing it as JSON and formatting it for std::fmt::Debug. An AST is as deep as the CSS that produced it, so a derived implementation of any of them would recurse once per level and abort the process on nothing worse than untrusted input. None of them is derived, for that reason.

Variants

Undefined

A key that exists but serialises to nothing (JavaScript undefined).

Null

JSON null.

Bool(bool)

JSON true / false.

Num(f64)

A JSON number. Integral values serialise without a decimal point.

Str(String)

A JSON string.

List(Vec<Value>)

A JSON array.

Node(Node)

A nested AST node (a JSON object).

Implementations

impl Value

pub fn as_str(&self) -> Option<&str>

The string held here, if this is a Value::Str.

pub fn as_node(&self) -> Option<&Node>

The node held here, if this is a Value::Node.

pub fn as_list(&self) -> Option<&[Value]>

The list held here, if this is a Value::List.

pub fn to_json(&self) -> String

This value as JSON. Undefined renders as null at the top level and inside an array — only an object KEY can be dropped entirely, which is what JavaScript’s JSON.stringify does too.

Examples found in repository

examples/parse.rs (line 63)

fn report(css: &Css, src: &str) -> String {
    match css.parse(src) {
        Ok(ast) => ast.to_json(),
        Err(err) => format!("ERROR:{}", err.code),
    }
}

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Value

The debug view is the JSON, with Undefined keys shown rather than dropped.

Not derived, and not a struct-shaped {:#?} dump. A derived formatter recurses once per nesting level, so format!("{ast:?}") on a stylesheet a few thousand rules deep aborts the process — on an AST whose parse, drop and serialisation are all depth-safe, and in the one operation a caller reaches for while debugging. This shares the iterative writer instead.

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

Formats the value using the given formatter.

impl From<&str> for Value

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<Node> for Value

fn from(n: Node) -> Self

Converts to this type from the input type.

impl From<String> for Value

fn from(s: String) -> Self

Converts to this type from the input type.

impl PartialEq for Value

fn eq(&self, other: &Value) -> bool

Equality operator ==.

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

Inequality operator !=.