Struct Index 

pub struct Index<'a> { /* private fields */ }

What is in a file, without what it says.

Borrows the source bytes and stores four parallel columns plus a table of distinct type names. At roughly 24 bytes per entity this is two orders of magnitude smaller than the decoded Model.

Use Index::entity to decode one record, or Index::materialize_closure to build a real Model from a chosen subset.

Implementations

impl<'a> Index<'a>

pub fn scan(source: &'a [u8]) -> Self

Scans source for record boundaries. Does not decode attributes.

pub fn len(&self) -> usize

Number of records found.

pub fn is_empty(&self) -> bool

Whether the file has no data records.

pub fn ids(&self) -> impl Iterator<Item = EntityId> + '_

Every id, in file order.

pub fn type_of(&self, id: EntityId) -> Option<&str>

Upper-cased type name of id, without decoding it.

pub fn count_by_type(&self) -> BTreeMap<&str, usize>

How many records of each type. The census a viewer opens with.

pub fn ids_of_type(&self, name: &str) -> Vec<EntityId>

Ids of every record whose type matches name, case-insensitively.

pub fn entity(&self, id: EntityId) -> Option<Entity>

Decodes one record into an Entity.

The record is wrapped in a minimal synthetic file and handed to the real parser, so a lazily decoded entity cannot drift from its eager counterpart: there is only one decoder.

pub fn materialize(&self, wanted: &[EntityId]) -> Model

Builds a Model from exactly wanted, and nothing else.

Dangling references

The result is a real Model but not a self-contained one: an entity that referenced #7 still says Ref(7) even when #7 was not requested. Traversal will not resolve it. Use Index::materialize_closure unless you specifically want the raw subset and will handle missing targets yourself.

pub fn materialize_closure(&self, wanted: &[EntityId]) -> Model

Builds a Model containing wanted and everything they reach.

Follows references transitively, so the result has no dangling Ref. This is the constructor to reach for: it is what makes a subset independently usable.