[−][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
Loading content...Required methods
pub fn get(&self, id: &I) -> Option<&Self::Node>
[src]
Obtains a reference to the node with the given ID.
Returns None
when no node with the given ID exists.
pub fn set(&mut self, id: I, node: Self::Node) -> Option<Self::Node>
[src]
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
pub fn get(&self, id: &K) -> Option<&V>
[src]
pub 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
pub fn get(&self, id: &K) -> Option<&V>
[src]
pub fn set(&mut self, id: K, node: V) -> Option<V>
[src]
impl<'ctx> NodeStorage<WaitStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<WaitStmt>
pub fn get(&self, id: &WaitStmtRef) -> Option<&&'ctx Stmt<WaitStmt>>
[src]
pub 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<VarAssignStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<VarAssignStmt>
pub fn get(&self, id: &VarAssignStmtRef) -> Option<&&'ctx Stmt<VarAssignStmt>>
[src]
pub 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<PkgDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx Package
pub fn get(&self, id: &PkgDeclRef) -> Option<&&'ctx Package>
[src]
pub fn set(
&mut self,
id: PkgDeclRef,
node: &'ctx Package
) -> Option<&'ctx Package>
[src]
&mut self,
id: PkgDeclRef,
node: &'ctx Package
) -> Option<&'ctx Package>
impl<'ast> NodeStorage<ProcessStmtRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Stmt)
pub fn get(&self, id: &ProcessStmtRef) -> Option<&(ScopeRef, &'ast Stmt)>
[src]
pub 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<IntfSignalRef> for HirTable<'ctx>
[src]
type Node = &'ctx IntfSignal
pub fn get(&self, id: &IntfSignalRef) -> Option<&&'ctx IntfSignal>
[src]
pub fn set(
&mut self,
id: IntfSignalRef,
node: &'ctx IntfSignal
) -> Option<&'ctx IntfSignal>
[src]
&mut self,
id: IntfSignalRef,
node: &'ctx IntfSignal
) -> Option<&'ctx IntfSignal>
impl<'ctx> NodeStorage<LatentSubprogRef> for HirTable<'ctx>
[src]
type Node = Spanned<SubprogRef>
pub fn get(&self, id: &LatentSubprogRef) -> Option<&Spanned<SubprogRef>>
[src]
pub fn set(
&mut self,
id: LatentSubprogRef,
node: Spanned<SubprogRef>
) -> Option<Spanned<SubprogRef>>
[src]
&mut self,
id: LatentSubprogRef,
node: Spanned<SubprogRef>
) -> Option<Spanned<SubprogRef>>
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, Global>>
pub fn get(
&self,
id: &SubtypeIndRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &SubtypeIndRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: SubtypeIndRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: SubtypeIndRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ctx> NodeStorage<NexitStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<NexitStmt>
pub fn get(&self, id: &NexitStmtRef) -> Option<&&'ctx Stmt<NexitStmt>>
[src]
pub 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<NullStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<NullStmt>
pub fn get(&self, id: &NullStmtRef) -> Option<&&'ctx Stmt<NullStmt>>
[src]
pub 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<'sb, 'ast, 'ctx> NodeStorage<CallStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
pub fn get(
&self,
id: &CallStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &CallStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: CallStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: CallStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ast> NodeStorage<GroupTempRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast GroupDecl)
pub fn get(&self, id: &GroupTempRef) -> Option<&(ScopeRef, &'ast GroupDecl)>
[src]
pub 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<'ctx> NodeStorage<SubtypeDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx SubtypeDecl
pub fn get(&self, id: &SubtypeDeclRef) -> Option<&&'ctx SubtypeDecl>
[src]
pub fn set(
&mut self,
id: SubtypeDeclRef,
node: &'ctx SubtypeDecl
) -> Option<&'ctx SubtypeDecl>
[src]
&mut self,
id: SubtypeDeclRef,
node: &'ctx SubtypeDecl
) -> Option<&'ctx SubtypeDecl>
impl<'ctx> NodeStorage<ArrayTypeIndexRef> for HirTable<'ctx>
[src]
type Node = &'ctx Spanned<ArrayTypeIndex>
pub fn get(
&self,
id: &ArrayTypeIndexRef
) -> Option<&&'ctx Spanned<ArrayTypeIndex>>
[src]
&self,
id: &ArrayTypeIndexRef
) -> Option<&&'ctx Spanned<ArrayTypeIndex>>
pub 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<'ast> NodeStorage<LatentPkgRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, LatentName<'ast>)
pub fn get(&self, id: &LatentPkgRef) -> Option<&(ScopeRef, LatentName<'ast>)>
[src]
pub 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<'ctx> NodeStorage<LatentPkgRef> for HirTable<'ctx>
[src]
type Node = Spanned<PkgRef>
pub fn get(&self, id: &LatentPkgRef) -> Option<&Spanned<PkgRef>>
[src]
pub fn set(
&mut self,
id: LatentPkgRef,
node: Spanned<PkgRef>
) -> Option<Spanned<PkgRef>>
[src]
&mut self,
id: LatentPkgRef,
node: Spanned<PkgRef>
) -> Option<Spanned<PkgRef>>
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, Global>>
pub fn get(
&self,
id: &SigAssignStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &SigAssignStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: SigAssignStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: SigAssignStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ast> NodeStorage<LatentSubprogRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, LatentName<'ast>)
pub fn get(
&self,
id: &LatentSubprogRef
) -> Option<&(ScopeRef, LatentName<'ast>)>
[src]
&self,
id: &LatentSubprogRef
) -> Option<&(ScopeRef, LatentName<'ast>)>
pub 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<'sb, 'ast, 'ctx> NodeStorage<VarAssignStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
pub fn get(
&self,
id: &VarAssignStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &VarAssignStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: VarAssignStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: VarAssignStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ctx> NodeStorage<PkgInstRef> for HirTable<'ctx>
[src]
type Node = &'ctx PackageInst
pub fn get(&self, id: &PkgInstRef) -> Option<&&'ctx PackageInst>
[src]
pub fn set(
&mut self,
id: PkgInstRef,
node: &'ctx PackageInst
) -> Option<&'ctx PackageInst>
[src]
&mut self,
id: PkgInstRef,
node: &'ctx PackageInst
) -> Option<&'ctx PackageInst>
impl<'ast> NodeStorage<SigAssignStmtRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Stmt)
pub fn get(&self, id: &SigAssignStmtRef) -> Option<&(ScopeRef, &'ast Stmt)>
[src]
pub 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<'sb, 'ast, 'ctx> NodeStorage<ExprRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
pub fn get(
&self,
id: &ExprRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &ExprRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: ExprRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: ExprRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ast> NodeStorage<CfgSpecRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast CfgSpec)
pub fn get(&self, id: &CfgSpecRef) -> Option<&(ScopeRef, &'ast CfgSpec)>
[src]
pub 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<AggregateRef> for HirTable<'ctx>
[src]
type Node = &'ctx Aggregate
pub fn get(&self, id: &AggregateRef) -> Option<&&'ctx Aggregate>
[src]
pub fn set(
&mut self,
id: AggregateRef,
node: &'ctx Aggregate
) -> Option<&'ctx Aggregate>
[src]
&mut self,
id: AggregateRef,
node: &'ctx Aggregate
) -> Option<&'ctx Aggregate>
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, Global>>
pub fn get(
&self,
id: &CaseStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &CaseStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: CaseStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: CaseStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ast> NodeStorage<SubprogBodyRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Subprog)
pub fn get(&self, id: &SubprogBodyRef) -> Option<&(ScopeRef, &'ast Subprog)>
[src]
pub 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<EntityRef> for AstTable<'ast>
[src]
type Node = (LibRef, CtxItemsRef, &'ast EntityDecl)
pub fn get(
&self,
id: &EntityRef
) -> Option<&(LibRef, CtxItemsRef, &'ast EntityDecl)>
[src]
&self,
id: &EntityRef
) -> Option<&(LibRef, CtxItemsRef, &'ast EntityDecl)>
pub 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<'ctx> NodeStorage<PkgBodyRef> for HirTable<'ctx>
[src]
type Node = &'ctx PackageBody
pub fn get(&self, id: &PkgBodyRef) -> Option<&&'ctx PackageBody>
[src]
pub fn set(
&mut self,
id: PkgBodyRef,
node: &'ctx PackageBody
) -> Option<&'ctx PackageBody>
[src]
&mut self,
id: PkgBodyRef,
node: &'ctx PackageBody
) -> Option<&'ctx PackageBody>
impl<'ctx> NodeStorage<CaseStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<CaseStmt>
pub fn get(&self, id: &CaseStmtRef) -> Option<&&'ctx Stmt<CaseStmt>>
[src]
pub 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<'sb, 'ast, 'ctx> NodeStorage<SignalDeclRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
pub fn get(
&self,
id: &SignalDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &SignalDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: SignalDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: SignalDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ctx> NodeStorage<LibRef> for HirTable<'ctx>
[src]
type Node = &'ctx Lib
pub fn get(&self, id: &LibRef) -> Option<&&'ctx Lib>
[src]
pub fn set(&mut self, id: LibRef, node: &'ctx Lib) -> Option<&'ctx Lib>
[src]
impl<'ast> NodeStorage<PkgInstRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast PkgInst)
pub fn get(&self, id: &PkgInstRef) -> Option<&(ScopeRef, &'ast PkgInst)>
[src]
pub 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<ExprRef> for HirTable<'ctx>
[src]
type Node = &'ctx Expr
pub fn get(&self, id: &ExprRef) -> Option<&&'ctx Expr>
[src]
pub fn set(&mut self, id: ExprRef, node: &'ctx Expr) -> Option<&'ctx Expr>
[src]
impl<'ctx> NodeStorage<SubprogInstRef> for HirTable<'ctx>
[src]
type Node = &'ctx SubprogInst
pub fn get(&self, id: &SubprogInstRef) -> Option<&&'ctx SubprogInst>
[src]
pub fn set(
&mut self,
id: SubprogInstRef,
node: &'ctx SubprogInst
) -> Option<&'ctx SubprogInst>
[src]
&mut self,
id: SubprogInstRef,
node: &'ctx SubprogInst
) -> Option<&'ctx SubprogInst>
impl<'ast> NodeStorage<SubtypeDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast SubtypeDecl)
pub fn get(&self, id: &SubtypeDeclRef) -> Option<&(ScopeRef, &'ast SubtypeDecl)>
[src]
pub 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<SubprogInstRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Subprog)
pub fn get(&self, id: &SubprogInstRef) -> Option<&(ScopeRef, &'ast Subprog)>
[src]
pub 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<DisconSpecRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast DisconSpec)
pub fn get(&self, id: &DisconSpecRef) -> Option<&(ScopeRef, &'ast DisconSpec)>
[src]
pub 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<'ctx> NodeStorage<ReportStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<ReportStmt>
pub fn get(&self, id: &ReportStmtRef) -> Option<&&'ctx Stmt<ReportStmt>>
[src]
pub 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<TypeDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast TypeDecl)
pub fn get(&self, id: &TypeDeclRef) -> Option<&(ScopeRef, &'ast TypeDecl)>
[src]
pub 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<PkgDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast PkgDecl)
pub fn get(&self, id: &PkgDeclRef) -> Option<&(ScopeRef, &'ast PkgDecl)>
[src]
pub 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<'ast> NodeStorage<AttrSpecRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast AttrDecl)
pub fn get(&self, id: &AttrSpecRef) -> Option<&(ScopeRef, &'ast AttrDecl)>
[src]
pub 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<'sb, 'ast, 'ctx> NodeStorage<ReportStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
pub fn get(
&self,
id: &ReportStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &ReportStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: ReportStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: ReportStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ast> NodeStorage<IntfPkgRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast PkgInst)
pub fn get(&self, id: &IntfPkgRef) -> Option<&(ScopeRef, &'ast PkgInst)>
[src]
pub 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<'ast> NodeStorage<CtxItemsRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast [CtxItem])
pub fn get(&self, id: &CtxItemsRef) -> Option<&(ScopeRef, &'ast [CtxItem])>
[src]
pub 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<'sb, 'ast, 'ctx> NodeStorage<NexitStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
pub fn get(
&self,
id: &NexitStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &NexitStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: NexitStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: NexitStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ctx> NodeStorage<ArchRef> for HirTable<'ctx>
[src]
type Node = &'ctx Arch
pub fn get(&self, id: &ArchRef) -> Option<&&'ctx Arch>
[src]
pub fn set(&mut self, id: ArchRef, node: &'ctx Arch) -> Option<&'ctx Arch>
[src]
impl<'ast> NodeStorage<AliasDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast AliasDecl)
pub fn get(&self, id: &AliasDeclRef) -> Option<&(ScopeRef, &'ast AliasDecl)>
[src]
pub 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<AttrDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast AttrDecl)
pub fn get(&self, id: &AttrDeclRef) -> Option<&(ScopeRef, &'ast AttrDecl)>
[src]
pub 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<'ast> NodeStorage<SubprogDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Subprog)
pub fn get(&self, id: &SubprogDeclRef) -> Option<&(ScopeRef, &'ast Subprog)>
[src]
pub 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<'ast> NodeStorage<CtxRef> for AstTable<'ast>
[src]
type Node = (LibRef, CtxItemsRef, &'ast CtxDecl)
pub fn get(&self, id: &CtxRef) -> Option<&(LibRef, CtxItemsRef, &'ast CtxDecl)>
[src]
pub 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<IntfSignalRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)
pub fn get(
&self,
id: &IntfSignalRef
) -> Option<&(ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)>
[src]
&self,
id: &IntfSignalRef
) -> Option<&(ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)>
pub 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<'ctx> NodeStorage<ReturnStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<ReturnStmt>
pub fn get(&self, id: &ReturnStmtRef) -> Option<&&'ctx Stmt<ReturnStmt>>
[src]
pub 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<LoopStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
pub fn get(
&self,
id: &LoopStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &LoopStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: LoopStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: LoopStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ast> NodeStorage<ArchRef> for AstTable<'ast>
[src]
type Node = (LibRef, CtxItemsRef, &'ast ArchBody)
pub fn get(
&self,
id: &ArchRef
) -> Option<&(LibRef, CtxItemsRef, &'ast ArchBody)>
[src]
&self,
id: &ArchRef
) -> Option<&(LibRef, CtxItemsRef, &'ast ArchBody)>
pub 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<'sb, 'ast, 'ctx> NodeStorage<WaitStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
pub fn get(
&self,
id: &WaitStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &WaitStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: WaitStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: WaitStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ast> NodeStorage<VarAssignStmtRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Stmt)
pub fn get(&self, id: &VarAssignStmtRef) -> Option<&(ScopeRef, &'ast Stmt)>
[src]
pub 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<'ast> NodeStorage<GroupDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast GroupDecl)
pub fn get(&self, id: &GroupDeclRef) -> Option<&(ScopeRef, &'ast GroupDecl)>
[src]
pub 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<AssertStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
pub fn get(
&self,
id: &AssertStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &AssertStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: AssertStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: AssertStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
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, Global>>
pub fn get(
&self,
id: &VarDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &VarDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: VarDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: VarDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ctx> NodeStorage<LatentTypeMarkRef> for HirTable<'ctx>
[src]
type Node = Spanned<TypeMarkRef>
pub fn get(&self, id: &LatentTypeMarkRef) -> Option<&Spanned<TypeMarkRef>>
[src]
pub fn set(
&mut self,
id: LatentTypeMarkRef,
node: Spanned<TypeMarkRef>
) -> Option<Spanned<TypeMarkRef>>
[src]
&mut self,
id: LatentTypeMarkRef,
node: Spanned<TypeMarkRef>
) -> Option<Spanned<TypeMarkRef>>
impl<'ast> NodeStorage<ArrayTypeIndexRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Expr)
pub fn get(&self, id: &ArrayTypeIndexRef) -> Option<&(ScopeRef, &'ast Expr)>
[src]
pub 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<LoopStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<LoopStmt>
pub fn get(&self, id: &LoopStmtRef) -> Option<&&'ctx Stmt<LoopStmt>>
[src]
pub 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<SubtypeIndRef> for HirTable<'ctx>
[src]
type Node = &'ctx SubtypeInd
pub fn get(&self, id: &SubtypeIndRef) -> Option<&&'ctx SubtypeInd>
[src]
pub fn set(
&mut self,
id: SubtypeIndRef,
node: &'ctx SubtypeInd
) -> Option<&'ctx SubtypeInd>
[src]
&mut self,
id: SubtypeIndRef,
node: &'ctx SubtypeInd
) -> Option<&'ctx SubtypeInd>
impl<'ctx> NodeStorage<VarDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx Decl<VarDecl>
pub fn get(&self, id: &VarDeclRef) -> Option<&&'ctx Decl<VarDecl>>
[src]
pub 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<'ctx> NodeStorage<TypeDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx TypeDecl
pub fn get(&self, id: &TypeDeclRef) -> Option<&&'ctx TypeDecl>
[src]
pub fn set(
&mut self,
id: TypeDeclRef,
node: &'ctx TypeDecl
) -> Option<&'ctx TypeDecl>
[src]
&mut self,
id: TypeDeclRef,
node: &'ctx TypeDecl
) -> Option<&'ctx TypeDecl>
impl<'ast> NodeStorage<IntfConstRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)
pub fn get(
&self,
id: &IntfConstRef
) -> Option<&(ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)>
[src]
&self,
id: &IntfConstRef
) -> Option<&(ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)>
pub 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<ReturnStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
pub fn get(
&self,
id: &ReturnStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &ReturnStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: ReturnStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: ReturnStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
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, Global>>
pub fn get(
&self,
id: &FileDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &FileDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: FileDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: FileDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ctx> NodeStorage<CallStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<CallStmt>
pub fn get(&self, id: &CallStmtRef) -> Option<&&'ctx Stmt<CallStmt>>
[src]
pub 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<ConstDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx Decl<ConstDecl>
pub fn get(&self, id: &ConstDeclRef) -> Option<&&'ctx Decl<ConstDecl>>
[src]
pub 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<CompDeclRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast CompDecl)
pub fn get(&self, id: &CompDeclRef) -> Option<&(ScopeRef, &'ast CompDecl)>
[src]
pub 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<'ctx> NodeStorage<FileDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx Decl<FileDecl>
pub fn get(&self, id: &FileDeclRef) -> Option<&&'ctx Decl<FileDecl>>
[src]
pub 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<'ast> NodeStorage<LatentTypeMarkRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, LatentName<'ast>)
pub fn get(
&self,
id: &LatentTypeMarkRef
) -> Option<&(ScopeRef, LatentName<'ast>)>
[src]
&self,
id: &LatentTypeMarkRef
) -> Option<&(ScopeRef, LatentName<'ast>)>
pub 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>
pub fn get(&self, id: &IfStmtRef) -> Option<&&'ctx Stmt<IfStmt>>
[src]
pub 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<NullStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
pub fn get(
&self,
id: &NullStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &NullStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: NullStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: NullStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ast> NodeStorage<IntfSubprogRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast IntfSubprogDecl)
pub fn get(
&self,
id: &IntfSubprogRef
) -> Option<&(ScopeRef, &'ast IntfSubprogDecl)>
[src]
&self,
id: &IntfSubprogRef
) -> Option<&(ScopeRef, &'ast IntfSubprogDecl)>
pub 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<PkgBodyRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast PkgBody)
pub fn get(&self, id: &PkgBodyRef) -> Option<&(ScopeRef, &'ast PkgBody)>
[src]
pub 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<CfgRef> for AstTable<'ast>
[src]
type Node = (LibRef, CtxItemsRef, &'ast CfgDecl)
pub fn get(&self, id: &CfgRef) -> Option<&(LibRef, CtxItemsRef, &'ast CfgDecl)>
[src]
pub 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<'ctx> NodeStorage<EntityRef> for HirTable<'ctx>
[src]
type Node = &'ctx Entity
pub fn get(&self, id: &EntityRef) -> Option<&&'ctx Entity>
[src]
pub fn set(&mut self, id: EntityRef, node: &'ctx Entity) -> Option<&'ctx Entity>
[src]
impl<'ctx> NodeStorage<SubprogDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx Subprog
pub fn get(&self, id: &SubprogDeclRef) -> Option<&&'ctx Subprog>
[src]
pub fn set(
&mut self,
id: SubprogDeclRef,
node: &'ctx Subprog
) -> Option<&'ctx Subprog>
[src]
&mut self,
id: SubprogDeclRef,
node: &'ctx Subprog
) -> Option<&'ctx Subprog>
impl<'ctx> NodeStorage<SubprogBodyRef> for HirTable<'ctx>
[src]
type Node = &'ctx SubprogBody
pub fn get(&self, id: &SubprogBodyRef) -> Option<&&'ctx SubprogBody>
[src]
pub 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<AggregateRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
pub fn get(
&self,
id: &AggregateRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &AggregateRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: AggregateRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: AggregateRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
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, Global>>
pub fn get(
&self,
id: &IfStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &IfStmtRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: IfStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: IfStmtRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
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, Global>>
pub fn get(
&self,
id: &TypeDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &TypeDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: TypeDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: TypeDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ctx> NodeStorage<SigAssignStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx SigAssignStmt
pub fn get(&self, id: &SigAssignStmtRef) -> Option<&&'ctx SigAssignStmt>
[src]
pub 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<ExprRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast Expr)
pub fn get(&self, id: &ExprRef) -> Option<&(ScopeRef, &'ast Expr)>
[src]
pub 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<SignalDeclRef> for HirTable<'ctx>
[src]
type Node = &'ctx Decl<SignalDecl>
pub fn get(&self, id: &SignalDeclRef) -> Option<&&'ctx Decl<SignalDecl>>
[src]
pub 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<IntfTypeRef> for AstTable<'ast>
[src]
type Node = (ScopeRef, &'ast TypeDecl)
pub fn get(&self, id: &IntfTypeRef) -> Option<&(ScopeRef, &'ast TypeDecl)>
[src]
pub 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<'ctx> NodeStorage<ProcessStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx ProcessStmt
pub fn get(&self, id: &ProcessStmtRef) -> Option<&&'ctx ProcessStmt>
[src]
pub 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<ConstDeclRef> for LazyHirTable<'sb, 'ast, 'ctx>
[src]
type Node = LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
pub fn get(
&self,
id: &ConstDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&self,
id: &ConstDeclRef
) -> Option<&LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
pub fn set(
&mut self,
id: ConstDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
[src]
&mut self,
id: ConstDeclRef,
node: LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>
) -> Option<LazyNode<Box<dyn Fn(&'a ScoreContext<'b, 'sb, 'ast, 'ctx>) + 'sb, Global>>>
impl<'ctx> NodeStorage<AssertStmtRef> for HirTable<'ctx>
[src]
type Node = &'ctx Stmt<AssertStmt>
pub fn get(&self, id: &AssertStmtRef) -> Option<&&'ctx Stmt<AssertStmt>>
[src]
pub 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>>