Struct Handle 

pub struct Handle<T> { /* private fields */ }

A handle that references a stored object

You can get an instance of Handle by inserting an object into a store. A handle dereferences to the object it points to, via its Deref implementation.

Bare objects and stored objects

A bare object is just that: an instance of a bare object type. Once a bare objects is inserted into storage, it becomes a stored object. A stored object is owned by the store, and can be referenced through instances of Handle.

The point of doing this, is to provide objects with a unique identity, via their location within storage. The importance of this is expanded upon in the next section.

Equality and Identity

Most objects have Eq/PartialEq implementations that can be used to determine equality. Those implementations are derived, meaning two objects are equal, if all of their fields are equal. This can be used to compare objects structurally. Handle’s own Eq/PartialEq implementations defer to those of the stored object it references.

However, that two objects are equal does not mean they are identical.

This distinction is relevant, because non-identical objects that are supposed to be equal can in fact end up equal, if they are created based on simple input data (as you might have in a unit test). But they might end up slightly different, if they are created based on complex input data (as you might have in a real-world scenario). This situation would most likely result in a bug that is not easily caught in testing.

You can compare the identity of two Handles, by comparing the values returned by Handle::id.

Validation Must Use Identity

To prevent situations where everything looks fine during development, but you end up with a bug in production, any validation code that compares objects and expects them to be the same, must do that comparison based on identity, not equality. That way, this problem can never happen, because we never expect non-identical objects to be equal.

Implementations

impl<T> Handle<T>

pub fn id(&self) -> ObjectId

Access the object’s unique id

pub fn clone_object(&self) -> T

where T: Clone,

Return a bare object, which is a clone of the referenced stored object

Trait Implementations

impl<T> Borrow<T> for Handle<T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl BoundingVolume<2> for Handle<HalfEdge>

fn aabb(&self, geometry: &Geometry) -> Option<Aabb<2>>

Compute an axis-aligned bounding box (AABB)

impl<T> Clone for Handle<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Handle<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Deref for Handle<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DeriveFrom for Handle<T>

where Self: Into<AnyObject<Stored>>,

fn derive_from(self, original: &Self, core: &mut Core) -> Self

Mark this object as derived from the other object provided

impl From<Handle<Curve>> for AnyObject<Stored>

fn from(object: Handle<Curve>) -> Self

Converts to this type from the input type.

impl From<Handle<Cycle>> for AnyObject<Stored>

fn from(object: Handle<Cycle>) -> Self

Converts to this type from the input type.

impl From<Handle<Face>> for AnyObject<Stored>

fn from(object: Handle<Face>) -> Self

Converts to this type from the input type.

impl From<Handle<HalfEdge>> for AnyObject<Stored>

fn from(object: Handle<HalfEdge>) -> Self

Converts to this type from the input type.

impl From<Handle<Region>> for AnyObject<Stored>

fn from(object: Handle<Region>) -> Self

Converts to this type from the input type.

impl From<Handle<Shell>> for AnyObject<Stored>

fn from(object: Handle<Shell>) -> Self

Converts to this type from the input type.

impl From<Handle<Sketch>> for AnyObject<Stored>

fn from(object: Handle<Sketch>) -> Self

Converts to this type from the input type.

impl From<Handle<Solid>> for AnyObject<Stored>

fn from(object: Handle<Solid>) -> Self

Converts to this type from the input type.

impl From<Handle<Surface>> for AnyObject<Stored>

fn from(object: Handle<Surface>) -> Self

Converts to this type from the input type.

impl<T> From<Handle<T>> for HandleWrapper<T>

fn from(handle: Handle<T>) -> Self

Converts to this type from the input type.

impl From<Handle<Vertex>> for AnyObject<Stored>

fn from(object: Handle<Vertex>) -> Self

Converts to this type from the input type.

impl<T> From<HandleWrapper<T>> for Handle<T>

fn from(wrapper: HandleWrapper<T>) -> Self

Converts to this type from the input type.

impl<O> FromIterator<Handle<O>> for ObjectSet<O>

where O: Debug + Ord,

fn from_iter<T: IntoIterator<Item = Handle<O>>>(handles: T) -> Self

Creates a value from an iterator.

impl GetColor for Handle<Region>

fn get_color(&self, core: &mut Core) -> Option<Color>

Get the color of the object

impl<T> Hash for Handle<T>

where T: Hash,

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<T> Insert for Handle<T>

where T: Insert,

type Inserted = Handle<T>

The type of Self, once it has been inserted

fn insert(self, _: &mut Core) -> Self::Inserted

Insert the object into its respective store

impl IsObject for Handle<Curve>

type BareObject = Curve

The type of the bare object

impl IsObject for Handle<Cycle>

type BareObject = Cycle

The type of the bare object

impl IsObject for Handle<Face>

type BareObject = Face

The type of the bare object

impl IsObject for Handle<HalfEdge>

type BareObject = HalfEdge

The type of the bare object

impl IsObject for Handle<Region>

type BareObject = Region

The type of the bare object

impl IsObject for Handle<Shell>

type BareObject = Shell

The type of the bare object

impl IsObject for Handle<Sketch>

type BareObject = Sketch

The type of the bare object

impl IsObject for Handle<Solid>

type BareObject = Solid

The type of the bare object

impl IsObject for Handle<Surface>

type BareObject = Surface

The type of the bare object

impl IsObject for Handle<Vertex>

type BareObject = Vertex

The type of the bare object

impl<T> Ord for Handle<T>

where T: Ord,

fn cmp(&self, other: &Self) -> 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<T> PartialEq for Handle<T>

where T: PartialEq,

fn eq(&self, other: &Self) -> 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<T> PartialOrd for Handle<T>

where T: PartialOrd,

fn partial_cmp(&self, other: &Self) -> 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 ReplaceCurve for Handle<Cycle>

fn replace_curve( &self, original: &Handle<Curve>, replacement: Handle<Curve>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the curve

impl ReplaceCurve for Handle<Face>

fn replace_curve( &self, original: &Handle<Curve>, replacement: Handle<Curve>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the curve

impl ReplaceCurve for Handle<HalfEdge>

fn replace_curve( &self, original: &Handle<Curve>, replacement: Handle<Curve>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the curve

impl ReplaceCurve for Handle<Region>

fn replace_curve( &self, original: &Handle<Curve>, replacement: Handle<Curve>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the curve

impl ReplaceCurve for Handle<Shell>

fn replace_curve( &self, original: &Handle<Curve>, replacement: Handle<Curve>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the curve

impl ReplaceCurve for Handle<Sketch>

fn replace_curve( &self, original: &Handle<Curve>, replacement: Handle<Curve>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the curve

impl ReplaceCurve for Handle<Solid>

fn replace_curve( &self, original: &Handle<Curve>, replacement: Handle<Curve>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the curve

impl ReplaceHalfEdge for Handle<Cycle>

fn replace_half_edge<const N: usize>( &self, original: &Handle<HalfEdge>, replacements: [Handle<HalfEdge>; N], core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the half-edge

impl ReplaceHalfEdge for Handle<Face>

fn replace_half_edge<const N: usize>( &self, original: &Handle<HalfEdge>, replacements: [Handle<HalfEdge>; N], core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the half-edge

impl ReplaceHalfEdge for Handle<Region>

fn replace_half_edge<const N: usize>( &self, original: &Handle<HalfEdge>, replacements: [Handle<HalfEdge>; N], core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the half-edge

impl ReplaceHalfEdge for Handle<Shell>

fn replace_half_edge<const N: usize>( &self, original: &Handle<HalfEdge>, replacements: [Handle<HalfEdge>; N], core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the half-edge

impl ReplaceHalfEdge for Handle<Sketch>

fn replace_half_edge<const N: usize>( &self, original: &Handle<HalfEdge>, replacements: [Handle<HalfEdge>; N], core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the half-edge

impl ReplaceHalfEdge for Handle<Solid>

fn replace_half_edge<const N: usize>( &self, original: &Handle<HalfEdge>, replacements: [Handle<HalfEdge>; N], core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the half-edge

impl ReplaceVertex for Handle<Cycle>

fn replace_vertex( &self, original: &Handle<Vertex>, replacement: Handle<Vertex>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the vertex

impl ReplaceVertex for Handle<Face>

fn replace_vertex( &self, original: &Handle<Vertex>, replacement: Handle<Vertex>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the vertex

impl ReplaceVertex for Handle<HalfEdge>

fn replace_vertex( &self, original: &Handle<Vertex>, replacement: Handle<Vertex>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the vertex

impl ReplaceVertex for Handle<Region>

fn replace_vertex( &self, original: &Handle<Vertex>, replacement: Handle<Vertex>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the vertex

impl ReplaceVertex for Handle<Shell>

fn replace_vertex( &self, original: &Handle<Vertex>, replacement: Handle<Vertex>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the vertex

impl ReplaceVertex for Handle<Sketch>

fn replace_vertex( &self, original: &Handle<Vertex>, replacement: Handle<Vertex>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the vertex

impl ReplaceVertex for Handle<Solid>

fn replace_vertex( &self, original: &Handle<Vertex>, replacement: Handle<Vertex>, core: &mut Core, ) -> ReplaceOutput<Self, Self::BareObject>

Replace the vertex

impl ReverseCurveCoordinateSystems for Handle<HalfEdge>

fn reverse_curve_coordinate_systems(&self, core: &mut Core) -> Self

Reverse the direction of the curve coordinate systems within an object

impl SetColor for Handle<Region>

fn set_color(&self, color: impl Into<Color>, core: &mut Core)

Set the color of the object

impl SplitHalfEdge for Handle<HalfEdge>

fn split_half_edge( &self, point: impl Into<Point<1>>, core: &mut Core, ) -> [Handle<HalfEdge>; 2]

Split the half-edge into two

impl SweepFace for Handle<Face>

fn sweep_face( &self, path: impl Into<Vector<3>>, cache: &mut SweepCache, core: &mut Core, ) -> Shell

Sweep the Face into a Shell

impl SweepHalfEdge for Handle<HalfEdge>

fn sweep_half_edge( &self, end_vertex: Handle<Vertex>, surface: &SurfaceGeometry, color: Option<Color>, path: impl Into<Vector<3>>, cache: &mut SweepCache, core: &mut Core, ) -> (Face, Handle<HalfEdge>)

Sweep the HalfEdge

impl SweepVertex for Handle<Vertex>

fn sweep_vertex( &self, cache: &mut SweepCache, core: &mut Core, ) -> (Handle<Curve>, Handle<Vertex>)

Sweep the vertex

impl TransformObject for Handle<HalfEdge>

fn transform_with_cache( &self, transform: &Transform, core: &mut Core, cache: &mut TransformCache, ) -> Self

Transform the object using the provided cache

fn transform(&self, transform: &Transform, core: &mut Core) -> Self

Transform the object

fn translate(&self, offset: impl Into<Vector<3>>, core: &mut Core) -> Self

Translate the object

fn rotate(&self, axis_angle: impl Into<Vector<3>>, core: &mut Core) -> Self

Rotate the object

impl TransformObject for Handle<Surface>

fn transform_with_cache( &self, transform: &Transform, core: &mut Core, cache: &mut TransformCache, ) -> Self

Transform the object using the provided cache

fn transform(&self, transform: &Transform, core: &mut Core) -> Self

Transform the object

fn translate(&self, offset: impl Into<Vector<3>>, core: &mut Core) -> Self

Translate the object

fn rotate(&self, axis_angle: impl Into<Vector<3>>, core: &mut Core) -> Self

Rotate the object

impl<T> TransformObject for Handle<T>

where T: Clone + Insert<Inserted = Handle<T>> + TransformObject + 'static, Handle<T>: Into<AnyObject<Stored>>,

fn transform_with_cache( &self, transform: &Transform, core: &mut Core, cache: &mut TransformCache, ) -> Self

Transform the object using the provided cache

fn transform(&self, transform: &Transform, core: &mut Core) -> Self

Transform the object

fn translate(&self, offset: impl Into<Vector<3>>, core: &mut Core) -> Self

Translate the object

fn rotate(&self, axis_angle: impl Into<Vector<3>>, core: &mut Core) -> Self

Rotate the object

impl UpdateHalfEdgeGeometry for Handle<HalfEdge>

fn set_path(self, path: SurfacePath, geometry: &mut Layer<Geometry>) -> Self

Set the path of the half-edge

fn update_path( &self, update: impl FnOnce(SurfacePath) -> SurfacePath, core: &mut Core, ) -> Self

Update the path of the half-edge

fn update_boundary( &self, update: impl FnOnce(CurveBoundary<Point<1>>) -> CurveBoundary<Point<1>>, core: &mut Core, ) -> Self

Update the boundary of the half-edge

impl<T> Eq for Handle<T>

where T: Eq,

impl<T> Send for Handle<T>

impl<T> Sync for Handle<T>