Struct binjs::generic::ast::Path

pub struct Path<I, F> where
    F: Debug,
    I: Debug,  { /* fields omitted */ }

The path followed when walking an AST.

Designed to be used both to quickly find out how to contextually handle a specific node and for error-reporting.

use binjs_shared::ast::Path;

let mut path = Path::new();
assert!(path.get(0).is_none());

// Once we have entered both an interface and a field, `path.get(0)` will be `Some`.
path.enter_interface("Interface 1");
assert!(path.get(0).is_none());

path.enter_field("Field 1");

{
  let item = path.get(0).unwrap();
  assert_eq!(item.field, "Field 1");
  assert_eq!(item.interface, "Interface 1");
}

path.enter_interface("Interface 2");
path.enter_field("Field 2");

{
  let item = path.get(0).unwrap();
  assert_eq!(item.field, "Field 2");
  assert_eq!(item.interface, "Interface 2");
}
{
  let item = path.get(1).unwrap();
  assert_eq!(item.field, "Field 1");
  assert_eq!(item.interface, "Interface 1");
}

// We need to exit the field before exiting the interface.
path.exit_field("Field 2"); // Exiting the wrong field would panic.
path.exit_interface("Interface 2"); // Exiting the wrong interface would panic.
path.exit_field("Field 1"); // Exiting the wrong field would panic.
path.exit_interface("Interface 1"); // Exiting the wrong interface would panic.

Methods

impl<I, F> Path<I, F> where
    F: Debug + PartialEq<F>,
    I: Debug + PartialEq<I>, 

pub fn new() -> Path<I, F>

Create an empty Path.

pub fn extend_from_slice(&mut self, slice: &[PathItem<I, F>]) where
    F: Clone,
    I: Clone, 

pub fn with_capacity(capacity: usize) -> Path<I, F>

Create an empty Path, initialized to hold up to capacity elements without resize.

pub fn enter_interface(&mut self, node: I)

Enter an interface.

All calls to enter_interface MUST be balanced with calls to exit_interface.

pub fn exit_interface(&mut self, node: I)

pub fn enter_field(&mut self, field: F)

pub fn exit_field(&mut self, field: F)

pub fn len(&self) -> usize

pub fn get(&self, index: usize) -> Option<&PathItem<I, F>>

pub fn tail(&self, len: usize) -> &[PathItem<I, F>]

Return the last len elements of the path, in the order in which they appear in the path (current element is last).

If there are fewer than len elements, return as many elements as possible.

pub fn iter(&self) -> impl Iterator<Item = &PathItem<I, F>>

Iter through the path, from the root to the current position.

Trait Implementations

impl<I, F> Borrow<[PathItem<I, F>]> for Path<I, F> where
    F: Debug + PartialEq<F>,
    I: Debug + PartialEq<I>, 

fn borrow(&self) -> &[PathItem<I, F>]

Immutably borrows from an owned value.

impl<I, F> Clone for Path<I, F> where
    F: Clone + Debug,
    I: Clone + Debug, 

fn clone(&self) -> Path<I, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, F> Debug for Path<I, F> where
    F: Debug,
    I: Debug, 

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

Formats the value using the given formatter.

impl<I, F> Default for Path<I, F> where
    F: Default + Debug,
    I: Default + Debug, 

fn default() -> Path<I, F>

Returns the "default value" for a type.

impl<'de, I, F> Deserialize<'de> for Path<I, F> where
    F: Debug + Deserialize<'de>,
    I: Debug + Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Path<I, F>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<I, F> Display for Path<I, F> where
    F: Debug + Display,
    I: Debug + Display, 

fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl<I, F> Eq for Path<I, F> where
    F: Debug + Eq,
    I: Debug + Eq, 

impl<I, F> From<Vec<PathItem<I, F>>> for Path<I, F> where
    F: Debug,
    I: Debug, 

fn from(items: Vec<PathItem<I, F>>) -> Path<I, F>

Performs the conversion.

impl<I, F> Hash for Path<I, F> where
    F: Debug + Hash,
    I: Debug + Hash, 

fn hash<H>(&self, hasher: &mut H) where
    H: Hasher, 

As we implement Borrow<[PathItem<...>] for Path, we must ensure that Hash gives the same result for a Path and its [PathItem] representation.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<I, F> PartialEq<Path<I, F>> for Path<I, F> where
    F: Debug + PartialEq<F>,
    I: Debug + PartialEq<I>, 

fn eq(&self, other: &Path<I, F>) -> bool

As we implement Borrow<[PathItem<...>] for Path, we must ensure that Eq gives the same result for a Eq and its [PathItem] representation.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<I, F> Serialize for Path<I, F> where
    F: Debug + Serialize,
    I: Debug + Serialize, 

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.