Struct Document 

pub struct Document {
    pub meta: Meta,
    pub settings: Settings,
    pub extra: BTreeMap<String, Value>,
    /* private fields */
}

A Dotloom document: the single editable source of truth (owned by the engine).

Entities are kept in a map keyed by stable ID plus a separate draw order, so reordering never changes identity. IDs for every object kind come from one monotonically increasing allocator (next_id) and are never reused.

Fields

meta: Meta

Metadata.

settings: Settings

Settings.

extra: BTreeMap<String, Value>

Unknown top-level fields preserved on save.

Implementations

impl Document

pub fn canonical_value(&self) -> Result<Value, DocError>

Canonical JSON value.

pub fn canonical_json(&self) -> Result<String, DocError>

Canonical JSON string (compact).

pub fn content_hash(&self) -> Result<String, DocError>

Content hash of the canonical form, as 16 hex digits.

pub fn semantic_eq(&self, other: &Self) -> bool

Semantic equality (canonical forms equal).

impl Document

pub fn copy(&self, ids: &[EntityId]) -> Clipboard

Copy entities (and the constraints/groups fully inside the selection).

pub fn paste( &mut self, clip: &Clipboard, offset: Vector, fallback_layer: LayerId, ) -> PasteReport

Paste clipboard content with new IDs, translated by offset. Entities whose layer does not exist here are placed on fallback_layer.

impl Document

pub fn new() -> Self

Empty document with one default layer.

pub fn alloc_id(&mut self) -> u64

Allocate a fresh ID (shared by all object kinds).

pub const fn next_id(&self) -> u64

Next ID that will be allocated.

pub fn reserve_id(&mut self, id: u64)

Raise the allocator so that id is never handed out again.

pub fn entity_count(&self) -> usize

Number of entities.

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

Entity by ID.

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

Mutable entity by ID (engine use; callers must re-validate).

pub fn entities(&self) -> impl Iterator<Item = &Entity>

Entities in draw order.

pub fn order(&self) -> &[EntityId]

Draw order.

pub fn insert_entity(&mut self, e: Entity)

Insert an entity at the top of the draw order (or replace one with the same ID in place).

pub fn insert_entity_at(&mut self, e: Entity, index: usize)

Insert an entity at a draw-order index.

pub fn remove_entity(&mut self, id: EntityId) -> Option<(Entity, usize)>

Remove an entity (does not touch constraints or references; see Document::dependents). Returns the entity and its draw-order index.

pub fn reorder(&mut self, id: EntityId, index: usize) -> Result<(), DocError>

Move an entity to a draw-order index. IDs never change.

pub fn order_index(&self, id: EntityId) -> Option<usize>

Draw-order index of an entity.

pub fn layers(&self) -> &[Layer]

Layers in display order.

pub fn layer(&self, id: LayerId) -> Option<&Layer>

Layer by ID.

pub fn layer_mut(&mut self, id: LayerId) -> Option<&mut Layer>

Mutable layer by ID.

pub fn upsert_layer(&mut self, l: Layer)

Insert or replace a layer (appended when new).

pub fn set_layers(&mut self, layers: Vec<Layer>)

Replace the whole layer list (used by undo/redo).

pub fn insert_layer_at(&mut self, l: Layer, index: usize)

Insert a layer at an index.

pub fn remove_layer(&mut self, id: LayerId) -> Result<(Layer, usize), DocError>

Remove a layer. Fails while entities still use it.

pub fn groups(&self) -> impl Iterator<Item = &Group>

Groups.

pub fn group(&self, id: GroupId) -> Option<&Group>

Group by ID.

pub fn upsert_group(&mut self, g: Group)

Insert or replace a group.

pub fn remove_group(&mut self, id: GroupId) -> Option<Group>

Remove a group (members stay in the document).

pub fn group_of(&self, id: EntityId) -> Option<GroupId>

Group that directly contains an entity.

pub fn constraints(&self) -> impl Iterator<Item = &Constraint>

Constraints.

pub fn constraint_count(&self) -> usize

Number of constraints.

pub fn constraint(&self, id: ConstraintId) -> Option<&Constraint>

Constraint by ID.

pub fn upsert_constraint(&mut self, c: Constraint)

Insert or replace a constraint.

pub fn remove_constraint(&mut self, id: ConstraintId) -> Option<Constraint>

Remove a constraint.

pub fn dependents(&self, id: EntityId) -> Dependents

Everything that references id (O(n); the engine keeps an index).

pub fn id_in_use(&self, raw: u64) -> bool

Whether any ID of any kind equals raw.

impl Document

pub fn from_json_str( s: &str, limits: &Limits, ) -> Result<(Self, Vec<MigrationNote>), DocError>

Parse, migrate and validate a document from JSON text.

Documents of the current schema are deserialized directly; only older schemas go through the JSON tree the migration steps work on (the tree costs several times the document’s own memory: ~150 MB for 100 000 shapes). Nesting depth stays bounded by serde_json’s recursion limit (128) on both paths.

pub fn from_json_slice( bytes: &[u8], limits: &Limits, ) -> Result<(Self, Vec<MigrationNote>), DocError>

Document::from_json_str on UTF-8 bytes.

pub fn from_json_value( v: Value, limits: &Limits, ) -> Result<(Self, Vec<MigrationNote>), DocError>

Migrate and validate a parsed JSON value.

pub fn to_json_string(&self) -> Result<String, DocError>

Serialize to pretty JSON.

impl Document

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

First invariant violation, if any.

pub fn validate_all(&self, limits: &Limits) -> Vec<DocError>

All invariant violations (bounded to the first 1000).

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.

impl Default for Document

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Document

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Document

fn eq(&self, other: &Document) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Document

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Document