[Boost-commit] svn:boost r45371 - sandbox/gtl/gtl

From: lucanus.j.simonson_at_[hidden]
Date: 2008-05-14 17:15:59

Author: ljsimons
Date: 2008-05-14 17:15:58 EDT (Wed, 14 May 2008)
New Revision: 45371
URL: http://svn.boost.org/trac/boost/changeset/45371

Log:
added polygon set operations and view with initial operator syntax
Added:
   sandbox/gtl/gtl/iterator_vertex_orient_conversion.h   (contents, props changed)
   sandbox/gtl/gtl/polygon_set_data.h   (contents, props changed)
   sandbox/gtl/gtl/polygon_set_traits.h   (contents, props changed)
   sandbox/gtl/gtl/polygon_set_view.h   (contents, props changed)
Text files modified: 
   sandbox/gtl/gtl/gtl.h                        |    97 +++++++++++++++++++++++++++++++++++++++ 
   sandbox/gtl/gtl/polygon_with_holes_concept.h |     2                                         
   2 files changed, 96 insertions(+), 3 deletions(-)

Modified: sandbox/gtl/gtl/gtl.h
==============================================================================
--- sandbox/gtl/gtl/gtl.h	(original)
+++ sandbox/gtl/gtl/gtl.h	2008-05-14 17:15:58 EDT (Wed, 14 May 2008)
@@ -56,7 +56,14 @@
 #include "boolean_op.h"
 #include "polygon_formation.h"
 #include "rectangle_formation.h"
+#include "iterator_vertex_orient_conversion.h"
 
+//polygon set data types
+#include "polygon_set_data.h"
+//polygon set trait types
+#include "polygon_set_traits.h"
+//polygon set concepts
+#include "polygon_set_view.h"
 //geometry traits
 #include "geometry_traits.h"
 
@@ -64,6 +71,8 @@
 #include "post_geometry_traits_definitions.h"
 
 
+
+
 template <typename geometry_type_1, typename geometry_type_2>
 bool contains(const geometry_type_1& geometry_object, const geometry_type_2& contained_geometry_object, 
               bool consider_touch = true) {
@@ -95,8 +104,92 @@
 }
 
 template <typename geometry_type_1, typename geometry_type_2>
-geometry_type_1& operator|(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
-  return assign(lvalue, rvalue);
+polygon_set_view<typename geometry_type_1::operator_arg_type,
+                 typename geometry_type_2::operator_arg_type,
+                 boolean_op::BinaryOr, 
+                 typename geometry_type_1::operator_storage_tag, 
+                 typename geometry_type_2::operator_storage_tag> 
+operator|(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+  return polygon_set_view<geometry_type_1, geometry_type_2,
+    boolean_op::BinaryOr, 
+    typename geometry_type_1::operator_storage_tag, 
+    typename geometry_type_2::operator_storage_tag>(lvalue, rvalue, 
+                                                    polygon_set_traits<geometry_type_1>::orient(lvalue),
+                                                    boolean_op::BinaryOr());
+}
+
+template <typename geometry_type_1, typename geometry_type_2>
+polygon_set_view<typename geometry_type_1::operator_arg_type,
+                 typename geometry_type_2::operator_arg_type,
+                 boolean_op::BinaryOr, 
+                 typename geometry_type_1::operator_storage_tag, 
+                 typename geometry_type_2::operator_storage_tag> 
+operator+(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+  return polygon_set_view<geometry_type_1, geometry_type_2,
+    boolean_op::BinaryOr, 
+    typename geometry_type_1::operator_storage_tag, 
+    typename geometry_type_2::operator_storage_tag>(lvalue, rvalue, 
+                                                    polygon_set_traits<geometry_type_1>::orient(lvalue),
+                                                    boolean_op::BinaryOr());
+}
+
+template <typename geometry_type_1, typename geometry_type_2>
+polygon_set_view<typename geometry_type_1::operator_arg_type,
+                 typename geometry_type_2::operator_arg_type,
+                 boolean_op::BinaryAnd, 
+                 typename geometry_type_1::operator_storage_tag, 
+                 typename geometry_type_2::operator_storage_tag> 
+operator*(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+  return polygon_set_view<geometry_type_1, geometry_type_2,
+    boolean_op::BinaryAnd, 
+    typename geometry_type_1::operator_storage_tag, 
+    typename geometry_type_2::operator_storage_tag>(lvalue, rvalue, 
+                                                    polygon_set_traits<geometry_type_1>::orient(lvalue),
+                                                    boolean_op::BinaryAnd());
+}
+
+template <typename geometry_type_1, typename geometry_type_2>
+polygon_set_view<typename geometry_type_1::operator_arg_type,
+                 typename geometry_type_2::operator_arg_type,
+                 boolean_op::BinaryAnd, 
+                 typename geometry_type_1::operator_storage_tag, 
+                 typename geometry_type_2::operator_storage_tag> 
+operator&(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+  return polygon_set_view<geometry_type_1, geometry_type_2,
+    boolean_op::BinaryAnd, 
+    typename geometry_type_1::operator_storage_tag, 
+    typename geometry_type_2::operator_storage_tag>(lvalue, rvalue, 
+                                                     polygon_set_traits<geometry_type_1>::orient(lvalue),
+                                                     boolean_op::BinaryAnd());
+}
+
+template <typename geometry_type_1, typename geometry_type_2>
+polygon_set_view<typename geometry_type_1::operator_arg_type,
+                 typename geometry_type_2::operator_arg_type,
+                 boolean_op::BinaryXor, 
+                 typename geometry_type_1::operator_storage_tag, 
+                 typename geometry_type_2::operator_storage_tag> 
+operator^(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+  return polygon_set_view<geometry_type_1, geometry_type_2,
+    boolean_op::BinaryXor, 
+    typename geometry_type_1::operator_storage_tag, 
+    typename geometry_type_2::operator_storage_tag>(lvalue, rvalue, 
+                                                    polygon_set_traits<geometry_type_1>::orient(lvalue),
+                                                    boolean_op::BinaryXor());
 }
  
+template <typename geometry_type_1, typename geometry_type_2>
+polygon_set_view<typename geometry_type_1::operator_arg_type,
+                 typename geometry_type_2::operator_arg_type,
+                 boolean_op::BinaryNot, 
+                 typename geometry_type_1::operator_storage_tag, 
+                 typename geometry_type_2::operator_storage_tag> 
+operator-(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+  return polygon_set_view<geometry_type_1, geometry_type_2,
+    boolean_op::BinaryNot, 
+    typename geometry_type_1::operator_storage_tag, 
+    typename geometry_type_2::operator_storage_tag>(lvalue, rvalue, 
+                                                    polygon_set_traits<geometry_type_1>::orient(lvalue),
+                                                    boolean_op::BinaryNot());
+}
 

Added: sandbox/gtl/gtl/iterator_vertex_orient_conversion.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/iterator_vertex_orient_conversion.h	2008-05-14 17:15:58 EDT (Wed, 14 May 2008)
@@ -0,0 +1,43 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+template <typename iterator_type>
+class iterator_vertex_orient_conversion {
+private:
+  iterator_type iter_;
+  typename iterator_type::value_type vertex_;
+public:
+  typedef std::forward_iterator_tag iterator_category;
+  typedef typename iterator_type::value_type value_type;
+  typedef std::ptrdiff_t difference_type;
+  typedef const value_type* pointer; //immutable
+  typedef const value_type& reference; //immutable
+  typedef typename value_type::first_type coordinate_type;
+
+  inline iterator_vertex_orient_conversion() {}
+  inline iterator_vertex_orient_conversion(iterator_type iter) : 
+    iter_(iter) {}
+  inline iterator_vertex_orient_conversion& operator++() {
+    ++iter_;
+    vertex_.first = (*iter_).second.first;
+    vertex_.second = std::pair<coordinate_type, int>((*iter_).first, (*iter_).second.second); 
+    return *this;
+  }
+  inline iterator_vertex_orient_conversion operator++(int) {
+    iterator_vertex_orient_conversion tmp(*this);
+    ++(*this);
+    return tmp;
+  }
+  inline bool operator==(const iterator_vertex_orient_conversion& that) const {
+    return (iter_ == that.iter_);
+  }
+  inline bool operator!=(const iterator_vertex_orient_conversion& that) const {
+    return (iter_ != that.iter_);
+  }
+  inline reference operator*() const { return vertex_; }
+};
+

Added: sandbox/gtl/gtl/polygon_set_data.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_set_data.h	2008-05-14 17:15:58 EDT (Wed, 14 May 2008)
@@ -0,0 +1,128 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+struct operator_provides_storage {};
+struct operator_requires_copy {};
+
+template <typename T>
+class polygon_set_data {
+public:
+  typedef T coordinate_type;
+  typedef std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > > value_type;
+  typedef typename std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > >::const_iterator iterator_type;
+  typedef polygon_set_data operator_arg_type;
+  typedef operator_provides_storage operator_storage_tag;
+
+  /// default constructor
+  inline polygon_set_data() : orient_(HORIZONTAL), dirty_(false), unsorted_(false) {}
+
+  /// constructor
+  inline polygon_set_data(orientation_2d orient) : orient_(orient), dirty_(false), unsorted_(false) {}
+
+  /// constructor from an iterator pair over vertex data
+  template <class iT>
+  inline polygon_set_data(orientation_2d orient, iT input_begin, iT input_end) {
+    dirty_ = true;
+    unsorted_ = true;
+    for( ; input_begin != input_end; ++input_begin) { data_.push_back(*input_begin); }
+  }
+
+  /// copy constructor
+  inline polygon_set_data(const polygon_set_data& that) : 
+    orient_(that.orient_), data_(that.data_), dirty_(that.dirty), unsorted_(that.unsorted_) {}
+
+  /// copy with orientation change constructor
+  inline polygon_set_data(orientation_2d orient, const polygon_set_data& that) : 
+    orient_(orient), dirty_(false), unsorted_(false) {
+    if(that.orient() == orient) { (*this) = that; }
+    else if(!that.data_.empty()) {
+      dirty_ = unsorted_ = true;
+      iterator_vertex_orient_conversion<iterator_type> itr1(that.data_.begin()), iter2(that.data_.end());
+      data_.resize(that.data_.size());
+      for( ; itr1 != iter2; ++itr1) {
+        data_.push_back(*itr1);
+      }
+    }
+  }
+
+  /// destructor
+  inline ~polygon_set_data() {}
+
+  /// assignement operator
+  inline polygon_set_data& operator=(const polygon_set_data& that) {
+    if(this == &that) return *this;
+    orient_ = that.orient_;
+    data_ = that.data_;
+    dirty_ = that.dirty_;
+    unsorted_ = that.unsorted_;
+    return *this;
+  }
+
+  /// equivilence operator 
+  inline bool operator==(const polygon_set_data& p) const {
+    if(orient_ == p.orient()) {
+      clean();
+      p.clean();
+      return data_ == p.data_;
+    } else {
+      return false;
+    }
+  }
+
+  /// inequivilence operator 
+  inline bool operator!=(const polygon_set_data& p) const {
+    return !((*this) == p);
+  }
+
+  /// get iterator to begin vertex data
+  inline iterator_type begin() const {
+    return data_.begin();
+  }
+
+  /// get iterator to end vertex data
+  inline iterator_type end() const {
+    return data_.end();
+  }
+
+  const value_type& value() const {
+    return data_;
+  }
+
+  /// clear the contents of the polygon_set_data
+  inline void clear() { data_.clear(); dirty_ = unsorted_ = false; }
+
+  /// find out if Polygon set is empty
+  inline bool empty() const { return data_.empty(); }
+
+  /// find out if Polygon set is sorted
+  inline bool sorted() const { return !unsorted_; }
+
+  /// find out if Polygon set is clean
+  inline bool dirty() const { return dirty_; }
+
+  /// get the scanline orientation of the polygon set
+  inline orientation_2d orient() const { return orient_; }
+
+  void clean() const {
+    if(unsorted_) sort();
+    if(dirty_) {
+      applyBooleanOr(data_);
+      dirty_ = false;
+    }
+  }
+
+  void sort() const{
+    std::sort(data_.begin(), data_.end());
+    unsorted_ = false;
+  }
+private:
+  orientation_2d orient_;
+  mutable value_type data_;
+  mutable bool dirty_;
+  mutable bool unsorted_;
+
+};

Added: sandbox/gtl/gtl/polygon_set_traits.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_set_traits.h	2008-05-14 17:15:58 EDT (Wed, 14 May 2008)
@@ -0,0 +1,35 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+template <typename T>
+struct polygon_set_traits {
+  typedef typename T::coordinate_type coordinate_type;
+  typedef typename T::iterator_type iterator_type;
+  typedef typename T::operator_arg_type operator_arg_type;
+
+  static inline iterator_type begin(const T& polygon_set) {
+    return polygon_set.value.begin();
+  }
+
+  static inline iterator_type end(const T& polygon_set) {
+    return polygon_set.value.end();
+  }
+
+  static inline void insert(T& polygon_set, const std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > >& value,
+                            orientation_2d orient) {
+    polygon_set.insert(value, orient);
+  }
+
+  static inline orientation_2d orient(const T& polygon_set) { return polygon_set.orient(); }
+
+  static inline bool dirty(const T& polygon_set) { return polygon_set.dirty(); }
+
+  static inline bool sorted(const T& polygon_set) { return polygon_set.sorted(); }
+
+};
+

Added: sandbox/gtl/gtl/polygon_set_view.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_set_view.h	2008-05-14 17:15:58 EDT (Wed, 14 May 2008)
@@ -0,0 +1,233 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+template <typename value_type, typename arg_type>
+inline void insert_into_view_arg(value_type& dest, const arg_type& arg, orientation_2d orient) {
+  typedef typename polygon_set_traits<arg_type>::iterator_type literator;
+  literator itr1, itr2;
+  itr1 = polygon_set_traits<arg_type>::begin(arg);
+  itr2 = polygon_set_traits<arg_type>::end(arg);
+  if(polygon_set_traits<arg_type>::orient(arg) == orient) {
+    for( ; itr1 != itr2; ++itr1) {
+      dest.push_back(*itr1);
+    }
+    if(!polygon_set_traits<arg_type>::sorted(arg)) std::sort(dest.begin(), dest.end());
+  } else {
+    iterator_vertex_orient_conversion<literator> citr2(itr2);
+    for(iterator_vertex_orient_conversion<literator> citr1(itr1); citr1 != citr2; ++citr1) {
+      dest.push_back(*citr1);
+    }
+    std::sort(dest.begin(), dest.end());
+  }
+}
+
+
+template <typename ltype, typename rtype, typename op_type, typename ltag, typename rtag>
+class polygon_set_view {
+public:
+  typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
+  typedef std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > > value_type;
+  typedef typename value_type::iterator iterator_type;
+  typedef polygon_set_view operator_arg_type;
+  typedef operator_provides_storage operator_storage_tag;
+private:
+  const ltype& lvalue_;
+  const rtype& rvalue_;
+  op_type op_;
+  orientation_2d orient_;
+  mutable value_type output_;
+public:
+  polygon_set_view(const ltype& lvalue,
+                   const rtype& rvalue,
+                   orientation_2d orient,
+                   op_type op) :
+    lvalue_(lvalue), rvalue_(rvalue), orient_(orient), op_(op) {}
+
+  /// get iterator to begin vertex data
+  const value_type& value() const {
+    if(output_.empty()) {
+      value_type linput_;
+      value_type rinput_;
+      insert_into_view_arg(linput_, lvalue_, orient_);
+      insert_into_view_arg(rinput_, rvalue_, orient_);
+      boolean_op::applyBooleanBinaryOp(output_, linput_, rinput_, boolean_op::BinaryCount<op_type>()); 
+    }
+    return output_;
+  }
+
+  orientation_2d orient() const { return orient_; }
+  bool dirty() const { return false; } //result of a boolean is clean
+  bool sorted() const { return true; } //result of a boolean is sorted
+
+  //insert is not inteded to be called because a view is read only
+  void insert(const value_type& value,
+              orientation_2d orient) const {
+    //throw a helpful exception
+  }
+  void sort() const {} //is always sorted
+};
+
+template <typename ltype, typename rtype, typename op_type>
+class polygon_set_view<ltype, rtype, op_type, operator_provides_storage, operator_provides_storage> {
+public:
+  typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
+  typedef std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > > value_type;
+  typedef typename value_type::iterator iterator_type;
+  typedef polygon_set_view operator_arg_type;
+  typedef operator_provides_storage operator_storage_tag;
+private:
+  const ltype& lvalue_;
+  const rtype& rvalue_;
+  op_type op_;
+  orientation_2d orient_;
+  mutable value_type output_;
+public:
+  polygon_set_view(const ltype& lvalue,
+                   const rtype& rvalue,
+                   orientation_2d orient,
+                   op_type op) :
+    lvalue_(lvalue), rvalue_(rvalue), orient_(orient), op_(op) {}
+
+  /// get iterator to begin vertex data
+  const value_type& value() const {
+    if(output_.empty()) {
+      value_type linput_;
+      value_type rinput_;
+      if(orient_ != lvalue_.orient()) {
+        insert_into_view_arg(linput_, lvalue_, orient_);
+        if(orient_ != rvalue_.orient()) {
+          insert_into_view_arg(rinput_, rvalue_, orient_);
+          boolean_op::applyBooleanBinaryOp(output_, linput_, rinput_, boolean_op::BinaryCount<op_type>()); 
+        } else {
+          boolean_op::applyBooleanBinaryOp(output_, linput_, rvalue_.value(), boolean_op::BinaryCount<op_type>()); 
+        }
+      } else {
+        if(!lvalue_.sorted()) lvalue_.sort();
+        if(orient_ != rvalue_.orient()) {
+          insert_into_view_arg(rinput_, rvalue_, orient_);
+          boolean_op::applyBooleanBinaryOp(output_, lvalue_.value(), rinput_, boolean_op::BinaryCount<op_type>()); 
+        } else {
+          if(!rvalue_.sorted()) rvalue_.sort();
+          boolean_op::applyBooleanBinaryOp(output_, lvalue_.value(), rvalue_.value(), boolean_op::BinaryCount<op_type>()); 
+        }
+      }
+    }
+    return output_;
+  }
+
+  orientation_2d orient() const { return orient_; }
+  bool dirty() const { return false; } //result of a boolean is clean
+  bool sorted() const { return true; } //result of a boolean is sorted
+
+  //insert is not inteded to be called because a view is read only
+  void insert(const value_type& value,
+              orientation_2d orient) const {
+    //throw a helpful exception
+  }
+  void sort() const {} //is always sorted
+};
+
+template <typename ltype, typename rtype, typename op_type, typename rtag>
+class polygon_set_view<ltype, rtype, op_type, operator_provides_storage, rtag> {
+public:
+  typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
+  typedef std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > > value_type;
+  typedef typename value_type::iterator iterator_type;
+  typedef polygon_set_view operator_arg_type;
+  typedef operator_provides_storage operator_storage_tag;
+private:
+  const ltype& lvalue_;
+  const rtype& rvalue_;
+  op_type op_;
+  orientation_2d orient_;
+  mutable value_type output_;
+public:
+  polygon_set_view(const ltype& lvalue,
+                   const rtype& rvalue,
+                   orientation_2d orient,
+                   op_type op) :
+    lvalue_(lvalue), rvalue_(rvalue), orient_(orient), op_(op) {}
+
+  /// get iterator to begin vertex data
+  const value_type& value() const {
+    if(output_.empty()) {
+      value_type linput_;
+      value_type rinput_;
+      insert_into_view_arg(rinput_, rvalue_, orient_);
+      if(orient_ != lvalue_.orient()) {
+        insert_into_view_arg(linput_, lvalue_, orient_);
+        boolean_op::applyBooleanBinaryOp(output_, linput_, rinput_, boolean_op::BinaryCount<op_type>()); 
+      } else {
+        if(!lvalue_.sorted()) lvalue_.sort();
+        boolean_op::applyBooleanBinaryOp(output_, lvalue_.value(), rinput_, boolean_op::BinaryCount<op_type>()); 
+      }
+    }
+    return output_;
+  }
+
+  orientation_2d orient() const { return orient_; }
+  bool dirty() const { return false; } //result of a boolean is clean
+  bool sorted() const { return true; } //result of a boolean is sorted
+
+  //insert is not inteded to be called because a view is read only
+  void insert(const value_type& value,
+              orientation_2d orient) const {
+    //throw a helpful exception
+  }
+  void sort() const {} //is always sorted
+};
+
+template <typename ltype, typename rtype, typename op_type, typename ltag>
+class polygon_set_view<ltype, rtype, op_type, ltag, operator_provides_storage> {
+public:
+  typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
+  typedef std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > > value_type;
+  typedef typename value_type::iterator iterator_type;
+  typedef polygon_set_view operator_arg_type;
+private:
+  const ltype& lvalue_;
+  const rtype& rvalue_;
+  op_type op_;
+  orientation_2d orient_;
+  mutable value_type output_;
+  mutable value_type linput_;
+public:
+  polygon_set_view(const ltype& lvalue,
+                   const rtype& rvalue,
+                   orientation_2d orient,
+                   op_type op) :
+    lvalue_(lvalue), rvalue_(rvalue), orient_(orient), op_(op) {}
+
+  /// get iterator to begin vertex data
+  const value_type& value() const {
+    if(output_.empty()) {
+      value_type linput_;
+      value_type rinput_;
+      insert_into_view_arg(linput_, lvalue_, orient_);
+      if(orient_ != lvalue_.orient()) {
+        insert_into_view_arg(rinput_, rvalue_, orient_);
+        boolean_op::applyBooleanBinaryOp(output_, linput_, rinput_, boolean_op::BinaryCount<op_type>()); 
+      } else {
+        if(!rvalue_.sorted()) rvalue_.sort();
+        boolean_op::applyBooleanBinaryOp(output_, linput_, rvalue_.value(), boolean_op::BinaryCount<op_type>()); 
+      }
+    }
+    return output_;
+  }
+
+  orientation_2d orient() const { return orient_; }
+  bool dirty() const { return false; } //result of a boolean is clean
+  bool sorted() const { return true; } //result of a boolean is sorted
+
+  //insert is not inteded to be called because a view is read only
+  void insert(const value_type& value,
+              orientation_2d orient) const {
+    //throw a helpful exception
+  }
+  void sort() const {} //is always sorted
+};

Modified: sandbox/gtl/gtl/polygon_with_holes_concept.h
==============================================================================
--- sandbox/gtl/gtl/polygon_with_holes_concept.h	(original)
+++ sandbox/gtl/gtl/polygon_with_holes_concept.h	2008-05-14 17:15:58 EDT (Wed, 14 May 2008)
@@ -39,7 +39,7 @@
 
   template <typename polygon_with_holes_type_1, typename polygon_with_holes_type_2>
   static polygon_with_holes_type_1& assign(polygon_with_holes_type_1& lvalue, const polygon_with_holes_type_2& rvalue) {
-    set(lvalue, begin(rvalue), end(rvalue));
+    set(lvalue, polygon_concept::begin(rvalue), polygon_concept::end(rvalue));
     set_holes(lvalue, begin_holes(rvalue), end_holes(rvalue));
     return lvalue;
   }