songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Take Laurent's review into account

This commit is contained in:
Andreas Fabri 2022-10-14 11:34:34 +01:00
parent def163afc2
commit 469a0362b5
11 changed files with 103 additions and 429 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Convex_hull_2/doc/Convex_hull_2/PackageDescription.txt
View File

@ -53,13 +53,11 @@ upper hull of a set of points.
\cgalCRPSection{Assertions} \cgalCRPSection{Assertions}
The assertion flags for the convex hull and extreme point algorithms
use `CH` in their names (<I>e.g.</I>, `CGAL_CH_NO_POSTCONDITIONS`).
For the convex hull algorithms, the postcondition For the convex hull algorithms, the postcondition
check tests only convexity (if not disabled), but not containment of the check tests only convexity (if not disabled), but not containment of the
input points in the polygon or polyhedron defined by the output points. input points in the polygon or polyhedron defined by the output points.
The latter is considered an expensive checking and can be enabled by The latter is considered an expensive checking and can be enabled by
defining `CGAL_CH_CHECK_EXPENSIVE`. defining `CGAL_CHECK_EXPENSIVE`.
\cgalCRPSection{Concepts} \cgalCRPSection{Concepts}
@ -105,4 +103,3 @@ defining `CGAL_CH_CHECK_EXPENSIVE`.
*/ */

4
Convex_hull_3/doc/Convex_hull_3/PackageDescription.txt
View File

@ -52,13 +52,11 @@ points in is strongly convex or not. This chapter describes the functions
available for three dimensions. available for three dimensions.
\cgalCRPSection{Assertions} \cgalCRPSection{Assertions}
The assertion flags for the convex hull and extreme point algorithms
use `CH` in their names (<I>e.g.</I>, `CGAL_CH_NO_POSTCONDITIONS`).
For the convex hull algorithms, the postcondition For the convex hull algorithms, the postcondition
check tests only convexity (if not disabled), but not containment of the check tests only convexity (if not disabled), but not containment of the
input points in the polygon or polyhedron defined by the output points. input points in the polygon or polyhedron defined by the output points.
The latter is considered an expensive checking and can be enabled by The latter is considered an expensive checking and can be enabled by
defining `CGAL_CH_CHECK_EXPENSIVE`. defining `CGAL_CHECK_EXPENSIVE`.
\cgalClassifedRefPages \cgalClassifedRefPages

14
Inscribed_areas/doc/Inscribed_areas/PackageDescription.txt
View File

@ -22,18 +22,11 @@
\cgalPkgDescriptionEnd \cgalPkgDescriptionEnd
\cgalCRPSection{Assertions}
The optimization code uses infix `OPTIMISATION` in the assertions,
e.g. defining the compiler flag
`CGAL_OPTIMISATION_NO_PRECONDITIONS` switches precondition
checking off, cf. Section \ref secchecks.
\cgalClassifedRefPages \cgalClassifedRefPages
- `CGAL::maximum_area_inscribed_k_gon_2` - `CGAL::maximum_area_inscribed_k_gon_2()`
- `CGAL::maximum_perimeter_inscribed_k_gon_2` - `CGAL::maximum_perimeter_inscribed_k_gon_2()`
- `CGAL::extremal_polygon_2` - `CGAL::extremal_polygon_2()`
- `CGAL::Largest_empty_iso_rectangle_2<T>` - `CGAL::Largest_empty_iso_rectangle_2<T>`
- `CGAL::Extremal_polygon_area_traits_2<K>` - `CGAL::Extremal_polygon_area_traits_2<K>`
- `CGAL::Extremal_polygon_perimeter_traits_2<K>` - `CGAL::Extremal_polygon_perimeter_traits_2<K>`
@ -41,4 +34,3 @@ checking off, cf. Section \ref secchecks.
- `LargestEmptyIsoRectangleTraits_2` - `LargestEmptyIsoRectangleTraits_2`
*/ */

4
Installation/CHANGES.md
View File

@ -6,6 +6,10 @@ Release History
Release date: December 2022 Release date: December 2022
### General Changes
- The per package assertions, pre- and postconditions are no longer supported.
### [Combinatorial Maps](https://doc.cgal.org/5.6/Manual/packages.html#PkgCombinatorialMaps) [Generalized Maps](https://doc.cgal.org/5.6/Manual/packages.html#PkgGeneralizedMaps) [Linear Cell Complex](https://doc.cgal.org/5.6/Manual/packages.html#PkgLinearCellComplex) ### [Combinatorial Maps](https://doc.cgal.org/5.6/Manual/packages.html#PkgCombinatorialMaps) [Generalized Maps](https://doc.cgal.org/5.6/Manual/packages.html#PkgGeneralizedMaps) [Linear Cell Complex](https://doc.cgal.org/5.6/Manual/packages.html#PkgLinearCellComplex)
- Added a version that uses indices instead of handles as dart and attribute descriptors. As the indices are integers convertible from and to `std::size_t`, they can be used as index into vectors which store properties. To use the index version, `Use_index` must be defined and be equal to `CGAL::Tag_true` in the item class. - Added a version that uses indices instead of handles as dart and attribute descriptors. As the indices are integers convertible from and to `std::size_t`, they can be used as index into vectors which store properties. To use the index version, `Use_index` must be defined and be equal to `CGAL::Tag_true` in the item class.

11
Matrix_search/doc/Matrix_search/PackageDescription.txt
View File

@ -23,24 +23,17 @@
This chapter describes concepts, classes, and functions for This chapter describes concepts, classes, and functions for
monotone and sorted matrix search. monotone and sorted matrix search.
\cgalCRPSection{Assertions}
The optimization code uses infix `OPTIMISATION` in the assertions,
e.g. defining the compiler flag
`CGAL_OPTIMISATION_NO_PRECONDITIONS` switches precondition
checking off, cf. Section \ref secchecks "Checks" in the chapter on STL extensions.
\cgalClassifedRefPages \cgalClassifedRefPages
- `CGAL::monotone_matrix_search` - `CGAL::monotone_matrix_search()`
- `CGAL::Dynamic_matrix<M>` - `CGAL::Dynamic_matrix<M>`
- `MonotoneMatrixSearchTraits` - `MonotoneMatrixSearchTraits`
- `BasicMatrix` - `BasicMatrix`
- `CGAL::sorted_matrix_search` - `CGAL::sorted_matrix_search()`
- `CGAL::Sorted_matrix_search_traits_adaptor<F,M>` - `CGAL::Sorted_matrix_search_traits_adaptor<F,M>`
- `SortedMatrixSearchTraits` - `SortedMatrixSearchTraits`
*/ */

3
Partition_2/doc/Partition_2/PackageDescription.txt
View File

@ -53,8 +53,6 @@ primitive types and predicates used by the algorithms.
\cgalCRPSection{Assertions} \cgalCRPSection{Assertions}
The assertion flags for this package use `PARTITION` in their names
(<I>e.g.</I>, `CGAL_PARTITION_NO_POSTCONDITIONS`).
The precondition checks for the planar polygon partitioning functions The precondition checks for the planar polygon partitioning functions
are: counterclockwise ordering of the input vertices and simplicity of the are: counterclockwise ordering of the input vertices and simplicity of the
polygon these vertices represent. polygon these vertices represent.
@ -99,4 +97,3 @@ original polygon).
- `CGAL::y_monotone_partition_is_valid_2()` - `CGAL::y_monotone_partition_is_valid_2()`
*/ */

4
Polygon/doc/Polygon/PackageDescription.txt
View File

@ -40,10 +40,6 @@
\cgalPkgShortInfoEnd \cgalPkgShortInfoEnd
\cgalPkgDescriptionEnd \cgalPkgDescriptionEnd
\cgalCRPSection{Assertions}
The assertion flags for the polygons and polygon operations use
`POLYGON` in their names (<I>e.g.</I>, `CGAL_POLYGON_NO_ASSERTIONS`).
\cgalClassifedRefPages \cgalClassifedRefPages

8
Polytope_distance_d/doc/Polytope_distance_d/PackageDescription.txt
View File

@ -19,17 +19,12 @@
\cgalPkgShortInfoEnd \cgalPkgShortInfoEnd
\cgalPkgDescriptionEnd \cgalPkgDescriptionEnd
\cgalCRPSection{Assertions}
The optimization code uses infix `OPTIMISATION` in the assertions,
e.g. defining the compiler flag
`CGAL_OPTIMISATION_NO_PRECONDITIONS` switches precondition
checking off, cf. Section \ref secchecks.
\cgalClassifedRefPages \cgalClassifedRefPages
\cgalCRPSection{All Furthest Neighbors} \cgalCRPSection{All Furthest Neighbors}
- `CGAL::all_furthest_neighbors_2` - `CGAL::all_furthest_neighbors_2()`
- `AllFurthestNeighborsTraits_2` - `AllFurthestNeighborsTraits_2`
\cgalCRPSection{Width} \cgalCRPSection{Width}
@ -48,4 +43,3 @@ checking off, cf. Section \ref secchecks.
*/ */

6
STL_Extension/doc/STL_Extension/CGAL/Multiset.h
View File

@ -69,12 +69,6 @@ less-than operator (`operator<`).
\tparam Allocator the allocator type. `CGAL_ALLOCATOR` is used by default. \tparam Allocator the allocator type. `CGAL_ALLOCATOR` is used by default.
\cgalHeading{Assertions}
The assertion and precondition flags for the `Multiset` class
use `MULTISET` in their names (i.e., `CGAL_MULTISET_NO_ASSERTIONS` and
`CGAL_MULTISET_NO_PRECONDITIONS`).
\cgalHeading{Implementation} \cgalHeading{Implementation}
`Multiset` uses a proprietary implementation of a red-black tree `Multiset` uses a proprietary implementation of a red-black tree

181
STL_Extension/include/CGAL/Multiset.h
View File

@ -14,7 +14,6 @@
#include <CGAL/config.h> #include <CGAL/config.h>
#include <CGAL/assertions.h> #include <CGAL/assertions.h>
#include <CGAL/multiset_assertions.h>
#include <CGAL/enum.h> #include <CGAL/enum.h>
#include <CGAL/memory.h> #include <CGAL/memory.h>
#include <CGAL/number_utils_classes.h> #include <CGAL/number_utils_classes.h>
@ -168,7 +167,7 @@ protected:
Node* predecessor () const Node* predecessor () const
{ {
// The DUMMY_BEGIN node has no predecessor. // The DUMMY_BEGIN node has no predecessor.
CGAL_multiset_assertion (color != DUMMY_BEGIN); CGAL_assertion (color != DUMMY_BEGIN);
Node *predP; Node *predP;
@ -203,7 +202,7 @@ protected:
Node* successor () const Node* successor () const
{ {
// The DUMMY_END node has no successor. // The DUMMY_END node has no successor.
CGAL_multiset_assertion (color != DUMMY_END); CGAL_assertion (color != DUMMY_END);
Node *succP; Node *succP;
@ -346,7 +345,7 @@ public:
/*! Increment operator (prefix notation). */ /*! Increment operator (prefix notation). */
iterator& operator++ () iterator& operator++ ()
{ {
CGAL_multiset_precondition (nodeP != nullptr); CGAL_precondition (nodeP != nullptr);
nodeP = nodeP->successor(); nodeP = nodeP->successor();
return (*this); return (*this);
@ -355,7 +354,7 @@ public:
/*! Increment operator (postfix notation). */ /*! Increment operator (postfix notation). */
iterator operator++ (int ) iterator operator++ (int )
{ {
CGAL_multiset_precondition (nodeP != nullptr); CGAL_precondition (nodeP != nullptr);
iterator temp = *this; iterator temp = *this;
@ -366,7 +365,7 @@ public:
/*! Decrement operator (prefix notation). */ /*! Decrement operator (prefix notation). */
iterator& operator-- () iterator& operator-- ()
{ {
CGAL_multiset_precondition (nodeP != nullptr); CGAL_precondition (nodeP != nullptr);
nodeP = nodeP->predecessor(); nodeP = nodeP->predecessor();
return (*this); return (*this);
@ -375,7 +374,7 @@ public:
/*! Decrement operator (postfix notation). */ /*! Decrement operator (postfix notation). */
iterator operator-- (int ) iterator operator-- (int )
{ {
CGAL_multiset_precondition (nodeP != nullptr); CGAL_precondition (nodeP != nullptr);
iterator temp = *this; iterator temp = *this;
@ -388,7 +387,7 @@ public:
*/ */
reference operator* () const reference operator* () const
{ {
CGAL_multiset_precondition (nodeP != nullptr && nodeP->is_valid()); CGAL_precondition (nodeP != nullptr && nodeP->is_valid());
return (nodeP->object); return (nodeP->object);
} }
@ -398,7 +397,7 @@ public:
*/ */
pointer operator-> () const pointer operator-> () const
{ {
CGAL_multiset_precondition (nodeP != nullptr && nodeP->is_valid()); CGAL_precondition (nodeP != nullptr && nodeP->is_valid());
return (&(nodeP->object)); return (&(nodeP->object));
} }
@ -461,7 +460,7 @@ public:
/*! Increment operator (prefix notation). */ /*! Increment operator (prefix notation). */
const_iterator& operator++ () const_iterator& operator++ ()
{ {
CGAL_multiset_precondition (nodeP != nullptr); CGAL_precondition (nodeP != nullptr);
nodeP = nodeP->successor(); nodeP = nodeP->successor();
return (*this); return (*this);
@ -470,7 +469,7 @@ public:
/*! Increment operator (postfix notation). */ /*! Increment operator (postfix notation). */
const_iterator operator++ (int ) const_iterator operator++ (int )
{ {
CGAL_multiset_precondition (nodeP != nullptr); CGAL_precondition (nodeP != nullptr);
const_iterator temp = *this; const_iterator temp = *this;
@ -481,7 +480,7 @@ public:
/*! Decrement operator (prefix notation). */ /*! Decrement operator (prefix notation). */
const_iterator& operator-- () const_iterator& operator-- ()
{ {
CGAL_multiset_precondition (nodeP != nullptr); CGAL_precondition (nodeP != nullptr);
nodeP = nodeP->predecessor(); nodeP = nodeP->predecessor();
return (*this); return (*this);
@ -490,7 +489,7 @@ public:
/*! Decrement operator (postfix notation). */ /*! Decrement operator (postfix notation). */
const_iterator operator-- (int ) const_iterator operator-- (int )
{ {
CGAL_multiset_precondition (nodeP != nullptr); CGAL_precondition (nodeP != nullptr);
const_iterator temp = *this; const_iterator temp = *this;
@ -503,7 +502,7 @@ public:
*/ */
reference operator* () const reference operator* () const
{ {
CGAL_multiset_precondition (nodeP != nullptr && nodeP->is_valid()); CGAL_precondition (nodeP != nullptr && nodeP->is_valid());
return (nodeP->object); return (nodeP->object);
} }
@ -513,7 +512,7 @@ public:
*/ */
pointer operator-> () const pointer operator-> () const
{ {
CGAL_multiset_precondition (nodeP != nullptr && nodeP->is_valid()); CGAL_precondition (nodeP != nullptr && nodeP->is_valid());
return (&(nodeP->object)); return (&(nodeP->object));
} }
@ -1956,7 +1955,7 @@ Multiset<Type, Compare, Allocator, UseCompactContainer>::insert (iterator positi
{ {
Node *nodeP = position.nodeP; Node *nodeP = position.nodeP;
CGAL_multiset_precondition (_is_valid (nodeP)); CGAL_precondition (_is_valid (nodeP));
// Compare the object to the one stored at the given node in order to decide // Compare the object to the one stored at the given node in order to decide
// in which direction to proceed. // in which direction to proceed.
@ -2033,7 +2032,7 @@ Multiset<Type, Compare, Allocator, UseCompactContainer>::insert_after (iterator
Node *nodeP = position.nodeP; Node *nodeP = position.nodeP;
// In case we are given a nullptr node, object should be the tree minimum. // In case we are given a nullptr node, object should be the tree minimum.
CGAL_multiset_assertion (nodeP != &endNode); CGAL_assertion (nodeP != &endNode);
if (nodeP == &beginNode) if (nodeP == &beginNode)
nodeP = nullptr; nodeP = nullptr;
@ -2042,7 +2041,7 @@ Multiset<Type, Compare, Allocator, UseCompactContainer>::insert_after (iterator
{ {
// In case the tree is empty, make sure that we did not receive a valid // In case the tree is empty, make sure that we did not receive a valid
// iterator. // iterator.
CGAL_multiset_precondition (nodeP == nullptr); CGAL_precondition (nodeP == nullptr);
// Assign a new root node. Notice that the root is always black. // Assign a new root node. Notice that the root is always black.
rootP = _allocate_node (object, Node::BLACK); rootP = _allocate_node (object, Node::BLACK);
@ -2070,7 +2069,7 @@ Multiset<Type, Compare, Allocator, UseCompactContainer>::insert_after (iterator
// child of the current minimal leaf. // child of the current minimal leaf.
parentP = beginNode.parentP; parentP = beginNode.parentP;
CGAL_multiset_precondition (comp_f(object, parentP->object) != LARGER); CGAL_precondition (comp_f(object, parentP->object) != LARGER);
parentP->leftP = newNodeP; parentP->leftP = newNodeP;
@ -2081,9 +2080,9 @@ Multiset<Type, Compare, Allocator, UseCompactContainer>::insert_after (iterator
else else
{ {
// Make sure the insertion does not violate the tree order. // Make sure the insertion does not violate the tree order.
CGAL_multiset_precondition_code (Node *_succP = nodeP->successor()); CGAL_precondition_code (Node *_succP = nodeP->successor());
CGAL_multiset_precondition (comp_f(object, nodeP->object) != SMALLER); CGAL_precondition (comp_f(object, nodeP->object) != SMALLER);
CGAL_multiset_precondition (! _succP->is_valid() || CGAL_precondition (! _succP->is_valid() ||
comp_f(object, _succP->object) != LARGER); comp_f(object, _succP->object) != LARGER);
// In case given node has no right child, place the new node as its // In case given node has no right child, place the new node as its
@ -2131,7 +2130,7 @@ Multiset<Type, Compare, Allocator, UseCompactContainer>::insert_before (iterator
Node *nodeP = position.nodeP; Node *nodeP = position.nodeP;
// In case we are given a nullptr node, object should be the tree maximum. // In case we are given a nullptr node, object should be the tree maximum.
CGAL_multiset_assertion (nodeP != &beginNode); CGAL_assertion (nodeP != &beginNode);
if (nodeP == &endNode) if (nodeP == &endNode)
nodeP = nullptr; nodeP = nullptr;
@ -2140,7 +2139,7 @@ Multiset<Type, Compare, Allocator, UseCompactContainer>::insert_before (iterator
{ {
// In case the tree is empty, make sure that we did not receive a valid // In case the tree is empty, make sure that we did not receive a valid
// iterator. // iterator.
CGAL_multiset_precondition (nodeP == nullptr); CGAL_precondition (nodeP == nullptr);
// Assign a new root node. Notice that the root is always black. // Assign a new root node. Notice that the root is always black.
rootP = _allocate_node(object, Node::BLACK); rootP = _allocate_node(object, Node::BLACK);
@ -2168,7 +2167,7 @@ Multiset<Type, Compare, Allocator, UseCompactContainer>::insert_before (iterator
// child of the current maximal leaf. // child of the current maximal leaf.
parentP = endNode.parentP; parentP = endNode.parentP;
CGAL_multiset_precondition (comp_f(object, parentP->object) != SMALLER); CGAL_precondition (comp_f(object, parentP->object) != SMALLER);
parentP->rightP = newNodeP; parentP->rightP = newNodeP;
@ -2179,9 +2178,9 @@ Multiset<Type, Compare, Allocator, UseCompactContainer>::insert_before (iterator
else else
{ {
// Make sure the insertion does not violate the tree order. // Make sure the insertion does not violate the tree order.
CGAL_multiset_precondition_code (Node *_predP = nodeP->predecessor()); CGAL_precondition_code (Node *_predP = nodeP->predecessor());
CGAL_multiset_precondition (comp_f(object, nodeP->object) != LARGER); CGAL_precondition (comp_f(object, nodeP->object) != LARGER);
CGAL_multiset_precondition (! _predP->is_valid() || CGAL_precondition (! _predP->is_valid() ||
comp_f(object, _predP->object) != SMALLER); comp_f(object, _predP->object) != SMALLER);
// In case given node has no left child, place the new node as its // In case given node has no left child, place the new node as its
@ -2258,7 +2257,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::erase (iterator po
{ {
Node *nodeP = position.nodeP; Node *nodeP = position.nodeP;
CGAL_multiset_precondition (_is_valid (nodeP)); CGAL_precondition (_is_valid (nodeP));
_remove_at (nodeP); _remove_at (nodeP);
return; return;
@ -2294,16 +2293,16 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::replace (iterator
{ {
Node *nodeP = position.nodeP; Node *nodeP = position.nodeP;
CGAL_multiset_precondition (_is_valid (nodeP)); CGAL_precondition (_is_valid (nodeP));
// Make sure the replacement does not violate the tree order. // Make sure the replacement does not violate the tree order.
CGAL_multiset_precondition_code (Node *_succP = nodeP->successor()); CGAL_precondition_code (Node *_succP = nodeP->successor());
CGAL_multiset_precondition (_succP == nullptr || CGAL_precondition (_succP == nullptr ||
_succP->color == Node::DUMMY_END || _succP->color == Node::DUMMY_END ||
comp_f(object, _succP->object) != LARGER); comp_f(object, _succP->object) != LARGER);
CGAL_multiset_precondition_code (Node *_predP = nodeP->predecessor()); CGAL_precondition_code (Node *_predP = nodeP->predecessor());
CGAL_multiset_precondition (_predP == nullptr || CGAL_precondition (_predP == nullptr ||
_predP->color == Node::DUMMY_BEGIN || _predP->color == Node::DUMMY_BEGIN ||
comp_f(object, _predP->object) != SMALLER); comp_f(object, _predP->object) != SMALLER);
@ -2323,30 +2322,30 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::swap (iterator pos
Node *node1_P = pos1.nodeP; Node *node1_P = pos1.nodeP;
Node *node2_P = pos2.nodeP; Node *node2_P = pos2.nodeP;
CGAL_multiset_precondition (_is_valid (node1_P)); CGAL_precondition (_is_valid (node1_P));
CGAL_multiset_precondition (_is_valid (node2_P)); CGAL_precondition (_is_valid (node2_P));
if (node1_P == node2_P) if (node1_P == node2_P)
return; return;
// Make sure the swap does not violate the tree order. // Make sure the swap does not violate the tree order.
CGAL_multiset_precondition_code (Node *_succ1_P = node1_P->successor()); CGAL_precondition_code (Node *_succ1_P = node1_P->successor());
CGAL_multiset_precondition (! _is_valid (_succ1_P) || CGAL_precondition (! _is_valid (_succ1_P) ||
comp_f (node2_P->object, comp_f (node2_P->object,
_succ1_P->object) != LARGER); _succ1_P->object) != LARGER);
CGAL_multiset_precondition_code (Node *_pred1_P = node1_P->predecessor()); CGAL_precondition_code (Node *_pred1_P = node1_P->predecessor());
CGAL_multiset_precondition (! _is_valid (_pred1_P) || CGAL_precondition (! _is_valid (_pred1_P) ||
comp_f (node2_P->object, comp_f (node2_P->object,
_pred1_P->object) != SMALLER); _pred1_P->object) != SMALLER);
CGAL_multiset_precondition_code (Node *_succ2_P = node2_P->successor()); CGAL_precondition_code (Node *_succ2_P = node2_P->successor());
CGAL_multiset_precondition (! _is_valid (_succ2_P) || CGAL_precondition (! _is_valid (_succ2_P) ||
comp_f (node1_P->object, comp_f (node1_P->object,
_succ2_P->object) != LARGER); _succ2_P->object) != LARGER);
CGAL_multiset_precondition_code (Node *_pred2_P = node2_P->predecessor()); CGAL_precondition_code (Node *_pred2_P = node2_P->predecessor());
CGAL_multiset_precondition (! _is_valid (_pred2_P) || CGAL_precondition (! _is_valid (_pred2_P) ||
comp_f (node1_P->object, comp_f (node1_P->object,
_pred2_P->object) != SMALLER); _pred2_P->object) != SMALLER);
@ -2438,13 +2437,13 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::catenate (Self& tr
if (min2_P == nullptr) if (min2_P == nullptr)
{ {
// The other tree is empty - nothing to do. // The other tree is empty - nothing to do.
CGAL_multiset_assertion (tree.rootP == nullptr); CGAL_assertion (tree.rootP == nullptr);
return; return;
} }
else if (max1_P == nullptr) else if (max1_P == nullptr)
{ {
// Our tree is empty: Copy all other tree properties to our tree. // Our tree is empty: Copy all other tree properties to our tree.
CGAL_multiset_assertion (rootP == nullptr); CGAL_assertion (rootP == nullptr);
_shallow_assign (tree); _shallow_assign (tree);
return; return;
@ -2452,12 +2451,12 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::catenate (Self& tr
// Make sure that the minimal object in the other tree is not less than the // Make sure that the minimal object in the other tree is not less than the
// maximal object in our tree. // maximal object in our tree.
CGAL_multiset_precondition (comp_f (max1_P->object, CGAL_precondition (comp_f (max1_P->object,
min2_P->object) != LARGER); min2_P->object) != LARGER);
// Make sure both tree roots black. // Make sure both tree roots black.
CGAL_multiset_assertion (_is_black (rootP)); CGAL_assertion (_is_black (rootP));
CGAL_multiset_assertion (_is_black (tree.rootP)); CGAL_assertion (_is_black (tree.rootP));
// Splice max1_P (or min2_P) from its tree, but without deleting it. // Splice max1_P (or min2_P) from its tree, but without deleting it.
Node* auxP = nullptr; Node* auxP = nullptr;
@ -2561,7 +2560,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::catenate (Self& tr
if (_is_red (node2_P)) if (_is_red (node2_P))
node2_P = node2_P->leftP; node2_P = node2_P->leftP;
CGAL_multiset_assertion (_is_valid (node2_P)); CGAL_assertion (_is_valid (node2_P));
} }
else else
{ {
@ -2578,7 +2577,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::catenate (Self& tr
if (_is_red (node1_P)) if (_is_red (node1_P))
node1_P = node1_P->rightP; node1_P = node1_P->rightP;
CGAL_multiset_assertion (_is_valid (node2_P)); CGAL_assertion (_is_valid (node2_P));
} }
// Check which one of the tree roots have we reached. // Check which one of the tree roots have we reached.
@ -2615,7 +2614,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::catenate (Self& tr
// moving auxP to be their parent. // moving auxP to be their parent.
parentP = node1_P->parentP; parentP = node1_P->parentP;
CGAL_multiset_assertion (parentP != nullptr); CGAL_assertion (parentP != nullptr);
// The catenated tree will be rooted at the current root of our tree. // The catenated tree will be rooted at the current root of our tree.
newRootP = rootP; newRootP = rootP;
@ -2670,7 +2669,7 @@ template <class Type, class Compare, typename Allocator, typename UseCompactCont
void Multiset<Type, Compare, Allocator, UseCompactContainer>::split (iterator position, void Multiset<Type, Compare, Allocator, UseCompactContainer>::split (iterator position,
Self& tree) Self& tree)
{ {
CGAL_multiset_precondition (tree.empty()); CGAL_precondition (tree.empty());
// Check the extremal cases. // Check the extremal cases.
if (position == begin()) if (position == begin())
@ -2691,7 +2690,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::split (iterator po
// is at most twice the black-height of the tree. // is at most twice the black-height of the tree.
Node *nodeP = position.nodeP; Node *nodeP = position.nodeP;
CGAL_multiset_precondition (_is_valid (nodeP)); CGAL_precondition (_is_valid (nodeP));
Node *currP = nodeP; Node *currP = nodeP;
Comparison_result *path = new Comparison_result [2 * iBlackHeight]; Comparison_result *path = new Comparison_result [2 * iBlackHeight];
@ -2708,7 +2707,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::split (iterator po
currP = currP->parentP; currP = currP->parentP;
} }
CGAL_multiset_assertion (currP == rootP); CGAL_assertion (currP == rootP);
// Now go down the path and split the tree accordingly. We also keep // Now go down the path and split the tree accordingly. We also keep
// track of the black-height of the current node. // track of the black-height of the current node.
@ -2726,7 +2725,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::split (iterator po
while (depth >= 0) while (depth >= 0)
{ {
CGAL_multiset_assertion (_is_valid (currP)); CGAL_assertion (_is_valid (currP));
// If we encounter a black node, the black-height of both its left and // If we encounter a black node, the black-height of both its left and
// right subtrees is decremented. // right subtrees is decremented.
@ -2770,8 +2769,8 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::split (iterator po
else if (_is_valid (childP)) else if (_is_valid (childP))
{ {
// Catenate T_r with the current rightTree. // Catenate T_r with the current rightTree.
CGAL_multiset_assertion (_is_valid (spineRightP) && CGAL_assertion (_is_valid (spineRightP) &&
_is_valid(auxRightP)); _is_valid(auxRightP));
// Make sure the root of T_r is black. // Make sure the root of T_r is black.
size_t iCurrRightBHeight = iCurrBHeight; size_t iCurrRightBHeight = iCurrBHeight;
@ -2784,7 +2783,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::split (iterator po
// Go down the leftmost path of rightTree until locating a black // Go down the leftmost path of rightTree until locating a black
// node whose black height is exactly iCurrRightBHeight. // node whose black height is exactly iCurrRightBHeight.
CGAL_multiset_assertion (iRightBHeight >= iCurrRightBHeight); CGAL_assertion (iRightBHeight >= iCurrRightBHeight);
while (iRightBHeight > iCurrRightBHeight) while (iRightBHeight > iCurrRightBHeight)
{ {
@ -2795,7 +2794,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::split (iterator po
if (_is_red (spineRightP)) if (_is_red (spineRightP))
spineRightP = spineRightP->leftP; spineRightP = spineRightP->leftP;
CGAL_multiset_assertion (_is_valid (spineRightP)); CGAL_assertion (_is_valid (spineRightP));
// Use the auxiliary node and make it the parent of T_r (which // Use the auxiliary node and make it the parent of T_r (which
// becomes its left sub-tree) and spineRightP (which becomes its // becomes its left sub-tree) and spineRightP (which becomes its
@ -2905,8 +2904,8 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::split (iterator po
else if (_is_valid (childP)) else if (_is_valid (childP))
{ {
// Catenate T_l with the current leftTree. // Catenate T_l with the current leftTree.
CGAL_multiset_assertion (_is_valid (spineLeftP) && CGAL_assertion (_is_valid (spineLeftP) &&
_is_valid(auxLeftP)); _is_valid(auxLeftP));
// Make sure the root of T_l is black. // Make sure the root of T_l is black.
size_t iCurrLeftBHeight = iCurrBHeight; size_t iCurrLeftBHeight = iCurrBHeight;
@ -2919,7 +2918,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::split (iterator po
// Go down the rightmost path of leftTree until locating a black // Go down the rightmost path of leftTree until locating a black
// node whose black height is exactly iCurrLeftBHeight. // node whose black height is exactly iCurrLeftBHeight.
CGAL_multiset_assertion (iLeftBHeight >= iCurrLeftBHeight); CGAL_assertion (iLeftBHeight >= iCurrLeftBHeight);
while (iLeftBHeight > iCurrLeftBHeight) while (iLeftBHeight > iCurrLeftBHeight)
{ {
@ -2930,7 +2929,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::split (iterator po
if (_is_red (spineLeftP)) if (_is_red (spineLeftP))
spineLeftP = spineLeftP->rightP; spineLeftP = spineLeftP->rightP;
CGAL_multiset_assertion (_is_valid (spineLeftP)); CGAL_assertion (_is_valid (spineLeftP));
// Use the auxiliary node and make it the parent of T_l (which // Use the auxiliary node and make it the parent of T_l (which
// becomes its right sub-tree) and spineLeftP (which becomes its // becomes its right sub-tree) and spineLeftP (which becomes its
@ -3012,7 +3011,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::split (iterator po
// It is now possible to free the path. // It is now possible to free the path.
delete[] path; delete[] path;
CGAL_multiset_assertion (auxLeftP == nullptr && auxRightP == nodeP); CGAL_assertion (auxLeftP == nullptr && auxRightP == nodeP);
// Fix the properties of the left tree: We know its minimal node is the // Fix the properties of the left tree: We know its minimal node is the
// same as the current minimum. // same as the current minimum.
@ -3020,7 +3019,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::split (iterator po
leftTree.beginNode.parentP->leftP = &(leftTree.beginNode); leftTree.beginNode.parentP->leftP = &(leftTree.beginNode);
// Traverse the rightmost path of the left tree to find the its maximum. // Traverse the rightmost path of the left tree to find the its maximum.
CGAL_multiset_assertion (_is_valid (spineLeftP)); CGAL_assertion (_is_valid (spineLeftP));
while (_is_valid (spineLeftP->rightP)) while (_is_valid (spineLeftP->rightP))
spineLeftP = spineLeftP->rightP; spineLeftP = spineLeftP->rightP;
@ -3130,7 +3129,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_shallow_clear ()
template <class Type, class Compare, typename Allocator, typename UseCompactContainer> template <class Type, class Compare, typename Allocator, typename UseCompactContainer>
void Multiset<Type, Compare, Allocator, UseCompactContainer>::_remove_at (Node* nodeP) void Multiset<Type, Compare, Allocator, UseCompactContainer>::_remove_at (Node* nodeP)
{ {
CGAL_multiset_precondition (_is_valid (nodeP)); CGAL_precondition (_is_valid (nodeP));
if (nodeP == rootP && if (nodeP == rootP &&
! _is_valid (rootP->leftP) && ! _is_valid (rootP->rightP)) ! _is_valid (rootP->leftP) && ! _is_valid (rootP->rightP))
@ -3155,7 +3154,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_remove_at (Node*
// which is the leftmost child in its right sub-tree and has at most // which is the leftmost child in its right sub-tree and has at most
// one child (it may have a right child). // one child (it may have a right child).
Node *succP = _sub_minimum (nodeP->rightP); Node *succP = _sub_minimum (nodeP->rightP);
CGAL_multiset_assertion (_is_valid (succP)); CGAL_assertion (_is_valid (succP));
// Now physically swap nodeP and its successor. Notice this may temporarily // Now physically swap nodeP and its successor. Notice this may temporarily
// violate the tree properties, but we are going to remove nodeP anyway. // violate the tree properties, but we are going to remove nodeP anyway.
@ -3169,7 +3168,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_remove_at (Node*
if (_is_valid (nodeP->leftP)) if (_is_valid (nodeP->leftP))
{ {
CGAL_multiset_assertion (! _is_valid (nodeP->rightP)); CGAL_assertion (! _is_valid (nodeP->rightP));
childP = nodeP->leftP; childP = nodeP->leftP;
} }
else else
@ -3247,8 +3246,8 @@ template <class Type, class Compare, typename Allocator, typename UseCompactCont
void Multiset<Type, Compare, Allocator, UseCompactContainer>::_swap (Node* node1_P, void Multiset<Type, Compare, Allocator, UseCompactContainer>::_swap (Node* node1_P,
Node* node2_P) Node* node2_P)
{ {
CGAL_multiset_assertion (_is_valid (node1_P)); CGAL_assertion (_is_valid (node1_P));
CGAL_multiset_assertion (_is_valid (node2_P)); CGAL_assertion (_is_valid (node2_P));
// Store the properties of the first node. // Store the properties of the first node.
typename Node::Node_color color1 = node1_P->color; typename Node::Node_color color1 = node1_P->color;
@ -3388,8 +3387,8 @@ template <class Type, class Compare, typename Allocator, typename UseCompactCont
void Multiset<Type, Compare, Allocator, UseCompactContainer>::_swap_siblings (Node* node1_P, void Multiset<Type, Compare, Allocator, UseCompactContainer>::_swap_siblings (Node* node1_P,
Node* node2_P) Node* node2_P)
{ {
CGAL_multiset_assertion (_is_valid (node1_P)); CGAL_assertion (_is_valid (node1_P));
CGAL_multiset_assertion (_is_valid (node2_P)); CGAL_assertion (_is_valid (node2_P));
// Store the properties of the first node. // Store the properties of the first node.
typename Node::Node_color color1 = node1_P->color; typename Node::Node_color color1 = node1_P->color;
@ -3422,7 +3421,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_swap_siblings (No
Node *parent_P = node1_P->parentP; Node *parent_P = node1_P->parentP;
Node *temp; Node *temp;
CGAL_multiset_assertion (parent_P == node2_P->parentP); CGAL_assertion (parent_P == node2_P->parentP);
temp = parent_P->leftP; temp = parent_P->leftP;
parent_P->leftP = parent_P->rightP; parent_P->leftP = parent_P->rightP;
@ -3464,7 +3463,7 @@ template <class Type, class Compare, typename Allocator, typename UseCompactCont
size_t Multiset<Type, Compare, Allocator, UseCompactContainer>::_sub_height size_t Multiset<Type, Compare, Allocator, UseCompactContainer>::_sub_height
(const Node* nodeP) const (const Node* nodeP) const
{ {
CGAL_multiset_assertion (_is_valid (nodeP)); CGAL_assertion (_is_valid (nodeP));
// Recursively calculate the heights of the left and right sub-trees. // Recursively calculate the heights of the left and right sub-trees.
size_t iRightHeight = 0; size_t iRightHeight = 0;
@ -3552,7 +3551,7 @@ template <class Type, class Compare, typename Allocator, typename UseCompactCont
typename Multiset<Type, Compare, Allocator, UseCompactContainer>::Node* typename Multiset<Type, Compare, Allocator, UseCompactContainer>::Node*
Multiset<Type, Compare, Allocator, UseCompactContainer>::_sub_minimum (Node* nodeP) const Multiset<Type, Compare, Allocator, UseCompactContainer>::_sub_minimum (Node* nodeP) const
{ {
CGAL_multiset_assertion (_is_valid (nodeP)); CGAL_assertion (_is_valid (nodeP));
Node *minP = nodeP; Node *minP = nodeP;
@ -3568,7 +3567,7 @@ template <class Type, class Compare, typename Allocator, typename UseCompactCont
typename Multiset<Type, Compare, Allocator, UseCompactContainer>::Node* typename Multiset<Type, Compare, Allocator, UseCompactContainer>::Node*
Multiset<Type, Compare, Allocator, UseCompactContainer>::_sub_maximum (Node* nodeP) const Multiset<Type, Compare, Allocator, UseCompactContainer>::_sub_maximum (Node* nodeP) const
{ {
CGAL_multiset_assertion (_is_valid (nodeP)); CGAL_assertion (_is_valid (nodeP));
Node *maxP = nodeP; Node *maxP = nodeP;
@ -3593,7 +3592,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_rotate_left (Node
// Get the right child of the node. // Get the right child of the node.
Node *yNodeP = xNodeP->rightP; Node *yNodeP = xNodeP->rightP;
CGAL_multiset_assertion (_is_valid (yNodeP)); CGAL_assertion (_is_valid (yNodeP));
// Change its left subtree (T2) to x's right subtree. // Change its left subtree (T2) to x's right subtree.
xNodeP->rightP = yNodeP->leftP; xNodeP->rightP = yNodeP->leftP;
@ -3639,7 +3638,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_rotate_right (Nod
// Get the left child of the node. // Get the left child of the node.
Node *xNodeP = yNodeP->leftP; Node *xNodeP = yNodeP->leftP;
CGAL_multiset_assertion (_is_valid (xNodeP)); CGAL_assertion (_is_valid (xNodeP));
// Change its right subtree (T2) to y's left subtree. // Change its right subtree (T2) to y's left subtree.
yNodeP->leftP = xNodeP->rightP; yNodeP->leftP = xNodeP->rightP;
@ -3683,7 +3682,7 @@ template <class Type, class Compare, typename Allocator, typename UseCompactCont
typename Multiset<Type, Compare, Allocator, UseCompactContainer>::Node* typename Multiset<Type, Compare, Allocator, UseCompactContainer>::Node*
Multiset<Type, Compare, Allocator, UseCompactContainer>::_duplicate (const Node* nodeP) Multiset<Type, Compare, Allocator, UseCompactContainer>::_duplicate (const Node* nodeP)
{ {
CGAL_multiset_assertion (_is_valid (nodeP)); CGAL_assertion (_is_valid (nodeP));
// Create a node of the same color, containing the same object. // Create a node of the same color, containing the same object.
Node *dupNodeP = _allocate_node(nodeP->object, nodeP->color); Node *dupNodeP = _allocate_node(nodeP->object, nodeP->color);
@ -3711,7 +3710,7 @@ Multiset<Type, Compare, Allocator, UseCompactContainer>::_duplicate (const Node*
template <class Type, class Compare, typename Allocator, typename UseCompactContainer> template <class Type, class Compare, typename Allocator, typename UseCompactContainer>
void Multiset<Type, Compare, Allocator, UseCompactContainer>::_destroy (Node* nodeP) void Multiset<Type, Compare, Allocator, UseCompactContainer>::_destroy (Node* nodeP)
{ {
CGAL_multiset_assertion (_is_valid (nodeP)); CGAL_assertion (_is_valid (nodeP));
// Destroy the children recursively. // Destroy the children recursively.
if (_is_valid (nodeP->rightP)) if (_is_valid (nodeP->rightP))
@ -3734,7 +3733,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_destroy (Node* no
template <class Type, class Compare, typename Allocator, typename UseCompactContainer> template <class Type, class Compare, typename Allocator, typename UseCompactContainer>
void Multiset<Type, Compare, Allocator, UseCompactContainer>::_insert_fixup (Node* nodeP) void Multiset<Type, Compare, Allocator, UseCompactContainer>::_insert_fixup (Node* nodeP)
{ {
CGAL_multiset_precondition (_is_red (nodeP)); CGAL_precondition (_is_red (nodeP));
// Fix the red-black propreties: we may have inserted a red leaf as the // Fix the red-black propreties: we may have inserted a red leaf as the
// child of a red parent - so we have to fix the coloring of the parent // child of a red parent - so we have to fix the coloring of the parent
@ -3748,7 +3747,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_insert_fixup (Nod
// Get a pointer to the current node's grandparent (notice the root is // Get a pointer to the current node's grandparent (notice the root is
// always black, so the red parent must have a parent). // always black, so the red parent must have a parent).
grandparentP = currP->parentP->parentP; grandparentP = currP->parentP->parentP;
CGAL_multiset_precondition (grandparentP != nullptr); CGAL_precondition (grandparentP != nullptr);
if (currP->parentP == grandparentP->leftP) if (currP->parentP == grandparentP->leftP)
{ {
@ -3781,7 +3780,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_insert_fixup (Nod
// Color the parent black and the grandparent red. // Color the parent black and the grandparent red.
currP->parentP->color = Node::BLACK; currP->parentP->color = Node::BLACK;
CGAL_multiset_assertion (grandparentP == currP->parentP->parentP); CGAL_assertion (grandparentP == currP->parentP->parentP);
grandparentP->color = Node::RED; grandparentP->color = Node::RED;
// Right-rotate the grandparent's sub-tree // Right-rotate the grandparent's sub-tree
@ -3819,7 +3818,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_insert_fixup (Nod
// Color the parent black and the grandparent red. // Color the parent black and the grandparent red.
currP->parentP->color = Node::BLACK; currP->parentP->color = Node::BLACK;
CGAL_multiset_assertion(grandparentP == currP->parentP->parentP); CGAL_assertion(grandparentP == currP->parentP->parentP);
grandparentP->color = Node::RED; grandparentP->color = Node::RED;
// Left-rotate the grandparent's sub-tree // Left-rotate the grandparent's sub-tree
@ -3873,7 +3872,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_remove_fixup (Nod
siblingP = currParentP->rightP; siblingP = currParentP->rightP;
} }
CGAL_multiset_assertion (_is_valid (siblingP)); CGAL_assertion (_is_valid (siblingP));
if (_is_black (siblingP->leftP) && _is_black (siblingP->rightP)) if (_is_black (siblingP->leftP) && _is_black (siblingP->rightP))
{ {
@ -3889,7 +3888,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_remove_fixup (Nod
// the black height of the entire tree. // the black height of the entire tree.
if (currP == rootP) if (currP == rootP)
{ {
CGAL_multiset_assertion (currParentP == nullptr); CGAL_assertion (currParentP == nullptr);
iBlackHeight--; iBlackHeight--;
} }
} }
@ -3938,7 +3937,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_remove_fixup (Nod
siblingP = currParentP->leftP; siblingP = currParentP->leftP;
} }
CGAL_multiset_assertion (_is_valid (siblingP)); CGAL_assertion (_is_valid (siblingP));
if (_is_black (siblingP->leftP) && _is_black (siblingP->rightP)) if (_is_black (siblingP->leftP) && _is_black (siblingP->rightP))
{ {
@ -3954,7 +3953,7 @@ void Multiset<Type, Compare, Allocator, UseCompactContainer>::_remove_fixup (Nod
// the black height of the entire tree. // the black height of the entire tree.
if (currP == rootP) if (currP == rootP)
{ {
CGAL_multiset_assertion (currParentP == nullptr); CGAL_assertion (currParentP == nullptr);
iBlackHeight--; iBlackHeight--;
} }
} }
@ -4011,8 +4010,8 @@ Multiset<Type, Compare, Allocator, UseCompactContainer>::_allocate_node
(const Type& object, (const Type& object,
typename Node::Node_color color) typename Node::Node_color color)
{ {
CGAL_multiset_assertion (color != Node::DUMMY_BEGIN && CGAL_assertion (color != Node::DUMMY_BEGIN &&
color != Node::DUMMY_END); color != Node::DUMMY_END);
Node* new_node = node_alloc.allocate(beginNode); Node* new_node = node_alloc.allocate(beginNode);
new_node->init(object, color); new_node->init(object, color);

290
STL_Extension/include/CGAL/multiset_assertions.h
View File

@ -1,290 +0,0 @@
// Copyright (c) 2005 Tel-Aviv University (Israel). All rights reserved.
//
// This file is part of CGAL (www.cgal.org)
//
// $URL$
// $Id$
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
//
//
// Author(s) : Geert-Jan Giezeman, Sven Schoenherr
//
// Generated from script create_assertions.sh
#ifndef CGAL_MULTISET_ASSERTIONS_H
#define CGAL_MULTISET_ASSERTIONS_H
#include <CGAL/assertions.h>
// macro definitions
// =================
// assertions
// ----------
#if defined(CGAL_MULTISET_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS)
# define CGAL_multiset_assertion(EX) (static_cast<void>(0))
# define CGAL_multiset_assertion_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_assertion_code(CODE)
#else
# define CGAL_multiset_assertion(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_assertion_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_assertion_code(CODE) CODE
# define CGAL_multiset_assertions 1
#endif // CGAL_MULTISET_NO_ASSERTIONS
#if defined(CGAL_MULTISET_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \
|| (!defined(CGAL_MULTISET_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))
# define CGAL_multiset_exactness_assertion(EX) (static_cast<void>(0))
# define CGAL_multiset_exactness_assertion_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_exactness_assertion_code(CODE)
#else
# define CGAL_multiset_exactness_assertion(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_exactness_assertion_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_exactness_assertion_code(CODE) CODE
# define CGAL_multiset_exactness_assertions 1
#endif // CGAL_MULTISET_NO_ASSERTIONS
#if defined(CGAL_MULTISET_NO_ASSERTIONS) \
|| defined(CGAL_NO_ASSERTIONS) \
|| (!defined(CGAL_MULTISET_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))
# define CGAL_multiset_expensive_assertion(EX) (static_cast<void>(0))
# define CGAL_multiset_expensive_assertion_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_expensive_assertion_code(CODE)
#else
# define CGAL_multiset_expensive_assertion(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_expensive_assertion_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_expensive_assertion_code(CODE) CODE
# define CGAL_multiset_expensive_assertions 1
#endif // CGAL_MULTISET_NO_ASSERTIONS
#if defined(CGAL_MULTISET_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \
|| (!defined(CGAL_MULTISET_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\
|| (!defined(CGAL_MULTISET_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))
# define CGAL_multiset_expensive_exactness_assertion(EX) (static_cast<void>(0))
# define CGAL_multiset_expensive_exactness_assertion_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_expensive_exactness_assertion_code(CODE)
#else
# define CGAL_multiset_expensive_exactness_assertion(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_expensive_exactness_assertion_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_expensive_exactness_assertion_code(CODE) CODE
# define CGAL_multiset_expensive_exactness_assertions 1
#endif // CGAL_MULTISET_NO_ASSERTIONS
// preconditions
// -------------
#if defined(CGAL_MULTISET_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS)
# define CGAL_multiset_precondition(EX) (static_cast<void>(0))
# define CGAL_multiset_precondition_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_precondition_code(CODE)
#else
# define CGAL_multiset_precondition(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_precondition_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_precondition_code(CODE) CODE
# define CGAL_multiset_preconditions 1
#endif // CGAL_MULTISET_NO_PRECONDITIONS
#if defined(CGAL_MULTISET_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \
|| (!defined(CGAL_MULTISET_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))
# define CGAL_multiset_exactness_precondition(EX) (static_cast<void>(0))
# define CGAL_multiset_exactness_precondition_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_exactness_precondition_code(CODE)
#else
# define CGAL_multiset_exactness_precondition(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_exactness_precondition_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_exactness_precondition_code(CODE) CODE
# define CGAL_multiset_exactness_preconditions 1
#endif // CGAL_MULTISET_NO_PRECONDITIONS
#if defined(CGAL_MULTISET_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \
|| (!defined(CGAL_MULTISET_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))
# define CGAL_multiset_expensive_precondition(EX) (static_cast<void>(0))
# define CGAL_multiset_expensive_precondition_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_expensive_precondition_code(CODE)
#else
# define CGAL_multiset_expensive_precondition(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_expensive_precondition_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_expensive_precondition_code(CODE) CODE
# define CGAL_multiset_expensive_preconditions 1
#endif // CGAL_MULTISET_NO_PRECONDITIONS
#if defined(CGAL_MULTISET_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \
|| (!defined(CGAL_MULTISET_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\
|| (!defined(CGAL_MULTISET_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))
# define CGAL_multiset_expensive_exactness_precondition(EX) (static_cast<void>(0))
# define CGAL_multiset_expensive_exactness_precondition_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_expensive_exactness_precondition_code(CODE)
#else
# define CGAL_multiset_expensive_exactness_precondition(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_expensive_exactness_precondition_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_expensive_exactness_precondition_code(CODE) CODE
# define CGAL_multiset_expensive_exactness_preconditions 1
#endif // CGAL_MULTISET_NO_PRECONDITIONS
// postconditions
// --------------
#if defined(CGAL_MULTISET_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS)
# define CGAL_multiset_postcondition(EX) (static_cast<void>(0))
# define CGAL_multiset_postcondition_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_postcondition_code(CODE)
#else
# define CGAL_multiset_postcondition(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_postcondition_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_postcondition_code(CODE) CODE
# define CGAL_multiset_postconditions 1
#endif // CGAL_MULTISET_NO_POSTCONDITIONS
#if defined(CGAL_MULTISET_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \
|| (!defined(CGAL_MULTISET_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))
# define CGAL_multiset_exactness_postcondition(EX) (static_cast<void>(0))
# define CGAL_multiset_exactness_postcondition_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_exactness_postcondition_code(CODE)
#else
# define CGAL_multiset_exactness_postcondition(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_exactness_postcondition_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_exactness_postcondition_code(CODE) CODE
# define CGAL_multiset_exactness_postconditions 1
#endif // CGAL_MULTISET_NO_POSTCONDITIONS
#if defined(CGAL_MULTISET_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \
|| (!defined(CGAL_MULTISET_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))
# define CGAL_multiset_expensive_postcondition(EX) (static_cast<void>(0))
# define CGAL_multiset_expensive_postcondition_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_expensive_postcondition_code(CODE)
#else
# define CGAL_multiset_expensive_postcondition(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_expensive_postcondition_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_expensive_postcondition_code(CODE) CODE
# define CGAL_multiset_expensive_postconditions 1
#endif // CGAL_MULTISET_NO_POSTCONDITIONS
#if defined(CGAL_MULTISET_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \
|| (!defined(CGAL_MULTISET_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\
|| (!defined(CGAL_MULTISET_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))
# define CGAL_multiset_expensive_exactness_postcondition(EX) (static_cast<void>(0))
# define CGAL_multiset_expensive_exactness_postcondition_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_expensive_exactness_postcondition_code(CODE)
#else
# define CGAL_multiset_expensive_exactness_postcondition(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_expensive_exactness_postcondition_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_expensive_exactness_postcondition_code(CODE) CODE
# define CGAL_multiset_expensive_exactness_postconditions 1
#endif // CGAL_MULTISET_NO_POSTCONDITIONS
// warnings
// --------
#if defined(CGAL_MULTISET_NO_WARNINGS) || defined(CGAL_NO_WARNINGS)
# define CGAL_multiset_warning(EX) (static_cast<void>(0))
# define CGAL_multiset_warning_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_warning_code(CODE)
#else
# define CGAL_multiset_warning(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_warning_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_warning_code(CODE) CODE
# define CGAL_multiset_warnings 1
#endif // CGAL_MULTISET_NO_WARNINGS
#if defined(CGAL_MULTISET_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \
|| (!defined(CGAL_MULTISET_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))
# define CGAL_multiset_exactness_warning(EX) (static_cast<void>(0))
# define CGAL_multiset_exactness_warning_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_exactness_warning_code(CODE)
#else
# define CGAL_multiset_exactness_warning(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_exactness_warning_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_exactness_warning_code(CODE) CODE
# define CGAL_multiset_exactness_warnings 1
#endif // CGAL_MULTISET_NO_WARNINGS
#if defined(CGAL_MULTISET_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \
|| (!defined(CGAL_MULTISET_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))
# define CGAL_multiset_expensive_warning(EX) (static_cast<void>(0))
# define CGAL_multiset_expensive_warning_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_expensive_warning_code(CODE)
#else
# define CGAL_multiset_expensive_warning(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_expensive_warning_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_expensive_warning_code(CODE) CODE
# define CGAL_multiset_expensive_warnings 1
#endif // CGAL_MULTISET_NO_WARNINGS
#if defined(CGAL_MULTISET_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \
|| (!defined(CGAL_MULTISET_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\
|| (!defined(CGAL_MULTISET_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))
# define CGAL_multiset_expensive_exactness_warning(EX) (static_cast<void>(0))
# define CGAL_multiset_expensive_exactness_warning_msg(EX,MSG) (static_cast<void>(0))
# define CGAL_multiset_expensive_exactness_warning_code(CODE)
#else
# define CGAL_multiset_expensive_exactness_warning(EX) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__))
# define CGAL_multiset_expensive_exactness_warning_msg(EX,MSG) \
(CGAL::possibly(EX)?(static_cast<void>(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG))
# define CGAL_multiset_expensive_exactness_warning_code(CODE) CODE
# define CGAL_multiset_expensive_exactness_warnings 1
#endif // CGAL_MULTISET_NO_WARNINGS
#endif // CGAL_MULTISET_ASSERTIONS