Struct CreateRelation 

pub struct CreateRelation<'a> {

    pub id: Id,
    pub relation_type: Id,
    pub from: Id,
    pub from_is_value_ref: bool,
    pub from_space: Option<Id>,
    pub from_version: Option<Id>,
    pub to: Id,
    pub to_is_value_ref: bool,
    pub to_space: Option<Id>,
    pub to_version: Option<Id>,
    pub entity: Option<Id>,
    pub position: Option<Cow<'a, str>>,
    pub context: Option<Context>,
}

Creates a new relation (spec Section 3.3).

Also implicitly creates the reified entity if it doesn’t exist.

Fields

id: Id

The relation’s unique identifier.

relation_type: Id

The relation type entity ID.

from: Id

Source entity or value ref ID.

from_is_value_ref: bool

If true, from is a value ref ID (inline encoding). If false, from is an entity ID (ObjectRef encoding).

from_space: Option<Id>

Optional space pin for source entity.

from_version: Option<Id>

Optional version (edit ID) to pin source entity.

to: Id

Target entity or value ref ID.

to_is_value_ref: bool

If true, to is a value ref ID (inline encoding). If false, to is an entity ID (ObjectRef encoding).

to_space: Option<Id>

Optional space pin for target entity.

to_version: Option<Id>

Optional version (edit ID) to pin target entity.

entity: Option<Id>

Explicit reified entity ID. If None, entity ID is auto-derived from the relation ID.

position: Option<Cow<'a, str>>

Optional ordering position (fractional indexing).

context: Option<Context>

Optional context for grouping changes (spec Section 4.5).

Implementations

impl CreateRelation<'_>

pub fn entity_id(&self) -> Id

Computes the reified entity ID.

If explicit entity is provided, returns it. Otherwise, derives it from the relation ID.

pub fn has_explicit_entity(&self) -> bool

Returns true if this relation has an explicit entity ID.

Trait Implementations

impl<'a> Clone for CreateRelation<'a>

fn clone(&self) -> CreateRelation<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for CreateRelation<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for CreateRelation<'a>

fn eq(&self, other: &CreateRelation<'a>) -> 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<'a> StructuralPartialEq for CreateRelation<'a>