CGAL improvement backported from CDT_3 branch

Arrangement_on_surface_2/include/CGAL/Arrangement_on_surface_2.h

@@ -1043,7 +1043,7 @@ class Arrangement_on_surface_2 {
   }
 
   /*!
-  returns a range over handles of the arrangement vertices .
+  returns a range over handles of the arrangement vertices.
   */
   Iterator_range<Prevent_deref<Vertex_iterator> >
   vertex_handles()
@@ -1068,7 +1068,7 @@ class Arrangement_on_surface_2 {
   }
 
   /*!
-  returns a const range (model of `ConstRange`) over handles of the arrangement vertices .
+  returns a const range (model of `ConstRange`) over handles of the arrangement vertices.
   */
   Iterator_range<Prevent_deref<Vertex_const_iterator> >
   vertex_handles() const
@@ -1098,7 +1098,7 @@ class Arrangement_on_surface_2 {
   }
 
   /*!
-  returns a range over handles of the arrangement halfedges .
+  returns a range over handles of the arrangement halfedges.
   */
   Iterator_range<Prevent_deref<Halfedge_iterator> >
   halfedge_handles()
@@ -1122,7 +1122,7 @@ class Arrangement_on_surface_2 {
                                     _Is_valid_halfedge(&m_topol_traits)));
   }
   /*!
-  returns a const range (model of `ConstRange`) over handles of the arrangement halfedges .
+  returns a const range (model of `ConstRange`) over handles of the arrangement halfedges.
   */
   Iterator_range<Prevent_deref<Halfedge_const_iterator> >
   halfedge_handles() const
@@ -1149,7 +1149,7 @@ class Arrangement_on_surface_2 {
   }
 
   /*!
-  returns a range over handles of the arrangement edges .
+  returns a range over handles of the arrangement edges.
   */
   Iterator_range<Prevent_deref<Edge_iterator> >
   edge_handles()
@@ -1172,7 +1172,7 @@ class Arrangement_on_surface_2 {
   }
 
   /*!
-  returns a const range (model of `ConstRange`) over handles of the arrangement edges .
+  returns a const range (model of `ConstRange`) over handles of the arrangement edges.
   */
   Iterator_range<Prevent_deref<Edge_const_iterator> >
   edge_handles() const
@@ -1199,7 +1199,7 @@ class Arrangement_on_surface_2 {
   }
 
   /*!
-  returns a range over handles of the arrangement faces .
+  returns a range over handles of the arrangement faces.
   */
   Iterator_range<Prevent_deref<Face_iterator> >
   face_handles()
@@ -1221,7 +1221,7 @@ class Arrangement_on_surface_2 {
   }
 
   /*!
-  returns a const range (model of `ConstRange`) over handles of the arrangement faces .
+  returns a const range (model of `ConstRange`) over handles of the arrangement faces.
   */
   Iterator_range<Prevent_deref<Face_const_iterator> >
   face_handles() const

Circulator/include/CGAL/circulator.h

@@ -698,14 +698,18 @@ typedef Iterator_from_circulator< C, const_reference, const_pointer>
 };
 template <class Container>
 class Circulator_from_container {
+    static auto begin(Container* c) {
+        using std::begin;
+        return begin(*c);
+    }
+
+    static auto end(Container* c) {
+        using std::end;
+        return end(*c);
+    }
+
     typedef Circulator_from_container<Container>      Self;
-    typedef typename Container::iterator              container_iterator;
-    typedef typename Container::const_iterator        container_const_iterator;
-    typedef std::conditional_t<
-        std::is_const<Container>::value,
-        container_const_iterator,
-        container_iterator
-        >                                             iterator;
+    using iterator = decltype(begin(std::declval<Container*>()));
     typedef std::iterator_traits<iterator>            iterator_traits;
 public:
     typedef typename iterator_traits::value_type      value_type;
@@ -717,7 +721,7 @@ class Circulator_from_container {
         typename iterator_traits::iterator_category
         >::iterator_category                          iterator_category;
 
-    typedef typename Container::size_type size_type;
+    using size_type = decltype(std::size(std::declval<Container&>()));
 private:
     Container*     ctnr;
     iterator  i;
@@ -734,27 +738,27 @@ class Circulator_from_container {
     bool operator==( std::nullptr_t p) const {
         CGAL_USE(p);
         CGAL_assertion( p == nullptr);
-        return (ctnr == nullptr) || (ctnr->begin() == ctnr->end());
+        return (ctnr == nullptr) || (begin(ctnr) == end(ctnr));
     }
     bool operator!=( std::nullptr_t p) const { return !(*this == p); }
     bool operator==( const Self& c) const { return i == c.i; }
     bool operator!=( const Self& c) const { return !(*this == c); }
     reference  operator*() const {
         CGAL_assertion( ctnr != nullptr);
-        CGAL_assertion( i != ctnr->end());
+        CGAL_assertion( i != end(ctnr));
         return *i;
     }
     pointer  operator->() const {
         CGAL_assertion( ctnr != nullptr);
-        CGAL_assertion( i != ctnr->end());
+        CGAL_assertion( i != end(ctnr));
         return i.operator->();
     }
     Self& operator++() {
         CGAL_assertion( ctnr != nullptr);
-        CGAL_assertion( i != ctnr->end());
+        CGAL_assertion( i != end(ctnr));
         ++i;
-        if ( i == ctnr->end())
-            i = ctnr->begin();
+        if ( i == end(ctnr))
+            i = begin(ctnr);
         return *this;
     }
     Self operator++(int) {
@@ -764,9 +768,9 @@ class Circulator_from_container {
     }
     Self& operator--() {
         CGAL_assertion( ctnr != nullptr);
-        CGAL_assertion( i != ctnr->end());
-        if ( i == ctnr->begin())
-            i = ctnr->end();
+        CGAL_assertion( i != end(ctnr));
+        if ( i == begin(ctnr))
+            i = end(ctnr);
         --i;
         return *this;
     }
@@ -777,15 +781,15 @@ class Circulator_from_container {
     }
     Self& operator+=( difference_type n) {
         CGAL_assertion( ctnr != nullptr);
-        CGAL_assertion( i != ctnr->end());
-        typename Container::difference_type j    = i - ctnr->begin();
+        CGAL_assertion( i != end(ctnr));
+        typename Container::difference_type j    = i - begin(ctnr);
         typename Container::difference_type size = ctnr->size();
         CGAL_assertion( j    >= 0);
         CGAL_assertion( size >= 0);
         j = non_negative_mod( j + n, size);
         CGAL_assertion( j >= 0);
         CGAL_assertion( j < size);
-        i = ctnr->begin() + j;
+        i = begin(ctnr) + j;
         return *this;
     }
     Self operator+( difference_type n) const {

Hash_map/include/CGAL/Hash_map/internal/chained_map.h

@@ -19,6 +19,8 @@
 #include <CGAL/memory.h>
 #include <iostream>
 #include <limits>
+#include <type_traits>
+#include <utility>
 
 namespace CGAL {
 
@@ -85,6 +87,10 @@ class chained_map
    chained_map(std::size_t n = default_size, const T& d = T());
    chained_map(const chained_map<T, Allocator>& D);
    chained_map& operator=(const chained_map<T, Allocator>& D);
+   chained_map(chained_map<T, Allocator>&& D)
+     noexcept(std::is_nothrow_move_constructible_v<Allocator> && std::is_nothrow_move_constructible_v<T>);
+   chained_map& operator=(chained_map<T, Allocator>&& D)
+     noexcept(std::is_nothrow_move_assignable_v<Allocator> && std::is_nothrow_move_assignable_v<T>);
 
    void reserve(std::size_t n);
    void clear();
@@ -246,6 +252,18 @@ chained_map<T, Allocator>::chained_map(const chained_map<T, Allocator>& D)
     }
   }
 }
+template <typename T, typename Allocator>
+chained_map<T, Allocator>::chained_map(chained_map<T, Allocator>&& D)
+  noexcept(std::is_nothrow_move_constructible_v<Allocator> && std::is_nothrow_move_constructible_v<T>)
+  : table(std::exchange(D.table, nullptr))
+  , table_end(std::exchange(D.table_end, nullptr))
+  , free(std::exchange(D.free, nullptr))
+  , table_size(std::exchange(D.table_size, 0))
+  , table_size_1(std::exchange(D.table_size_1, 0))
+  , alloc(std::move(D.alloc))
+  , reserved_size(std::exchange(D.reserved_size, 0))
+  , def(std::move(D.def))
+{}
 
 template <typename T, typename Allocator>
 chained_map<T, Allocator>& chained_map<T, Allocator>::operator=(const chained_map<T, Allocator>& D)
@@ -263,6 +281,24 @@ chained_map<T, Allocator>& chained_map<T, Allocator>::operator=(const chained_ma
   return *this;
 }
 
+template <typename T, typename Allocator>
+chained_map<T, Allocator>& chained_map<T, Allocator>::operator=(chained_map<T, Allocator>&& D)
+  noexcept(std::is_nothrow_move_assignable_v<Allocator> && std::is_nothrow_move_assignable_v<T>)
+{
+  clear();
+
+  table = std::exchange(D.table, nullptr);
+  table_end = std::exchange(D.table_end, nullptr);
+  free = std::exchange(D.free, nullptr);
+  table_size = std::exchange(D.table_size, 0);
+  table_size_1 = std::exchange(D.table_size_1, 0);
+  alloc = std::move(D.alloc);
+  reserved_size = std::exchange(D.reserved_size, 0);
+  def = std::move(D.def);
+
+  return *this;
+}
+
 template <typename T, typename Allocator>
 void chained_map<T, Allocator>::reserve(std::size_t n)
 {

Hash_map/test/Hash_map/Unique_hash_map_test.cpp

@@ -1,6 +1,7 @@
 #include <list>
 #include <CGAL/Unique_hash_map.h>
 #include <CGAL/test_macros.h>
+#include <type_traits>
 
 using namespace std;
 typedef list<int>::iterator Iterator;
@@ -24,6 +25,10 @@ int main() {
     H1[it1] = 2;
     CGAL_TEST(H1[it1]==2);
     CGAL_TEST(H2[it1]==-1);
+    static_assert(std::is_nothrow_move_constructible_v<decltype(H1)>);
+    auto H1_moved = std::move(H1);
+    CGAL_TEST(H1_moved[it1]==2);
+    CGAL_TEST(H1[it1]==H1.default_value());
     H1.clear();
     H2.clear(-2);
     H2[it1] = 2;
@@ -67,6 +72,7 @@ int main() {
     CGAL_TEST(get(H4_pmap, L.begin()) == 0);
 
     typedef CGAL::Unique_hash_map<int, int, Integer_hash_function>  Int_hmap;
+    static_assert(std::is_nothrow_move_constructible_v<Int_hmap>);
     typedef boost::associative_property_map<Int_hmap>               Int_pmap;
     Int_hmap H5(-1);
     Int_pmap H5_pmap(H5);

Installation/CHANGES.md

@@ -1,8 +1,6 @@
-Release History
-===============
+# Release History
 
-[Release 6.0](https://github.com/CGAL/cgal/releases/tag/v6.0)
------------
+## [Release 6.0](https://github.com/CGAL/cgal/releases/tag/v6.0)
 
 Release date: June 2024
 
@@ -119,6 +117,9 @@ Release date: June 2024
 ### [Surface Mesh Parameterization](https://doc.cgal.org/6.0/Manual/packages.html#PkgSurfaceMeshParameterization)
 - **Breaking change**: LSCM_parameterizer_3 needs Eigen
 
+### [2D Triangulations](https://doc.cgal.org/6.0/Manual/packages.html#PkgTriangulation2)
+-   **Breaking change**: the concept [`TriangulationTraits_2`](https://doc.cgal.org/6.0/Triangulation_2/classTriangulationTraits__2.html) now requires an additional functor `Compare_xy_2`.
+
 ### [3D Triangulations](https://doc.cgal.org/6.0/Manual/packages.html#PkgTriangulation3)
 -   Added three functions `vertices()` to the class `Triangulation_3`.
     Each of them returns an array containing the vertices of the given triangulation simplex.

Installation/include/CGAL/config.h

@@ -293,7 +293,9 @@ using std::max;
 // Macros to detect features of clang. We define them for the other
 // compilers.
 // See https://clang.llvm.org/docs/LanguageExtensions.html
-// See also https://en.cppreference.com/w/cpp/experimental/feature_test
+//
+// Some of those macro have been standardized. See C++20 feature testing:
+//   https://en.cppreference.com/w/cpp/feature_test
 #ifndef __has_feature
   #define __has_feature(x) 0  // Compatibility with non-clang compilers.
 #endif
@@ -316,6 +318,10 @@ using std::max;
   #define __has_warning(x) 0  // Compatibility with non-clang compilers.
 #endif
 
+#if __has_include(<version>)
+#  include <version>
+#endif
+
 // Macro to specify a 'unused' attribute.
 #if __has_cpp_attribute(maybe_unused)
 #  define CGAL_UNUSED [[maybe_unused]]
@@ -470,6 +476,14 @@ namespace cpp11{
 }//namespace cpp11
 } //namespace CGAL
 
+#if __cpp_lib_concepts >= 201806L
+#  define CGAL_CPP20_REQUIRE_CLAUSE(x) requires x
+#  define CGAL_TYPE_CONSTRAINT(x) x
+#else
+#  define CGAL_CPP20_REQUIRE_CLAUSE(x)
+#  define CGAL_TYPE_CONSTRAINT(x) typename
+#endif
+
 // The fallthrough attribute
 // See for clang:
 //   https://clang.llvm.org/docs/AttributeReference.html#statement-attributes
@@ -487,6 +501,10 @@ namespace cpp11{
 #  define CGAL_FALLTHROUGH while(false){}
 #endif
 
+#if __cpp_lib_format >= 201907L || (__has_include(<format>) && (__cplusplus >= 202000L || _MSVC_LANG >= 202000L))
+#  define CGAL_CAN_USE_CXX20_FORMAT 1
+#endif
+
 #ifndef CGAL_NO_ASSERTIONS
 #  define CGAL_NO_ASSERTIONS_BOOL false
 #else

Interpolation/include/CGAL/Voronoi_intersection_2_traits_3.h

@@ -291,6 +291,24 @@ class Voronoi_intersection_2_traits_3
   typedef typename Rep::Less_distance_to_point_3    Less_distance_to_point_2;
   typedef typename Rep::Compute_squared_distance_3  Compute_squared_distance_2;
 
+  struct Compare_xy_2 {
+    Compare_x_2 cx_2;
+    Compare_y_2 cy_2;
+
+    Compare_xy_2(const Compare_x_2& cx_2, const Compare_y_2& cy_2)
+      : cx_2(cx_2), cy_2(cy_2)
+    {}
+
+    Comparison_result operator()(const Point_2& p, const Point_2& q) const
+    {
+       Comparison_result res = cx_2(p, q);
+       if (res == EQUAL) {
+         return cy_2(p, q);
+       }
+       return res;
+    }
+  };
+
   //instantiations and creation of functors:
   //for the triangulation:
   Orientation_2
@@ -312,6 +330,10 @@ class Voronoi_intersection_2_traits_3
   compare_y_2_object() const
   { return Compare_y_2(normal); }
 
+  Compare_xy_2
+  compare_xy_2_object() const
+  { return Compare_xy_2(compare_x_2_object(), compare_y_2_object()); }
+
   Less_x_2
   less_x_2_object() const
   { return compare_to_less(compare_x_2_object()); }