Struct IdOwner 

pub struct IdOwner { /* private fields */ }

A container for ExclusiveIds, allowing for explicit ownership management. There is an implicit IdOwner for each thread, to which ExclusiveIds are associated when they are dropped, and which can be queried via the local_ids constraint.

Example

use triblespace_core::id::{IdOwner, ExclusiveId, fucid};
let mut owner = IdOwner::new();
let exclusive_id = fucid();
let id = owner.insert(exclusive_id);

assert!(owner.owns(&id));
assert_eq!(owner.take(&id), Some(ExclusiveId::force(id)));
assert!(!owner.owns(&id));

Implementations

impl IdOwner

pub fn new() -> Self

Creates a new IdOwner.

This is typically not necessary, as each thread has an implicit IdOwner associated with it.

Returns

A new IdOwner.

pub fn insert(&mut self, id: ExclusiveId) -> Id

Inserts an ExclusiveId into the IdOwner, returning the underlying Id.

Arguments

• id - The ExclusiveId to be inserted.

Returns

The underlying Id.

pub fn defer_insert(&self, id: ExclusiveId) -> OwnedId<'_>

Defers inserting an ExclusiveId into the IdOwner, returning an OwnedId. The OwnedId will return the ExclusiveId to the IdOwner when dropped. This is useful if you generated an ExclusiveId that you want to use temporarily, but want to make sure it is returned to the IdOwner when you are done.

Arguments

• id - The ExclusiveId to be inserted.

Returns

An OwnedId that will return the ExclusiveId to the IdOwner when dropped.

Example

use triblespace_core::prelude::*;
use valueschemas::ShortString;
use triblespace_core::id_hex;

let mut owner = IdOwner::new();
let owned_id = owner.defer_insert(fucid());
let trible = Trible::new(&owned_id, &id_hex!("7830D7B3C2DCD44EB3FA68C93D06B973"), &ShortString::value_from("Hello, World!"));

pub fn force_insert(&self, id: &Id)

Forces an Id into the IdOwner as an ExclusiveId.

Arguments

• id - The Id to be forced into an ExclusiveId.

pub fn take(&self, id: &Id) -> Option<ExclusiveId>

Takes an Id from the IdOwner, returning it as an ExclusiveId.

Arguments

• id - The Id to be taken.

Returns

An ExclusiveId if the Id was found, otherwise None.

pub fn borrow<'a>(&'a self, id: &Id) -> Option<OwnedId<'a>>

Get an OwnedId from the IdOwner. The OwnedId will return the ExclusiveId to the IdOwner when dropped. This is useful for temporary exclusive access to an Id. If you want to keep the Id for longer, you can use the take method, but you will have to manually return it to the IdOwner when you are done.

Arguments

• id - The Id to be taken.

Returns

An OwnedId if the Id was found, otherwise None.

Example

use triblespace_core::id::{IdOwner, ExclusiveId, fucid};
let mut owner = IdOwner::new();
let exclusive_id = fucid();
let id = owner.insert(exclusive_id);
 {
    let mut owned_id = owner.borrow(&id).unwrap();

    assert_eq!(owned_id.id, id);
    assert!(!owner.owns(&id));
 }
assert!(owner.owns(&id));

pub fn owns(&self, id: &Id) -> bool

Checks if the IdOwner owns an Id.

Arguments

• id - The Id to be checked.

Returns

true if the Id is owned by the IdOwner, otherwise false.

Trait Implementations

impl ContainsConstraint<'static, GenId> for &IdOwner

type Constraint = <PATCH<ID_LEN> as ContainsConstraint<'static, GenId>>::Constraint

The concrete constraint type produced by has.

fn has(self, v: Variable<GenId>) -> Self::Constraint

Create a constraint that filters the values assigned to the variable to only those that are contained in the collection.

impl Default for IdOwner

fn default() -> Self

Returns the “default value” for a type.