Struct Defs 

pub struct Defs<T> {
    pub stems: HashSet<String>,
    /* private fields */
}

Defs contain: a mapping of scope_name to a mapping of an id to T, an array of scopes in order of scope creation. a set of stem names

Fields

stems: HashSet<String>

Implementations

impl<T> Defs<T>

where T: Clone + Sized,

pub fn new() -> Self

This new is specific to WereSoCool. It creates an IndexMap<String, IndexMap> to keep track of the map of scopes. An IndexMap is an ordered HashMap. It also creates an array of scopes with a global scope prepopulated. Finally, it creates HashSet for stem names.

pub fn push_stem<S: Into<String> + Clone>(&mut self, stem_name: S)

Insert a stem into stems set.

pub fn iter_scopes(&self) -> Rev<Iter<'_, String>>

Iterate through the scope stack from inner to outer scopes.

pub fn iter(&self) -> Iter<'_, String, IndexMap<String, T>>

Returns an iterator over each scope.

pub fn iter_mut(&mut self) -> IterMut<'_, String, IndexMap<String, T>>

Returns a mutable iterator over each scope.

pub fn create_uuid_scope(&mut self) -> String

Create a new scope with a uuid as the scope name. Returns the scope name that was created.

pub fn create_named_scope<S: Into<String> + Clone>(&mut self, new_scope: S)

Creates a named scope with the name passed in.

pub fn insert<S: Into<String>>(&mut self, scope: &str, name: S, value: T)

Insert a into a given scope under the name provided.

pub fn get(&self, id: &str) -> Option<&T>

Searches through inner -> outer scopes looking for the given id.

Trait Implementations

impl<T: Clone> Clone for Defs<T>

fn clone(&self) -> Defs<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Defs<T>

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

Formats the value using the given formatter.

impl<T> Default for Defs<T>

where T: Clone + Sized,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Defs<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq> PartialEq for Defs<T>

fn eq(&self, other: &Defs<T>) -> 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<T> Serialize for Defs<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for Defs<T>

impl<T> StructuralPartialEq for Defs<T>