Enum AntRecord 

pub enum AntRecord {
    Manifest(Manifest),
    SchemaType {
        data: SchemaType,
    },
    Vertex {
        data: Vertex,
    },
    Edge {
        data: Edge,
    },
    Observation {
        data: Observation,
    },
    Evidence {
        data: Evidence,
    },
    Belief {
        data: Belief,
    },
    Vector {
        data: VectorRecord,
    },
    VertexTombstone {
        data: Tombstone,
    },
    EdgeTombstone {
        data: Tombstone,
    },
    Trailer {
        counts: Counts,
        sha256: String,
    },
}

One record in the stream.

Variants

Manifest(Manifest)

The stream header. Exactly one, first line.

SchemaType

A schema type declaration.

Fields

data: SchemaType

The declaration.

Vertex

A graph vertex.

Fields

data: Vertex

The vertex.

Edge

A graph edge.

Fields

data: Edge

The edge.

Observation

An observation.

Fields

data: Observation

The observation.

Evidence

An evidence record.

Fields

data: Evidence

The evidence.

Belief

A belief version.

Fields

data: Belief

The belief.

Vector

An embedding document.

Fields

data: VectorRecord

The embedding document.

VertexTombstone

Deletion of a vertex. Cascades to its edges on import, exactly as a live delete does.

Fields

data: Tombstone

The deletion.

EdgeTombstone

Deletion of an edge.

Fields

data: Tombstone

The deletion.

Trailer

The stream footer: per-kind counts and the integrity hash. Exactly one, last line.

Fields

counts: Counts

Per-kind record tallies.

sha256: String

Hex sha256 over every preceding uncompressed line.

Trait Implementations

impl Clone for AntRecord

fn clone(&self) -> AntRecord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AntRecord

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AntRecord

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for AntRecord

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for AntRecord

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for AntRecord