Struct WithCs 

#[repr(transparent)]
pub struct WithCs<T, Cs: CoordinateSystem> {
    pub inner: T,
    /* private fields */
}

Re-tag any Point with a different coordinate system, without changing its storage layout.

Zero-cost: #[repr(transparent)] plus pure forwarding impls means &WithCs<T, Cs> is layout-compatible with &T and monomorphises to identical code. Only the Cs associated type of the Point impl changes — Scalar, DIM, get, and set all forward to the inner point.

See proposal §3.7 for the design rationale (orthogonality of shape vs. coordinate system, and the silent-Cartesian risk mitigation that lives in T31).

Example

use geometry_adapt::{Adapt, WithCs};
use geometry_cs::{Degree, Geographic};
use geometry_trait::Point;

// An [f64; 2] adapted as a Cartesian point, then re-tagged as
// a geographic lat/lon pair in degrees.
let p: WithCs<Adapt<[f64; 2]>, Geographic<Degree>> =
    WithCs::new(Adapt([4.9, 52.4]));
assert_eq!(p.get::<0>(), 4.9);
assert_eq!(p.get::<1>(), 52.4);

Fields

inner: T

The wrapped inner point. Public so call sites can read or mutate the foreign storage directly when convenient.

Implementations

impl<T, Cs: CoordinateSystem> WithCs<T, Cs>

pub const fn new(inner: T) -> Self

Wrap an inner point and tag it with coordinate system Cs.

pub fn into_inner(self) -> T

Unwrap, returning the inner point.

Trait Implementations

impl<T: Clone, Cs: Clone + CoordinateSystem> Clone for WithCs<T, Cs>

fn clone(&self) -> WithCs<T, Cs>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy, Cs: Copy + CoordinateSystem> Copy for WithCs<T, Cs>

impl<T: Debug, Cs: Debug + CoordinateSystem> Debug for WithCs<T, Cs>

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

Formats the value using the given formatter.

impl<T: Default, Cs: Default + CoordinateSystem> Default for WithCs<T, Cs>

fn default() -> WithCs<T, Cs>

Returns the “default value” for a type.

impl<T: Eq, Cs: Eq + CoordinateSystem> Eq for WithCs<T, Cs>

impl<P: Point, Cs: CoordinateSystem> Geometry for WithCs<P, Cs>

type Kind = PointTag

One of the *Tag types from geometry_tag.

type Point = WithCs<P, Cs>

The point type this geometry is built from. For a value modelling Point, this is Self.

impl<T: Hash, Cs: Hash + CoordinateSystem> Hash for WithCs<T, Cs>

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: PartialEq, Cs: PartialEq + CoordinateSystem> PartialEq for WithCs<T, Cs>

fn eq(&self, other: &WithCs<T, Cs>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<P: Point, Cs: CoordinateSystem> Point for WithCs<P, Cs>

const DIM: usize = P::DIM

The number of dimensions.

type Scalar = <P as Point>::Scalar

The scalar coordinate type.

type Cs = Cs

The coordinate system this point lives in.

fn get<const D: usize>(&self) -> P::Scalar

Read coordinate D.

impl<P: PointMut, Cs: CoordinateSystem> PointMut for WithCs<P, Cs>

fn set<const D: usize>(&mut self, value: P::Scalar)

Write coordinate D.

impl<T: PartialEq, Cs: PartialEq + CoordinateSystem> StructuralPartialEq for WithCs<T, Cs>