Struct Tag

pub struct Tag {
    pub namespace: Option<String>,
    pub name: String,
    pub values: Vec<Value>,
    pub attrs: Vec<Attribute>,
    pub tags: Vec<Tag>,
}

A series of values and attributes, with a name (and namespace), and optionally a subtree of tags.

All data in SDLang is stored through these.

Fields

namespace: Option<String>

The namespace (if any) of the tag.

name: String

The name of the tag. "" if none was given.

values: Vec<Value>

A list of values.

attrs: Vec<Attribute>

A list of attributes.

tags: Vec<Tag>

A list of subtags (empty vector if none exist).

Implementations

impl Tag

pub fn new(name: String) -> Self

Creates a new tag.

Note that no allocation is performed. Everything is initialised to a default empty state.

pub fn namespace(self, namespace: String) -> Self

Sets the namespace.

pub fn values(self, values: Vec<Value>) -> Self

Sets the value list.

pub fn attrs(self, attrs: Vec<Attribute>) -> Self

Sets the attribute list from a list of Attributes.

pub fn tags(self, tags: Vec<Tag>) -> Self

Sets the child tags.

pub fn attr<'a, 'b>(&'a self, name: &'b str) -> Option<&'a Attribute>

Finds the given attribute by name.

pub fn attr_mut<'a, 'b>( &'a mut self, name: &'b str, ) -> Option<&'a mut Attribute>

Finds the given attribute by name, returning a mutable reference.

pub fn tag<'a, 'b>(&'a self, name: &'b str) -> Option<&'a Tag>

Finds the given subtag by name.

pub fn tag_mut<'a, 'b>(&'a mut self, name: &'b str) -> Option<&'a mut Tag>

Finds the given tag by name, returning a mutable reference.

Trait Implementations

impl Debug for Tag

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

Formats the value using the given formatter.

impl Display for Tag

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

Returns a human-readable representation of the tag. The format is roughly this:

tag "<namespace>:<name>": <values>, <attributes>
* <subtag_1>
  * <subtag_1_subtag>
  * ...
* <subtag_2>
* ...

impl FromStr for Tag

fn from_str(s: &str) -> Result<Self>

Parses the text for a Tag, returning a parse error on failure.

type Err = Error<Rule>

The associated error which can be returned from parsing.

impl PartialEq for Tag

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