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

Merge pull request #657 from afabri/Kernel_fix-warnings-GF 

Use CGAL_USE to avoid g++6.0 warning
This commit is contained in:
Sebastien Loriot 2016-01-25 08:57:24 +01:00
parent 30ebd33ba4 d1ffbee57a
commit 313cd7cf6c
22 changed files with 79 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Bounding_volumes/include/CGAL/Approximate_min_ellipsoid_d/Khachiyan_approximation_impl.h
View File

@ -28,6 +28,7 @@
#include <numeric> #include <numeric>
#include <CGAL/tags.h> #include <CGAL/tags.h>
#include <CGAL/use.h>
#include <CGAL/Approximate_min_ellipsoid_d/Khachiyan_approximation.h> #include <CGAL/Approximate_min_ellipsoid_d/Khachiyan_approximation.h>
namespace CGAL { namespace CGAL {
@ -366,7 +367,7 @@ namespace CGAL {
CGAL_APPEL_ASSERT(!check_tag(Exact_flag()) || tau == eps/((1+eps)*d-1)); CGAL_APPEL_ASSERT(!check_tag(Exact_flag()) || tau == eps/((1+eps)*d-1));
CGAL_APPEL_ASSERT(!check_tag(Exact_flag()) || CGAL_APPEL_ASSERT(!check_tag(Exact_flag()) ||
excess<ET>(tco.cartesian_begin(*P[k])) == (1+eps)*d); excess<ET>(tco.cartesian_begin(*P[k])) == (1+eps)*d);
CGAL_USE(tau);
const FT mu = eps / ((d-1)*(1+eps)); const FT mu = eps / ((d-1)*(1+eps));
const FT alpha = 1 + mu; const FT alpha = 1 + mu;
const FT beta = mu / (1+eps); const FT beta = mu / (1+eps);

11
Circulator/include/CGAL/Circulator/Circulator_adapters.h
View File

@ -26,6 +26,7 @@
#define CGAL_CIRCULATOR_IMPL_H 1 #define CGAL_CIRCULATOR_IMPL_H 1
#include <CGAL/circulator.h> #include <CGAL/circulator.h>
#include <CGAL/use.h>
namespace CGAL { namespace CGAL {
@ -68,6 +69,7 @@ public:
bool operator==( Nullptr_t p) const { bool operator==( Nullptr_t p) const {
CGAL_assertion( p == NULL); CGAL_assertion( p == NULL);
CGAL_USE(p);
return this->_ptr == NULL; return this->_ptr == NULL;
} }
bool operator!=( Nullptr_t p) const { return !(*this == p); } bool operator!=( Nullptr_t p) const { return !(*this == p); }
@ -111,6 +113,7 @@ public:
bool operator==( Nullptr_t p) const { bool operator==( Nullptr_t p) const {
CGAL_assertion( p == NULL); CGAL_assertion( p == NULL);
CGAL_USE(p);
return this->_ptr == NULL; return this->_ptr == NULL;
} }
bool operator!=( Nullptr_t p) const { return !(*this == p); } bool operator!=( Nullptr_t p) const { return !(*this == p); }
@ -158,6 +161,7 @@ public:
bool operator==( Nullptr_t p) const { bool operator==( Nullptr_t p) const {
CGAL_assertion( p == NULL); CGAL_assertion( p == NULL);
CGAL_USE(p);
return this->_ptr == NULL; return this->_ptr == NULL;
} }
bool operator!=( Nullptr_t p) const { return !(*this == p); } bool operator!=( Nullptr_t p) const { return !(*this == p); }
@ -210,6 +214,7 @@ public:
bool operator==( Nullptr_t p) const { bool operator==( Nullptr_t p) const {
CGAL_assertion( p == NULL); CGAL_assertion( p == NULL);
CGAL_USE(p);
return this->_ptr == NULL; return this->_ptr == NULL;
} }
bool operator!=( Nullptr_t p) const { return !(*this == p); } bool operator!=( Nullptr_t p) const { return !(*this == p); }
@ -269,6 +274,7 @@ public:
bool operator==( Nullptr_t p) const { bool operator==( Nullptr_t p) const {
CGAL_assertion( p == NULL); CGAL_assertion( p == NULL);
CGAL_USE(p);
return this->_ptr == NULL; return this->_ptr == NULL;
} }
bool operator!=( Nullptr_t p) const { return !(*this == p); } bool operator!=( Nullptr_t p) const { return !(*this == p); }
@ -307,6 +313,7 @@ public:
bool operator==( Nullptr_t p) const { bool operator==( Nullptr_t p) const {
CGAL_assertion( p == NULL); CGAL_assertion( p == NULL);
CGAL_USE(p);
return this->_ptr == NULL; return this->_ptr == NULL;
} }
bool operator!=( Nullptr_t p) const { return !(*this == p); } bool operator!=( Nullptr_t p) const { return !(*this == p); }
@ -344,6 +351,7 @@ public:
bool operator==( Nullptr_t p) const { bool operator==( Nullptr_t p) const {
CGAL_assertion( p == NULL); CGAL_assertion( p == NULL);
CGAL_USE(p);
return this->_ptr == NULL; return this->_ptr == NULL;
} }
bool operator!=( Nullptr_t p) const { return !(*this == p); } bool operator!=( Nullptr_t p) const { return !(*this == p); }
@ -393,6 +401,7 @@ public:
bool operator==( Nullptr_t p) const { bool operator==( Nullptr_t p) const {
CGAL_assertion( p == NULL); CGAL_assertion( p == NULL);
CGAL_USE(p);
return this->_ptr == NULL; return this->_ptr == NULL;
} }
bool operator!=( Nullptr_t p) const { return !(*this == p); } bool operator!=( Nullptr_t p) const { return !(*this == p); }
@ -465,6 +474,7 @@ public:
bool operator==( Nullptr_t p) const { bool operator==( Nullptr_t p) const {
CGAL_assertion( p == NULL); CGAL_assertion( p == NULL);
CGAL_USE(p);
return _i >= _size; return _i >= _size;
} }
bool operator!=( Nullptr_t p) const { return !(*this == p); } bool operator!=( Nullptr_t p) const { return !(*this == p); }
@ -589,6 +599,7 @@ public:
bool operator==( Nullptr_t p) const { bool operator==( Nullptr_t p) const {
CGAL_assertion( p == NULL); CGAL_assertion( p == NULL);
CGAL_USE(p);
return _i >= _size; return _i >= _size;
} }
bool operator!=( Nullptr_t p) const { return !(*this == p); } bool operator!=( Nullptr_t p) const { return !(*this == p); }

9
Kernel_23/include/CGAL/Kernel_checker.h
View File

@ -34,6 +34,7 @@
// So the template parameter will be a comparator, not a converter. // So the template parameter will be a comparator, not a converter.
#include <CGAL/basic.h> #include <CGAL/basic.h>
#include <CGAL/use.h>
#include <utility> #include <utility>
#include <typeinfo> #include <typeinfo>
@ -52,28 +53,28 @@ template <>
struct Pairify <bool, bool> { struct Pairify <bool, bool> {
typedef bool result_type; typedef bool result_type;
result_type operator()(const bool &t1, const bool &t2) const result_type operator()(const bool &t1, const bool &t2) const
{ CGAL_kernel_assertion(t1 == t2); return t1; } { CGAL_kernel_assertion(t1 == t2); CGAL_USE(t2); return t1; }
}; };
template <> template <>
struct Pairify <Sign, Sign> { struct Pairify <Sign, Sign> {
typedef Sign result_type; typedef Sign result_type;
result_type operator()(const Sign &t1, const Sign &t2) const result_type operator()(const Sign &t1, const Sign &t2) const
{ CGAL_kernel_assertion(t1 == t2); return t1; } { CGAL_kernel_assertion(t1 == t2); CGAL_USE(t2); return t1; }
}; };
template <> template <>
struct Pairify <Bounded_side, Bounded_side> { struct Pairify <Bounded_side, Bounded_side> {
typedef Bounded_side result_type; typedef Bounded_side result_type;
result_type operator()(const Bounded_side &t1, const Bounded_side &t2) const result_type operator()(const Bounded_side &t1, const Bounded_side &t2) const
{ CGAL_kernel_assertion(t1 == t2); return t1; } { CGAL_kernel_assertion(t1 == t2); CGAL_USE(t2); return t1; }
}; };
template <> template <>
struct Pairify <Angle, Angle> { struct Pairify <Angle, Angle> {
typedef Angle result_type; typedef Angle result_type;
result_type operator()(const Angle &t1, const Angle &t2) const result_type operator()(const Angle &t1, const Angle &t2) const
{ CGAL_kernel_assertion(t1 == t2); return t1; } { CGAL_kernel_assertion(t1 == t2); CGAL_USE(t2); return t1; }
}; };

2
Kernel_d/include/CGAL/Kernel_d/Sphere_d.h
View File

@ -28,6 +28,7 @@
#include <CGAL/basic.h> #include <CGAL/basic.h>
#include <vector> #include <vector>
#include <CGAL/Dimension.h> #include <CGAL/Dimension.h>
#include <CGAL/use.h>
namespace CGAL { namespace CGAL {
@ -56,6 +57,7 @@ public:
P(first,last), cp(0) P(first,last), cp(0)
{ TUPLE_DIM_CHECK(P.begin(),P.end(),Sphere_d); { TUPLE_DIM_CHECK(P.begin(),P.end(),Sphere_d);
CGAL_assertion(d+1==int(P.size())); CGAL_assertion(d+1==int(P.size()));
CGAL_USE(d);
typename R::Orientation_d orientation_; typename R::Orientation_d orientation_;
orient = orientation_(P.begin(),P.end()); } orient = orientation_(P.begin(),P.end()); }

1
Kernel_d/include/CGAL/Kernel_d/function_objectsCd.h
View File

@ -27,6 +27,7 @@
#include <CGAL/basic.h> #include <CGAL/basic.h>
#include <CGAL/enum.h> #include <CGAL/enum.h>
#include <CGAL/use.h>
#include <CGAL/Referenced_argument.h> #include <CGAL/Referenced_argument.h>
#undef CGAL_KD_TRACE #undef CGAL_KD_TRACE

1
Kernel_d/include/CGAL/Kernel_d/function_objectsHd.h
View File

@ -128,6 +128,7 @@ typedef typename R::LA LA;
template <class Forward_iterator> template <class Forward_iterator>
Point_d operator()(Forward_iterator start, Forward_iterator end) const Point_d operator()(Forward_iterator start, Forward_iterator end) const
{ CGAL_assertion(start!=end); { CGAL_assertion(start!=end);
CGAL_USE(end);
int d = start->dimension(); int d = start->dimension();
typename LA::Matrix M(d); typename LA::Matrix M(d);
typename LA::Vector b(d); typename LA::Vector b(d);

4
Kinetic_data_structures/include/CGAL/Kinetic/Regular_triangulation_3.h
View File

@ -464,6 +464,7 @@ public:
public: public:
void audit_move(Event_key k, Point_key pk, Cell_handle h, int) const { void audit_move(Event_key k, Point_key pk, Cell_handle h, int) const {
CGAL_USE(k);
CGAL_assertion(kdel_.vertex_handle(pk) == Vertex_handle()); CGAL_assertion(kdel_.vertex_handle(pk) == Vertex_handle());
CGAL_assertion(redundant_points_.find(pk) != redundant_points_.end()); CGAL_assertion(redundant_points_.find(pk) != redundant_points_.end());
CGAL_assertion(redundant_points_.find(pk)->second == k); CGAL_assertion(redundant_points_.find(pk)->second == k);
@ -471,12 +472,15 @@ public:
} }
void audit_push(Event_key k, Point_key pk, Cell_handle h) const { void audit_push(Event_key k, Point_key pk, Cell_handle h) const {
CGAL_USE(k);
CGAL_assertion(kdel_.vertex_handle(pk) == Vertex_handle()); CGAL_assertion(kdel_.vertex_handle(pk) == Vertex_handle());
CGAL_assertion(redundant_points_.find(pk) != redundant_points_.end()); CGAL_assertion(redundant_points_.find(pk) != redundant_points_.end());
CGAL_assertion(redundant_points_.find(pk)->second == k); CGAL_assertion(redundant_points_.find(pk)->second == k);
audit_redundant(pk, h); audit_redundant(pk, h);
} }
void audit_pop(Event_key k, Vertex_handle vh) const { void audit_pop(Event_key k, Vertex_handle vh) const {
CGAL_USE(k);
CGAL_USE(vh);
CGAL_assertion_code(if (vh->info() != k) std::cerr << vh->info() << std::endl << k << std::endl); CGAL_assertion_code(if (vh->info() != k) std::cerr << vh->info() << std::endl << k << std::endl);
CGAL_assertion(vh->info() == k); CGAL_assertion(vh->info() == k);
} }

8
Kinetic_data_structures/include/CGAL/Kinetic/Sort.h
View File

@ -26,6 +26,7 @@
#include <CGAL/Kinetic/internal/debug_counters.h> #include <CGAL/Kinetic/internal/debug_counters.h>
#include <CGAL/Kinetic/Sort_visitor_base.h> #include <CGAL/Kinetic/Sort_visitor_base.h>
#include <CGAL/Kinetic/Event_base.h> #include <CGAL/Kinetic/Event_base.h>
#include <CGAL/use.h>
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
#include <iterator> #include <iterator>
@ -453,15 +454,12 @@ public:
if (s_.will_fail()) out << " next is " << s_.failure_time(); if (s_.will_fail()) out << " next is " << s_.failure_time();
else out << " out of failures"; else out << " out of failures";
} }
void audit(typename Sort::Event_key void audit(typename Sort::Event_key tk) const {
#ifndef NDEBUG
tk
#endif
) const {
//std::cout << "Auditing event "; //std::cout << "Auditing event ";
//write(std::cout); //write(std::cout);
//std::cout << std::endl; //std::cout << std::endl;
CGAL_assertion(left_object_->event() == tk); CGAL_assertion(left_object_->event() == tk);
CGAL_USE(tk);
} }
Id left_object_; Solver s_; Id left_object_; Solver s_;
}; };

2
Matrix_search/include/CGAL/sorted_matrix_search.h
View File

@ -397,7 +397,7 @@ sorted_matrix_search(InputIterator f, InputIterator l, Traits t)
} // both upper_median and lower_median are infeasible } // both upper_median and lower_median are infeasible
active_cells.erase( new_end, active_cells.end()); active_cells.erase( new_end, active_cells.end());
} // for (;;) } // for (;;)
// there must be only one cell left: // there must be only one cell left:

3
Nef_2/include/CGAL/Nef_2/PM_point_locator.h
View File

@ -174,8 +174,9 @@ public:
Direction d_res = direction(e_res); Direction d_res = direction(e_res);
Halfedge_around_vertex_const_circulator el(e_res),ee(el); Halfedge_around_vertex_const_circulator el(e_res),ee(el);
CGAL_For_all(el,ee) { CGAL_For_all(el,ee) {
if ( K.strictly_ordered_ccw(d_res, direction(el), d) ) if ( K.strictly_ordered_ccw(d_res, direction(el), d) ){
e_res = el; d_res = direction(e_res); e_res = el; d_res = direction(e_res);
}
} }
CGAL_NEF_TRACEN(" determined "<<PE(e_res)<<" "<<d_res); CGAL_NEF_TRACEN(" determined "<<PE(e_res)<<" "<<d_res);
if ( direction(cyclic_adj_succ(e_res)) == d ) { if ( direction(cyclic_adj_succ(e_res)) == d ) {

12
Nef_2/include/CGAL/Nef_polyhedron_2.h
View File

@ -282,9 +282,17 @@ protected:
D(d), _e(), _v(), _it(it), _m(m) {} D(d), _e(), _v(), _it(it), _m(m) {}
void supporting_segment(Halfedge_handle e, ES_iterator it) void supporting_segment(Halfedge_handle e, ES_iterator it)
{ if ( it == _it ) _e = e; D.mark(e) = _m; } {
if ( it == _it )
_e = e;
D.mark(e) = _m;
}
void trivial_segment(Vertex_handle v, ES_iterator it) void trivial_segment(Vertex_handle v, ES_iterator it)
{ if ( it == _it ) _v = v; D.mark(v) = _m; } {
if ( it == _it )
_v = v;
D.mark(v) = _m;
}
void starting_segment(Vertex_handle v, ES_iterator) void starting_segment(Vertex_handle v, ES_iterator)
{ D.mark(v) = _m; } { D.mark(v) = _m; }
void passing_segment(Vertex_handle v, ES_iterator) void passing_segment(Vertex_handle v, ES_iterator)

25
Nef_3/include/CGAL/Nef_polyhedron_3.h
View File

@ -193,12 +193,25 @@ class Nef_polyhedron_3 : public CGAL::Handle_for< Nef_polyhedron_3_rep<Kernel_,
/*{\Menum selection flag for the point location mode.}*/ /*{\Menum selection flag for the point location mode.}*/
protected: protected:
struct AND { Mark operator()(const Mark& b1, const Mark& b2, bool /* inverted */ =false) const { return b1&&b2; } }; struct AND {
struct OR { Mark operator()(const Mark& b1, const Mark& b2, bool /* inverted */ =false) const { return b1||b2; } }; Mark operator()(const Mark& b1, const Mark& b2, bool /* inverted */ =false)const
struct DIFF { Mark operator()(const Mark& b1, const Mark& b2, bool inverted=false) const { { return b1&&b2; }
if(inverted) return !b1&&b2; return b1&&!b2; } }; };
struct XOR { Mark operator()(const Mark& b1, const Mark& b2, bool /* inverted */ =false) const
{ return (b1&&!b2)||(!b1&&b2); } }; struct OR {
Mark operator()(const Mark& b1, const Mark& b2, bool /* inverted */ =false) const
{ return b1||b2; }
};
struct DIFF {
Mark operator()(const Mark& b1, const Mark& b2, bool inverted=false) const
{ return (inverted) ? !b1&&b2 : b1&&!b2 ; }
};
struct XOR {
Mark operator()(const Mark& b1, const Mark& b2, bool /* inverted */ =false) const
{ return (b1&&!b2)||(!b1&&b2); }
};
public: public:
typedef Nef_polyhedron_3_rep<Kernel,Items, Mark> Nef_rep; typedef Nef_polyhedron_3_rep<Kernel,Items, Mark> Nef_rep;

3
Nef_S2/include/CGAL/Nef_S2/Sphere_triangle.h
View File

@ -103,7 +103,8 @@ template <typename R>
std::ostream& operator<<(std::ostream& os, std::ostream& operator<<(std::ostream& os,
const CGAL::Sphere_triangle<R>& t) const CGAL::Sphere_triangle<R>& t)
{ for (int i=0; i<3; ++i) os << t.point(i); { for (int i=0; i<3; ++i) os << t.point(i);
for (int i=0; i<3; ++i) os << t.circle(i); return os; } for (int i=0; i<3; ++i) os << t.circle(i);
return os; }
template <typename R> template <typename R>
std::istream& operator>>(std::istream& is, std::istream& operator>>(std::istream& is,

4
NewKernel_d/include/CGAL/NewKernel_d/Vector/array.h
View File

@ -56,7 +56,7 @@ template<class NT_,class Dim_,class Max_dim_=Dim_> struct Array_vector {
struct Construct_vector { struct Construct_vector {
struct Dimension { struct Dimension {
// Initialize with NaN if possible? // Initialize with NaN if possible?
Vector operator()(unsigned d) const { Vector operator()(unsigned CGAL_assertion_code(d)) const {
CGAL_assertion(d<=d_); CGAL_assertion(d<=d_);
return Vector(); return Vector();
} }
@ -91,7 +91,7 @@ template<class NT_,class Dim_,class Max_dim_=Dim_> struct Array_vector {
struct Iterator_and_last { struct Iterator_and_last {
template<typename Iter,typename T> template<typename Iter,typename T>
Vector operator()(unsigned d,Iter const& f,Iter const& e,CGAL_FORWARDABLE(T) t) const { Vector operator()(unsigned CGAL_assertion_code(d),Iter const& f,Iter const& e,CGAL_FORWARDABLE(T) t) const {
CGAL_assertion(d==std::distance(f,e)+1); CGAL_assertion(d==std::distance(f,e)+1);
CGAL_assertion(d<=d_); CGAL_assertion(d<=d_);
//TODO: optimize for forward iterators //TODO: optimize for forward iterators

2
NewKernel_d/include/CGAL/NewKernel_d/Vector/vector.h
View File

@ -59,7 +59,7 @@ template<class NT_,class Dim_,class Max_dim_=Dim_> struct Vector_vector {
#if 0 #if 0
struct Iterator_add_one { struct Iterator_add_one {
template<typename Iter> template<typename Iter>
Vector operator()(int d,Iter const& f,Iter const& e) const { Vector operator()(int CGAL_assertion_code(d),Iter const& f,Iter const& e) const {
CGAL_assertion(d==std::distance(f,e)+1); CGAL_assertion(d==std::distance(f,e)+1);
Vector a; Vector a;
a.reserve(d+1); a.reserve(d+1);

2
Polynomial/include/CGAL/Polynomial/Polynomial_type.h
View File

@ -597,7 +597,7 @@ public:
//! return \c -p if \c p.sign()<0 and \c p otherwise //! return \c -p if \c p.sign()<0 and \c p otherwise
Polynomial<NT> abs() const Polynomial<NT> abs() const
{ if ( sign()<0 ) return -*this; return *this; } { return ( sign()<0 )? -*this : *this; }
//! return the gcd of all coefficients //! return the gcd of all coefficients
/*! The content is defined as 1 for the zero polynomial. */ /*! The content is defined as 1 for the zero polynomial. */

1
STL_Extension/include/CGAL/Circulator_identity.h
View File

@ -61,6 +61,7 @@ public:
bool operator==( Nullptr_t p) const { bool operator==( Nullptr_t p) const {
CGAL_assertion( p == 0); CGAL_assertion( p == 0);
CGAL_USE(p);
return ( nt == 0); //###// return ( nt == 0); //###//
} }
bool operator!=( Nullptr_t p) const { bool operator!=( Nullptr_t p) const {

1
STL_Extension/include/CGAL/Circulator_on_node.h
View File

@ -63,6 +63,7 @@ public:
bool operator==( Nullptr_t p) const { bool operator==( Nullptr_t p) const {
CGAL_assertion( p == 0); CGAL_assertion( p == 0);
CGAL_USE(p);
return ( nt == 0); return ( nt == 0);
} }
bool operator!=( Nullptr_t p) const { return !(*this == p); } bool operator!=( Nullptr_t p) const { return !(*this == p); }

8
SearchStructures/include/CGAL/Range_tree_d.h
View File

@ -399,10 +399,10 @@ public:
if (v!=0) if (v!=0)
delete_tree(v); delete_tree(v);
if (header!=0) if (header!=0)
delete header; delete header;
if (sublayer_tree!=0) if (sublayer_tree!=0)
delete sublayer_tree; delete sublayer_tree;
} }

2
Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h
View File

@ -1810,7 +1810,7 @@ public:
if(!valid) { if(!valid) {
if (verbose) if (verbose)
std::cerr << "Integrity of opposite halfedge of " << *it << " corrupted." << std::endl; std::cerr << "Integrity of opposite halfedge of " << *it << " corrupted." << std::endl;
break; break;
} }
valid = valid && (next(prev(*it)) == *it); valid = valid && (next(prev(*it)) == *it);

2
Visibility_2/include/CGAL/Triangular_expansion_visibility_2.h
View File

@ -28,6 +28,7 @@
#include <CGAL/Constrained_Delaunay_triangulation_2.h> #include <CGAL/Constrained_Delaunay_triangulation_2.h>
#include <CGAL/Arr_observer.h> #include <CGAL/Arr_observer.h>
#include <CGAL/assertions.h> #include <CGAL/assertions.h>
#include <CGAL/use.h>
namespace CGAL { namespace CGAL {
@ -217,6 +218,7 @@ public:
out_arr.clear(); out_arr.clear();
needles.clear(); needles.clear();
CGAL_USE(face);
CGAL_assertion(!face->is_unbounded()); CGAL_assertion(!face->is_unbounded());

4
Voronoi_diagram_2/include/CGAL/Voronoi_diagram_2.h
View File

@ -26,6 +26,7 @@
#include <CGAL/Iterator_project.h> #include <CGAL/Iterator_project.h>
#include <CGAL/circulator.h> #include <CGAL/circulator.h>
#include <CGAL/tags.h> #include <CGAL/tags.h>
#include <CGAL/use.h>
#include <iostream> #include <iostream>
#include <iterator> #include <iterator>
@ -603,6 +604,7 @@ public:
Ccb_halfedge_circulator ccb_halfedges(const Face_handle& f, Ccb_halfedge_circulator ccb_halfedges(const Face_handle& f,
const Halfedge_handle& he) const { const Halfedge_handle& he) const {
CGAL_precondition( he->face() == f ); CGAL_precondition( he->face() == f );
CGAL_USE(f);
return Ccb_halfedge_circulator(*he); return Ccb_halfedge_circulator(*he);
} }
@ -614,7 +616,7 @@ public:
Halfedge_around_vertex_circulator Halfedge_around_vertex_circulator
incident_halfedges(const Vertex_handle& v, const Halfedge_handle& he) const { incident_halfedges(const Vertex_handle& v, const Halfedge_handle& he) const {
internal::use(v); CGAL_USE(v);
CGAL_precondition( he->target() == v ); CGAL_precondition( he->target() == v );
return Halfedge_around_vertex_circulator(*he); return Halfedge_around_vertex_circulator(*he);
} }