Struct hyper_ast::types::SimpleHyperAST

pub struct SimpleHyperAST<T, TS, NS, LS> {
    pub type_store: TS,
    pub node_store: NS,
    pub label_store: LS,
    pub _phantom: PhantomData<T>,
}

Fields

type_store: TS

node_store: NS

label_store: LS

_phantom: PhantomData<T>

Trait Implementations

impl<T, TS: Default, NS: Default, LS: Default> Default for SimpleHyperAST<T, 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, T, TS, NS, LS> HyperAST<'store> for SimpleHyperAST<T, TS, NS, LS>where T: Tree, T::TreeId: NodeId<IdN = T::TreeId>, T::Type: 'static, TS: TypeStore<T, Ty = T::Type>, NS: 'store + NodeStore<T::TreeId, R<'store> = T>, LS: LabelStore<str, I = T::Label>,

type IdN = <T as Stored>::TreeId

type Idx = <T as WithChildren>::ChildIdx

type Label = <T as Labeled>::Label

type T = T

type NS = NS

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

type LS = LS

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, T, TS, NS, LS> LabelStore<str> for SimpleHyperAST<T, TS, NS, LS>where T: Tree, T::TreeId: NodeId<IdN = T::TreeId>, T::Type: 'static, LS: LabelStore<str, I = T::Label>, <T as Labeled>::Label: Copy,

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<T, TS, NS, LS> NodeStore<<T as Stored>::TreeId> for SimpleHyperAST<T, TS, NS, LS>where T: Tree, T::TreeId: NodeId<IdN = T::TreeId>, T::Type: 'static, NS: NodeStore<T::TreeId>,

type R<'a> = <NS as NodeStore<<T as Stored>::TreeId>>::R<'a> where Self: 'a

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

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

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