Struct BidirectionalIndex 

pub struct BidirectionalIndex { /* private fields */ }

Bidirectional index for fast entity-chunk lookups

This structure maintains two indexes:

1. Entity → Chunks: Given an entity, find all chunks it appears in
2. Chunk → Entities: Given a chunk, find all entities it contains

Implementations

impl BidirectionalIndex

pub fn new() -> Self

Create a new empty bidirectional index

pub fn from_entities(entities: &[Entity]) -> Self

Create a bidirectional index from a collection of entities

This is useful for building the index from extracted entities

pub fn add_mapping(&mut self, entity_id: &EntityId, chunk_id: &ChunkId)

Add a mapping between an entity and a chunk

This is idempotent - adding the same mapping multiple times has no effect

pub fn add_entity_mappings( &mut self, entity_id: &EntityId, chunk_ids: &[ChunkId], )

Add multiple mappings for an entity

pub fn add_chunk_mappings( &mut self, chunk_id: &ChunkId, entity_ids: &[EntityId], )

Add multiple mappings for a chunk

pub fn remove_mapping( &mut self, entity_id: &EntityId, chunk_id: &ChunkId, ) -> bool

Remove a specific mapping between an entity and a chunk

Returns true if the mapping existed and was removed

pub fn remove_entity(&mut self, entity_id: &EntityId) -> usize

Remove all mappings for an entity

Returns the number of mappings removed

pub fn remove_chunk(&mut self, chunk_id: &ChunkId) -> usize

Remove all mappings for a chunk

Returns the number of mappings removed

pub fn get_chunks_for_entity(&self, entity_id: &EntityId) -> Vec<ChunkId>

Get all chunks that contain a specific entity

Returns an empty vector if the entity is not found

pub fn get_entities_for_chunk(&self, chunk_id: &ChunkId) -> Vec<EntityId>

Get all entities in a specific chunk

Returns an empty vector if the chunk is not found

pub fn has_mapping(&self, entity_id: &EntityId, chunk_id: &ChunkId) -> bool

Check if a specific entity-chunk mapping exists

pub fn get_entity_chunk_count(&self, entity_id: &EntityId) -> usize

Get the number of chunks an entity appears in

pub fn get_chunk_entity_count(&self, chunk_id: &ChunkId) -> usize

Get the number of entities in a chunk

pub fn get_all_entities(&self) -> Vec<EntityId>

Get all entity IDs in the index

pub fn get_all_chunks(&self) -> Vec<ChunkId>

Get all chunk IDs in the index

pub fn entity_count(&self) -> usize

Get the total number of unique entities

pub fn chunk_count(&self) -> usize

Get the total number of unique chunks

pub fn mapping_count(&self) -> usize

Get the total number of entity-chunk mappings

pub fn is_empty(&self) -> bool

Check if the index is empty

pub fn clear(&mut self)

Clear all mappings from the index

pub fn get_co_occurring_entities( &self, entity_id: &EntityId, ) -> HashMap<EntityId, usize>

Get co-occurring entities for a given entity

Returns entities that appear in the same chunks, along with their co-occurrence count

pub fn get_common_entities( &self, min_chunk_count: usize, ) -> Vec<(EntityId, usize)>

Get entities that appear in multiple chunks (common entities)

Returns entities sorted by the number of chunks they appear in (descending)

pub fn get_dense_chunks(&self, min_entity_count: usize) -> Vec<(ChunkId, usize)>

Get chunks that contain multiple entities (dense chunks)

Returns chunks sorted by the number of entities they contain (descending)

pub fn merge(&mut self, other: &BidirectionalIndex)

Merge another index into this one

Useful for combining indices from multiple documents

pub fn get_statistics(&self) -> IndexStatistics

Get statistics about the index

Trait Implementations

impl Clone for BidirectionalIndex

fn clone(&self) -> BidirectionalIndex

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BidirectionalIndex

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

Formats the value using the given formatter.

impl Default for BidirectionalIndex

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BidirectionalIndex

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BidirectionalIndex

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.