From 503707f3610d655da6abf51ab80dbc93f63820e4 Mon Sep 17 00:00:00 2001
From: Matthias Koefferlein <matthias@koefferlein.de>
Date: Wed, 20 Feb 2019 10:10:54 +0100
Subject: [PATCH] Refactoring: based results of edge/polygon operations on
 delegates entirely

---
 src/db/db/dbAsIfFlatEdges.cc  |  8 ++---
 src/db/db/dbAsIfFlatEdges.h   | 14 ++++----
 src/db/db/dbAsIfFlatRegion.cc | 41 +++++++++++-----------
 src/db/db/dbAsIfFlatRegion.h  | 26 +++++++-------
 src/db/db/dbDeepEdges.cc      |  5 +--
 src/db/db/dbDeepEdges.h       | 14 ++++----
 src/db/db/dbDeepRegion.cc     | 23 ++++++------
 src/db/db/dbDeepRegion.h      | 26 +++++++-------
 src/db/db/dbEdges.h           | 12 +++----
 src/db/db/dbEdgesDelegate.h   | 12 +++----
 src/db/db/dbEmptyEdges.cc     | 36 +++++++++++++++++++
 src/db/db/dbEmptyEdges.h      | 12 +++----
 src/db/db/dbEmptyRegion.cc    | 66 +++++++++++++++++++++++++++++++++++
 src/db/db/dbEmptyRegion.h     | 22 ++++++------
 src/db/db/dbRegion.h          | 22 ++++++------
 src/db/db/dbRegionDelegate.h  | 22 ++++++------
 16 files changed, 233 insertions(+), 128 deletions(-)

diff --git a/src/db/db/dbAsIfFlatEdges.cc b/src/db/db/dbAsIfFlatEdges.cc
index 2ed17d5f7..4e5e03581 100644
--- a/src/db/db/dbAsIfFlatEdges.cc
+++ b/src/db/db/dbAsIfFlatEdges.cc
@@ -422,10 +422,10 @@ AsIfFlatEdges::filtered (const EdgeFilterBase &filter) const
   return new_region.release ();
 }
 
-EdgePairs 
+EdgePairsDelegate *
 AsIfFlatEdges::run_check (db::edge_relation_type rel, const Edges *other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
 {
-  EdgePairs result;
+  std::auto_ptr<FlatEdgePairs> result (new FlatEdgePairs ());
 
   db::box_scanner<db::Edge, size_t> scanner (report_progress (), progress_desc ());
   scanner.reserve (size () + (other ? other->size () : 0));
@@ -456,10 +456,10 @@ AsIfFlatEdges::run_check (db::edge_relation_type rel, const Edges *other, db::Co
   check.set_min_projection (min_projection);
   check.set_max_projection (max_projection);
 
-  edge2edge_check_for_edges<db::EdgePairs> edge_check (check, result, other != 0);
+  edge2edge_check_for_edges<db::FlatEdgePairs> edge_check (check, *result, other != 0);
   scanner.process (edge_check, d, db::box_convert<db::Edge> ());
 
-  return result;
+  return result.release ();
 }
 
 EdgesDelegate * 
diff --git a/src/db/db/dbAsIfFlatEdges.h b/src/db/db/dbAsIfFlatEdges.h
index 2b19fdf1a..ffc1150b7 100644
--- a/src/db/db/dbAsIfFlatEdges.h
+++ b/src/db/db/dbAsIfFlatEdges.h
@@ -52,32 +52,32 @@ public:
   virtual distance_type length (const db::Box &) const;
   virtual Box bbox () const;
 
-  virtual EdgePairs width_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  virtual EdgePairsDelegate *width_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::WidthRelation, 0, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
     
-  virtual EdgePairs space_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  virtual EdgePairsDelegate *space_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::SpaceRelation, 0, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  virtual EdgePairs enclosing_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  virtual EdgePairsDelegate *enclosing_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::OverlapRelation, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  virtual EdgePairs overlap_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  virtual EdgePairsDelegate *overlap_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::WidthRelation, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  virtual EdgePairs separation_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  virtual EdgePairsDelegate *separation_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::SpaceRelation, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  virtual EdgePairs inside_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  virtual EdgePairsDelegate *inside_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::InsideRelation, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
@@ -172,7 +172,7 @@ public:
 protected:
   void update_bbox (const db::Box &box);
   void invalidate_bbox ();
-  EdgePairs run_check (db::edge_relation_type rel, const Edges *other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const;
+  EdgePairsDelegate *run_check (db::edge_relation_type rel, const Edges *other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const;
   virtual EdgesDelegate *selected_interacting_generic (const Edges &edges, bool inverse) const;
   virtual EdgesDelegate *selected_interacting_generic (const Region &region, bool inverse) const;
 
diff --git a/src/db/db/dbAsIfFlatRegion.cc b/src/db/db/dbAsIfFlatRegion.cc
index 2ebd71ec0..a13e49823 100644
--- a/src/db/db/dbAsIfFlatRegion.cc
+++ b/src/db/db/dbAsIfFlatRegion.cc
@@ -26,6 +26,7 @@
 #include "dbFlatEdgePairs.h"
 #include "dbFlatEdges.h"
 #include "dbEmptyRegion.h"
+#include "dbEmptyEdgePairs.h"
 #include "dbRegion.h"
 #include "dbRegionUtils.h"
 #include "dbShapeProcessor.h"
@@ -72,26 +73,26 @@ AsIfFlatRegion::to_string (size_t nmax) const
   return os.str ();
 }
 
-Edges
+EdgesDelegate *
 AsIfFlatRegion::edges (const EdgeFilterBase *filter) const
 {
-  Edges edges;
+  std::auto_ptr<FlatEdges> result (new FlatEdges ());
 
   size_t n = 0;
   for (RegionIterator p (begin_merged ()); ! p.at_end (); ++p) {
     n += p->vertices ();
   }
-  edges.reserve (n);
+  result->reserve (n);
 
   for (RegionIterator p (begin_merged ()); ! p.at_end (); ++p) {
     for (db::Polygon::polygon_edge_iterator e = p->begin_edge (); ! e.at_end (); ++e) {
       if (! filter || filter->selected (*e)) {
-        edges.insert (*e);
+        result->insert (*e);
       }
     }
   }
 
-  return edges;
+  return result.release ();
 }
 
 RegionDelegate *
@@ -454,7 +455,7 @@ AsIfFlatRegion::produce_markers_for_grid_check (const db::Polygon &poly, const T
 template void AsIfFlatRegion::produce_markers_for_grid_check<db::ICplxTrans> (const db::Polygon &poly, const db::ICplxTrans &tr, db::Coord gx, db::Coord gy, db::Shapes &shapes);
 template void AsIfFlatRegion::produce_markers_for_grid_check<db::UnitTrans> (const db::Polygon &poly, const db::UnitTrans &tr, db::Coord gx, db::Coord gy, db::Shapes &shapes);
 
-EdgePairs
+EdgePairsDelegate *
 AsIfFlatRegion::grid_check (db::Coord gx, db::Coord gy) const
 {
   if (gx < 0 || gy < 0) {
@@ -462,7 +463,7 @@ AsIfFlatRegion::grid_check (db::Coord gx, db::Coord gy) const
   }
 
   if (gx == 0 && gy == 0) {
-    return EdgePairs ();
+    return new EmptyEdgePairs ();
   }
 
   std::auto_ptr<db::FlatEdgePairs> res (new db::FlatEdgePairs ());
@@ -471,7 +472,7 @@ AsIfFlatRegion::grid_check (db::Coord gx, db::Coord gy) const
     produce_markers_for_grid_check (*p, db::UnitTrans (), gx, gy, res->raw_edge_pairs ());
   }
 
-  return EdgePairs (res.release ());
+  return res.release ();
 }
 
 static bool ac_less (double cos_a, bool gt180_a, double cos_b, bool gt180_b)
@@ -532,7 +533,7 @@ AsIfFlatRegion::produce_markers_for_angle_check (const db::Polygon &poly, const
 template void AsIfFlatRegion::produce_markers_for_angle_check<db::ICplxTrans> (const db::Polygon &poly, const db::ICplxTrans &tr, double min, double max, bool inverse, db::Shapes &shapes);
 template void AsIfFlatRegion::produce_markers_for_angle_check<db::UnitTrans> (const db::Polygon &poly, const db::UnitTrans &tr, double min, double max, bool inverse, db::Shapes &shapes);
 
-EdgePairs
+EdgePairsDelegate *
 AsIfFlatRegion::angle_check (double min, double max, bool inverse) const
 {
   std::auto_ptr<db::FlatEdgePairs> res (new db::FlatEdgePairs ());
@@ -541,7 +542,7 @@ AsIfFlatRegion::angle_check (double min, double max, bool inverse) const
     produce_markers_for_angle_check (*p, db::UnitTrans (), min, max, inverse, res->raw_edge_pairs ());
   }
 
-  return EdgePairs (res.release ());
+  return res.release ();
 }
 
 static inline db::Coord snap_to_grid (db::Coord c, db::Coord g)
@@ -610,10 +611,10 @@ AsIfFlatRegion::snapped (db::Coord gx, db::Coord gy)
   return new_region.release ();
 }
 
-EdgePairs
+EdgePairsDelegate *
 AsIfFlatRegion::run_check (db::edge_relation_type rel, bool different_polygons, const Region *other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
 {
-  EdgePairs result;
+  std::auto_ptr<FlatEdgePairs> result (new FlatEdgePairs ());
 
   db::box_scanner<db::Polygon, size_t> scanner (report_progress (), progress_desc ());
   scanner.reserve (size () + (other ? other->size () : 0));
@@ -647,20 +648,20 @@ AsIfFlatRegion::run_check (db::edge_relation_type rel, bool different_polygons,
   check.set_min_projection (min_projection);
   check.set_max_projection (max_projection);
 
-  edge2edge_check<db::EdgePairs> edge_check (check, result, different_polygons, other != 0);
-  poly2poly_check<db::EdgePairs> poly_check (edge_check);
+  edge2edge_check<db::FlatEdgePairs> edge_check (check, *result, different_polygons, other != 0);
+  poly2poly_check<db::FlatEdgePairs> poly_check (edge_check);
 
   do {
     scanner.process (poly_check, d, db::box_convert<db::Polygon> ());
   } while (edge_check.prepare_next_pass ());
 
-  return result;
+  return result.release ();
 }
 
-EdgePairs
+EdgePairsDelegate *
 AsIfFlatRegion::run_single_polygon_check (db::edge_relation_type rel, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
 {
-  EdgePairs result;
+  std::auto_ptr<FlatEdgePairs> result (new FlatEdgePairs ());
 
   EdgeRelationFilter check (rel, d, metrics);
   check.set_whole_edges (whole_edges);
@@ -668,8 +669,8 @@ AsIfFlatRegion::run_single_polygon_check (db::edge_relation_type rel, db::Coord
   check.set_min_projection (min_projection);
   check.set_max_projection (max_projection);
 
-  edge2edge_check<db::EdgePairs> edge_check (check, result, false, false);
-  poly2poly_check<db::EdgePairs> poly_check (edge_check);
+  edge2edge_check<db::FlatEdgePairs> edge_check (check, *result, false, false);
+  poly2poly_check<db::FlatEdgePairs> poly_check (edge_check);
 
   do {
 
@@ -681,7 +682,7 @@ AsIfFlatRegion::run_single_polygon_check (db::edge_relation_type rel, db::Coord
 
   } while (edge_check.prepare_next_pass ());
 
-  return result;
+  return result.release ();
 }
 
 RegionDelegate *
diff --git a/src/db/db/dbAsIfFlatRegion.h b/src/db/db/dbAsIfFlatRegion.h
index 974c105c2..b6c1b3e93 100644
--- a/src/db/db/dbAsIfFlatRegion.h
+++ b/src/db/db/dbAsIfFlatRegion.h
@@ -55,48 +55,48 @@ public:
 
   virtual std::string to_string (size_t nmax) const;
 
-  EdgePairs width_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *width_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_single_polygon_check (db::WidthRelation, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs space_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *space_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::SpaceRelation, false, 0, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs isolated_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *isolated_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::SpaceRelation, true, 0, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs notch_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *notch_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_single_polygon_check (db::SpaceRelation, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs enclosing_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *enclosing_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::OverlapRelation, true, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs overlap_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *overlap_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::WidthRelation, true, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs separation_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *separation_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::SpaceRelation, true, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs inside_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *inside_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::InsideRelation, true, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  virtual EdgePairs grid_check (db::Coord gx, db::Coord gy) const;
-  virtual EdgePairs angle_check (double min, double max, bool inverse) const;
+  virtual EdgePairsDelegate *grid_check (db::Coord gx, db::Coord gy) const;
+  virtual EdgePairsDelegate *angle_check (double min, double max, bool inverse) const;
 
   virtual RegionDelegate *snapped_in_place (db::Coord gx, db::Coord gy)
   {
@@ -105,7 +105,7 @@ public:
 
   virtual RegionDelegate *snapped (db::Coord gx, db::Coord gy);
 
-  virtual Edges edges (const EdgeFilterBase *) const;
+  virtual EdgesDelegate *edges (const EdgeFilterBase *) const;
 
   virtual RegionDelegate *process_in_place (const PolygonProcessorBase &filter)
   {
@@ -216,8 +216,8 @@ protected:
   void update_bbox (const db::Box &box);
   void invalidate_bbox ();
 
-  EdgePairs run_check (db::edge_relation_type rel, bool different_polygons, const Region *other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const;
-  EdgePairs run_single_polygon_check (db::edge_relation_type rel, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const;
+  EdgePairsDelegate *run_check (db::edge_relation_type rel, bool different_polygons, const Region *other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const;
+  EdgePairsDelegate *run_single_polygon_check (db::edge_relation_type rel, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const;
   RegionDelegate *selected_interacting_generic (const Region &other, int mode, bool touching, bool inverse) const;
   RegionDelegate *selected_interacting_generic (const Edges &other, bool inverse) const;
 
diff --git a/src/db/db/dbDeepEdges.cc b/src/db/db/dbDeepEdges.cc
index 2e4a7dfd8..d7dc9c3cc 100644
--- a/src/db/db/dbDeepEdges.cc
+++ b/src/db/db/dbDeepEdges.cc
@@ -1390,7 +1390,8 @@ private:
 
 }
 
-EdgePairs DeepEdges::run_check (db::edge_relation_type rel, const Edges *other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+EdgePairsDelegate *
+DeepEdges::run_check (db::edge_relation_type rel, const Edges *other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
 {
   const db::DeepEdges *other_deep = 0;
   if (other) {
@@ -1422,7 +1423,7 @@ EdgePairs DeepEdges::run_check (db::edge_relation_type rel, const Edges *other,
 
   proc.run (&op, m_merged_edges.layer (), other_deep ? other_deep->deep_layer ().layer () : m_merged_edges.layer (), res->deep_layer ().layer ());
 
-  return db::EdgePairs (res.release ());
+  return res.release ();
 }
 
 }
diff --git a/src/db/db/dbDeepEdges.h b/src/db/db/dbDeepEdges.h
index c72a8c9d9..a114d7e66 100644
--- a/src/db/db/dbDeepEdges.h
+++ b/src/db/db/dbDeepEdges.h
@@ -78,32 +78,32 @@ public:
 
   virtual std::string to_string (size_t nmax) const;
 
-  virtual EdgePairs width_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  virtual EdgePairsDelegate *width_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::WidthRelation, 0, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
     
-  virtual EdgePairs space_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  virtual EdgePairsDelegate *space_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::SpaceRelation, 0, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  virtual EdgePairs enclosing_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  virtual EdgePairsDelegate *enclosing_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::OverlapRelation, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  virtual EdgePairs overlap_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  virtual EdgePairsDelegate *overlap_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::WidthRelation, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  virtual EdgePairs separation_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  virtual EdgePairsDelegate *separation_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::SpaceRelation, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  virtual EdgePairs inside_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  virtual EdgePairsDelegate *inside_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::InsideRelation, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
@@ -173,7 +173,7 @@ private:
   void ensure_merged_edges_valid () const;
   DeepLayer and_or_not_with(const DeepEdges *other, bool and_op) const;
   DeepLayer edge_region_op (const DeepRegion *other, bool outside, bool include_borders) const;
-  EdgePairs run_check (db::edge_relation_type rel, const Edges *other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const;
+  EdgePairsDelegate *run_check (db::edge_relation_type rel, const Edges *other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const;
   EdgesDelegate *selected_interacting_generic (const Edges &edges, bool invert) const;
   EdgesDelegate *selected_interacting_generic (const Region &region, bool invert) const;
   template <class Result, class OutputContainer> OutputContainer *processed_impl (const edge_processor<Result> &filter) const;
diff --git a/src/db/db/dbDeepRegion.cc b/src/db/db/dbDeepRegion.cc
index 7f2221c0c..e626c5126 100644
--- a/src/db/db/dbDeepRegion.cc
+++ b/src/db/db/dbDeepRegion.cc
@@ -24,6 +24,7 @@
 #include "dbDeepRegion.h"
 #include "dbDeepShapeStore.h"
 #include "dbEmptyRegion.h"
+#include "dbEmptyEdgePairs.h"
 #include "dbRegion.h"
 #include "dbRegionUtils.h"
 #include "dbDeepEdges.h"
@@ -715,7 +716,7 @@ DeepRegion::to_string (size_t nmax) const
   return db::AsIfFlatRegion::to_string (nmax);
 }
 
-EdgePairs
+EdgePairsDelegate *
 DeepRegion::grid_check (db::Coord gx, db::Coord gy) const
 {
   if (gx < 0 || gy < 0) {
@@ -728,7 +729,7 @@ DeepRegion::grid_check (db::Coord gx, db::Coord gy) const
   }
 
   if (gx == 0) {
-    return EdgePairs ();
+    return new EmptyEdgePairs ();
   }
 
   ensure_merged_polygons_valid ();
@@ -771,10 +772,10 @@ DeepRegion::grid_check (db::Coord gx, db::Coord gy) const
   //  propagate the markers with a similar algorithm used for producing the variants
   res->deep_layer ().commit_shapes (vars, to_commit);
 
-  return db::EdgePairs (res.release ());
+  return res.release ();
 }
 
-EdgePairs
+EdgePairsDelegate *
 DeepRegion::angle_check (double min, double max, bool inverse) const
 {
   ensure_merged_polygons_valid ();
@@ -796,7 +797,7 @@ DeepRegion::angle_check (double min, double max, bool inverse) const
 
   }
 
-  return db::EdgePairs (res.release ());
+  return res.release ();
 }
 
 RegionDelegate *
@@ -853,7 +854,7 @@ DeepRegion::snapped (db::Coord gx, db::Coord gy)
   return res.release ();
 }
 
-Edges
+EdgesDelegate *
 DeepRegion::edges (const EdgeFilterBase *filter) const
 {
   ensure_merged_polygons_valid ();
@@ -902,7 +903,7 @@ DeepRegion::edges (const EdgeFilterBase *filter) const
   }
 
   res->set_is_merged (true);
-  return db::Edges (res.release ());
+  return res.release ();
 }
 
 RegionDelegate *
@@ -1448,7 +1449,7 @@ private:
 
 }
 
-EdgePairs
+EdgePairsDelegate *
 DeepRegion::run_check (db::edge_relation_type rel, bool different_polygons, const Region *other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
 {
   const db::DeepRegion *other_deep = 0;
@@ -1481,10 +1482,10 @@ DeepRegion::run_check (db::edge_relation_type rel, bool different_polygons, cons
 
   proc.run (&op, m_merged_polygons.layer (), other_deep ? other_deep->deep_layer ().layer () : m_merged_polygons.layer (), res->deep_layer ().layer ());
 
-  return db::EdgePairs (res.release ());
+  return res.release ();
 }
 
-EdgePairs
+EdgePairsDelegate *
 DeepRegion::run_single_polygon_check (db::edge_relation_type rel, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
 {
   ensure_merged_polygons_valid ();
@@ -1519,7 +1520,7 @@ DeepRegion::run_single_polygon_check (db::edge_relation_type rel, db::Coord d, b
 
   }
 
-  return db::EdgePairs (res.release ());
+  return res.release ();
 }
 
 namespace
diff --git a/src/db/db/dbDeepRegion.h b/src/db/db/dbDeepRegion.h
index 76e9cb1a1..6ede2cee0 100644
--- a/src/db/db/dbDeepRegion.h
+++ b/src/db/db/dbDeepRegion.h
@@ -86,48 +86,48 @@ public:
   virtual RegionDelegate *add_in_place (const Region &other);
   virtual RegionDelegate *add (const Region &other) const;
 
-  EdgePairs width_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *width_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_single_polygon_check (db::WidthRelation, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs space_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *space_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::SpaceRelation, false, 0, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs isolated_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *isolated_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::SpaceRelation, true, 0, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs notch_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *notch_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_single_polygon_check (db::SpaceRelation, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs enclosing_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *enclosing_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::OverlapRelation, true, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs overlap_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *overlap_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::WidthRelation, true, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs separation_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *separation_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::SpaceRelation, true, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  EdgePairs inside_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
+  EdgePairsDelegate *inside_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const
   {
     return run_check (db::InsideRelation, true, &other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
   }
 
-  virtual EdgePairs grid_check (db::Coord gx, db::Coord gy) const;
-  virtual EdgePairs angle_check (double min, double max, bool inverse) const;
+  virtual EdgePairsDelegate *grid_check (db::Coord gx, db::Coord gy) const;
+  virtual EdgePairsDelegate *angle_check (double min, double max, bool inverse) const;
 
   virtual RegionDelegate *snapped_in_place (db::Coord gx, db::Coord gy)
   {
@@ -136,7 +136,7 @@ public:
 
   virtual RegionDelegate *snapped (db::Coord gx, db::Coord gy);
 
-  virtual Edges edges (const EdgeFilterBase *) const;
+  virtual EdgesDelegate *edges (const EdgeFilterBase *) const;
 
   virtual RegionDelegate *process_in_place (const PolygonProcessorBase &filter);
   virtual RegionDelegate *processed (const PolygonProcessorBase &filter) const;
@@ -235,8 +235,8 @@ private:
   void init ();
   void ensure_merged_polygons_valid () const;
   DeepLayer and_or_not_with(const DeepRegion *other, bool and_op) const;
-  EdgePairs run_check (db::edge_relation_type rel, bool different_polygons, const Region *other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const;
-  EdgePairs run_single_polygon_check (db::edge_relation_type rel, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const;
+  EdgePairsDelegate *run_check (db::edge_relation_type rel, bool different_polygons, const Region *other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const;
+  EdgePairsDelegate *run_single_polygon_check (db::edge_relation_type rel, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const;
   RegionDelegate *selected_interacting_generic (const Region &other, int mode, bool touching, bool inverse) const;
   RegionDelegate *selected_interacting_generic (const Edges &other, bool inverse) const;
 
diff --git a/src/db/db/dbEdges.h b/src/db/db/dbEdges.h
index 2dadfa51d..84de5a6b4 100644
--- a/src/db/db/dbEdges.h
+++ b/src/db/db/dbEdges.h
@@ -675,7 +675,7 @@ public:
    */
   EdgePairs width_check (db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->width_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->width_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
@@ -690,7 +690,7 @@ public:
    */
   EdgePairs space_check (db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->space_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->space_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
@@ -708,7 +708,7 @@ public:
    */
   EdgePairs enclosing_check (const Edges &other, db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->enclosing_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->enclosing_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
@@ -726,7 +726,7 @@ public:
    */
   EdgePairs overlap_check (const Edges &other, db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->overlap_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->overlap_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
@@ -744,7 +744,7 @@ public:
    */
   EdgePairs separation_check (const Edges &other, db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->separation_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->separation_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
@@ -762,7 +762,7 @@ public:
    */
   EdgePairs inside_check (const Edges &other, db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->inside_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->inside_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
diff --git a/src/db/db/dbEdgesDelegate.h b/src/db/db/dbEdgesDelegate.h
index 0986e2604..5bd4651dd 100644
--- a/src/db/db/dbEdgesDelegate.h
+++ b/src/db/db/dbEdgesDelegate.h
@@ -240,12 +240,12 @@ public:
   virtual distance_type length (const db::Box &box) const = 0;
   virtual Box bbox () const = 0;
 
-  virtual EdgePairs width_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
-  virtual EdgePairs space_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
-  virtual EdgePairs enclosing_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
-  virtual EdgePairs overlap_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
-  virtual EdgePairs separation_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
-  virtual EdgePairs inside_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *width_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *space_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *enclosing_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *overlap_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *separation_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *inside_check (const Edges &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
 
   virtual EdgesDelegate *filter_in_place (const EdgeFilterBase &filter) = 0;
   virtual EdgesDelegate *filtered (const EdgeFilterBase &filter) const = 0;
diff --git a/src/db/db/dbEmptyEdges.cc b/src/db/db/dbEmptyEdges.cc
index 78dbd6576..211172085 100644
--- a/src/db/db/dbEmptyEdges.cc
+++ b/src/db/db/dbEmptyEdges.cc
@@ -72,6 +72,42 @@ EmptyEdges::processed_to_polygons (const EdgeToPolygonProcessorBase &) const
   return new EmptyRegion ();
 }
 
+EdgePairsDelegate *
+EmptyEdges::width_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyEdges::space_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyEdges::enclosing_check (const Edges &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyEdges::overlap_check (const Edges &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyEdges::separation_check (const Edges &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyEdges::inside_check (const Edges &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
 EdgesDelegate *
 EmptyEdges::add_in_place (const Edges &other)
 {
diff --git a/src/db/db/dbEmptyEdges.h b/src/db/db/dbEmptyEdges.h
index 83251d92a..8f590bc32 100644
--- a/src/db/db/dbEmptyEdges.h
+++ b/src/db/db/dbEmptyEdges.h
@@ -56,12 +56,12 @@ public:
   virtual distance_type length (const db::Box &) const { return 0; }
   virtual Box bbox () const { return db::Box (); }
 
-  virtual EdgePairs width_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
-  virtual EdgePairs space_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
-  virtual EdgePairs enclosing_check (const Edges &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
-  virtual EdgePairs overlap_check (const Edges &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
-  virtual EdgePairs separation_check (const Edges &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
-  virtual EdgePairs inside_check (const Edges &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
+  virtual EdgePairsDelegate *width_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const;
+  virtual EdgePairsDelegate *space_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const;
+  virtual EdgePairsDelegate *enclosing_check (const Edges &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const;
+  virtual EdgePairsDelegate *overlap_check (const Edges &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const;
+  virtual EdgePairsDelegate *separation_check (const Edges &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const;
+  virtual EdgePairsDelegate *inside_check (const Edges &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const;
 
   virtual EdgesDelegate *filter_in_place (const EdgeFilterBase &) { return this; }
   virtual EdgesDelegate *filtered (const EdgeFilterBase &) const { return new EmptyEdges (); }
diff --git a/src/db/db/dbEmptyRegion.cc b/src/db/db/dbEmptyRegion.cc
index fa42cdb71..ff66619b4 100644
--- a/src/db/db/dbEmptyRegion.cc
+++ b/src/db/db/dbEmptyRegion.cc
@@ -96,6 +96,72 @@ EmptyRegion::processed_to_edge_pairs (const PolygonToEdgePairProcessorBase &) co
   return new EmptyEdgePairs ();
 }
 
+EdgePairsDelegate *
+EmptyRegion::width_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyRegion::space_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyRegion::isolated_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyRegion::notch_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyRegion::enclosing_check (const Region &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyRegion::overlap_check (const Region &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyRegion::separation_check (const Region &, db::Coord, bool , metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyRegion::inside_check (const Region &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyRegion::grid_check (db::Coord, db::Coord) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgePairsDelegate *
+EmptyRegion::angle_check (double, double, bool) const
+{
+  return new EmptyEdgePairs ();
+}
+
+EdgesDelegate *
+EmptyRegion::edges (const EdgeFilterBase *) const
+{
+  return new EmptyEdges ();
+}
+
 bool
 EmptyRegion::equals (const Region &other) const
 {
diff --git a/src/db/db/dbEmptyRegion.h b/src/db/db/dbEmptyRegion.h
index 107448b97..d57a8e512 100644
--- a/src/db/db/dbEmptyRegion.h
+++ b/src/db/db/dbEmptyRegion.h
@@ -59,21 +59,21 @@ public:
 
   virtual Box bbox () const { return Box (); }
 
-  virtual EdgePairs width_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
-  virtual EdgePairs space_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
-  virtual EdgePairs isolated_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
-  virtual EdgePairs notch_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
-  virtual EdgePairs enclosing_check (const Region &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
-  virtual EdgePairs overlap_check (const Region &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
-  virtual EdgePairs separation_check (const Region &, db::Coord, bool , metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
-  virtual EdgePairs inside_check (const Region &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const { return EdgePairs (); }
-  virtual EdgePairs grid_check (db::Coord, db::Coord) const { return EdgePairs (); }
-  virtual EdgePairs angle_check (double, double, bool) const { return EdgePairs (); }
+  virtual EdgePairsDelegate *width_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const;
+  virtual EdgePairsDelegate *space_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const;
+  virtual EdgePairsDelegate *isolated_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const;
+  virtual EdgePairsDelegate *notch_check (db::Coord, bool, metrics_type, double, distance_type, distance_type) const;
+  virtual EdgePairsDelegate *enclosing_check (const Region &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const;
+  virtual EdgePairsDelegate *overlap_check (const Region &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const;
+  virtual EdgePairsDelegate *separation_check (const Region &, db::Coord, bool , metrics_type, double, distance_type, distance_type) const;
+  virtual EdgePairsDelegate *inside_check (const Region &, db::Coord, bool, metrics_type, double, distance_type, distance_type) const;
+  virtual EdgePairsDelegate *grid_check (db::Coord, db::Coord) const;
+  virtual EdgePairsDelegate *angle_check (double, double, bool) const;
 
   virtual RegionDelegate *snapped_in_place (db::Coord, db::Coord) { return this; }
   virtual RegionDelegate *snapped (db::Coord, db::Coord)  { return new EmptyRegion (); }
 
-  virtual Edges edges (const EdgeFilterBase *) const { return db::Edges (); }
+  virtual EdgesDelegate *edges (const EdgeFilterBase *) const;
   virtual RegionDelegate *filter_in_place (const PolygonFilterBase &) { return this; }
   virtual RegionDelegate *filtered (const PolygonFilterBase &) const { return new EmptyRegion (); }
   virtual RegionDelegate *process_in_place (const PolygonProcessorBase &) { return this; }
diff --git a/src/db/db/dbRegion.h b/src/db/db/dbRegion.h
index 6b28f7ec3..5aa72d6d8 100644
--- a/src/db/db/dbRegion.h
+++ b/src/db/db/dbRegion.h
@@ -711,7 +711,7 @@ public:
    */
   EdgePairs width_check (db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->width_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->width_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
@@ -724,7 +724,7 @@ public:
    */
   EdgePairs space_check (db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->space_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->space_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
@@ -737,7 +737,7 @@ public:
    */
   EdgePairs isolated_check (db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->isolated_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->isolated_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
@@ -750,7 +750,7 @@ public:
    */
   EdgePairs notch_check (db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->notch_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->notch_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
@@ -767,7 +767,7 @@ public:
    */
   EdgePairs enclosing_check (const Region &other, db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->enclosing_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->enclosing_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
@@ -784,7 +784,7 @@ public:
    */
   EdgePairs overlap_check (const Region &other, db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->overlap_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->overlap_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
@@ -801,7 +801,7 @@ public:
    */
   EdgePairs separation_check (const Region &other, db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->separation_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->separation_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
@@ -818,7 +818,7 @@ public:
    */
   EdgePairs inside_check (const Region &other, db::Coord d, bool whole_edges = false, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max ()) const
   {
-    return mp_delegate->inside_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection);
+    return EdgePairs (mp_delegate->inside_check (other, d, whole_edges, metrics, ignore_angle, min_projection, max_projection));
   }
 
   /**
@@ -828,7 +828,7 @@ public:
    */
   Edges edges () const
   {
-    return mp_delegate->edges (0);
+    return Edges (mp_delegate->edges (0));
   }
 
   /**
@@ -869,7 +869,7 @@ public:
    */
   EdgePairs grid_check (db::Coord gx, db::Coord gy) const
   {
-    return mp_delegate->grid_check (gx, gy);
+    return EdgePairs (mp_delegate->grid_check (gx, gy));
   }
 
   /**
@@ -881,7 +881,7 @@ public:
    */
   EdgePairs angle_check (double min, double max, bool inverse) const
   {
-    return mp_delegate->angle_check (min, max, inverse);
+    return EdgePairs (mp_delegate->angle_check (min, max, inverse));
   }
 
   /**
diff --git a/src/db/db/dbRegionDelegate.h b/src/db/db/dbRegionDelegate.h
index 17108cf18..fbeb35198 100644
--- a/src/db/db/dbRegionDelegate.h
+++ b/src/db/db/dbRegionDelegate.h
@@ -245,21 +245,21 @@ public:
   virtual perimeter_type perimeter (const db::Box &box) const = 0;
   virtual Box bbox () const = 0;
 
-  virtual EdgePairs width_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
-  virtual EdgePairs space_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
-  virtual EdgePairs isolated_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
-  virtual EdgePairs notch_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
-  virtual EdgePairs enclosing_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
-  virtual EdgePairs overlap_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
-  virtual EdgePairs separation_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
-  virtual EdgePairs inside_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
-  virtual EdgePairs grid_check (db::Coord gx, db::Coord gy) const = 0;
-  virtual EdgePairs angle_check (double min, double max, bool inverse) const = 0;
+  virtual EdgePairsDelegate *width_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *space_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *isolated_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *notch_check (db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *enclosing_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *overlap_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *separation_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *inside_check (const Region &other, db::Coord d, bool whole_edges, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection) const = 0;
+  virtual EdgePairsDelegate *grid_check (db::Coord gx, db::Coord gy) const = 0;
+  virtual EdgePairsDelegate *angle_check (double min, double max, bool inverse) const = 0;
 
   virtual RegionDelegate *snapped_in_place (db::Coord gx, db::Coord gy) = 0;
   virtual RegionDelegate *snapped (db::Coord gx, db::Coord gy) = 0;
 
-  virtual Edges edges (const EdgeFilterBase *filter) const = 0;
+  virtual EdgesDelegate *edges (const EdgeFilterBase *filter) const = 0;
   virtual RegionDelegate *filter_in_place (const PolygonFilterBase &filter) = 0;
   virtual RegionDelegate *filtered (const PolygonFilterBase &filter) const = 0;
   virtual RegionDelegate *process_in_place (const PolygonProcessorBase &filter) = 0;