Struct Document 

pub struct Document {
    pub id: DocumentId,
    pub root: BlockId,
    pub structure: HashMap<BlockId, Vec<BlockId>>,
    pub blocks: HashMap<BlockId, Block>,
    pub metadata: DocumentMetadata,
    pub indices: DocumentIndices,
    pub edge_index: EdgeIndex,
    pub version: DocumentVersion,
}

A UCM document is a collection of blocks with hierarchical structure.

Fields

id: DocumentId

Document identifier

root: BlockId

Root block ID

structure: HashMap<BlockId, Vec<BlockId>>

Adjacency map: parent -> ordered children

blocks: HashMap<BlockId, Block>

All blocks in the document

metadata: DocumentMetadata

Document-level metadata

indices: DocumentIndices

Secondary indices for fast lookup

edge_index: EdgeIndex

Edge index for relationship traversal

version: DocumentVersion

Document version for concurrency control

Implementations

impl Document

pub fn new(id: DocumentId) -> Self

Create a new empty document

pub fn create() -> Self

Create with a generated ID

pub fn with_metadata(self, metadata: DocumentMetadata) -> Self

Set document metadata

pub fn get_block(&self, id: &BlockId) -> Option<&Block>

Get a block by ID

pub fn get_block_mut(&mut self, id: &BlockId) -> Option<&mut Block>

Get a mutable block by ID

pub fn children(&self, parent: &BlockId) -> &[BlockId]

Get children of a block

pub fn parent(&self, child: &BlockId) -> Option<&BlockId>

Get parent of a block

pub fn parent_of(&self, child: &BlockId) -> Option<&Block>

Get the parent block (convenience method)

pub fn add_block(&mut self, block: Block, parent: &BlockId) -> Result<BlockId>

Add a block to the document

pub fn add_block_at( &mut self, block: Block, parent: &BlockId, index: usize, ) -> Result<BlockId>

Add a block at a specific position

pub fn add_edge( &mut self, source: &BlockId, edge_type: EdgeType, target: BlockId, )

Add an edge between two blocks (wrapper for edge_index)

pub fn remove_from_structure(&mut self, id: &BlockId) -> bool

Remove a block from the structure (makes it orphaned)

pub fn delete_block(&mut self, id: &BlockId) -> Result<Block>

Delete a block completely

pub fn delete_cascade(&mut self, id: &BlockId) -> Result<Vec<Block>>

Delete a block and all its descendants

pub fn move_block(&mut self, id: &BlockId, new_parent: &BlockId) -> Result<()>

Move a block to a new parent

pub fn move_block_at( &mut self, id: &BlockId, new_parent: &BlockId, index: usize, ) -> Result<()>

Move a block to a specific position under a parent

pub fn move_block_before( &mut self, id: &BlockId, before: &BlockId, ) -> Result<()>

Move a block before another block (sibling ordering)

pub fn move_block_after(&mut self, id: &BlockId, after: &BlockId) -> Result<()>

Move a block after another block (sibling ordering)

pub fn is_ancestor(&self, potential_ancestor: &BlockId, block: &BlockId) -> bool

Check if a block is an ancestor of another

pub fn descendants(&self, id: &BlockId) -> Vec<BlockId>

Get all descendants of a block

pub fn is_reachable(&self, id: &BlockId) -> bool

Check if a block is reachable from root

pub fn find_orphans(&self) -> Vec<BlockId>

Find all orphaned blocks

pub fn block_state(&self, id: &BlockId) -> BlockState

Get block state

pub fn prune_unreachable(&mut self) -> Vec<Block>

Prune unreachable blocks

pub fn block_count(&self) -> usize

Get total block count

pub fn total_tokens(&self, model: TokenModel) -> u32

Get total token estimate

pub fn validate(&self) -> Vec<ValidationIssue>

Validate document structure

pub fn rebuild_indices(&mut self)

Rebuild all indices

Trait Implementations

impl Clone for Document

fn clone(&self) -> Document

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Document

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

Formats the value using the given formatter.