Struct Borrowed

pub struct Borrowed<'a, H>(/* private fields */);

Borrowed version of some handle

A handle is typically just a pointer, but we cannot copy it as we need to update the reference counters accordingly. However, if we want to have multiple instances of the same handle without changing the reference counters, we can use shared references. This works as long as one does not attempt to change the handle’s tag. In this case, we need ownership of the handle with the different tag, but need to restrict its lifetime to the one of the original handle. Furthermore, we must not drop the new handle. This is exactly, what this data structure provides.

Borrowed<'a, H> always has the same representation as H.

Implementations

impl<'a, H> Borrowed<'a, H>

pub fn new(handle: H) -> Self

Create a new borrowed handle

While the type of handle suggests that the handle is owned, it should be just the owned representation of a borrowed handle, e.g. no reference counters should be increased when creating handle.

pub unsafe fn into_inner(this: Self) -> ManuallyDrop<H>

Convert a borrowed handle into the underlying ManuallyDrop handle

Safety

The caller must ensure that the resources referenced by the handle remain valid during its usage. Furthermore the returned handle must not be dropped.

impl<'a, E: Edge> Borrowed<'a, E>

pub fn edge_with_tag(self, tag: E::Tag) -> Self

Change the tag of a borrowed Edge

This is equivalent to Edge::with_tag(), but can be used in some situations where Edge::with_tag() can’t due to lifetime restrictions.

Trait Implementations

impl<'a, H> Deref for Borrowed<'a, H>

type Target = H

The resulting type after dereferencing.

fn deref(&self) -> &H

Dereferences the value.

impl<'a, H: Ord> Ord for Borrowed<'a, H>

fn cmp(&self, other: &Borrowed<'a, H>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a, H: PartialEq> PartialEq for Borrowed<'a, H>

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

fn partial_cmp(&self, other: &Borrowed<'a, H>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, H: Eq> Eq for Borrowed<'a, H>

impl<'a, H> StructuralPartialEq for Borrowed<'a, H>