Struct GlobalEdge 

pub struct GlobalEdge {}

An undirected edge, defined in global (3D) coordinates

In contrast to HalfEdge, GlobalEdge is undirected, meaning it has no defined direction. This means it can be used to determine whether two HalfEdges map to the same GlobalEdge, regardless of their direction.

See HalfEdge’s documentation for more information on the relationship between HalfEdge and GlobalEdge.

Equality

GlobalEdge contains no data and exists purely to be used within a Handle, where Handle::id can be used to compare different instances of GlobalEdge.

If GlobalEdge had Eq/PartialEq implementations, it containing no data would mean that all instances of GlobalEdge would be considered equal. This would be very error-prone.

If you need to reference a GlobalEdge from a struct that needs to derive Eq/Ord/…, you can use HandleWrapper<GlobalEdge> to do that. It will use Handle::id to provide those Eq/Ord/… implementations.

Implementations

impl GlobalEdge

pub fn new() -> Self

Create a new instance

The order of vertices is irrelevant. Two GlobalEdges with the same curve and vertices will end up being equal, regardless of the order of vertices here.

Trait Implementations

impl Clone for GlobalEdge

fn clone(&self) -> GlobalEdge

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GlobalEdge

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

Formats the value using the given formatter.

impl Default for GlobalEdge

fn default() -> GlobalEdge

Returns the “default value” for a type.

impl From<GlobalEdge> for Object<Bare>

fn from(object: GlobalEdge) -> Self

Converts to this type from the input type.

impl Hash for GlobalEdge

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 Insert for GlobalEdge

type Inserted = Handle<GlobalEdge>

The type of Self, once it has been inserted

fn insert(self, services: &mut Services) -> Self::Inserted

Insert the object into its respective store

impl TransformObject for GlobalEdge

fn transform_with_cache( self, _: &Transform, _: &mut Services, _: &mut TransformCache, ) -> Self

Transform the object using the provided cache

fn transform(self, transform: &Transform, services: &mut Services) -> Self

Transform the object

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

Translate the object

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

Rotate the object

impl Validate for GlobalEdge

fn validate_with_config( &self, _: &ValidationConfig, _: &mut Vec<ValidationError>, )

Validate the object

fn validate_and_return_first_error(&self) -> Result<(), ValidationError>

Validate the object using default config and return on first error

fn validate(&self, errors: &mut Vec<ValidationError>)

Validate the object using default configuration