Struct GeometryResolver 

pub struct GeometryResolver<'a> { /* private fields */ }

Resolves gml:id/xlink:href references to the geometry they point at.

Indexes borrowed AbstractGeometryKindRefs by Id, so lookups by reference are O(1) instead of re-walking the geometry tree. Geometries without an id are not indexed — they cannot be referenced by xlink:href in the first place.

Implementations

impl<'a> GeometryResolver<'a>

pub fn new() -> Self

Creates an empty resolver.

pub fn build<T: IterGeometries>(root: &'a T) -> Self

Builds a resolver by recursively walking root and indexing every descendant geometry (including root itself) that carries an id.

Examples

use egml_core::model::geometry::DirectPosition;
use egml_core::model::geometry::primitives::Point;
use egml_core::model::base::{AsAbstractGmlMut, Id};
use egml_core::resolver::GeometryResolver;

let mut point = Point::new(DirectPosition::new(1.0, 2.0, 3.0).unwrap());
point.set_id(Id::try_from("point-1").expect("valid id"));

let resolver = GeometryResolver::build(&point);
assert!(resolver.resolve(&Id::try_from("point-1").expect("valid id")).is_some());

pub fn insert_root<T: IterGeometries>(&mut self, root: &'a T)

Recursively walks root and indexes every descendant geometry (including root itself) that carries an id.

Unlike build, this adds to an existing resolver instead of creating a new one — call it once per top-level geometry when a document has several independent roots (e.g. one per feature in a city model) that should all resolve through the same table.

Examples

use egml_core::model::base::{AsAbstractGmlMut, Id};
use egml_core::model::geometry::DirectPosition;
use egml_core::model::geometry::primitives::Point;
use egml_core::resolver::GeometryResolver;

let mut first = Point::new(DirectPosition::new(1.0, 2.0, 3.0).unwrap());
first.set_id(Id::try_from("point-1").expect("valid id"));
let mut second = Point::new(DirectPosition::new(4.0, 5.0, 6.0).unwrap());
second.set_id(Id::try_from("point-2").expect("valid id"));

let mut resolver = GeometryResolver::new();
resolver.insert_root(&first);
resolver.insert_root(&second);

assert_eq!(resolver.len(), 2);

pub fn insert(&mut self, geometry: AbstractGeometryKindRef<'a>) -> bool

Indexes a single geometry by its id, if it has one.

Returns true if the geometry had an id and was stored. If another geometry was already indexed under the same id, it is silently replaced — gml:id is supposed to be unique within a document, so a collision indicates malformed input rather than a case this resolver needs to arbitrate.

pub fn extend( &mut self, geometries: impl IntoIterator<Item = AbstractGeometryKindRef<'a>>, )

Indexes every geometry in geometries that carries an id.

pub fn resolve(&self, id: &Id) -> Option<AbstractGeometryKindRef<'a>>

Looks up the geometry stored under id, if any.

pub fn resolve_as<T>(&self, id: &Id) -> Option<T>

where T: TryFrom<AbstractGeometryKindRef<'a>>,

Looks up the geometry stored under id and downcasts it to a concrete leaf type or intermediate *Ref enum via the TryFrom conversions generated across the geometry ref hierarchy.

Returns None if id is unresolved, or if it resolves to a geometry of a different concrete type than T.

Examples

use egml_core::model::base::{AsAbstractGmlMut, Id};
use egml_core::model::geometry::DirectPosition;
use egml_core::model::geometry::primitives::LinearRing;
use egml_core::resolver::GeometryResolver;

let mut ring = LinearRing::new([
    DirectPosition::new(0.0, 0.0, 0.0).unwrap(),
    DirectPosition::new(1.0, 0.0, 0.0).unwrap(),
    DirectPosition::new(0.0, 1.0, 0.0).unwrap(),
])
.unwrap();
ring.set_id(Id::try_from("ring-1").expect("valid id"));

let resolver = GeometryResolver::build(&ring);
let resolved: Option<&LinearRing> = resolver.resolve_as(&Id::try_from("ring-1").expect("valid id"));
assert!(resolved.is_some());

pub fn contains(&self, id: &Id) -> bool

Returns true if id is indexed.

pub fn ids(&self) -> impl Iterator<Item = &Id>

Returns an iterator over all indexed ids, in arbitrary order.

pub fn iter(&self) -> impl Iterator<Item = (&Id, &AbstractGeometryKindRef<'a>)>

Returns an iterator over all indexed (id, geometry) pairs, in arbitrary order.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

Trait Implementations

impl<'a> Clone for GeometryResolver<'a>

fn clone(&self) -> GeometryResolver<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for GeometryResolver<'a>

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

Formats the value using the given formatter.

impl<'a> Default for GeometryResolver<'a>

fn default() -> GeometryResolver<'a>

Returns the “default value” for a type.