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

remove cpp11 workaround in kernel related packages

This commit is contained in:
Sébastien Loriot 2019-03-19 13:47:58 +01:00
parent ecd818a3a7
commit 82c13e6e74
14 changed files with 18 additions and 763 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Bitstream_descartes_E08_tree.h
View File

@ -476,9 +476,7 @@ private:
log_C_eps_ = n.log_C_eps_;
}
#ifndef CGAL_CFG_NO_CPP0X_DELETED_AND_DEFAULT_FUNCTIONS
Self& operator= (const Self&) = delete;
#endif
}; // struct Bitstream_descartes_E08_node

2
Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Bitstream_descartes_rndl_tree.h
View File

@ -567,9 +567,7 @@ private:
log_C_eps_ = n.log_C_eps_;
}
#ifndef CGAL_CFG_NO_CPP0X_DELETED_AND_DEFAULT_FUNCTIONS
Self& operator= (const Self&)=delete;
#endif
}; // struct Bitstream_descartes_rndl_node

24
Circular_kernel_2/include/CGAL/Circular_kernel_2/Intersection_traits.h
View File

@ -209,28 +209,16 @@ namespace internal{
// the real type.
// Overloads for empty returns are also provided.
#if CGAL_INTERSECTION_VERSION < 2
#if defined(CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE)
template<typename, typename T>
inline
CGAL::Object ck2_intersection_return(const T& t) { return CGAL::make_object(t); }
#else
template<typename, typename T>
inline
CGAL::Object ck2_intersection_return(T&& t) { return CGAL::make_object(std::forward<T>(t)); }
#endif // CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE
template<typename, typename T>
inline
CGAL::Object ck2_intersection_return(T&& t) { return CGAL::make_object(std::forward<T>(t)); }
template<typename>
inline
CGAL::Object ck2_intersection_return() { return CGAL::Object(); }
#else
#if defined(CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE)
template<typename RT, typename T>
inline RT
ck2_intersection_return(const T& t) { return RT(t); }
#else
template<typename RT, typename T>
inline RT
ck2_intersection_return(T&& t) { return RT(std::forward<T>(t)); }
#endif // CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE
template<typename RT, typename T>
inline RT
ck2_intersection_return(T&& t) { return RT(std::forward<T>(t)); }
template<typename RT>
inline RT
ck2_intersection_return() { return RT(); }

24
Circular_kernel_3/include/CGAL/Circular_kernel_3/Intersection_traits.h
View File

@ -201,28 +201,16 @@ namespace internal{
// the real type.
// Overloads for empty returns are also provided.
#if CGAL_INTERSECTION_VERSION < 2
#if defined(CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE)
template<typename, typename T>
inline
CGAL::Object sk3_intersection_return(const T& t) { return CGAL::make_object(t); }
#else
template<typename, typename T>
inline
CGAL::Object sk3_intersection_return(T&& t) { return CGAL::make_object(std::forward<T>(t)); }
#endif // CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE
template<typename, typename T>
inline
CGAL::Object sk3_intersection_return(T&& t) { return CGAL::make_object(std::forward<T>(t)); }
template<typename>
inline
CGAL::Object sk3_intersection_return() { return CGAL::Object(); }
#else
#if defined(CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE)
template<typename RT, typename T>
inline RT
sk3_intersection_return(const T& t) { return RT(t); }
#else
template<typename RT, typename T>
inline RT
sk3_intersection_return(T&& t) { return RT(std::forward<T>(t)); }
#endif // CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE
template<typename RT, typename T>
inline RT
sk3_intersection_return(T&& t) { return RT(std::forward<T>(t)); }
template<typename RT>
inline RT
sk3_intersection_return() { return RT(); }

305
Filtered_kernel/include/CGAL/Filtered_predicate.h
View File

@ -87,72 +87,11 @@ public:
: ep(e), ap(a)
{}
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template <typename... Args>
result_type
operator()(const Args&... args) const;
#else
template <class A1>
result_type
operator()(const A1 &a1) const;
template <class A1, class A2>
result_type
operator()(const A1 &a1, const A2 &a2) const;
template <class A1, class A2, class A3>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3) const;
template <class A1, class A2, class A3, class A4>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const;
template <class A1, class A2, class A3, class A4, class A5>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5) const;
template <class A1, class A2, class A3, class A4, class A5, class A6>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6) const;
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7) const;
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8) const;
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8, class A9>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8,
const A9 &a9) const;
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8, class A9, class A10>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8,
const A9 &a9, const A10 &a10) const;
// Idem for more than 10 arguments. Do it on demand.
#endif
};
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template <class EP, class AP, class C2E, class C2A, bool Protection>
template <typename... Args>
typename Filtered_predicate<EP,AP,C2E,C2A,Protection>::result_type
@ -176,250 +115,6 @@ Filtered_predicate<EP,AP,C2E,C2A,Protection>::
return ep(c2e(args)...);
}
#else
template <class EP, class AP, class C2E, class C2A, bool Protection>
template <class A1>
typename Filtered_predicate<EP,AP,C2E,C2A,Protection>::result_type
Filtered_predicate<EP,AP,C2E,C2A,Protection>::
operator()(const A1 &a1) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
return ep(c2e(a1));
}
template <class EP, class AP, class C2E, class C2A, bool Protection>
template <class A1, class A2>
typename Filtered_predicate<EP,AP,C2E,C2A,Protection>::result_type
Filtered_predicate<EP,AP,C2E,C2A,Protection>::
operator()(const A1 &a1, const A2 &a2) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2));
}
template <class EP, class AP, class C2E, class C2A, bool Protection>
template <class A1, class A2, class A3>
typename Filtered_predicate<EP,AP,C2E,C2A,Protection>::result_type
Filtered_predicate<EP,AP,C2E,C2A,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3));
}
template <class EP, class AP, class C2E, class C2A, bool Protection>
template <class A1, class A2, class A3, class A4>
typename Filtered_predicate<EP,AP,C2E,C2A,Protection>::result_type
Filtered_predicate<EP,AP,C2E,C2A,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4));
}
template <class EP, class AP, class C2E, class C2A, bool Protection>
template <class A1, class A2, class A3, class A4, class A5>
typename Filtered_predicate<EP,AP,C2E,C2A,Protection>::result_type
Filtered_predicate<EP,AP,C2E,C2A,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4), c2a(a5));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5));
}
template <class EP, class AP, class C2E, class C2A, bool Protection>
template <class A1, class A2, class A3, class A4, class A5, class A6>
typename Filtered_predicate<EP,AP,C2E,C2A,Protection>::result_type
Filtered_predicate<EP,AP,C2E,C2A,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4), c2a(a5), c2a(a6));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6));
}
template <class EP, class AP, class C2E, class C2A, bool Protection>
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7>
typename Filtered_predicate<EP,AP,C2E,C2A,Protection>::result_type
Filtered_predicate<EP,AP,C2E,C2A,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4), c2a(a5), c2a(a6),
c2a(a7));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7));
}
template <class EP, class AP, class C2E, class C2A, bool Protection>
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8>
typename Filtered_predicate<EP,AP,C2E,C2A,Protection>::result_type
Filtered_predicate<EP,AP,C2E,C2A,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4), c2a(a5), c2a(a6),
c2a(a7), c2a(a8));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7),
c2e(a8));
}
template <class EP, class AP, class C2E, class C2A, bool Protection>
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8, class A9>
typename Filtered_predicate<EP,AP,C2E,C2A,Protection>::result_type
Filtered_predicate<EP,AP,C2E,C2A,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8,
const A9 &a9) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4), c2a(a5), c2a(a6),
c2a(a7), c2a(a8), c2a(a9));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7),
c2e(a8), c2e(a9));
}
template <class EP, class AP, class C2E, class C2A, bool Protection>
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8, class A9, class A10>
typename Filtered_predicate<EP,AP,C2E,C2A,Protection>::result_type
Filtered_predicate<EP,AP,C2E,C2A,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8,
const A9 &a9, const A10 &a10) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4), c2a(a5), c2a(a6),
c2a(a7), c2a(a8), c2a(a9), c2a(a10));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7),
c2e(a8), c2e(a9), c2e(a10));
}
#endif
} //namespace CGAL
#endif // CGAL_FILTERED_PREDICATE_H

312
Filtered_kernel/include/CGAL/Filtered_predicate_with_state.h
View File

@ -58,70 +58,11 @@ public:
: c2e(), c2a(), o1(o1), oep(), ap(c2a(o1))
{}
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template <typename... Args>
result_type
operator()(const Args&... args) const;
#else
template <class A1>
result_type
operator()(const A1 &a1) const;
template <class A1, class A2>
result_type
operator()(const A1 &a1, const A2 &a2) const;
template <class A1, class A2, class A3>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3) const;
template <class A1, class A2, class A3, class A4>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const;
template <class A1, class A2, class A3, class A4, class A5>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5) const;
template <class A1, class A2, class A3, class A4, class A5, class A6>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6) const;
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7) const;
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8) const;
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8, class A9>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8,
const A9 &a9) const;
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8, class A9, class A10>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8,
const A9 &a9, const A10 &a10) const;
// Idem for more than 10 arguments. Do it on demand.
#endif
};
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template <class EP, class AP, class C2E, class C2A, class O1, bool Protection>
template <typename... Args>
typename Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::result_type
@ -152,259 +93,6 @@ Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::
return (*oep)(c2e(args)...);
}
#else
template <class EP, class AP, class C2E, class C2A, class O1, bool Protection>
template <class A1>
typename Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::result_type
Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::
operator()(const A1 &a1) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
if(!oep) oep = EP(c2e(o1));
return *oep(c2e(a1));
}
template <class EP, class AP, class C2E, class C2A, class O1, bool Protection>
template <class A1, class A2>
typename Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::result_type
Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::
operator()(const A1 &a1, const A2 &a2) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
if(! oep) oep = EP(c2e(o1));
return (*oep)(c2e(a1), c2e(a2));
}
template <class EP, class AP, class C2E, class C2A, class O1, bool Protection>
template <class A1, class A2, class A3>
typename Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::result_type
Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
if(!oep) oep = EP(c2e(o1));
return (*oep)(c2e(a1), c2e(a2), c2e(a3));
}
template <class EP, class AP, class C2E, class C2A, class O1, bool Protection>
template <class A1, class A2, class A3, class A4>
typename Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::result_type
Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
if(! oep) oep = EP(c2e(o1));
return (*oep)(c2e(a1), c2e(a2), c2e(a3), c2e(a4));
}
template <class EP, class AP, class C2E, class C2A, class O1, bool Protection>
template <class A1, class A2, class A3, class A4, class A5>
typename Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::result_type
Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4), c2a(a5));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
if(!oep) oep = EP(c2e(o1));
return (*oep)(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5));
}
template <class EP, class AP, class C2E, class C2A, class O1, bool Protection>
template <class A1, class A2, class A3, class A4, class A5, class A6>
typename Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::result_type
Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4), c2a(a5), c2a(a6));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
if(!oep) oep = EP(c2e(o1));
return (*oep)(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6));
}
template <class EP, class AP, class C2E, class C2A, class O1, bool Protection>
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7>
typename Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::result_type
Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4), c2a(a5), c2a(a6),
c2a(a7));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
return ep(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7));
}
template <class EP, class AP, class C2E, class C2A, class O1, bool Protection>
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8>
typename Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::result_type
Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4), c2a(a5), c2a(a6),
c2a(a7), c2a(a8));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
if(!oep) oep = EP(c2e(o1));
return (*oep)(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7),
c2e(a8));
}
template <class EP, class AP, class C2E, class C2A, class O1, bool Protection>
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8, class A9>
typename Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::result_type
Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8,
const A9 &a9) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4), c2a(a5), c2a(a6),
c2a(a7), c2a(a8), c2a(a9));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
if(!oep) oep = EP(c2e(o1));
return (*oep)(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7),
c2e(a8), c2e(a9));
}
template <class EP, class AP, class C2E, class C2A, class O1, bool Protection>
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8, class A9, class A10>
typename Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::result_type
Filtered_predicate_with_state<EP,AP,C2E,C2A,O1,Protection>::
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8,
const A9 &a9, const A10 &a10) const
{
CGAL_BRANCH_PROFILER(std::string(" failures/calls to : ") + std::string(CGAL_PRETTY_FUNCTION), tmp);
{
Protect_FPU_rounding<Protection> p;
try
{
Ares res = ap(c2a(a1), c2a(a2), c2a(a3), c2a(a4), c2a(a5), c2a(a6),
c2a(a7), c2a(a8), c2a(a9), c2a(a10));
if (is_certain(res))
return get_certain(res);
}
catch (Uncertain_conversion_exception&) {}
}
CGAL_BRANCH_PROFILER_BRANCH(tmp);
Protect_FPU_rounding<!Protection> p(CGAL_FE_TONEAREST);
if(!oep) oep = EP(c2e(o1));
return (*oep)(c2e(a1), c2e(a2), c2e(a3), c2e(a4), c2e(a5), c2e(a6), c2e(a7),
c2e(a8), c2e(a9), c2e(a10));
}
#endif
} //namespace CGAL
#endif // CGAL_FILTERED_PREDICATE_WITH_STATE_H

72
Filtered_kernel/include/CGAL/Robust_construction.h
View File

@ -59,82 +59,10 @@ public:
typedef A2E Approximate_to_exact_converter;
typedef E2A Exact_to_approximate_converter;
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template <typename... Args>
result_type
operator()(const Args&... args) const
{ return e2a(ec(a2e(args)...)); }
#else
template <class A1>
result_type
operator()(const A1 &a1) const
{ return e2a(ec(a2e(a1))); }
template <class A1, class A2>
result_type
operator()(const A1 &a1, const A2 &a2) const
{ return e2a(ec(a2e(a1), a2e(a2))); }
template <class A1, class A2, class A3>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3) const
{ return e2a(ec(a2e(a1), a2e(a2), a2e(a3))); }
template <class A1, class A2, class A3, class A4>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const
{ return e2a(ec(a2e(a1), a2e(a2), a2e(a3), a2e(a4))); }
template <class A1, class A2, class A3, class A4, class A5>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5) const
{ return e2a(ec(a2e(a1), a2e(a2), a2e(a3), a2e(a4), a2e(a5))); }
template <class A1, class A2, class A3, class A4, class A5, class A6>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6) const
{ return e2a(ec(a2e(a1), a2e(a2), a2e(a3), a2e(a4), a2e(a5), a2e(a6))); }
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7) const
{ return e2a(ec(a2e(a1), a2e(a2), a2e(a3), a2e(a4), a2e(a5),
a2e(a6), a2e(a7))); }
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8) const
{ return e2a(ec(a2e(a1), a2e(a2), a2e(a3), a2e(a4), a2e(a5),
a2e(a6), a2e(a7), a2e(a8))); }
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8, class A9>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8,
const A9 &a9) const
{ return e2a(ec(a2e(a1), a2e(a2), a2e(a3), a2e(a4), a2e(a5),
a2e(a6), a2e(a7), a2e(a8), a2e(a9))); }
template <class A1, class A2, class A3, class A4, class A5, class A6,
class A7, class A8, class A9, class A10>
result_type
operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4,
const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8,
const A9 &a9, const A10 &a10) const
{ return e2a(ec(a2e(a1), a2e(a2), a2e(a3), a2e(a4), a2e(a5),
a2e(a6), a2e(a7), a2e(a8), a2e(a9), a2e(a10))); }
// Idem for more than 10 arguments. Do it on demand (or use C++0x).
#endif
};
} //namespace CGAL

4
Intersections_2/benchmark/Intersections_2/variant_any_object.cpp
View File

@ -16,11 +16,9 @@
#include <boost/timer.hpp>
#include <boost/lexical_cast.hpp>
#if !defined(CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES) && !defined(CGAL_CFG_NO_CPP0X_TUPLE)
#include <tuple>
#include <functional>
#include <CGAL/Overload.h>
#endif
// Intersection_traits
template<typename, typename, typename>
@ -208,7 +206,6 @@ struct Do_f : Vec_holder {
}
};
#if !defined(CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES) && !defined(CGAL_CFG_NO_CPP0X_TUPLE)
cpp0x::tuple<int, int, int> intersect_each_variant_overload(const Vector& segs) {
cpp0x::tuple<int, int, int> ret = cpp0x::make_tuple(0, 0, 0);
typedef Intersection_traits<K, Segment, Segment> Traits;
@ -236,7 +233,6 @@ cpp0x::tuple<int, int, int> intersect_each_variant_overload(const Vector& segs)
return ret;
}
#endif
int main(int argc, char* argv[]) {
int repeats = 100;

24
Intersections_2/include/CGAL/Intersection_traits.h
View File

@ -158,28 +158,16 @@ namespace internal {
// the real type.
// Overloads for empty returns are also provided.
#if CGAL_INTERSECTION_VERSION < 2
#if defined(CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE)
template<typename, typename, typename, typename T>
inline
CGAL::Object intersection_return(const T& t) { return CGAL::make_object(t); }
#else
template<typename, typename, typename, typename T>
inline
CGAL::Object intersection_return(T&& t) { return CGAL::make_object(std::forward<T>(t)); }
#endif // CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE
template<typename, typename, typename, typename T>
inline
CGAL::Object intersection_return(T&& t) { return CGAL::make_object(std::forward<T>(t)); }
template<typename, typename, typename>
inline
CGAL::Object intersection_return() { return CGAL::Object(); }
#else
#if defined(CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE)
template<typename F, typename A, typename B, typename T>
inline typename cpp11::result_of<F(A, B)>::type
intersection_return(const T& t) { return typename cpp11::result_of<F(A, B)>::type(t); }
#else
template<typename F, typename A, typename B, typename T>
inline typename cpp11::result_of<F(A, B)>::type
intersection_return(T&& t) { return typename cpp11::result_of<F(A, B)>::type(std::forward<T>(t)); }
#endif // CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE
template<typename F, typename A, typename B, typename T>
inline typename cpp11::result_of<F(A, B)>::type
intersection_return(T&& t) { return typename cpp11::result_of<F(A, B)>::type(std::forward<T>(t)); }
template<typename F, typename A, typename B>
inline typename cpp11::result_of<F(A, B)>::type
intersection_return() { return typename cpp11::result_of<F(A, B)>::type(); }

3
Kernel_23/include/CGAL/basic.h
View File

@ -35,9 +35,6 @@
// This cannot be disabled for now until we have a clear idea which
// compilers implement N3276.
// #if !defined(CGAL_CFG_NO_CPP0X_DECLTYPE)
// #define BOOST_RESULT_OF_USE_DECLTYPE
// #endif
#include <CGAL/result_of.h>
#include <CGAL/assertions.h>

2
Kernel_23/test/Kernel_23/include/CGAL/_test_cls_object.h
View File

@ -40,10 +40,8 @@ public:
Object_handle(const CGAL::Object& o) : Base(o) {}
Object_handle(const Object_handle& h) : Base(h) {}
#ifndef CGAL_CFG_NO_CPP0X_DELETED_AND_DEFAULT_FUNCTIONS
Object_handle&
operator=(const Object_handle& v)=default;
#endif
};
Object_handle return_obj()

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

@ -362,10 +362,8 @@ public:
{ reduce(); simplify_coefficients(); }
#endif // defined(CGAL_USE_LEDA) || defined(DOXYGEN_RUNNING)
#ifndef CGAL_CFG_NO_CPP0X_DELETED_AND_DEFAULT_FUNCTIONS
Polynomial&
operator=(const Polynomial& p)=default;
#endif
//
// Public member functions

3
Property_map/include/CGAL/property_map.h
View File

@ -342,7 +342,6 @@ struct Nth_of_tuple_property_map
/// @}
};
#ifndef CGAL_CFG_NO_CPP0X_TUPLE
template <int N, typename ... T>
struct Nth_of_tuple_property_map<N,std::tuple<T...> >
{
@ -358,8 +357,6 @@ struct Nth_of_tuple_property_map<N,std::tuple<T...> >
friend reference get(const Self&,const key_type& k) {return std::get<N>(k);}
friend void put(const Self&,key_type& k, const value_type& v) {std::get<N>(k)=v;}
};
#endif
/// Free function to create a Nth_of_tuple_property_map property map.
///

2
Stream_support/include/CGAL/IO/io_tags.h
View File

@ -53,10 +53,8 @@ template<> struct Io_traits<unsigned short> { typedef io_Read_write Io_tag; };
template<> struct Io_traits<unsigned int> { typedef io_Read_write Io_tag; };
template<> struct Io_traits<unsigned long> { typedef io_Read_write Io_tag; };
#ifndef CGAL_CFG_NO_CPP0X_LONG_LONG
template<> struct Io_traits<long long> { typedef io_Read_write Io_tag; };
template<> struct Io_traits<unsigned long long> { typedef io_Read_write Io_tag; };
#endif
template<> struct Io_traits<float> { typedef io_Read_write Io_tag; };
template<> struct Io_traits<double> { typedef io_Read_write Io_tag; };