Struct EdgeSlot 

pub struct EdgeSlot {
    pub a: EntityId,
    pub rel: TermId,
    pub b: EntityId,
    pub fact: FactId,
    pub edge: EdgeId,
    pub valid_from: u64,
}

A typed graph edge, currently open (28-byte slot, Ordered arena, key [a BE | rel BE | b BE], payload fact | edge | valid_from).

Stored twice, in two mirrored arenas: the out-arena keys by (src, rel, dst), the in-arena by (dst, rel, src) — a/b are whichever end comes first in that arena’s key. Neighbor traversal is a prefix range scan. An edge is unique per (src, rel, dst); re-linking closes this version and opens a new one.

The slot carries the identity of its open EdgeHistorySlot version — edge and valid_from are exactly that record’s key tail — so closing an edge addresses its history record directly instead of searching for the open version among the triple’s other versions.

Fields

a: EntityId

First key component (out-arena: source; in-arena: destination).

rel: TermId

Interned relation term ("works_at", "owns", …).

b: EntityId

Second key component (out-arena: destination; in-arena: source).

fact: FactId

Provenance fact, or FactId::NONE. Like FactRecord::revises, it may name a burned id once the provenance fact has been forgotten and purged.

edge: EdgeId

The open edge version this slot mirrors.

valid_from: u64

Start of the open version’s validity — with edge, the key tail of its EdgeHistorySlot.

Trait Implementations

impl Clone for EdgeSlot

fn clone(&self) -> EdgeSlot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for EdgeSlot

impl Debug for EdgeSlot

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

Formats the value using the given formatter.

impl Eq for EdgeSlot

impl PartialEq for EdgeSlot

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

Equality operator ==.

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

Inequality operator !=.

impl Slot for EdgeSlot

const SIZE: usize = edge_at::SIZE

Total size of the record in bytes.

const KEY_LEN: usize = edge_at::KEY_LEN

Length of the key prefix; sorting and lookups compare only these leading bytes. Must not exceed SIZE.

fn write(&self, out: &mut [u8])

Serializes the record into out (out.len() == SIZE), filling every byte.

fn read(bytes: &[u8]) -> Self

Reconstructs the record from bytes (bytes.len() == SIZE).

impl StructuralPartialEq for EdgeSlot