Struct hyper_ast::store::SimpleStores

pub struct SimpleStores<TS, NS = DefaultNodeStore, LS = LabelStore> {
    pub label_store: LS,
    pub type_store: TS,
    pub node_store: NS,
}

Fields

label_store: LS

type_store: TS

node_store: NS

Trait Implementations

impl<TS: Default, NS: Default, LS: Default> Default for SimpleStores<TS, NS, LS>

fn default() -> Self

Returns the “default value” for a type.

impl<'store, TS> From<&'store SimpleStores<TS, NodeStore, LabelStore>> for SimpleHyperAST<HashedNodeRef<'store>, &'store TS, &'store DefaultNodeStore, &'store LabelStore>

fn from(value: &'store SimpleStores<TS, DefaultNodeStore>) -> Self

Converts to this type from the input type.

impl<'store, TS> HyperAST<'store> for SimpleStores<TS, DefaultNodeStore>where TS: TypeStore<HashedNodeRef<'store, DefaultNodeIdentifier>, Ty = AnyType>,

type IdN = Entity

type Idx = u16

type Label = SymbolU32

type T = HashedNodeRef<'store, <SimpleStores<TS, NodeStore, LabelStore> as HyperAST<'store>>::IdN>

type NS = NodeStore

fn node_store(&self) -> &Self::NS

type LS = LabelStore

fn label_store(&self) -> &Self::LS

type TS = TS

fn type_store(&self) -> &Self::TS

fn decompress<D: DecompressedSubtree<'store, Self::T, Out = D>>( &'store self, id: &Self::IdN ) -> (&'store Self, D)where Self: Sized,

fn decompress_pair<D1, D2>( &'store self, id1: &Self::IdN, id2: &Self::IdN ) -> (&'store Self, (D1, D2))where Self: Sized, D1: DecompressedSubtree<'store, Self::T, Out = D1>, D2: DecompressedSubtree<'store, Self::T, Out = D2>,

impl<'store, TS, NS, LS> LabelStore<str> for SimpleStores<TS, NS, LS>where LS: LabelStore<str>,

type I = <LS as LabelStore<str>>::I

fn get_or_insert<U: Borrow<str>>(&mut self, node: U) -> Self::I

fn get<U: Borrow<str>>(&self, node: U) -> Option<Self::I>

fn resolve(&self, id: &Self::I) -> &str

impl<IdN, TS, NS, LS> NodeStore<IdN> for SimpleStores<TS, NS, LS>where for<'a> NS::R<'a>: Tree<TreeId = IdN>, IdN: NodeId<IdN = IdN>, NS: NodeStore<IdN>,

type R<'a> = <NS as NodeStore<IdN>>::R<'a> where Self: 'a

fn resolve(&self, id: &IdN) -> Self::R<'_>

impl<'store, T, TS, NS, LS> TypeStore<T> for SimpleStores<TS, NS, LS>where T: Tree, T::TreeId: NodeId<IdN = T::TreeId>, T::Type: 'static + Hash, TS: TypeStore<T, Ty = T::Type>, NS: NodeStore<T::TreeId>,

type Ty = <TS as TypeStore<T>>::Ty

const MASK: u16 = TS::MASK

fn resolve_type(&self, n: &T) -> Self::Ty

fn resolve_lang(&self, n: &T) -> LangWrapper<Self::Ty>

type Marshaled = <TS as TypeStore<T>>::Marshaled

fn marshal_type(&self, n: &T) -> Self::Marshaled

impl<'store, TIdN, TS> TypedHyperAST<'store, TIdN> for SimpleStores<TS, DefaultNodeStore>where TIdN: 'static + TypedNodeId<IdN = Self::IdN>, TS: TypeStore<HashedNodeRef<'store, DefaultNodeIdentifier>, Ty = AnyType>,

type T = HashedNodeRef<'store, TIdN>

type NS = NodeStore

fn typed_node_store(&self) -> &<Self as TypedHyperAST<'store, TIdN>>::NS