Struct Triple 

pub struct Triple {
    pub subject: NodeId,
    pub predicate: Predicate,
    pub object: Value,
    pub meta: TripleMeta,
}

A semantic triple, representing a single fact as a (Subject, Predicate, Object) statement.

A triple is the fundamental unit of data in the graph database. It represents a relationship between a subject and an object through a predicate.

Examples

Creating a triple with a literal value:

use aingle_graph::{Triple, NodeId, Predicate, Value};

let triple = Triple::new(
    NodeId::named("user:alice"),
    Predicate::named("has_age"),
    Value::integer(30),
);

Creating a triple that links two nodes:

use aingle_graph::{Triple, NodeId, Predicate};

let triple = Triple::link(
    NodeId::named("user:alice"),
    Predicate::named("knows"),
    NodeId::named("user:bob"),
);

Creating a triple with metadata:

use aingle_graph::{Triple, TripleMeta, NodeId, Predicate, Value};

let meta = TripleMeta::new()
    .with_author(NodeId::named("system"))
    .with_source("import");

let triple = Triple::with_meta(
    NodeId::named("user:alice"),
    Predicate::named("has_name"),
    Value::literal("Alice"),
    meta,
);

Fields

subject: NodeId

The subject of the triple (the “thing” being described).

predicate: Predicate

The predicate (the relationship type).

object: Value

The object (the value or related node).

meta: TripleMeta

Associated metadata, providing context and provenance for the triple.

Implementations

impl Triple

pub fn new(subject: NodeId, predicate: Predicate, object: Value) -> Self

Creates a new Triple with default metadata.

Examples

use aingle_graph::{Triple, NodeId, Predicate, Value};

let triple = Triple::new(
    NodeId::named("user:alice"),
    Predicate::named("has_email"),
    Value::literal("alice@example.com"),
);

pub fn with_meta( subject: NodeId, predicate: Predicate, object: Value, meta: TripleMeta, ) -> Self

Creates a new Triple with the specified metadata.

pub fn literal( subject: impl Into<NodeId>, predicate: impl Into<Predicate>, value: impl Into<String>, ) -> Self

where NodeId: From<String>,

A convenience method to create a triple with a literal string object.

Examples

use aingle_graph::{Triple, NodeId};

let triple = Triple::literal("user:alice", "has_name", "Alice Smith");
assert_eq!(triple.object.as_string(), Some("Alice Smith"));

pub fn link( subject: impl Into<NodeId>, predicate: impl Into<Predicate>, object: impl Into<NodeId>, ) -> Self

A convenience method to create a triple that links two nodes.

This creates a relationship between two nodes in the graph.

Examples

use aingle_graph::{Triple, NodeId};

let triple = Triple::link(
    NodeId::named("user:alice"),
    "knows",
    NodeId::named("user:bob"),
);

assert!(triple.is_link());
assert_eq!(triple.object_node(), Some(&NodeId::named("user:bob")));

pub fn id(&self) -> TripleId

Generates the unique, content-based ID for this triple.

The ID is deterministic - identical triples will always produce the same ID.

Examples

use aingle_graph::{Triple, NodeId, Predicate, Value};

let triple = Triple::new(
    NodeId::named("alice"),
    Predicate::named("age"),
    Value::integer(30),
);

let id = triple.id();
println!("Triple ID: {}", id);

pub fn is_link(&self) -> bool

Returns true if the triple’s object is a reference to another node.

pub fn is_literal(&self) -> bool

Returns true if the triple’s object is a literal value.

pub fn object_node(&self) -> Option<&NodeId>

Returns the object as a NodeId if it is a node reference.

pub fn object_string(&self) -> Option<&str>

Returns the object as a string slice if it is a string-like literal.

pub fn to_ntriples(&self) -> String

Formats the triple into the N-Triples standard string format.

pub fn to_bytes(&self) -> Vec<u8>

Serializes the Triple to a byte vector for storage.

pub fn from_bytes(bytes: &[u8]) -> Option<Self>

Deserializes a Triple from a byte slice.

pub fn index_keys(&self) -> TripleIndexKeys

Creates a set of pre-computed, lexicographically sortable keys for database indexing.

Trait Implementations

impl Clone for Triple

fn clone(&self) -> Triple

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Triple

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Triple

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Triple

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

Formats the value using the given formatter.

impl PartialEq for Triple

fn eq(&self, other: &Triple) -> 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 Triple

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 Triple