Macro register_ring 

macro_rules! register_ring {
    ($Ty:ty, $Point:ty, |$s:ident| $iter:expr) => { ... };
    (
        $Ty:ty,
        $Point:ty,
        |$s:ident| $iter:expr,
        closure = $closure:expr,
        point_order = $order:expr $(,)?
    ) => { ... };
}

Register a user-owned ring type whose storage is iterable as &Point via a user-supplied expression.

Emits impl Geometry for $Ty with Kind = RingTag and Point = $Point, plus impl Ring for $Ty whose points() returns the iterator the closure-shaped argument produces. Optional trailing closure = … and point_order = … clauses override the defaults geometry_trait::Ring inherits from boost/geometry/core/{closure,point_order}.hpp (closed, clockwise).

Mirrors BOOST_GEOMETRY_REGISTER_RING from boost/geometry/geometries/register/ring.hpp, plus the per-ring traits::closure<R> / traits::point_order<R> specialisations from boost/geometry/core/closure.hpp and boost/geometry/core/point_order.hpp.

Examples

Default-orientation ring (closed, clockwise):

use geometry_adapt::register_ring;
use geometry_cs::Cartesian;
use geometry_model::Point2D;
use geometry_trait::Ring;

struct MyRing { points: Vec<Point2D<f64, Cartesian>> }

register_ring!(MyRing, Point2D<f64, Cartesian>, |s| s.points.iter());

let r = MyRing {
    points: vec![
        Point2D::new(0.0, 0.0),
        Point2D::new(1.0, 0.0),
        Point2D::new(1.0, 1.0),
        Point2D::new(0.0, 0.0),
    ],
};
assert_eq!(r.points().count(), 4);

Override closure and point_order:

use geometry_adapt::register_ring;
use geometry_cs::Cartesian;
use geometry_model::Point2D;
use geometry_trait::{Closure, PointOrder, Ring};

struct OpenCcwRing { points: Vec<Point2D<f64, Cartesian>> }

register_ring!(
    OpenCcwRing,
    Point2D<f64, Cartesian>,
    |s| s.points.iter(),
    closure = Closure::Open,
    point_order = PointOrder::CounterClockwise
);

let r = OpenCcwRing { points: vec![] };
assert_eq!(r.closure(), Closure::Open);
assert_eq!(r.point_order(), PointOrder::CounterClockwise);