[−][src]Trait moore::score::NodeStorage
The NodeStorage
trait allows for references to nodes to be stored and
retrieved via a unique node ID.
Once a node is created for example in an arena, a reference to it can be
stored in a NodeStorage
to associate it with an ID. If that ID is
presented to the NodeStorage
again, that same reference will be produced.
Implementors of this trait are expected to implement it multiple times, once
for each different ID/node type pair that they support. This then allows for
nodes to be looked up in a type safe manner based on their ID.
The NodeStorage
does not assume ownership over the nodes added to it.
Therefore all nodes are references of at least the lifetime 'tn
.
Example
use moore_common::score::NodeStorage; use std::collections::HashMap; #[derive(PartialEq, Eq, Debug)] struct Foo; #[derive(PartialEq, Eq, Debug)] struct Bar; #[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)] struct FooId(usize); #[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)] struct BarId(usize); struct Table<'tn> { foos: HashMap<FooId, &'tn Foo>, bars: HashMap<BarId, &'tn Bar>, } impl<'tn> NodeStorage<FooId> for Table<'tn> { type Node = &'tn Foo; fn get(&self, id: &FooId) -> Option<&&'tn Foo> { self.foos.get(id) } fn set(&mut self, id: FooId, node: &'tn Foo) -> Option<&'tn Foo> { self.foos.insert(id, node) } } impl<'tn> NodeStorage<BarId> for Table<'tn> { type Node = &'tn Bar; fn get(&self, id: &BarId) -> Option<&&'tn Bar> { self.bars.get(id) } fn set(&mut self, id: BarId, node: &'tn Bar) -> Option<&'tn Bar> { self.bars.insert(id, node) } } // Store node refs in table: let foo = Foo; let bar = Bar; let mut tbl = Table{ foos: HashMap::new(), bars: HashMap::new() }; tbl.set(FooId(1), &foo); tbl.set(BarId(2), &bar); // Retrieve node refs again: assert_eq!(tbl.get(&FooId(1)), Some(&&foo)); assert_eq!(tbl.get(&BarId(2)), Some(&&bar)); assert_eq!(tbl.get(&BarId(1)), None); assert_eq!(tbl.get(&FooId(2)), None); // The following would produce a compiler error due to type mismatch: // let _: &Foo = *tbl.get(&BarId(1)).unwrap(); // let _: &Bar = *tbl.get(&FooId(2)).unwrap();
Associated Types
type Node
The type of the node that is returned when presented with an ID of type
I
.
Required methods
fn get(&self, id: &I) -> Option<&Self::Node>
Obtains a reference to the node with the given ID.
Returns None
when no node with the given ID exists.
fn set(&mut self, id: I, node: Self::Node) -> Option<Self::Node>
Store a reference to a node under the given ID.
Later that reference can be retrieved again by presenting the same ID to
the get
function. Returns the previously stored entry, if any.
Implementations on Foreign Types
impl<K, V> NodeStorage<K> for HashMap<K, V, RandomState> where
K: Hash + Eq,
[src]
K: Hash + Eq,
type Node = V
fn get(&self, id: &K) -> Option<&V>
[src]
fn set(&mut self, id: K, node: V) -> Option<V>
[src]
impl<K, V> NodeStorage<K> for BTreeMap<K, V> where
K: Ord,
[src]
K: Ord,
type Node = V
fn get(&self, id: &K) -> Option<&V>
[src]
fn set(&mut self, id: K, node: V) -> Option<V>
[src]
impl<'ast> NodeStorage<AttrDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast AttrDecl)
fn get(&self, id: &AttrDeclRef) -> Option<&(ScopeRef, &'ast AttrDecl)>
[src]
fn set(
&mut self,
id: AttrDeclRef,
node: (ScopeRef, &'ast AttrDecl)
) -> Option<(ScopeRef, &'ast AttrDecl)>
[src]
&mut self,
id: AttrDeclRef,
node: (ScopeRef, &'ast AttrDecl)
) -> Option<(ScopeRef, &'ast AttrDecl)>
impl<'sb, 'ast, 'ctx> NodeStorage<ReturnStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &ReturnStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &ReturnStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: ReturnStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: ReturnStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'sb, 'ast, 'ctx> NodeStorage<SubtypeIndRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &SubtypeIndRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &SubtypeIndRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: SubtypeIndRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: SubtypeIndRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'sb, 'ast, 'ctx> NodeStorage<AssertStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &AssertStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &AssertStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: AssertStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: AssertStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'ast> NodeStorage<IntfTypeRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast TypeDecl)
fn get(&self, id: &IntfTypeRef) -> Option<&(ScopeRef, &'ast TypeDecl)>
[src]
fn set(
&mut self,
id: IntfTypeRef,
node: (ScopeRef, &'ast TypeDecl)
) -> Option<(ScopeRef, &'ast TypeDecl)>
[src]
&mut self,
id: IntfTypeRef,
node: (ScopeRef, &'ast TypeDecl)
) -> Option<(ScopeRef, &'ast TypeDecl)>
impl<'sb, 'ast, 'ctx> NodeStorage<VarDeclRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &VarDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &VarDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: VarDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: VarDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'sb, 'ast, 'ctx> NodeStorage<ReportStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &ReportStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &ReportStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: ReportStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: ReportStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'ctx> NodeStorage<ArrayTypeIndexRef> for HirTable<'ctx>
[src]
type Node = &'ctx Spanned<ArrayTypeIndex>
fn get(&self, id: &ArrayTypeIndexRef) -> Option<&&'ctx Spanned<ArrayTypeIndex>>
[src]
fn set(
&mut self,
id: ArrayTypeIndexRef,
node: &'ctx Spanned<ArrayTypeIndex>
) -> Option<&'ctx Spanned<ArrayTypeIndex>>
[src]
&mut self,
id: ArrayTypeIndexRef,
node: &'ctx Spanned<ArrayTypeIndex>
) -> Option<&'ctx Spanned<ArrayTypeIndex>>
impl<'sb, 'ast, 'ctx> NodeStorage<FileDeclRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &FileDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &FileDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: FileDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: FileDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'ctx> NodeStorage<NexitStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<NexitStmt>
fn get(&self, id: &NexitStmtRef) -> Option<&&'ctx Stmt<NexitStmt>>
[src]
fn set(
&mut self,
id: NexitStmtRef,
node: &'ctx Stmt<NexitStmt>
) -> Option<&'ctx Stmt<NexitStmt>>
[src]
&mut self,
id: NexitStmtRef,
node: &'ctx Stmt<NexitStmt>
) -> Option<&'ctx Stmt<NexitStmt>>
impl<'ctx> NodeStorage<ArchRef> for HirTable<'ctx>
[src]
type Node = &'ctx Arch
fn get(&self, id: &ArchRef) -> Option<&&'ctx Arch>
[src]
fn set(&mut self, id: ArchRef, node: &'ctx Arch) -> Option<&'ctx Arch>
[src]
impl<'ctx> NodeStorage<LatentSubprogRef> for HirTable<'ctx>
[src]
type Node = Spanned<SubprogRef>
fn get(&self, id: &LatentSubprogRef) -> Option<&Spanned<SubprogRef>>
[src]
fn set(
&mut self,
id: LatentSubprogRef,
node: Spanned<SubprogRef>
) -> Option<Spanned<SubprogRef>>
[src]
&mut self,
id: LatentSubprogRef,
node: Spanned<SubprogRef>
) -> Option<Spanned<SubprogRef>>
impl<'ctx> NodeStorage<WaitStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<WaitStmt>
fn get(&self, id: &WaitStmtRef) -> Option<&&'ctx Stmt<WaitStmt>>
[src]
fn set(
&mut self,
id: WaitStmtRef,
node: &'ctx Stmt<WaitStmt>
) -> Option<&'ctx Stmt<WaitStmt>>
[src]
&mut self,
id: WaitStmtRef,
node: &'ctx Stmt<WaitStmt>
) -> Option<&'ctx Stmt<WaitStmt>>
impl<'ctx> NodeStorage<TypeDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx TypeDecl
fn get(&self, id: &TypeDeclRef) -> Option<&&'ctx TypeDecl>
[src]
fn set(
&mut self,
id: TypeDeclRef,
node: &'ctx TypeDecl
) -> Option<&'ctx TypeDecl>
[src]
&mut self,
id: TypeDeclRef,
node: &'ctx TypeDecl
) -> Option<&'ctx TypeDecl>
impl<'ctx> NodeStorage<SubprogInstRef> for HirTable<'ctx>
[src]
type Node = &'ctx SubprogInst
fn get(&self, id: &SubprogInstRef) -> Option<&&'ctx SubprogInst>
[src]
fn set(
&mut self,
id: SubprogInstRef,
node: &'ctx SubprogInst
) -> Option<&'ctx SubprogInst>
[src]
&mut self,
id: SubprogInstRef,
node: &'ctx SubprogInst
) -> Option<&'ctx SubprogInst>
impl<'sb, 'ast, 'ctx> NodeStorage<NexitStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &NexitStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &NexitStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: NexitStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: NexitStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'ctx> NodeStorage<ReportStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<ReportStmt>
fn get(&self, id: &ReportStmtRef) -> Option<&&'ctx Stmt<ReportStmt>>
[src]
fn set(
&mut self,
id: ReportStmtRef,
node: &'ctx Stmt<ReportStmt>
) -> Option<&'ctx Stmt<ReportStmt>>
[src]
&mut self,
id: ReportStmtRef,
node: &'ctx Stmt<ReportStmt>
) -> Option<&'ctx Stmt<ReportStmt>>
impl<'ast> NodeStorage<CfgSpecRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast CfgSpec)
fn get(&self, id: &CfgSpecRef) -> Option<&(ScopeRef, &'ast CfgSpec)>
[src]
fn set(
&mut self,
id: CfgSpecRef,
node: (ScopeRef, &'ast CfgSpec)
) -> Option<(ScopeRef, &'ast CfgSpec)>
[src]
&mut self,
id: CfgSpecRef,
node: (ScopeRef, &'ast CfgSpec)
) -> Option<(ScopeRef, &'ast CfgSpec)>
impl<'ctx> NodeStorage<SubprogBodyRef> for HirTable<'ctx>
[src]
type Node = &'ctx SubprogBody
fn get(&self, id: &SubprogBodyRef) -> Option<&&'ctx SubprogBody>
[src]
fn set(
&mut self,
id: SubprogBodyRef,
node: &'ctx SubprogBody
) -> Option<&'ctx SubprogBody>
[src]
&mut self,
id: SubprogBodyRef,
node: &'ctx SubprogBody
) -> Option<&'ctx SubprogBody>
impl<'sb, 'ast, 'ctx> NodeStorage<VarAssignStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &VarAssignStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &VarAssignStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: VarAssignStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: VarAssignStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'sb, 'ast, 'ctx> NodeStorage<TypeDeclRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &TypeDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &TypeDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: TypeDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: TypeDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'ctx> NodeStorage<NullStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<NullStmt>
fn get(&self, id: &NullStmtRef) -> Option<&&'ctx Stmt<NullStmt>>
[src]
fn set(
&mut self,
id: NullStmtRef,
node: &'ctx Stmt<NullStmt>
) -> Option<&'ctx Stmt<NullStmt>>
[src]
&mut self,
id: NullStmtRef,
node: &'ctx Stmt<NullStmt>
) -> Option<&'ctx Stmt<NullStmt>>
impl<'ast> NodeStorage<IntfConstRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)
fn get(
&self,
id: &IntfConstRef
) -> Option<&(ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)>
[src]
&self,
id: &IntfConstRef
) -> Option<&(ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)>
fn set(
&mut self,
id: IntfConstRef,
node: (ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)
) -> Option<(ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)>
[src]
&mut self,
id: IntfConstRef,
node: (ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)
) -> Option<(ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)>
impl<'sb, 'ast, 'ctx> NodeStorage<ConstDeclRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &ConstDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &ConstDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: ConstDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: ConstDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'ctx> NodeStorage<IntfSignalRef> for HirTable<'ctx>
[src]
type Node = &'ctx IntfSignal
fn get(&self, id: &IntfSignalRef) -> Option<&&'ctx IntfSignal>
[src]
fn set(
&mut self,
id: IntfSignalRef,
node: &'ctx IntfSignal
) -> Option<&'ctx IntfSignal>
[src]
&mut self,
id: IntfSignalRef,
node: &'ctx IntfSignal
) -> Option<&'ctx IntfSignal>
impl<'ast> NodeStorage<IntfSubprogRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast IntfSubprogDecl)
fn get(&self, id: &IntfSubprogRef) -> Option<&(ScopeRef, &'ast IntfSubprogDecl)>
[src]
fn set(
&mut self,
id: IntfSubprogRef,
node: (ScopeRef, &'ast IntfSubprogDecl)
) -> Option<(ScopeRef, &'ast IntfSubprogDecl)>
[src]
&mut self,
id: IntfSubprogRef,
node: (ScopeRef, &'ast IntfSubprogDecl)
) -> Option<(ScopeRef, &'ast IntfSubprogDecl)>
impl<'ast> NodeStorage<AliasDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast AliasDecl)
fn get(&self, id: &AliasDeclRef) -> Option<&(ScopeRef, &'ast AliasDecl)>
[src]
fn set(
&mut self,
id: AliasDeclRef,
node: (ScopeRef, &'ast AliasDecl)
) -> Option<(ScopeRef, &'ast AliasDecl)>
[src]
&mut self,
id: AliasDeclRef,
node: (ScopeRef, &'ast AliasDecl)
) -> Option<(ScopeRef, &'ast AliasDecl)>
impl<'ast> NodeStorage<EntityRef> for AstTable<'ast>
[src]
type Node = (LibRef, CtxItemsRef, &'ast EntityDecl)
fn get(
&self,
id: &EntityRef
) -> Option<&(LibRef, CtxItemsRef, &'ast EntityDecl)>
[src]
&self,
id: &EntityRef
) -> Option<&(LibRef, CtxItemsRef, &'ast EntityDecl)>
fn set(
&mut self,
id: EntityRef,
node: (LibRef, CtxItemsRef, &'ast EntityDecl)
) -> Option<(LibRef, CtxItemsRef, &'ast EntityDecl)>
[src]
&mut self,
id: EntityRef,
node: (LibRef, CtxItemsRef, &'ast EntityDecl)
) -> Option<(LibRef, CtxItemsRef, &'ast EntityDecl)>
impl<'ast> NodeStorage<GroupTempRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast GroupDecl)
fn get(&self, id: &GroupTempRef) -> Option<&(ScopeRef, &'ast GroupDecl)>
[src]
fn set(
&mut self,
id: GroupTempRef,
node: (ScopeRef, &'ast GroupDecl)
) -> Option<(ScopeRef, &'ast GroupDecl)>
[src]
&mut self,
id: GroupTempRef,
node: (ScopeRef, &'ast GroupDecl)
) -> Option<(ScopeRef, &'ast GroupDecl)>
impl<'ast> NodeStorage<SubtypeDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast SubtypeDecl)
fn get(&self, id: &SubtypeDeclRef) -> Option<&(ScopeRef, &'ast SubtypeDecl)>
[src]
fn set(
&mut self,
id: SubtypeDeclRef,
node: (ScopeRef, &'ast SubtypeDecl)
) -> Option<(ScopeRef, &'ast SubtypeDecl)>
[src]
&mut self,
id: SubtypeDeclRef,
node: (ScopeRef, &'ast SubtypeDecl)
) -> Option<(ScopeRef, &'ast SubtypeDecl)>
impl<'ast> NodeStorage<IntfPkgRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast PkgInst)
fn get(&self, id: &IntfPkgRef) -> Option<&(ScopeRef, &'ast PkgInst)>
[src]
fn set(
&mut self,
id: IntfPkgRef,
node: (ScopeRef, &'ast PkgInst)
) -> Option<(ScopeRef, &'ast PkgInst)>
[src]
&mut self,
id: IntfPkgRef,
node: (ScopeRef, &'ast PkgInst)
) -> Option<(ScopeRef, &'ast PkgInst)>
impl<'ctx> NodeStorage<ExprRef> for HirTable<'ctx>
[src]
type Node = &'ctx Expr
fn get(&self, id: &ExprRef) -> Option<&&'ctx Expr>
[src]
fn set(&mut self, id: ExprRef, node: &'ctx Expr) -> Option<&'ctx Expr>
[src]
impl<'ctx> NodeStorage<SigAssignStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx SigAssignStmt
fn get(&self, id: &SigAssignStmtRef) -> Option<&&'ctx SigAssignStmt>
[src]
fn set(
&mut self,
id: SigAssignStmtRef,
node: &'ctx SigAssignStmt
) -> Option<&'ctx SigAssignStmt>
[src]
&mut self,
id: SigAssignStmtRef,
node: &'ctx SigAssignStmt
) -> Option<&'ctx SigAssignStmt>
impl<'ast> NodeStorage<ProcessStmtRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Stmt)
fn get(&self, id: &ProcessStmtRef) -> Option<&(ScopeRef, &'ast Stmt)>
[src]
fn set(
&mut self,
id: ProcessStmtRef,
node: (ScopeRef, &'ast Stmt)
) -> Option<(ScopeRef, &'ast Stmt)>
[src]
&mut self,
id: ProcessStmtRef,
node: (ScopeRef, &'ast Stmt)
) -> Option<(ScopeRef, &'ast Stmt)>
impl<'ctx> NodeStorage<LatentTypeMarkRef> for HirTable<'ctx>
[src]
type Node = Spanned<TypeMarkRef>
fn get(&self, id: &LatentTypeMarkRef) -> Option<&Spanned<TypeMarkRef>>
[src]
fn set(
&mut self,
id: LatentTypeMarkRef,
node: Spanned<TypeMarkRef>
) -> Option<Spanned<TypeMarkRef>>
[src]
&mut self,
id: LatentTypeMarkRef,
node: Spanned<TypeMarkRef>
) -> Option<Spanned<TypeMarkRef>>
impl<'ctx> NodeStorage<AggregateRef> for HirTable<'ctx>
[src]
type Node = &'ctx Aggregate
fn get(&self, id: &AggregateRef) -> Option<&&'ctx Aggregate>
[src]
fn set(
&mut self,
id: AggregateRef,
node: &'ctx Aggregate
) -> Option<&'ctx Aggregate>
[src]
&mut self,
id: AggregateRef,
node: &'ctx Aggregate
) -> Option<&'ctx Aggregate>
impl<'ast> NodeStorage<SubprogBodyRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Subprog)
fn get(&self, id: &SubprogBodyRef) -> Option<&(ScopeRef, &'ast Subprog)>
[src]
fn set(
&mut self,
id: SubprogBodyRef,
node: (ScopeRef, &'ast Subprog)
) -> Option<(ScopeRef, &'ast Subprog)>
[src]
&mut self,
id: SubprogBodyRef,
node: (ScopeRef, &'ast Subprog)
) -> Option<(ScopeRef, &'ast Subprog)>
impl<'ast> NodeStorage<LatentPkgRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, LatentName<'ast>)
fn get(&self, id: &LatentPkgRef) -> Option<&(ScopeRef, LatentName<'ast>)>
[src]
fn set(
&mut self,
id: LatentPkgRef,
node: (ScopeRef, LatentName<'ast>)
) -> Option<(ScopeRef, LatentName<'ast>)>
[src]
&mut self,
id: LatentPkgRef,
node: (ScopeRef, LatentName<'ast>)
) -> Option<(ScopeRef, LatentName<'ast>)>
impl<'ast> NodeStorage<PkgDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast PkgDecl)
fn get(&self, id: &PkgDeclRef) -> Option<&(ScopeRef, &'ast PkgDecl)>
[src]
fn set(
&mut self,
id: PkgDeclRef,
node: (ScopeRef, &'ast PkgDecl)
) -> Option<(ScopeRef, &'ast PkgDecl)>
[src]
&mut self,
id: PkgDeclRef,
node: (ScopeRef, &'ast PkgDecl)
) -> Option<(ScopeRef, &'ast PkgDecl)>
impl<'ctx> NodeStorage<SubtypeIndRef> for HirTable<'ctx>
[src]
type Node = &'ctx SubtypeInd
fn get(&self, id: &SubtypeIndRef) -> Option<&&'ctx SubtypeInd>
[src]
fn set(
&mut self,
id: SubtypeIndRef,
node: &'ctx SubtypeInd
) -> Option<&'ctx SubtypeInd>
[src]
&mut self,
id: SubtypeIndRef,
node: &'ctx SubtypeInd
) -> Option<&'ctx SubtypeInd>
impl<'sb, 'ast, 'ctx> NodeStorage<CallStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &CallStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &CallStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: CallStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: CallStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'ctx> NodeStorage<SubprogDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx Subprog
fn get(&self, id: &SubprogDeclRef) -> Option<&&'ctx Subprog>
[src]
fn set(
&mut self,
id: SubprogDeclRef,
node: &'ctx Subprog
) -> Option<&'ctx Subprog>
[src]
&mut self,
id: SubprogDeclRef,
node: &'ctx Subprog
) -> Option<&'ctx Subprog>
impl<'sb, 'ast, 'ctx> NodeStorage<SignalDeclRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &SignalDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &SignalDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: SignalDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: SignalDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'ast> NodeStorage<IntfSignalRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)
fn get(
&self,
id: &IntfSignalRef
) -> Option<&(ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)>
[src]
&self,
id: &IntfSignalRef
) -> Option<&(ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)>
fn set(
&mut self,
id: IntfSignalRef,
node: (ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)
) -> Option<(ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)>
[src]
&mut self,
id: IntfSignalRef,
node: (ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)
) -> Option<(ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)>
impl<'ast> NodeStorage<TypeDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast TypeDecl)
fn get(&self, id: &TypeDeclRef) -> Option<&(ScopeRef, &'ast TypeDecl)>
[src]
fn set(
&mut self,
id: TypeDeclRef,
node: (ScopeRef, &'ast TypeDecl)
) -> Option<(ScopeRef, &'ast TypeDecl)>
[src]
&mut self,
id: TypeDeclRef,
node: (ScopeRef, &'ast TypeDecl)
) -> Option<(ScopeRef, &'ast TypeDecl)>
impl<'ast> NodeStorage<DisconSpecRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast DisconSpec)
fn get(&self, id: &DisconSpecRef) -> Option<&(ScopeRef, &'ast DisconSpec)>
[src]
fn set(
&mut self,
id: DisconSpecRef,
node: (ScopeRef, &'ast DisconSpec)
) -> Option<(ScopeRef, &'ast DisconSpec)>
[src]
&mut self,
id: DisconSpecRef,
node: (ScopeRef, &'ast DisconSpec)
) -> Option<(ScopeRef, &'ast DisconSpec)>
impl<'ast> NodeStorage<CtxRef> for AstTable<'ast>
[src]
type Node = (LibRef, CtxItemsRef, &'ast CtxDecl)
fn get(&self, id: &CtxRef) -> Option<&(LibRef, CtxItemsRef, &'ast CtxDecl)>
[src]
fn set(
&mut self,
id: CtxRef,
node: (LibRef, CtxItemsRef, &'ast CtxDecl)
) -> Option<(LibRef, CtxItemsRef, &'ast CtxDecl)>
[src]
&mut self,
id: CtxRef,
node: (LibRef, CtxItemsRef, &'ast CtxDecl)
) -> Option<(LibRef, CtxItemsRef, &'ast CtxDecl)>
impl<'ast> NodeStorage<AttrSpecRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast AttrDecl)
fn get(&self, id: &AttrSpecRef) -> Option<&(ScopeRef, &'ast AttrDecl)>
[src]
fn set(
&mut self,
id: AttrSpecRef,
node: (ScopeRef, &'ast AttrDecl)
) -> Option<(ScopeRef, &'ast AttrDecl)>
[src]
&mut self,
id: AttrSpecRef,
node: (ScopeRef, &'ast AttrDecl)
) -> Option<(ScopeRef, &'ast AttrDecl)>
impl<'ctx> NodeStorage<LoopStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<LoopStmt>
fn get(&self, id: &LoopStmtRef) -> Option<&&'ctx Stmt<LoopStmt>>
[src]
fn set(
&mut self,
id: LoopStmtRef,
node: &'ctx Stmt<LoopStmt>
) -> Option<&'ctx Stmt<LoopStmt>>
[src]
&mut self,
id: LoopStmtRef,
node: &'ctx Stmt<LoopStmt>
) -> Option<&'ctx Stmt<LoopStmt>>
impl<'ctx> NodeStorage<EntityRef> for HirTable<'ctx>
[src]
type Node = &'ctx Entity
fn get(&self, id: &EntityRef) -> Option<&&'ctx Entity>
[src]
fn set(&mut self, id: EntityRef, node: &'ctx Entity) -> Option<&'ctx Entity>
[src]
impl<'sb, 'ast, 'ctx> NodeStorage<LoopStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &LoopStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &LoopStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: LoopStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: LoopStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'ctx> NodeStorage<FileDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx Decl<FileDecl>
fn get(&self, id: &FileDeclRef) -> Option<&&'ctx Decl<FileDecl>>
[src]
fn set(
&mut self,
id: FileDeclRef,
node: &'ctx Decl<FileDecl>
) -> Option<&'ctx Decl<FileDecl>>
[src]
&mut self,
id: FileDeclRef,
node: &'ctx Decl<FileDecl>
) -> Option<&'ctx Decl<FileDecl>>
impl<'sb, 'ast, 'ctx> NodeStorage<NullStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &NullStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &NullStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: NullStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: NullStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'sb, 'ast, 'ctx> NodeStorage<AggregateRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &AggregateRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &AggregateRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: AggregateRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: AggregateRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'ctx> NodeStorage<PkgBodyRef> for HirTable<'ctx>
[src]
type Node = &'ctx PackageBody
fn get(&self, id: &PkgBodyRef) -> Option<&&'ctx PackageBody>
[src]
fn set(
&mut self,
id: PkgBodyRef,
node: &'ctx PackageBody
) -> Option<&'ctx PackageBody>
[src]
&mut self,
id: PkgBodyRef,
node: &'ctx PackageBody
) -> Option<&'ctx PackageBody>
impl<'ast> NodeStorage<SubprogDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Subprog)
fn get(&self, id: &SubprogDeclRef) -> Option<&(ScopeRef, &'ast Subprog)>
[src]
fn set(
&mut self,
id: SubprogDeclRef,
node: (ScopeRef, &'ast Subprog)
) -> Option<(ScopeRef, &'ast Subprog)>
[src]
&mut self,
id: SubprogDeclRef,
node: (ScopeRef, &'ast Subprog)
) -> Option<(ScopeRef, &'ast Subprog)>
impl<'ctx> NodeStorage<ConstDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx Decl<ConstDecl>
fn get(&self, id: &ConstDeclRef) -> Option<&&'ctx Decl<ConstDecl>>
[src]
fn set(
&mut self,
id: ConstDeclRef,
node: &'ctx Decl<ConstDecl>
) -> Option<&'ctx Decl<ConstDecl>>
[src]
&mut self,
id: ConstDeclRef,
node: &'ctx Decl<ConstDecl>
) -> Option<&'ctx Decl<ConstDecl>>
impl<'ast> NodeStorage<PkgInstRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast PkgInst)
fn get(&self, id: &PkgInstRef) -> Option<&(ScopeRef, &'ast PkgInst)>
[src]
fn set(
&mut self,
id: PkgInstRef,
node: (ScopeRef, &'ast PkgInst)
) -> Option<(ScopeRef, &'ast PkgInst)>
[src]
&mut self,
id: PkgInstRef,
node: (ScopeRef, &'ast PkgInst)
) -> Option<(ScopeRef, &'ast PkgInst)>
impl<'ctx> NodeStorage<SignalDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx Decl<SignalDecl>
fn get(&self, id: &SignalDeclRef) -> Option<&&'ctx Decl<SignalDecl>>
[src]
fn set(
&mut self,
id: SignalDeclRef,
node: &'ctx Decl<SignalDecl>
) -> Option<&'ctx Decl<SignalDecl>>
[src]
&mut self,
id: SignalDeclRef,
node: &'ctx Decl<SignalDecl>
) -> Option<&'ctx Decl<SignalDecl>>
impl<'ast> NodeStorage<VarAssignStmtRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Stmt)
fn get(&self, id: &VarAssignStmtRef) -> Option<&(ScopeRef, &'ast Stmt)>
[src]
fn set(
&mut self,
id: VarAssignStmtRef,
node: (ScopeRef, &'ast Stmt)
) -> Option<(ScopeRef, &'ast Stmt)>
[src]
&mut self,
id: VarAssignStmtRef,
node: (ScopeRef, &'ast Stmt)
) -> Option<(ScopeRef, &'ast Stmt)>
impl<'ctx> NodeStorage<VarAssignStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<VarAssignStmt>
fn get(&self, id: &VarAssignStmtRef) -> Option<&&'ctx Stmt<VarAssignStmt>>
[src]
fn set(
&mut self,
id: VarAssignStmtRef,
node: &'ctx Stmt<VarAssignStmt>
) -> Option<&'ctx Stmt<VarAssignStmt>>
[src]
&mut self,
id: VarAssignStmtRef,
node: &'ctx Stmt<VarAssignStmt>
) -> Option<&'ctx Stmt<VarAssignStmt>>
impl<'ctx> NodeStorage<AssertStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<AssertStmt>
fn get(&self, id: &AssertStmtRef) -> Option<&&'ctx Stmt<AssertStmt>>
[src]
fn set(
&mut self,
id: AssertStmtRef,
node: &'ctx Stmt<AssertStmt>
) -> Option<&'ctx Stmt<AssertStmt>>
[src]
&mut self,
id: AssertStmtRef,
node: &'ctx Stmt<AssertStmt>
) -> Option<&'ctx Stmt<AssertStmt>>
impl<'ast> NodeStorage<SigAssignStmtRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Stmt)
fn get(&self, id: &SigAssignStmtRef) -> Option<&(ScopeRef, &'ast Stmt)>
[src]
fn set(
&mut self,
id: SigAssignStmtRef,
node: (ScopeRef, &'ast Stmt)
) -> Option<(ScopeRef, &'ast Stmt)>
[src]
&mut self,
id: SigAssignStmtRef,
node: (ScopeRef, &'ast Stmt)
) -> Option<(ScopeRef, &'ast Stmt)>
impl<'ctx> NodeStorage<LatentPkgRef> for HirTable<'ctx>
[src]
type Node = Spanned<PkgRef>
fn get(&self, id: &LatentPkgRef) -> Option<&Spanned<PkgRef>>
[src]
fn set(
&mut self,
id: LatentPkgRef,
node: Spanned<PkgRef>
) -> Option<Spanned<PkgRef>>
[src]
&mut self,
id: LatentPkgRef,
node: Spanned<PkgRef>
) -> Option<Spanned<PkgRef>>
impl<'ast> NodeStorage<CompDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast CompDecl)
fn get(&self, id: &CompDeclRef) -> Option<&(ScopeRef, &'ast CompDecl)>
[src]
fn set(
&mut self,
id: CompDeclRef,
node: (ScopeRef, &'ast CompDecl)
) -> Option<(ScopeRef, &'ast CompDecl)>
[src]
&mut self,
id: CompDeclRef,
node: (ScopeRef, &'ast CompDecl)
) -> Option<(ScopeRef, &'ast CompDecl)>
impl<'ast> NodeStorage<GroupDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast GroupDecl)
fn get(&self, id: &GroupDeclRef) -> Option<&(ScopeRef, &'ast GroupDecl)>
[src]
fn set(
&mut self,
id: GroupDeclRef,
node: (ScopeRef, &'ast GroupDecl)
) -> Option<(ScopeRef, &'ast GroupDecl)>
[src]
&mut self,
id: GroupDeclRef,
node: (ScopeRef, &'ast GroupDecl)
) -> Option<(ScopeRef, &'ast GroupDecl)>
impl<'sb, 'ast, 'ctx> NodeStorage<SigAssignStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &SigAssignStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &SigAssignStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: SigAssignStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: SigAssignStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'sb, 'ast, 'ctx> NodeStorage<ExprRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &ExprRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &ExprRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: ExprRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: ExprRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'ast> NodeStorage<CtxItemsRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast [CtxItem])
fn get(&self, id: &CtxItemsRef) -> Option<&(ScopeRef, &'ast [CtxItem])>
[src]
fn set(
&mut self,
id: CtxItemsRef,
node: (ScopeRef, &'ast [CtxItem])
) -> Option<(ScopeRef, &'ast [CtxItem])>
[src]
&mut self,
id: CtxItemsRef,
node: (ScopeRef, &'ast [CtxItem])
) -> Option<(ScopeRef, &'ast [CtxItem])>
impl<'ctx> NodeStorage<SubtypeDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx SubtypeDecl
fn get(&self, id: &SubtypeDeclRef) -> Option<&&'ctx SubtypeDecl>
[src]
fn set(
&mut self,
id: SubtypeDeclRef,
node: &'ctx SubtypeDecl
) -> Option<&'ctx SubtypeDecl>
[src]
&mut self,
id: SubtypeDeclRef,
node: &'ctx SubtypeDecl
) -> Option<&'ctx SubtypeDecl>
impl<'ast> NodeStorage<LatentSubprogRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, LatentName<'ast>)
fn get(&self, id: &LatentSubprogRef) -> Option<&(ScopeRef, LatentName<'ast>)>
[src]
fn set(
&mut self,
id: LatentSubprogRef,
node: (ScopeRef, LatentName<'ast>)
) -> Option<(ScopeRef, LatentName<'ast>)>
[src]
&mut self,
id: LatentSubprogRef,
node: (ScopeRef, LatentName<'ast>)
) -> Option<(ScopeRef, LatentName<'ast>)>
impl<'ctx> NodeStorage<PkgDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx Package
fn get(&self, id: &PkgDeclRef) -> Option<&&'ctx Package>
[src]
fn set(&mut self, id: PkgDeclRef, node: &'ctx Package) -> Option<&'ctx Package>
[src]
impl<'ctx> NodeStorage<ReturnStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<ReturnStmt>
fn get(&self, id: &ReturnStmtRef) -> Option<&&'ctx Stmt<ReturnStmt>>
[src]
fn set(
&mut self,
id: ReturnStmtRef,
node: &'ctx Stmt<ReturnStmt>
) -> Option<&'ctx Stmt<ReturnStmt>>
[src]
&mut self,
id: ReturnStmtRef,
node: &'ctx Stmt<ReturnStmt>
) -> Option<&'ctx Stmt<ReturnStmt>>
impl<'sb, 'ast, 'ctx> NodeStorage<IfStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &IfStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &IfStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: IfStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: IfStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'ctx> NodeStorage<VarDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx Decl<VarDecl>
fn get(&self, id: &VarDeclRef) -> Option<&&'ctx Decl<VarDecl>>
[src]
fn set(
&mut self,
id: VarDeclRef,
node: &'ctx Decl<VarDecl>
) -> Option<&'ctx Decl<VarDecl>>
[src]
&mut self,
id: VarDeclRef,
node: &'ctx Decl<VarDecl>
) -> Option<&'ctx Decl<VarDecl>>
impl<'ast> NodeStorage<SubprogInstRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Subprog)
fn get(&self, id: &SubprogInstRef) -> Option<&(ScopeRef, &'ast Subprog)>
[src]
fn set(
&mut self,
id: SubprogInstRef,
node: (ScopeRef, &'ast Subprog)
) -> Option<(ScopeRef, &'ast Subprog)>
[src]
&mut self,
id: SubprogInstRef,
node: (ScopeRef, &'ast Subprog)
) -> Option<(ScopeRef, &'ast Subprog)>
impl<'ast> NodeStorage<ArchRef> for AstTable<'ast>
[src]
type Node = (LibRef, CtxItemsRef, &'ast ArchBody)
fn get(&self, id: &ArchRef) -> Option<&(LibRef, CtxItemsRef, &'ast ArchBody)>
[src]
fn set(
&mut self,
id: ArchRef,
node: (LibRef, CtxItemsRef, &'ast ArchBody)
) -> Option<(LibRef, CtxItemsRef, &'ast ArchBody)>
[src]
&mut self,
id: ArchRef,
node: (LibRef, CtxItemsRef, &'ast ArchBody)
) -> Option<(LibRef, CtxItemsRef, &'ast ArchBody)>
impl<'ast> NodeStorage<CfgRef> for AstTable<'ast>
[src]
type Node = (LibRef, CtxItemsRef, &'ast CfgDecl)
fn get(&self, id: &CfgRef) -> Option<&(LibRef, CtxItemsRef, &'ast CfgDecl)>
[src]
fn set(
&mut self,
id: CfgRef,
node: (LibRef, CtxItemsRef, &'ast CfgDecl)
) -> Option<(LibRef, CtxItemsRef, &'ast CfgDecl)>
[src]
&mut self,
id: CfgRef,
node: (LibRef, CtxItemsRef, &'ast CfgDecl)
) -> Option<(LibRef, CtxItemsRef, &'ast CfgDecl)>
impl<'ast> NodeStorage<ArrayTypeIndexRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Expr)
fn get(&self, id: &ArrayTypeIndexRef) -> Option<&(ScopeRef, &'ast Expr)>
[src]
fn set(
&mut self,
id: ArrayTypeIndexRef,
node: (ScopeRef, &'ast Expr)
) -> Option<(ScopeRef, &'ast Expr)>
[src]
&mut self,
id: ArrayTypeIndexRef,
node: (ScopeRef, &'ast Expr)
) -> Option<(ScopeRef, &'ast Expr)>
impl<'ctx> NodeStorage<LibRef> for HirTable<'ctx>
[src]
type Node = &'ctx Lib
fn get(&self, id: &LibRef) -> Option<&&'ctx Lib>
[src]
fn set(&mut self, id: LibRef, node: &'ctx Lib) -> Option<&'ctx Lib>
[src]
impl<'ast> NodeStorage<PkgBodyRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast PkgBody)
fn get(&self, id: &PkgBodyRef) -> Option<&(ScopeRef, &'ast PkgBody)>
[src]
fn set(
&mut self,
id: PkgBodyRef,
node: (ScopeRef, &'ast PkgBody)
) -> Option<(ScopeRef, &'ast PkgBody)>
[src]
&mut self,
id: PkgBodyRef,
node: (ScopeRef, &'ast PkgBody)
) -> Option<(ScopeRef, &'ast PkgBody)>
impl<'ast> NodeStorage<ExprRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Expr)
fn get(&self, id: &ExprRef) -> Option<&(ScopeRef, &'ast Expr)>
[src]
fn set(
&mut self,
id: ExprRef,
node: (ScopeRef, &'ast Expr)
) -> Option<(ScopeRef, &'ast Expr)>
[src]
&mut self,
id: ExprRef,
node: (ScopeRef, &'ast Expr)
) -> Option<(ScopeRef, &'ast Expr)>
impl<'ctx> NodeStorage<CallStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<CallStmt>
fn get(&self, id: &CallStmtRef) -> Option<&&'ctx Stmt<CallStmt>>
[src]
fn set(
&mut self,
id: CallStmtRef,
node: &'ctx Stmt<CallStmt>
) -> Option<&'ctx Stmt<CallStmt>>
[src]
&mut self,
id: CallStmtRef,
node: &'ctx Stmt<CallStmt>
) -> Option<&'ctx Stmt<CallStmt>>
impl<'ctx> NodeStorage<PkgInstRef> for HirTable<'ctx>
[src]
type Node = &'ctx PackageInst
fn get(&self, id: &PkgInstRef) -> Option<&&'ctx PackageInst>
[src]
fn set(
&mut self,
id: PkgInstRef,
node: &'ctx PackageInst
) -> Option<&'ctx PackageInst>
[src]
&mut self,
id: PkgInstRef,
node: &'ctx PackageInst
) -> Option<&'ctx PackageInst>
impl<'ctx> NodeStorage<ProcessStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx ProcessStmt
fn get(&self, id: &ProcessStmtRef) -> Option<&&'ctx ProcessStmt>
[src]
fn set(
&mut self,
id: ProcessStmtRef,
node: &'ctx ProcessStmt
) -> Option<&'ctx ProcessStmt>
[src]
&mut self,
id: ProcessStmtRef,
node: &'ctx ProcessStmt
) -> Option<&'ctx ProcessStmt>
impl<'sb, 'ast, 'ctx> NodeStorage<WaitStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &WaitStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &WaitStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: WaitStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: WaitStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
impl<'ctx> NodeStorage<CaseStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<CaseStmt>
fn get(&self, id: &CaseStmtRef) -> Option<&&'ctx Stmt<CaseStmt>>
[src]
fn set(
&mut self,
id: CaseStmtRef,
node: &'ctx Stmt<CaseStmt>
) -> Option<&'ctx Stmt<CaseStmt>>
[src]
&mut self,
id: CaseStmtRef,
node: &'ctx Stmt<CaseStmt>
) -> Option<&'ctx Stmt<CaseStmt>>
impl<'ast> NodeStorage<LatentTypeMarkRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, LatentName<'ast>)
fn get(&self, id: &LatentTypeMarkRef) -> Option<&(ScopeRef, LatentName<'ast>)>
[src]
fn set(
&mut self,
id: LatentTypeMarkRef,
node: (ScopeRef, LatentName<'ast>)
) -> Option<(ScopeRef, LatentName<'ast>)>
[src]
&mut self,
id: LatentTypeMarkRef,
node: (ScopeRef, LatentName<'ast>)
) -> Option<(ScopeRef, LatentName<'ast>)>
impl<'ctx> NodeStorage<IfStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<IfStmt>
fn get(&self, id: &IfStmtRef) -> Option<&&'ctx Stmt<IfStmt>>
[src]
fn set(
&mut self,
id: IfStmtRef,
node: &'ctx Stmt<IfStmt>
) -> Option<&'ctx Stmt<IfStmt>>
[src]
&mut self,
id: IfStmtRef,
node: &'ctx Stmt<IfStmt>
) -> Option<&'ctx Stmt<IfStmt>>
impl<'sb, 'ast, 'ctx> NodeStorage<CaseStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
fn get(
&self,
id: &CaseStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&self,
id: &CaseStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
fn set(
&mut self,
id: CaseStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>
[src]
&mut self,
id: CaseStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb>>>