Struct NumericStore 

pub struct NumericStore {

    pub ids: Vec<u64>,
    pub modules: Vec<u32>,
    pub effective_times: Vec<u32>,
    pub flags: Vec<u8>,
    pub parents: Adjacency,
    pub children: Adjacency,
    pub attributes: Attributes,
    pub concrete: Attributes,
    pub concrete_values: Vec<ConcreteValue>,
    pub membership: Option<MembershipIndex>,
    pub descriptions: DescriptionStore,
    pub search: SearchStore,
    pub history: HistoryStore,
    pub member_tables: MemberStore,
    pub identifiers: IdentifierStore,
    pub config: QueryConfig,
}

Fields

ids: Vec<u64>

modules: Vec<u32>

effective_times: Vec<u32>

flags: Vec<u8>

Bit 0: active. Bit 1: fully defined.

parents: Adjacency

children: Adjacency

attributes: Attributes

concrete: Attributes

concrete_values: Vec<ConcreteValue>

membership: Option<MembershipIndex>

Active refset member rows referencing concepts. None means the index was not built.

descriptions: DescriptionStore

search: SearchStore

history: HistoryStore

member_tables: MemberStore

identifiers: IdentifierStore

config: QueryConfig

Implementations

impl NumericStore

pub fn ordinal(&self, sctid: u64) -> Option<u32>

pub fn is_active(&self, ordinal: u32) -> bool

pub fn hierarchy( &self, sctid: u64, ancestors: bool, direct: bool, include_self: bool, ) -> Vec<u64>

Returns numeric-sorted SCTIDs through active edges, including an inactive self if requested.

pub fn validate_bounds(&self) -> Result<()>

Checks that every stored index stays inside its own arrays.

Opening a store runs only these. They are what later evaluation relies on to index safely; the semantic invariants in validate were proved when the index was written, and the section checksum already shows the bytes are the same ones.

pub fn validate(&self) -> Result<()>

Checks the bounds above and then every semantic invariant: ordering, that the two hierarchy directions agree, that the graph is acyclic, and that active rows reference active concepts.

Import runs this before publishing an index and verify runs it on demand. Opening a store does not, because re-deriving these properties on every process start costs more than it protects: the checksum detects the corruption they would otherwise catch.

pub fn write(&self, path: &Path) -> Result<()>

pub fn open(directory: &Path) -> Result<Self>

Trait Implementations

impl Debug for NumericStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for NumericStore

fn default() -> Self

Returns the “default value” for a type.