Struct runestick::Item

pub struct Item { /* fields omitted */ }

The name of an item.

This is made up of a collection of strings, like ["foo", "bar"]. This is indicated in rune as foo::bar.

Panics

The max length of a string component is is 2**15 = 32768. Attempting to add a string larger than that will panic.

Component encoding

A component is encoded as:

• A two byte tag as a u16 in native endianess, indicating its type (least significant 2 bits) and data (most significant 15 bits).
• If the type is a STRING, the data is treated as the length of the string. Any other type this the data is treated as the numeric id of the component.
• If the type is a STRING, the tag is repeated at the end of it to allow for seeking backwards. This is not the case for other types. Since they are fixed size its not necessary.

So all in all, a string is encoded as:

dddddddd dddddddt *string content* dddddddd dddddddt

And any other component is just the two bytes:

dddddddd dddddddt

Implementations

impl Item

pub const fn new() -> Self

Construct an empty item.

pub fn with_item<I>(iter: I) -> Self where
    I: IntoIterator,
    I::Item: IntoComponent, 

Construct a new item path.

pub fn with_crate(name: &str) -> Self

Construct item for a crate.

Examples

use runestick::{Item, ComponentRef};

let item = Item::with_crate("std");
assert_eq!(item.as_crate(), Some("std"));

let mut it = item.iter();
assert_eq!(it.next(), Some(ComponentRef::Crate("std")));
assert_eq!(it.next(), None);

pub fn with_crate_item<I>(name: &str, iter: I) -> Self where
    I: IntoIterator,
    I::Item: IntoComponent, 

Create a crated item with the given name.

Examples

use runestick::{Item, ComponentRef};

let item = Item::with_crate_item("std", &["option"]);
assert_eq!(item.as_crate(), Some("std"));

let mut it = item.iter();
assert_eq!(it.next(), Some(ComponentRef::Crate("std")));
assert_eq!(it.next(), Some(ComponentRef::Str("option")));
assert_eq!(it.next(), None);

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

Get the crate corresponding to the item.

Examples

use runestick::Item;

let item = Item::with_crate("std");
assert_eq!(item.as_crate(), Some("std"));

let item = Item::with_item(&["local"]);
assert_eq!(item.as_crate(), None);

pub fn first(&self) -> Option<ComponentRef<'_>>

Access the first component of this item.

Examples

use runestick::{ComponentRef, Item};

let item = Item::with_item(&["foo", "bar"]);
assert_eq!(item.first(), Some(ComponentRef::Str("foo")));

pub fn push<C>(&mut self, c: C) where
    C: IntoComponent, 

Push the given component to the current item.

pub fn pop(&mut self) -> Option<Component>

Push the given component to the current item.

pub fn extend<I>(&mut self, i: I) where
    I: IntoIterator,
    I::Item: IntoComponent, 

Extend the current item with an iterator.

pub fn is_empty(&self) -> bool

Check if the item is empty.

Examples

use runestick::Item;

let item = Item::new();
assert!(item.is_empty());

let item = Item::with_crate("std");
assert!(!item.is_empty());

pub fn clear(&mut self)

Clear the current item.

pub fn as_vec(&self) -> Vec<Component>

Construct a new vector from the current item.

pub fn into_vec(self) -> Vec<Component>

Convert into a vector from the current item.

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

If the item only contains one element, return that element.

pub fn join<I>(&self, other: I) -> Self where
    I: IntoIterator,
    I::Item: IntoComponent, 

Join this path with another.

pub fn extended<C>(&self, part: C) -> Self where
    C: IntoComponent, 

Clone and extend the item path.

pub fn last(&self) -> Option<ComponentRef<'_>>

Access the last component in the path.

pub fn iter(&self) -> Iter<'_>

Implement an iterator.

pub fn starts_with(&self, other: &Self) -> bool

Test if current item starts with another.

pub fn is_super_of(&self, other: &Self, n: usize) -> bool

Test if current is immediate super of other.

pub fn ancestry(&self, other: &Self) -> (Self, Self)

Get the ancestry of one module to another.

This returns three things:

• The shared prefix between the current and the other path.
• The suffix to get to the other path from the shared prefix.

Trait Implementations

impl Clone for Item

fn clone(&self) -> Item

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Item

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

Formats the value using the given formatter.

impl Default for Item

fn default() -> Item

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Item

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for Item

Format implementation for item.

An empty item is formatted as {root}, because it refers to the topmost root module.

Examples

use runestick::{Item, ComponentRef::*};

assert_eq!("{root}", Item::new().to_string());
assert_eq!("hello::$0", Item::with_item(&[Str("hello"), Id(0)]).to_string());

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

Formats the value using the given formatter.

impl From<Item> for CompileItem

fn from(item: Item) -> Self

Performs the conversion.

impl Hash for Item

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<'a> IntoIterator for Item

type IntoIter = IntoIter<Component>

Which kind of iterator are we turning this into?

type Item = Component

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a Item

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

type Item = ComponentRef<'a>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Ord for Item

fn cmp(&self, other: &Item) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Item> for Item

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

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

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

This method tests for !=.

impl PartialOrd<Item> for Item

fn partial_cmp(&self, other: &Item) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Item

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

Serialize this value into the given Serde serializer.

impl Eq for Item

impl StructuralEq for Item

impl StructuralPartialEq for Item