Enum Object 

#[non_exhaustive]
pub enum Object {
    Migration {
        src: ObjectId,
        tgt: ObjectId,
        mapping: Migration,
    },
    Commit(CommitObject),
    Tag(TagObject),
    DataSet(DataSetObject),
    Complement(ComplementObject),
    Protocol(Box<Protocol>),
    Expr(Box<Expr>),
    EditLog(EditLogObject),
    Theory(Box<Theory>),
    TheoryMorphism(Box<TheoryMorphism>),
    CstComplement(CstComplementObject),
    FileSchema(Box<FileSchemaObject>),
    FlatSchema(Box<Schema>),
    SchemaTree(Box<SchemaTreeObject>),
}

A content-addressed object in the store.

Marked #[non_exhaustive] so that adding new variants downstream (new on-disk object kinds, new enrichments) does not silently break exhaustive match expressions in consumers of this crate.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Migration

A migration between two schemas, identified by their object IDs.

Fields

src: ObjectId

Object ID of the source schema.

tgt: ObjectId

Object ID of the target schema.

mapping: Migration

The migration morphism.

Commit(CommitObject)

A commit in the schema evolution DAG.

Tag(TagObject)

An annotated tag pointing to another object.

DataSet(DataSetObject)

A data snapshot: instances conforming to a specific schema.

Complement(ComplementObject)

A complement from data migration, for backward migration.

Protocol(Box<Protocol>)

A protocol (metaschema) definition.

Expr(Box<Expr>)

A standalone expression (e.g., coercion, merge, default).

EditLog(EditLogObject)

An edit log recording incremental edits against a schema.

Theory(Box<Theory>)

A GAT theory definition.

TheoryMorphism(Box<TheoryMorphism>)

A structure-preserving map between two theories.

CstComplement(CstComplementObject)

A CST complement for format-preserving round-trips.

Stores the full tree-sitter CST Schema alongside a data set, enabling byte-identical reconstruction of the original file formatting after schema migration.

FileSchema(Box<FileSchemaObject>)

A schema for a single file.

Content-addressed independently so that unchanged files deduplicate across commits. The project-level schema is assembled by walking a tree of Self::FileSchema leaves joined by Self::SchemaTree nodes; see crate::tree.

FlatSchema(Box<Schema>)

A flat schema, stored only as a migration endpoint.

Object::Migration references its source and target schemas by ObjectId. Commits content-address their project schema as an Object::SchemaTree whose leaves are Object::FileSchemas, so a migration between two tree roots cannot reuse that addressing: the migration morphism speaks of a single flat vertex/edge space, not a tree. This variant stores that flat form so that gc::mark_reachable can find the referenced schema and migration composition has an object to load from.

SchemaTree(Box<SchemaTreeObject>)

A directory or project root in the schema Merkle tree.

A sorted list of (name, ObjectId) entries where each ObjectId points at either an Self::FileSchema leaf or another Self::SchemaTree. Mirrors git’s tree object model: sibling entries are sorted lexicographically so the resulting ObjectId is deterministic.

Implementations

impl Object

pub const fn type_name(&self) -> &'static str

Returns the type name of this object (for error messages).

Trait Implementations

impl Clone for Object

fn clone(&self) -> Object

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Object

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Object

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Object

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

where __S: Serializer,

Serialize this value into the given Serde serializer.