Struct Reversed 

pub struct Reversed<S>(pub S);

Reversed<S> lifts a DistanceStrategy<A, B> into a DistanceStrategy<B, A> by calling the inner strategy with the arguments swapped.

Replaces boost::geometry::reverse_dispatch (boost/geometry/core/reverse_dispatch.hpp) together with the partial specialisation that uses it in boost/geometry/algorithms/detail/distance/interface.hpp:53-77. Boost has one such specialisation per algorithm; in Rust the symmetry is expressed once, at the strategy-trait layer, with a single blanket impl below — every algorithm that goes through a DistanceStrategy<A, B> automatically gets the swap.

Cost

#[repr(transparent)] is deliberately not applied — Reversed is a one-field tuple struct and monomorphisation collapses the indirection. There is no runtime overhead: the wrapper exists solely to give the trait system a different Self type to dispatch on, the same way boost::geometry::detail::distance:: reverse_dispatch_call exists in C++ only to give the partial specialisation something to bind to.

Tuple Fields

0: S

Trait Implementations

impl<S: Clone> Clone for Reversed<S>

fn clone(&self) -> Reversed<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Copy> Copy for Reversed<S>

impl<S: Debug> Debug for Reversed<S>

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

Formats the value using the given formatter.

impl<S: Default> Default for Reversed<S>

fn default() -> Reversed<S>

Returns the “default value” for a type.

impl<A, B, S> DistanceStrategy<B, A> for Reversed<S>

where A: Geometry, B: Geometry, S: DistanceStrategy<A, B>,

type Out = <S as DistanceStrategy<A, B>>::Out

The output scalar type. Typically the promoted scalar of A and B. Mirrors services::return_type<Strategy, P1, P2>::type from strategies/distance/services.hpp.

type Comparable = Reversed<<S as DistanceStrategy<A, B>>::Comparable>

The “skip the sqrt” form of this strategy.

fn distance(&self, b: &B, a: &A) -> S::Out

Compute the distance between a and b.

fn comparable(&self) -> Self::Comparable

Return the comparable-form companion of this strategy.