Struct balena_temen::ast::Identifier

pub struct Identifier {
    pub values: Vec<IdentifierValue>,
}

An identifier

Examples

networks[0].name
  |      │   |
  |      |   └ IdentifierValue::Name("name")
  |      |
  |      └ IdentifierValue::Index(0)
  |
  └ IdentifierValue::Name("networks")

persons[boss.id]["name"]
  |      │         |
  |      |         └ IdentifierValue::Name("name")
  |      |
  |      └ IdentifierValue::Identifier(boss.id)
  |                                     |   |
  |                                     |   └ IdentifierValue::Name("id")
  |                                     |
  |                                     └ IdentifierValue::Name("boss")
  |
  └ IdentifierValue::Name("persons")

this.id
  |  |
  |  └ IdentifierValue::Name("id")
  |
  └ IdentifierValue::This

Fields

values: Vec<IdentifierValue>

List of identifier values (components)

Methods

impl Identifier

pub fn new(values: Vec<IdentifierValue>) -> Identifier

Creates new identifier

Arguments

• values - List of identifier values (components)

pub fn is_canonical(&self) -> bool

Check if an identifier is canonical

An identifier is considered as canonical if none relative identifier values (IdentifierValue::This, IdentifierValue::Super) are present.

It affects (checks) nested identifiers as well.

Examples

Canonical identifiers.

use balena_temen::ast::*;

let identifier: Identifier = "names.wifi".parse().unwrap();
assert!(identifier.is_canonical());

let identifier: Identifier = "names.wifi[first].id".parse().unwrap();
assert!(identifier.is_canonical());

Not canonical identifiers.

use balena_temen::ast::*;

let identifier: Identifier = "names.this".parse().unwrap();
assert!(!identifier.is_canonical());

let identifier: Identifier = "names[this.index]".parse().unwrap();
assert!(!identifier.is_canonical());

pub fn canonicalize(&self, position: &Identifier) -> Result<Identifier>

Returns the canonical, absolute, identifier with all intermediate components normalized and nested identifiers canonicalized.

Nested identifiers (IdentifierValue::Identifier) are canonicalized too.

Arguments

• position - An identifier position

Examples

use balena_temen::ast::*;

let identifier: Identifier = "names".parse().unwrap();
assert_eq!(identifier.canonicalize(&Identifier::default()).unwrap(), identifier);

let identifier: Identifier = "names.this.id.this.super".parse().unwrap();
let canonicalized: Identifier = "names".parse().unwrap();
assert_eq!(identifier.canonicalize(&Identifier::default()).unwrap(), canonicalized);

let identifier: Identifier = "super.id".parse().unwrap();
let position: Identifier = "wifi[`zrzka`].ssid".parse().unwrap();
let canonicalized: Identifier = "wifi[`zrzka`].id".parse().unwrap();
assert_eq!(identifier.canonicalize(&position).unwrap(), canonicalized);

pub fn name<S>(self, name: S) -> Identifier where
    S: Into<String>, 

Appends IdentifierValue::Name to the identifier

Arguments

• name - A name (object field, string index)

Examples

use balena_temen::ast::*;

let identifier = Identifier::default()
    .name("wifi")
    .name("ssid");

let parsed = "wifi.ssid".parse().unwrap();

assert_eq!(identifier, parsed);

pub fn index(self, index: isize) -> Identifier

Appends IdentifierValue::Index to the identifier

Arguments

• index - An array index

use balena_temen::ast::*;

let identifier = Identifier::default()
    .name("networks")
    .index(0);

let parsed = "networks[0]".parse().unwrap();

assert_eq!(identifier, parsed);

pub fn identifier(self, identifier: Identifier) -> Identifier

Appends IdentifierValue::Identifier to the identifier

Arguments

• identifier - An identifier index

use balena_temen::ast::*;

let identifier = Identifier::default()
    .name("wifi")
    .identifier(Identifier::default().name("first_wifi_id"));

let parsed = "wifi[first_wifi_id]".parse().unwrap();

assert_eq!(identifier, parsed);

pub fn pop(self) -> Result<Identifier>

Returns Identifier with the last identifier value removed

Trait Implementations

impl PartialEq<Identifier> for Identifier

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Clone for Identifier

fn clone(&self) -> Identifier

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Identifier

fn default() -> Identifier

Creates new, empty, identifier

This identifier can be used to refer to the root.

impl Debug for Identifier

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

Formats the value using the given formatter.

impl FromStr for Identifier

type Err = Error

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.