Trait moore::score::NodeStorage

pub trait NodeStorage<I> {
    type Node;
    fn get(&self, id: &I) -> Option<&Self::Node>;
    fn set(&mut self, id: I, node: Self::Node) -> Option<Self::Node>;
}

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.

Loading content...

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.

Loading content...

Implementations on Foreign Types

impl<K, V> NodeStorage<K> for BTreeMap<K, V> where
    K: Ord, 

type Node = V

fn get(&self, id: &K) -> Option<&V>

fn set(&mut self, id: K, node: V) -> Option<V>

impl<K, V> NodeStorage<K> for HashMap<K, V, RandomState> where
    K: Hash + Eq, 

type Node = V

fn get(&self, id: &K) -> Option<&V>

fn set(&mut self, id: K, node: V) -> Option<V>

impl<'ast> NodeStorage<SubtypeDeclRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast SubtypeDecl)

fn get(&self, id: &SubtypeDeclRef) -> Option<&(ScopeRef, &'ast SubtypeDecl)>

fn set(
    &mut self,
    id: SubtypeDeclRef,
    node: (ScopeRef, &'ast SubtypeDecl)
) -> Option<(ScopeRef, &'ast SubtypeDecl)>

impl<'ctx> NodeStorage<LibRef> for HirTable<'ctx>

type Node = &'ctx Lib

fn get(&self, id: &LibRef) -> Option<&&'ctx Lib>

fn set(&mut self, id: LibRef, node: &'ctx Lib) -> Option<&'ctx Lib>

impl<'sb, 'ast, 'ctx> NodeStorage<AssertStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ast> NodeStorage<IntfTypeRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast TypeDecl)

fn get(&self, id: &IntfTypeRef) -> Option<&(ScopeRef, &'ast TypeDecl)>

fn set(
    &mut self,
    id: IntfTypeRef,
    node: (ScopeRef, &'ast TypeDecl)
) -> Option<(ScopeRef, &'ast TypeDecl)>

impl<'sb, 'ast, 'ctx> NodeStorage<IfStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ast> NodeStorage<ArchRef> for AstTable<'ast>

type Node = (LibRef, CtxItemsRef, &'ast ArchBody)

fn get(&self, id: &ArchRef) -> Option<&(LibRef, CtxItemsRef, &'ast ArchBody)>

fn set(
    &mut self,
    id: ArchRef,
    node: (LibRef, CtxItemsRef, &'ast ArchBody)
) -> Option<(LibRef, CtxItemsRef, &'ast ArchBody)>

impl<'ctx> NodeStorage<CaseStmtRef> for HirTable<'ctx>

type Node = &'ctx Stmt<CaseStmt>

fn get(&self, id: &CaseStmtRef) -> Option<&&'ctx Stmt<CaseStmt>>

fn set(
    &mut self,
    id: CaseStmtRef,
    node: &'ctx Stmt<CaseStmt>
) -> Option<&'ctx Stmt<CaseStmt>>

impl<'sb, 'ast, 'ctx> NodeStorage<VarAssignStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ctx> NodeStorage<ReportStmtRef> for HirTable<'ctx>

type Node = &'ctx Stmt<ReportStmt>

fn get(&self, id: &ReportStmtRef) -> Option<&&'ctx Stmt<ReportStmt>>

fn set(
    &mut self,
    id: ReportStmtRef,
    node: &'ctx Stmt<ReportStmt>
) -> Option<&'ctx Stmt<ReportStmt>>

impl<'ast> NodeStorage<CfgRef> for AstTable<'ast>

type Node = (LibRef, CtxItemsRef, &'ast CfgDecl)

fn get(&self, id: &CfgRef) -> Option<&(LibRef, CtxItemsRef, &'ast CfgDecl)>

fn set(
    &mut self,
    id: CfgRef,
    node: (LibRef, CtxItemsRef, &'ast CfgDecl)
) -> Option<(LibRef, CtxItemsRef, &'ast CfgDecl)>

impl<'ctx> NodeStorage<SubprogBodyRef> for HirTable<'ctx>

type Node = &'ctx SubprogBody

fn get(&self, id: &SubprogBodyRef) -> Option<&&'ctx SubprogBody>

fn set(
    &mut self,
    id: SubprogBodyRef,
    node: &'ctx SubprogBody
) -> Option<&'ctx SubprogBody>

impl<'ast> NodeStorage<PkgBodyRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast PkgBody)

fn get(&self, id: &PkgBodyRef) -> Option<&(ScopeRef, &'ast PkgBody)>

fn set(
    &mut self,
    id: PkgBodyRef,
    node: (ScopeRef, &'ast PkgBody)
) -> Option<(ScopeRef, &'ast PkgBody)>

impl<'ctx> NodeStorage<SignalDeclRef> for HirTable<'ctx>

type Node = &'ctx Decl<SignalDecl>

fn get(&self, id: &SignalDeclRef) -> Option<&&'ctx Decl<SignalDecl>>

fn set(
    &mut self,
    id: SignalDeclRef,
    node: &'ctx Decl<SignalDecl>
) -> Option<&'ctx Decl<SignalDecl>>

impl<'ast> NodeStorage<TypeDeclRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast TypeDecl)

fn get(&self, id: &TypeDeclRef) -> Option<&(ScopeRef, &'ast TypeDecl)>

fn set(
    &mut self,
    id: TypeDeclRef,
    node: (ScopeRef, &'ast TypeDecl)
) -> Option<(ScopeRef, &'ast TypeDecl)>

impl<'sb, 'ast, 'ctx> NodeStorage<ExprRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'sb, 'ast, 'ctx> NodeStorage<SubtypeIndRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ast> NodeStorage<SigAssignStmtRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast Stmt)

fn get(&self, id: &SigAssignStmtRef) -> Option<&(ScopeRef, &'ast Stmt)>

fn set(
    &mut self,
    id: SigAssignStmtRef,
    node: (ScopeRef, &'ast Stmt)
) -> Option<(ScopeRef, &'ast Stmt)>

impl<'ctx> NodeStorage<LoopStmtRef> for HirTable<'ctx>

type Node = &'ctx Stmt<LoopStmt>

fn get(&self, id: &LoopStmtRef) -> Option<&&'ctx Stmt<LoopStmt>>

fn set(
    &mut self,
    id: LoopStmtRef,
    node: &'ctx Stmt<LoopStmt>
) -> Option<&'ctx Stmt<LoopStmt>>

impl<'ctx> NodeStorage<PkgDeclRef> for HirTable<'ctx>

type Node = &'ctx Package

fn get(&self, id: &PkgDeclRef) -> Option<&&'ctx Package>

fn set(&mut self, id: PkgDeclRef, node: &'ctx Package) -> Option<&'ctx Package>

impl<'ctx> NodeStorage<IfStmtRef> for HirTable<'ctx>

type Node = &'ctx Stmt<IfStmt>

fn get(&self, id: &IfStmtRef) -> Option<&&'ctx Stmt<IfStmt>>

fn set(
    &mut self,
    id: IfStmtRef,
    node: &'ctx Stmt<IfStmt>
) -> Option<&'ctx Stmt<IfStmt>>

impl<'ctx> NodeStorage<SubprogInstRef> for HirTable<'ctx>

type Node = &'ctx SubprogInst

fn get(&self, id: &SubprogInstRef) -> Option<&&'ctx SubprogInst>

fn set(
    &mut self,
    id: SubprogInstRef,
    node: &'ctx SubprogInst
) -> Option<&'ctx SubprogInst>

impl<'sb, 'ast, 'ctx> NodeStorage<ConstDeclRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ctx> NodeStorage<PkgBodyRef> for HirTable<'ctx>

type Node = &'ctx PackageBody

fn get(&self, id: &PkgBodyRef) -> Option<&&'ctx PackageBody>

fn set(
    &mut self,
    id: PkgBodyRef,
    node: &'ctx PackageBody
) -> Option<&'ctx PackageBody>

impl<'ast> NodeStorage<ProcessStmtRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast Stmt)

fn get(&self, id: &ProcessStmtRef) -> Option<&(ScopeRef, &'ast Stmt)>

fn set(
    &mut self,
    id: ProcessStmtRef,
    node: (ScopeRef, &'ast Stmt)
) -> Option<(ScopeRef, &'ast Stmt)>

impl<'ctx> NodeStorage<AssertStmtRef> for HirTable<'ctx>

type Node = &'ctx Stmt<AssertStmt>

fn get(&self, id: &AssertStmtRef) -> Option<&&'ctx Stmt<AssertStmt>>

fn set(
    &mut self,
    id: AssertStmtRef,
    node: &'ctx Stmt<AssertStmt>
) -> Option<&'ctx Stmt<AssertStmt>>

impl<'ast> NodeStorage<SubprogBodyRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast Subprog)

fn get(&self, id: &SubprogBodyRef) -> Option<&(ScopeRef, &'ast Subprog)>

fn set(
    &mut self,
    id: SubprogBodyRef,
    node: (ScopeRef, &'ast Subprog)
) -> Option<(ScopeRef, &'ast Subprog)>

impl<'ctx> NodeStorage<EntityRef> for HirTable<'ctx>

type Node = &'ctx Entity

fn get(&self, id: &EntityRef) -> Option<&&'ctx Entity>

fn set(&mut self, id: EntityRef, node: &'ctx Entity) -> Option<&'ctx Entity>

impl<'ctx> NodeStorage<FileDeclRef> for HirTable<'ctx>

type Node = &'ctx Decl<FileDecl>

fn get(&self, id: &FileDeclRef) -> Option<&&'ctx Decl<FileDecl>>

fn set(
    &mut self,
    id: FileDeclRef,
    node: &'ctx Decl<FileDecl>
) -> Option<&'ctx Decl<FileDecl>>

impl<'ctx> NodeStorage<AggregateRef> for HirTable<'ctx>

type Node = &'ctx Aggregate

fn get(&self, id: &AggregateRef) -> Option<&&'ctx Aggregate>

fn set(
    &mut self,
    id: AggregateRef,
    node: &'ctx Aggregate
) -> Option<&'ctx Aggregate>

impl<'ctx> NodeStorage<ConstDeclRef> for HirTable<'ctx>

type Node = &'ctx Decl<ConstDecl>

fn get(&self, id: &ConstDeclRef) -> Option<&&'ctx Decl<ConstDecl>>

fn set(
    &mut self,
    id: ConstDeclRef,
    node: &'ctx Decl<ConstDecl>
) -> Option<&'ctx Decl<ConstDecl>>

impl<'ast> NodeStorage<AliasDeclRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast AliasDecl)

fn get(&self, id: &AliasDeclRef) -> Option<&(ScopeRef, &'ast AliasDecl)>

fn set(
    &mut self,
    id: AliasDeclRef,
    node: (ScopeRef, &'ast AliasDecl)
) -> Option<(ScopeRef, &'ast AliasDecl)>

impl<'sb, 'ast, 'ctx> NodeStorage<NullStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ctx> NodeStorage<NexitStmtRef> for HirTable<'ctx>

type Node = &'ctx Stmt<NexitStmt>

fn get(&self, id: &NexitStmtRef) -> Option<&&'ctx Stmt<NexitStmt>>

fn set(
    &mut self,
    id: NexitStmtRef,
    node: &'ctx Stmt<NexitStmt>
) -> Option<&'ctx Stmt<NexitStmt>>

impl<'ctx> NodeStorage<SigAssignStmtRef> for HirTable<'ctx>

type Node = &'ctx SigAssignStmt

fn get(&self, id: &SigAssignStmtRef) -> Option<&&'ctx SigAssignStmt>

fn set(
    &mut self,
    id: SigAssignStmtRef,
    node: &'ctx SigAssignStmt
) -> Option<&'ctx SigAssignStmt>

impl<'ast> NodeStorage<IntfConstRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)

fn get(
    &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)>

impl<'ast> NodeStorage<CfgSpecRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast CfgSpec)

fn get(&self, id: &CfgSpecRef) -> Option<&(ScopeRef, &'ast CfgSpec)>

fn set(
    &mut self,
    id: CfgSpecRef,
    node: (ScopeRef, &'ast CfgSpec)
) -> Option<(ScopeRef, &'ast CfgSpec)>

impl<'ast> NodeStorage<DisconSpecRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast DisconSpec)

fn get(&self, id: &DisconSpecRef) -> Option<&(ScopeRef, &'ast DisconSpec)>

fn set(
    &mut self,
    id: DisconSpecRef,
    node: (ScopeRef, &'ast DisconSpec)
) -> Option<(ScopeRef, &'ast DisconSpec)>

impl<'ast> NodeStorage<GroupTempRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast GroupDecl)

fn get(&self, id: &GroupTempRef) -> Option<&(ScopeRef, &'ast GroupDecl)>

fn set(
    &mut self,
    id: GroupTempRef,
    node: (ScopeRef, &'ast GroupDecl)
) -> Option<(ScopeRef, &'ast GroupDecl)>

impl<'ast> NodeStorage<ExprRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast Expr)

fn get(&self, id: &ExprRef) -> Option<&(ScopeRef, &'ast Expr)>

fn set(
    &mut self,
    id: ExprRef,
    node: (ScopeRef, &'ast Expr)
) -> Option<(ScopeRef, &'ast Expr)>

impl<'ast> NodeStorage<IntfSignalRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast IntfObjDecl, SubtypeIndRef, &'ast Ident)

fn get(
    &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)>

impl<'ctx> NodeStorage<ProcessStmtRef> for HirTable<'ctx>

type Node = &'ctx ProcessStmt

fn get(&self, id: &ProcessStmtRef) -> Option<&&'ctx ProcessStmt>

fn set(
    &mut self,
    id: ProcessStmtRef,
    node: &'ctx ProcessStmt
) -> Option<&'ctx ProcessStmt>

impl<'ctx> NodeStorage<LatentSubprogRef> for HirTable<'ctx>

type Node = Spanned<SubprogRef>

fn get(&self, id: &LatentSubprogRef) -> Option<&Spanned<SubprogRef>>

fn set(
    &mut self,
    id: LatentSubprogRef,
    node: Spanned<SubprogRef>
) -> Option<Spanned<SubprogRef>>

impl<'ast> NodeStorage<LatentSubprogRef> for AstTable<'ast>

type Node = (ScopeRef, LatentName<'ast>)

fn get(&self, id: &LatentSubprogRef) -> Option<&(ScopeRef, LatentName<'ast>)>

fn set(
    &mut self,
    id: LatentSubprogRef,
    node: (ScopeRef, LatentName<'ast>)
) -> Option<(ScopeRef, LatentName<'ast>)>

impl<'ctx> NodeStorage<PkgInstRef> for HirTable<'ctx>

type Node = &'ctx PackageInst

fn get(&self, id: &PkgInstRef) -> Option<&&'ctx PackageInst>

fn set(
    &mut self,
    id: PkgInstRef,
    node: &'ctx PackageInst
) -> Option<&'ctx PackageInst>

impl<'sb, 'ast, 'ctx> NodeStorage<SignalDeclRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ctx> NodeStorage<ReturnStmtRef> for HirTable<'ctx>

type Node = &'ctx Stmt<ReturnStmt>

fn get(&self, id: &ReturnStmtRef) -> Option<&&'ctx Stmt<ReturnStmt>>

fn set(
    &mut self,
    id: ReturnStmtRef,
    node: &'ctx Stmt<ReturnStmt>
) -> Option<&'ctx Stmt<ReturnStmt>>

impl<'ctx> NodeStorage<TypeDeclRef> for HirTable<'ctx>

type Node = &'ctx TypeDecl

fn get(&self, id: &TypeDeclRef) -> Option<&&'ctx TypeDecl>

fn set(
    &mut self,
    id: TypeDeclRef,
    node: &'ctx TypeDecl
) -> Option<&'ctx TypeDecl>

impl<'sb, 'ast, 'ctx> NodeStorage<AggregateRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ctx> NodeStorage<ArchRef> for HirTable<'ctx>

type Node = &'ctx Arch

fn get(&self, id: &ArchRef) -> Option<&&'ctx Arch>

fn set(&mut self, id: ArchRef, node: &'ctx Arch) -> Option<&'ctx Arch>

impl<'ast> NodeStorage<IntfSubprogRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast IntfSubprogDecl)

fn get(&self, id: &IntfSubprogRef) -> Option<&(ScopeRef, &'ast IntfSubprogDecl)>

fn set(
    &mut self,
    id: IntfSubprogRef,
    node: (ScopeRef, &'ast IntfSubprogDecl)
) -> Option<(ScopeRef, &'ast IntfSubprogDecl)>

impl<'ctx> NodeStorage<SubprogDeclRef> for HirTable<'ctx>

type Node = &'ctx Subprog

fn get(&self, id: &SubprogDeclRef) -> Option<&&'ctx Subprog>

fn set(
    &mut self,
    id: SubprogDeclRef,
    node: &'ctx Subprog
) -> Option<&'ctx Subprog>

impl<'sb, 'ast, 'ctx> NodeStorage<ReturnStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'sb, 'ast, 'ctx> NodeStorage<TypeDeclRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'sb, 'ast, 'ctx> NodeStorage<CallStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ast> NodeStorage<EntityRef> for AstTable<'ast>

type Node = (LibRef, CtxItemsRef, &'ast EntityDecl)

fn get(
    &self,
    id: &EntityRef
) -> Option<&(LibRef, CtxItemsRef, &'ast EntityDecl)>

fn set(
    &mut self,
    id: EntityRef,
    node: (LibRef, CtxItemsRef, &'ast EntityDecl)
) -> Option<(LibRef, CtxItemsRef, &'ast EntityDecl)>

impl<'ctx> NodeStorage<ExprRef> for HirTable<'ctx>

type Node = &'ctx Expr

fn get(&self, id: &ExprRef) -> Option<&&'ctx Expr>

fn set(&mut self, id: ExprRef, node: &'ctx Expr) -> Option<&'ctx Expr>

impl<'ast> NodeStorage<IntfPkgRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast PkgInst)

fn get(&self, id: &IntfPkgRef) -> Option<&(ScopeRef, &'ast PkgInst)>

fn set(
    &mut self,
    id: IntfPkgRef,
    node: (ScopeRef, &'ast PkgInst)
) -> Option<(ScopeRef, &'ast PkgInst)>

impl<'ctx> NodeStorage<CallStmtRef> for HirTable<'ctx>

type Node = &'ctx Stmt<CallStmt>

fn get(&self, id: &CallStmtRef) -> Option<&&'ctx Stmt<CallStmt>>

fn set(
    &mut self,
    id: CallStmtRef,
    node: &'ctx Stmt<CallStmt>
) -> Option<&'ctx Stmt<CallStmt>>

impl<'ast> NodeStorage<SubprogInstRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast Subprog)

fn get(&self, id: &SubprogInstRef) -> Option<&(ScopeRef, &'ast Subprog)>

fn set(
    &mut self,
    id: SubprogInstRef,
    node: (ScopeRef, &'ast Subprog)
) -> Option<(ScopeRef, &'ast Subprog)>

impl<'sb, 'ast, 'ctx> NodeStorage<VarDeclRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ast> NodeStorage<ArrayTypeIndexRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast Expr)

fn get(&self, id: &ArrayTypeIndexRef) -> Option<&(ScopeRef, &'ast Expr)>

fn set(
    &mut self,
    id: ArrayTypeIndexRef,
    node: (ScopeRef, &'ast Expr)
) -> Option<(ScopeRef, &'ast Expr)>

impl<'ctx> NodeStorage<SubtypeDeclRef> for HirTable<'ctx>

type Node = &'ctx SubtypeDecl

fn get(&self, id: &SubtypeDeclRef) -> Option<&&'ctx SubtypeDecl>

fn set(
    &mut self,
    id: SubtypeDeclRef,
    node: &'ctx SubtypeDecl
) -> Option<&'ctx SubtypeDecl>

impl<'ast> NodeStorage<VarAssignStmtRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast Stmt)

fn get(&self, id: &VarAssignStmtRef) -> Option<&(ScopeRef, &'ast Stmt)>

fn set(
    &mut self,
    id: VarAssignStmtRef,
    node: (ScopeRef, &'ast Stmt)
) -> Option<(ScopeRef, &'ast Stmt)>

impl<'sb, 'ast, 'ctx> NodeStorage<NexitStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ast> NodeStorage<AttrSpecRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast AttrDecl)

fn get(&self, id: &AttrSpecRef) -> Option<&(ScopeRef, &'ast AttrDecl)>

fn set(
    &mut self,
    id: AttrSpecRef,
    node: (ScopeRef, &'ast AttrDecl)
) -> Option<(ScopeRef, &'ast AttrDecl)>

impl<'sb, 'ast, 'ctx> NodeStorage<FileDeclRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ctx> NodeStorage<VarDeclRef> for HirTable<'ctx>

type Node = &'ctx Decl<VarDecl>

fn get(&self, id: &VarDeclRef) -> Option<&&'ctx Decl<VarDecl>>

fn set(
    &mut self,
    id: VarDeclRef,
    node: &'ctx Decl<VarDecl>
) -> Option<&'ctx Decl<VarDecl>>

impl<'sb, 'ast, 'ctx> NodeStorage<ReportStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ast> NodeStorage<GroupDeclRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast GroupDecl)

fn get(&self, id: &GroupDeclRef) -> Option<&(ScopeRef, &'ast GroupDecl)>

fn set(
    &mut self,
    id: GroupDeclRef,
    node: (ScopeRef, &'ast GroupDecl)
) -> Option<(ScopeRef, &'ast GroupDecl)>

impl<'sb, 'ast, 'ctx> NodeStorage<LoopStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ast> NodeStorage<AttrDeclRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast AttrDecl)

fn get(&self, id: &AttrDeclRef) -> Option<&(ScopeRef, &'ast AttrDecl)>

fn set(
    &mut self,
    id: AttrDeclRef,
    node: (ScopeRef, &'ast AttrDecl)
) -> Option<(ScopeRef, &'ast AttrDecl)>

impl<'ctx> NodeStorage<ArrayTypeIndexRef> for HirTable<'ctx>

type Node = &'ctx Spanned<ArrayTypeIndex>

fn get(&self, id: &ArrayTypeIndexRef) -> Option<&&'ctx Spanned<ArrayTypeIndex>>

fn set(
    &mut self,
    id: ArrayTypeIndexRef,
    node: &'ctx Spanned<ArrayTypeIndex>
) -> Option<&'ctx Spanned<ArrayTypeIndex>>

impl<'sb, 'ast, 'ctx> NodeStorage<CaseStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ctx> NodeStorage<WaitStmtRef> for HirTable<'ctx>

type Node = &'ctx Stmt<WaitStmt>

fn get(&self, id: &WaitStmtRef) -> Option<&&'ctx Stmt<WaitStmt>>

fn set(
    &mut self,
    id: WaitStmtRef,
    node: &'ctx Stmt<WaitStmt>
) -> Option<&'ctx Stmt<WaitStmt>>

impl<'ctx> NodeStorage<SubtypeIndRef> for HirTable<'ctx>

type Node = &'ctx SubtypeInd

fn get(&self, id: &SubtypeIndRef) -> Option<&&'ctx SubtypeInd>

fn set(
    &mut self,
    id: SubtypeIndRef,
    node: &'ctx SubtypeInd
) -> Option<&'ctx SubtypeInd>

impl<'ctx> NodeStorage<IntfSignalRef> for HirTable<'ctx>

type Node = &'ctx IntfSignal

fn get(&self, id: &IntfSignalRef) -> Option<&&'ctx IntfSignal>

fn set(
    &mut self,
    id: IntfSignalRef,
    node: &'ctx IntfSignal
) -> Option<&'ctx IntfSignal>

impl<'sb, 'ast, 'ctx> NodeStorage<WaitStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ast> NodeStorage<SubprogDeclRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast Subprog)

fn get(&self, id: &SubprogDeclRef) -> Option<&(ScopeRef, &'ast Subprog)>

fn set(
    &mut self,
    id: SubprogDeclRef,
    node: (ScopeRef, &'ast Subprog)
) -> Option<(ScopeRef, &'ast Subprog)>

impl<'ast> NodeStorage<PkgInstRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast PkgInst)

fn get(&self, id: &PkgInstRef) -> Option<&(ScopeRef, &'ast PkgInst)>

fn set(
    &mut self,
    id: PkgInstRef,
    node: (ScopeRef, &'ast PkgInst)
) -> Option<(ScopeRef, &'ast PkgInst)>

impl<'ast> NodeStorage<PkgDeclRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast PkgDecl)

fn get(&self, id: &PkgDeclRef) -> Option<&(ScopeRef, &'ast PkgDecl)>

fn set(
    &mut self,
    id: PkgDeclRef,
    node: (ScopeRef, &'ast PkgDecl)
) -> Option<(ScopeRef, &'ast PkgDecl)>

impl<'ast> NodeStorage<CtxItemsRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast [CtxItem])

fn get(&self, id: &CtxItemsRef) -> Option<&(ScopeRef, &'ast [CtxItem])>

fn set(
    &mut self,
    id: CtxItemsRef,
    node: (ScopeRef, &'ast [CtxItem])
) -> Option<(ScopeRef, &'ast [CtxItem])>

impl<'ctx> NodeStorage<LatentTypeMarkRef> for HirTable<'ctx>

type Node = Spanned<TypeMarkRef>

fn get(&self, id: &LatentTypeMarkRef) -> Option<&Spanned<TypeMarkRef>>

fn set(
    &mut self,
    id: LatentTypeMarkRef,
    node: Spanned<TypeMarkRef>
) -> Option<Spanned<TypeMarkRef>>

impl<'ast> NodeStorage<LatentPkgRef> for AstTable<'ast>

type Node = (ScopeRef, LatentName<'ast>)

fn get(&self, id: &LatentPkgRef) -> Option<&(ScopeRef, LatentName<'ast>)>

fn set(
    &mut self,
    id: LatentPkgRef,
    node: (ScopeRef, LatentName<'ast>)
) -> Option<(ScopeRef, LatentName<'ast>)>

impl<'sb, 'ast, 'ctx> NodeStorage<SigAssignStmtRef> for LazyHirTable<'sb, 'ast, 'ctx>

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>>>

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>>>

impl<'ast> NodeStorage<CompDeclRef> for AstTable<'ast>

type Node = (ScopeRef, &'ast CompDecl)

fn get(&self, id: &CompDeclRef) -> Option<&(ScopeRef, &'ast CompDecl)>

fn set(
    &mut self,
    id: CompDeclRef,
    node: (ScopeRef, &'ast CompDecl)
) -> Option<(ScopeRef, &'ast CompDecl)>

impl<'ast> NodeStorage<LatentTypeMarkRef> for AstTable<'ast>

type Node = (ScopeRef, LatentName<'ast>)

fn get(&self, id: &LatentTypeMarkRef) -> Option<&(ScopeRef, LatentName<'ast>)>

fn set(
    &mut self,
    id: LatentTypeMarkRef,
    node: (ScopeRef, LatentName<'ast>)
) -> Option<(ScopeRef, LatentName<'ast>)>

impl<'ast> NodeStorage<CtxRef> for AstTable<'ast>

type Node = (LibRef, CtxItemsRef, &'ast CtxDecl)

fn get(&self, id: &CtxRef) -> Option<&(LibRef, CtxItemsRef, &'ast CtxDecl)>

fn set(
    &mut self,
    id: CtxRef,
    node: (LibRef, CtxItemsRef, &'ast CtxDecl)
) -> Option<(LibRef, CtxItemsRef, &'ast CtxDecl)>

impl<'ctx> NodeStorage<NullStmtRef> for HirTable<'ctx>

type Node = &'ctx Stmt<NullStmt>

fn get(&self, id: &NullStmtRef) -> Option<&&'ctx Stmt<NullStmt>>

fn set(
    &mut self,
    id: NullStmtRef,
    node: &'ctx Stmt<NullStmt>
) -> Option<&'ctx Stmt<NullStmt>>

impl<'ctx> NodeStorage<VarAssignStmtRef> for HirTable<'ctx>

type Node = &'ctx Stmt<VarAssignStmt>

fn get(&self, id: &VarAssignStmtRef) -> Option<&&'ctx Stmt<VarAssignStmt>>

fn set(
    &mut self,
    id: VarAssignStmtRef,
    node: &'ctx Stmt<VarAssignStmt>
) -> Option<&'ctx Stmt<VarAssignStmt>>

impl<'ctx> NodeStorage<LatentPkgRef> for HirTable<'ctx>

type Node = Spanned<PkgRef>

fn get(&self, id: &LatentPkgRef) -> Option<&Spanned<PkgRef>>

fn set(
    &mut self,
    id: LatentPkgRef,
    node: Spanned<PkgRef>
) -> Option<Spanned<PkgRef>>

Loading content...

Implementors

Loading content...