Struct balena_temen::ast::Identifier

source ·

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

Expand description

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)

Implementations

source

impl Identifier

source

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

Creates new identifier

Arguments

values - List of identifier values (components)

source

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());

source

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);

source

pub fn name<S>(self, name: S) -> Identifierwhere
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);

source

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);

source

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);

source