Macro register_polygon 

macro_rules! register_polygon {
    (
        $Ty:ty,
        $Point:ty,
        ring = $Ring:ty,
        |$s:ident| outer = $outer:expr, inners = $inners:expr $(,)?
    ) => { ... };
}

Register a user-owned polygon type whose interior decomposes as { outer: $Ring, inners: <iterable of $Ring> }.

Emits impl Geometry for $Ty with Kind = PolygonTag and Point = $Point, plus impl Polygon for $Ty with the supplied $Ring as the associated Ring type. The outer = … expression must produce &$Ring; the inners = … expression must produce impl ExactSizeIterator<Item = &$Ring> — the bound geometry_trait::Polygon::interiors requires.

Mirrors the five-trait pattern in doc/example_adapting_a_legacy_geometry_object_model.qbk (tag, ring_const_type, interior_const_type, exterior_ring, interior_rings) — Boost.Geometry has no register/polygon.hpp, so this macro is the equivalent shortcut on the Rust side.

Example

use geometry_adapt::{register_polygon, register_ring};
use geometry_cs::Cartesian;
use geometry_model::Point2D;
use geometry_trait::{Polygon, Ring};

type P = Point2D<f64, Cartesian>;

struct MyRing { points: Vec<P> }
register_ring!(MyRing, P, |s| s.points.iter());

struct MyPoly { outer: MyRing, inners: Vec<MyRing> }
register_polygon!(
    MyPoly,
    P,
    ring = MyRing,
    |s| outer = &s.outer, inners = s.inners.iter()
);

let poly = MyPoly {
    outer: MyRing { points: vec![] },
    inners: vec![],
};
assert_eq!(poly.exterior().points().count(), 0);
assert_eq!(poly.interiors().count(), 0);