Struct Shape 

pub struct Shape { /* private fields */ }

A shape: a topology node, a placement, and an orientation.

Cheap to copy (a key, a small chain and an enum), so it is passed by value everywhere.

Implementations

impl Shape

pub const fn new( node: TShapeId, location: Location, orientation: Orientation, ) -> Self

A shape from its three parts.

pub fn of(node: TShapeId) -> Self

A shape at the identity placement, oriented forward.

pub const fn node(&self) -> TShapeId

The topology node.

pub const fn location(&self) -> &Location

The placement.

pub const fn orientation(&self) -> Orientation

The orientation.

pub fn located(&self, location: Location) -> Self

This shape with a different placement.

pub fn moved(&self, outer: &Location) -> Self

This shape moved by outer, applied before its own placement.

The operation traversal uses on descent: a child’s placement within the world is its parent’s composed with its own.

pub fn oriented(&self, orientation: Orientation) -> Self

This shape with a different orientation.

pub fn reversed(&self) -> Self

This shape with its orientation reversed.

pub fn composed(&self, outer: Orientation) -> Self

This shape’s orientation composed under outer.

The other half of what traversal does on descent.

pub fn transform(&self, store: &DatumStore) -> OgeomResult<Transform>

The composed placement as a transform.

Errors

As Location::composed.

pub fn is_partner(&self, other: &Self) -> bool

Whether two shapes share a topology node, ignoring placement and orientation.

“Is this the same underlying topology, anywhere, any way round?”: the question to ask when relating a shape to another instance of itself elsewhere in an assembly.

pub fn is_same(&self, other: &Self) -> bool

Whether two shapes share a node and a placement, ignoring orientation.

The common case, and the one most algorithms want: an edge and its reverse are the same edge in the same place, and a set of edges should hold one of them, not two.

pub fn is_equal(&self, other: &Self) -> bool

Whether two shapes agree in all three parts.

Exact identity. An edge and its reverse are not equal, which is what makes a wire’s direction of travel expressible.

pub fn is_same_position( &self, other: &Self, store: &DatumStore, tol: Tolerances, ) -> OgeomResult<bool>

Whether two shapes occupy the same place, comparing composed transforms rather than chains.

Costlier than Shape::is_same and answers a different question: two placements built by different routes can land in the same position.

Errors

As Location::composed.

Trait Implementations

impl Clone for Shape

fn clone(&self) -> Shape

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Shape

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

Formats the value using the given formatter.

impl Eq for Shape

impl Hash for Shape

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 PartialEq for Shape

Equality by Shape::is_equal: node, placement and orientation.

The strictest of the three, chosen as the derive-shaped default so that a plain == never silently means something looser than the reader expects. Code that wants a weaker equivalence says so, through SameKey or PartnerKey.

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.