Struct EdgeId 

pub struct EdgeId {
    pub src: NodeId,
    pub dst: NodeId,
    pub label: String,
    pub seq: u64,
}

Identifies a graph edge. Returned by graph_insert_edge.

An edge is uniquely identified by (src, dst, label, seq). The seq field disambiguates parallel edges — multiple edges that share the same (src, dst, label) bucket. seq = 0 means “the first (or only) edge in this bucket”. The engine-side allocator that assigns monotonically increasing seq values is a follow-up TODO; until it is wired in, callers use seq = 0 via EdgeId::try_first.

Wire format

Serialization uses the structured fields (serde / zerompk). The Display / FromStr impl uses the length-prefixed text form "{src_len}:{src}|{label_len}:{label}|{dst_len}:{dst}|{seq}" — unambiguous even when node IDs or labels contain |, :, or -- characters. The Display form is used only for logging and the pgwire DELETE path.

Fields

src: NodeId

Source node identifier.

dst: NodeId

Destination node identifier.

label: String

Edge label / relationship type (e.g. "KNOWS", "RELATES_TO").

seq: u64

Sequence number within the (src, dst, label) bucket.

0 = “the only edge in this bucket (for now)”. Engine-side allocation of monotonically increasing seq values is a TODO — see nodedb/src/engine/graph/ for the follow-up location.

Implementations

impl EdgeId

pub fn try_first( src: NodeId, dst: NodeId, label: impl Into<String>, ) -> Result<Self, IdError>

Create an EdgeId for the first (or only) edge in a (src, dst, label) bucket.

Validates the label against the same rules as NodeId::try_new. Returns Err(IdError) if the label is empty, too long, or contains a NUL byte. Node IDs are accepted pre-validated (callers hold NodeId values which were already validated at construction time).

pub fn try_with_seq( src: NodeId, dst: NodeId, label: impl Into<String>, seq: u64, ) -> Result<Self, IdError>

Create an EdgeId with an explicit sequence number.

Validates the label against the same rules as NodeId::try_new. Returns Err(IdError) if the label is empty, too long, or contains a NUL byte.

Trait Implementations

impl Archive for EdgeId

where NodeId: Archive, String: Archive, u64: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedEdgeId

The archived representation of this type.

type Resolver = EdgeIdResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for EdgeId

fn clone(&self) -> EdgeId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EdgeId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EdgeId

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<EdgeId, __D> for Archived<EdgeId>

where NodeId: Archive, <NodeId as Archive>::Archived: Deserialize<NodeId, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, u64: Archive, <u64 as Archive>::Archived: Deserialize<u64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<EdgeId, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Display for EdgeId

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

Length-prefixed format: "{src_len}:{src}|{label_len}:{label}|{dst_len}:{dst}|{seq}".

Unambiguous regardless of what characters appear in node IDs or labels.

impl<'__msgpack_de> FromMessagePack<'__msgpack_de> for EdgeId

fn read<R: Read<'__msgpack_de>>(reader: &mut R) -> Result<Self, Error>

where Self: Sized,

Reads the MessagePack representation of this value from the provided reader.

impl FromStr for EdgeId

type Err = EdgeIdParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for EdgeId

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for EdgeId

fn eq(&self, other: &EdgeId) -> 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<__S: Fallible + ?Sized> Serialize<__S> for EdgeId

where NodeId: Serialize<__S>, String: Serialize<__S>, u64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for EdgeId

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToMessagePack for EdgeId

fn write<W: Write>(&self, writer: &mut W) -> Result<(), Error>

Writes the MessagePack representation of this value into the provided writer.

impl Eq for EdgeId

impl StructuralPartialEq for EdgeId