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

remove variadic template workaround for cmap, gmap, and lcell

This commit is contained in:
Sébastien Loriot 2019-03-19 13:17:37 +01:00
parent 8ec090d1d1
commit 6e8e4a4b10
13 changed files with 1 additions and 4552 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
BGL/examples/BGL_LCC/range_lcc.cpp
View File

@ -37,12 +37,10 @@ void fct(const LCC& lcc)
{
vertex_range vr(vertices(lcc));
#ifndef CGAL_CFG_NO_CPP0X_RANGE_BASED_FOR
std::cout << "new for loop" << std::endl;
for(vertex_descriptor vd : vr){
std::cout << vd->point() << std::endl;
}
#endif
std::cout << "BOOST_FOREACH" << std::endl;
BOOST_FOREACH(vertex_descriptor vd, vr){

2
BGL/examples/BGL_polyhedron_3/range.cpp
View File

@ -36,12 +36,10 @@ void fct(const Polyhedron& p)
{
vertex_range vr(vertices(p));
#ifndef CGAL_CFG_NO_CPP0X_RANGE_BASED_FOR
std::cout << "new for loop" << std::endl;
for(vertex_descriptor vd : vr){
std::cout << vd->point() << std::endl;
}
#endif
std::cout << "BOOST_FOREACH" << std::endl;
BOOST_FOREACH(vertex_descriptor vd, vr){

649
Combinatorial_map/include/CGAL/Combinatorial_map.h
View File

@ -431,7 +431,6 @@ namespace CGAL {
* is unmarked for all the marks.
* @return a Dart_handle on the new dart.
*/
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template < typename... Args >
Dart_handle create_dart(const Args&... args)
{
@ -439,90 +438,6 @@ namespace CGAL {
init_dart(res);
return res;
}
#else
Dart_handle create_dart()
{
Dart_handle res=mdarts.emplace();
init_dart(res);
return res;
}
template < typename T1 >
Dart_handle create_dart(const T1 &t1)
{
Dart_handle res=mdarts.emplace(t1);
init_dart(res);
return res;
}
template < typename T1, typename T2 >
Dart_handle create_dart(const T1 &t1, const T2 &t2)
{
Dart_handle res=mdarts.emplace(t1, t2);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3)
{
Dart_handle res=mdarts.emplace(t1, t2, t3);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3, typename T4 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3,
const T4 &t4)
{
Dart_handle res=mdarts.emplace(t1, t2, t3, t4);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3, typename T4, typename T5 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3,
const T4 &t4, const T5 &t5)
{
Dart_handle res=mdarts.emplace(t1, t2, t3, t4, t5);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3,
const T4 &t4, const T5 &t5, const T6 &t6)
{
Dart_handle res=mdarts.emplace(t1, t2, t3, t4, t5, t6);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3,
const T4 &t4, const T5 &t5, const T6 &t6,
const T7 &t7)
{
Dart_handle res=mdarts.emplace(t1, t2, t3, t4, t5, t6, t7);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3,
const T4 &t4, const T5 &t5, const T6 &t6,
const T7 &t7, const T8 &t8)
{
Dart_handle res=mdarts.emplace(t1, t2, t3, t4, t5, t6, t7, t8);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3,
const T4 &t4, const T5 &t5, const T6 &t6,
const T7 &t7, const T8 &t8, const T9 &t9)
{
Dart_handle res=mdarts.emplace(t1, t2, t3, t4, t5, t6, t7, t8, t9);
init_dart(res);
return res;
}
#endif
/** Erase a dart from the list of darts.
* @param adart the dart to erase.
@ -731,8 +646,6 @@ namespace CGAL {
/// @return the betas of ADart (beta are used in the same order than
/// they are given as parameters)
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename ...Betas>
Dart_handle beta(Dart_handle ADart, Betas... betas)
{ return CGAL::internal::Beta_functor<Self, Dart_handle, Betas...>::
@ -749,119 +662,6 @@ namespace CGAL {
Dart_const_handle beta(Dart_const_handle ADart) const
{ return CGAL::internal::Beta_functor_static<const Self, Dart_const_handle, Betas...>::
run(*this, ADart); }
#else
Dart_handle beta(Dart_handle ADart, int B1)
{ return this->get_beta(ADart, B1); }
Dart_handle beta(Dart_handle ADart, int B1, int B2)
{ return beta(beta(ADart, B1), B2); }
Dart_handle beta(Dart_handle ADart, int B1, int B2, int B3)
{ return beta(beta(ADart, B1), B2, B3); }
Dart_handle beta(Dart_handle ADart, int B1, int B2, int B3,
int B4)
{ return beta(beta(ADart, B1), B2, B3, B4); }
Dart_handle beta(Dart_handle ADart, int B1, int B2, int B3,
int B4, int B5)
{ return beta(beta(ADart, B1), B2, B3, B4, B5); }
Dart_handle beta(Dart_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6)
{ return beta(beta(ADart, B1), B2, B3, B4, B5, B6); }
Dart_handle beta(Dart_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6, int B7)
{ return beta(beta(ADart, B1), B2, B3, B4, B5, B6, B7); }
Dart_handle beta(Dart_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6, int B7, int B8)
{ return beta(beta(ADart, B1), B2, B3, B4, B5, B6, B7, B8); }
Dart_handle beta(Dart_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6, int B7, int B8, int B9)
{ return beta(beta(ADart, B1), B2, B3, B4, B5, B6, B7, B8, B9); }
template<int B1>
Dart_handle beta(Dart_handle ADart)
{ return this->template get_beta<B1>(ADart); }
template<int B1, int B2>
Dart_handle beta(Dart_handle ADart)
{ return beta<B2>(beta<B1>(ADart)); }
template<int B1, int B2, int B3>
Dart_handle beta(Dart_handle ADart)
{ return beta<B2, B3>(beta<B1>(ADart)); }
template<int B1, int B2, int B3, int B4>
Dart_handle beta(Dart_handle ADart)
{ return beta<B2, B3, B4>(beta<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5>
Dart_handle beta(Dart_handle ADart)
{ return beta<B2, B3, B4, B5>(beta<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6>
Dart_handle beta(Dart_handle ADart)
{ return beta<B2, B3, B4, B5, B6>(beta<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6,
int B7>
Dart_handle beta(Dart_handle ADart)
{ return beta<B2, B3, B4, B5, B6, B7>(beta<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6,
int B7, int B8>
Dart_handle beta(Dart_handle ADart)
{ return beta<B2, B3, B4, B5, B6, B7, B8>(beta<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6,
int B7, int B8, int B9>
Dart_handle beta(Dart_handle ADart)
{ return beta<B2, B3, B4, B5, B6, B7, B8, B9>(beta<B1>(ADart)); }
Dart_const_handle beta(Dart_const_handle ADart, int B1) const
{ return this->get_beta(ADart, B1); }
Dart_const_handle beta(Dart_const_handle ADart, int B1, int B2) const
{ return beta(beta(ADart, B1), B2); }
Dart_const_handle beta(Dart_const_handle ADart, int B1, int B2, int B3) const
{ return beta(beta(ADart, B1), B2, B3); }
Dart_const_handle beta(Dart_const_handle ADart, int B1, int B2, int B3,
int B4) const
{ return beta(beta(ADart, B1), B2, B3, B4); }
Dart_const_handle beta(Dart_const_handle ADart, int B1, int B2, int B3,
int B4, int B5) const
{ return beta(beta(ADart, B1), B2, B3, B4, B5); }
Dart_const_handle beta(Dart_const_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6) const
{ return beta(beta(ADart, B1), B2, B3, B4, B5, B6); }
Dart_const_handle beta(Dart_const_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6, int B7) const
{ return beta(beta(ADart, B1), B2, B3, B4, B5, B6, B7); }
Dart_const_handle beta(Dart_const_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6, int B7, int B8) const
{ return beta(beta(ADart, B1), B2, B3, B4, B5, B6, B7, B8); }
Dart_const_handle beta(Dart_const_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6, int B7, int B8, int B9) const
{ return beta(beta(ADart, B1), B2, B3, B4, B5, B6, B7, B8, B9); }
template<int B1>
Dart_const_handle beta(Dart_const_handle ADart) const
{ return this->template get_beta<B1>(ADart); }
template<int B1, int B2>
Dart_const_handle beta(Dart_const_handle ADart) const
{ return beta<B2>(beta<B1>(ADart)); }
template<int B1, int B2, int B3>
Dart_const_handle beta(Dart_const_handle ADart) const
{ return beta<B2, B3>(beta<B1>(ADart)); }
template<int B1, int B2, int B3, int B4>
Dart_const_handle beta(Dart_const_handle ADart) const
{ return beta<B2, B3, B4>(beta<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5>
Dart_const_handle beta(Dart_const_handle ADart) const
{ return beta<B2, B3, B4, B5>(beta<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6>
Dart_const_handle beta(Dart_const_handle ADart) const
{ return beta<B2, B3, B4, B5, B6>(beta<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6,
int B7>
Dart_const_handle beta(Dart_const_handle ADart) const
{ return beta<B2, B3, B4, B5, B6, B7>(beta<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6,
int B7, int B8>
Dart_const_handle beta(Dart_const_handle ADart) const
{ return beta<B2, B3, B4, B5, B6, B7, B8>(beta<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6,
int B7, int B8, int B9>
Dart_const_handle beta(Dart_const_handle ADart) const
{ return beta<B2, B3, B4, B5, B6, B7, B8, B9>(beta<B1>(ADart)); }
#endif
// Generic function to iterate on CMap or GMap in a generic way
bool is_previous_exist(Dart_const_handle ADart) const
@ -1505,7 +1305,6 @@ namespace CGAL {
/// Create a new attribute.
/// @return a handle on the new attribute.
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<unsigned int i, typename ...Args>
typename Attribute_handle<i>::type create_attribute(const Args&... args)
{
@ -1521,152 +1320,6 @@ namespace CGAL {
(this->template attributes<i>(), res);
return res;
}
#else
template<unsigned int i>
typename Attribute_handle<i>::type
create_attribute()
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace();
internal::Init_id<typename Attribute_range<i>::type>::run
(this->template attributes<i>(), res);
return res;
}
template<unsigned int i, typename T1>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1);
// Reinitialize the ref counting of the new attribute. This is normally
// not required except if create_attribute is used as "copy contructor".
this->template init_attribute_ref_counting<i>(res);
internal::Init_id<typename Attribute_range<i>::type>::run
(this->template attributes<i>(), res);
return res;
}
template<unsigned int i, typename T1, typename T2>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2);
internal::Init_id<typename Attribute_range<i>::type>::run
(this->template attributes<i>(), res);
return res;
}
template<unsigned int i, typename T1, typename T2, typename T3>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3);
internal::Init_id<typename Attribute_range<i>::type>::run
(this->template attributes<i>(), res);
return res;
}
template<unsigned int i, typename T1, typename T2, typename T3, typename T4>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3, t4);
internal::Init_id<typename Attribute_range<i>::type>::run
(this->template attributes<i>(), res);
return res;
}
template<unsigned int i, typename T1, typename T2, typename T3, typename T4,
typename T5>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3, t4, t5);
internal::Init_id<typename Attribute_range<i>::type>::run
(this->template attributes<i>(), res);
return res;
}
template<unsigned int i, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3, t4, t5, t6);
internal::Init_id<typename Attribute_range<i>::type>::run
(this->template attributes<i>(), res);
return res;
}
template<unsigned int i, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6, const T7 &t7)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3, t4, t5, t6, t7);
internal::Init_id<typename Attribute_range<i>::type>::run
(this->template attributes<i>(), res);
return res;
}
template<unsigned int i, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3, t4, t5, t6, t7, t8);
internal::Init_id<typename Attribute_range<i>::type>::run
(this->template attributes<i>(), res);
return res;
}
template<unsigned int i, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8, typename T9>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8,
const T9 &t9)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3, t4, t5, t6, t7, t8, t9);
internal::Init_id<typename Attribute_range<i>::type>::run
(this->template attributes<i>(), res);
return res;
}
#endif
/// Erase an attribute.
/// @param h a handle to the attribute to erase.
@ -2815,7 +2468,6 @@ namespace CGAL {
return res;
}
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//**************************************************************************
// Dart_of_orbit_basic_range
template<unsigned int ... Beta>
@ -2894,307 +2546,6 @@ namespace CGAL {
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<Beta...>(*this,adart,amark); }
//**************************************************************************
#else
//**************************************************************************
// Dart_of_orbit_basic_range
template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
int B6=-1,int B7=-1,int B8=-1,int B9=-1>
struct Dart_of_orbit_basic_range: public CGAL::CMap_range
<Self, CGAL::CMap_dart_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9>,
CGAL::CMap_dart_const_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9> >
{
typedef CGAL::CMap_range
<Self, CGAL::CMap_dart_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9>,
CGAL::CMap_dart_const_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,
B6,B7,B8,B9> > Base;
Dart_of_orbit_basic_range(Self &amap, Dart_handle adart,
size_type /*amark*/=INVALID_MARK):
Base(amap, adart)
{}
};
//**************************************************************************
// Dart_of_orbit_basic_const_range
template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
int B6=-1,int B7=-1,int B8=-1,int B9=-1>
struct Dart_of_orbit_basic_const_range: public CMap_const_range
<Self,
CGAL::CMap_dart_const_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9> >
{
typedef CMap_const_range
<Self, CGAL::CMap_dart_const_iterator_basic_of_orbit
<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> > Base;
Dart_of_orbit_basic_const_range(const Self &amap,
Dart_const_handle adart, size_type amark=INVALID_MARK):
Base(amap, adart, amark)
{}
};
//**************************************************************************
// Dart_of_orbit_range
template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
int B6=-1,int B7=-1,int B8=-1,int B9=-1>
struct Dart_of_orbit_range: public CGAL::CMap_range
<Self, CGAL::CMap_dart_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9>,
CGAL::CMap_dart_const_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> >
{
typedef CGAL::CMap_range
<Self, CGAL::CMap_dart_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9>,
CGAL::CMap_dart_const_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9> >
Base;
Dart_of_orbit_range(Self &amap, Dart_handle adart):
Base(amap, adart)
{}
};
//**************************************************************************
// Dart_of_orbit_const_range
template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
int B6=-1,int B7=-1,int B8=-1,int B9=-1>
struct Dart_of_orbit_const_range: public CMap_const_range
<Self, CGAL::CMap_dart_const_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9> >
{
typedef CMap_const_range
<Self, CGAL::CMap_dart_const_iterator_of_orbit
<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> > Base;
Dart_of_orbit_const_range(const Self &amap, Dart_const_handle adart):
Base(amap, adart)
{}
};
//**************************************************************************
/// @return a range on all the darts of the given orbit
Dart_of_orbit_range<> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1>
Dart_of_orbit_range<B1> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2>
Dart_of_orbit_range<B1,B2> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3>
Dart_of_orbit_range<B1,B2,B3> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4>
Dart_of_orbit_range<B1,B2,B3,B4> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3,B4>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5>
Dart_of_orbit_range<B1,B2,B3,B4,B5> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3,B4,B5>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6>
Dart_of_orbit_range<B1,B2,B3,B4,B5,B6> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3,B4,B5,B6>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7>
Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7,B8> darts_of_orbit
(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7,B8>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
unsigned int B9>
Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>(*this,adart); }
//--------------------------------------------------------------------------
// Const versions.
Dart_of_orbit_const_range<> darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1>
Dart_of_orbit_const_range<B1> darts_of_orbit(Dart_const_handle
adart) const
{ return Dart_of_orbit_const_range<B1>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2>
Dart_of_orbit_const_range<B1,B2> darts_of_orbit(Dart_const_handle
adart) const
{ return Dart_of_orbit_const_range<B1,B2>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3>
Dart_of_orbit_const_range<B1,B2,B3> darts_of_orbit
(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4>
Dart_of_orbit_const_range<B1,B2,B3,B4>
darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3,B4>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5>
Dart_of_orbit_const_range<B1,B2,B3,B4,B5>
darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3,B4,B5>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6>
Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6>
darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7>
Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7>
darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8>
darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
unsigned int B9>
Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
(*this,adart); }
//--------------------------------------------------------------------------
// Basic versions
Dart_of_orbit_basic_range<> darts_of_orbit_basic(Dart_handle adart,
size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<>(*this,adart,amark); }
//--------------------------------------------------------------------------
Dart_of_orbit_basic_const_range<> darts_of_orbit_basic
(Dart_const_handle adart,size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1>
Dart_of_orbit_basic_range<B1> darts_of_orbit_basic(Dart_handle adart,
size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1>
Dart_of_orbit_basic_const_range<B1> darts_of_orbit_basic
(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2>
Dart_of_orbit_basic_range<B1,B2> darts_of_orbit_basic(Dart_handle adart,
size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2>
Dart_of_orbit_basic_const_range<B1,B2> darts_of_orbit_basic
(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3>
Dart_of_orbit_basic_range<B1,B2,B3> darts_of_orbit_basic(Dart_handle adart,
size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3>
Dart_of_orbit_basic_const_range<B1,B2,B3> darts_of_orbit_basic
(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4>
Dart_of_orbit_basic_range<B1,B2,B3,B4> darts_of_orbit_basic
(Dart_handle adart, size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3,B4>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4>
Dart_of_orbit_basic_const_range<B1,B2,B3,B4>
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3,B4>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5>
Dart_of_orbit_basic_range<B1,B2,B3,B4,B5> darts_of_orbit_basic
(Dart_handle adart, size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5>
Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5>
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6>
Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6> darts_of_orbit_basic
(Dart_handle adart, size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6>
Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6>
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7>
Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7> darts_of_orbit_basic
(Dart_handle adart, size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7>
Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7>
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7,B8> darts_of_orbit
(Dart_handle adart, size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7,B8>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7,B8>
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7,B8>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
unsigned int B9>
Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
darts_of_orbit_basic(Dart_handle adart, size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
unsigned int B9>
Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
(*this,adart,amark); }
//**************************************************************************
#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//**************************************************************************
// Dart_of_cell_basic_range
template<unsigned int i,int dim=Self::dimension>
struct Dart_of_cell_basic_range: public CGAL::CMap_range

67
Combinatorial_map/include/CGAL/Dart_const_iterators.h
View File

@ -38,7 +38,7 @@ namespace CGAL {
* - CMap_dart_const_iterator_basic_of_involution_inv<Map,i,d>
*/
//****************************************************************************
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename Map_,unsigned int...Beta>
class CMap_dart_const_iterator_basic_of_orbit:
public CMap_dart_iterator_basic_of_orbit_generic<Map_,true,Beta...>
@ -92,71 +92,6 @@ namespace CGAL {
it.get_first_dart())
{}
};
#else
//****************************************************************************
template<typename Map_,int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
int B6=-1,int B7=-1,int B8=-1,int B9=-1>
class CMap_dart_const_iterator_basic_of_orbit:
public CMap_dart_iterator_basic_of_orbit_generic<Map_,true,B1,B2,B3,B4,
B5,B6,B7,B8,B9>
{
public:
typedef CMap_dart_const_iterator_basic_of_orbit<Map_,B1,B2,B3,B4,B5,B6,
B7,B8,B9> Self;
typedef CMap_dart_iterator_basic_of_orbit_generic<Map_,true,B1,B2,B3,B4,
B5,B6,B7,B8,B9> Base;
typedef typename Map_::Dart_const_handle Dart_const_handle;
typedef typename Map_::size_type size_type;
/// Main constructor.
CMap_dart_const_iterator_basic_of_orbit(const Map_& amap,
Dart_const_handle adart):
Base(amap,adart)
{}
/// Main constructor.
CMap_dart_const_iterator_basic_of_orbit(const Map_& amap,
Dart_const_handle adart,
size_type amark):
Base(amap,adart,amark)
{}
/// Constructor from non const version.
CMap_dart_const_iterator_basic_of_orbit
(const CMap_dart_iterator_basic_of_orbit<Map_,B1,B2,B3,B4,B5,B6,
B7,B8,B9>& it):
Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
it.get_first_dart(),
it.mmark_number)
{}
};
//****************************************************************************
template<typename Map_,int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
int B6=-1,int B7=-1,int B8=-1,int B9=-1>
class CMap_dart_const_iterator_of_orbit:
public CMap_dart_iterator_of_orbit_generic<Map_,true,B1,B2,B3,B4,
B5,B6,B7,B8,B9>
{
public:
typedef CMap_dart_const_iterator_of_orbit<Map_,B1,B2,B3,B4,B5,B6,
B7,B8,B9> Self;
typedef CMap_dart_iterator_of_orbit_generic<Map_,true,B1,B2,B3,B4,
B5,B6,B7,B8,B9> Base;
typedef typename Map_::Dart_const_handle Dart_const_handle;
/// Main constructor.
CMap_dart_const_iterator_of_orbit(const Map_& amap,
Dart_const_handle adart):
Base(amap,adart)
{}
/// Constructor from non const version.
CMap_dart_const_iterator_of_orbit
(const CMap_dart_iterator_of_orbit<Map_,B1,B2,B3,B4,B5,B6,B7,B8,B9>& it):
Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
it.get_first_dart())
{}
};
#endif // CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//****************************************************************************
template<typename Map_>
class CMap_dart_const_iterator_basic_of_all:

198
Combinatorial_map/include/CGAL/Dart_iterators.h
View File

@ -45,97 +45,8 @@ namespace CGAL {
/* Class CMap_dart_iterator_basic_of_orbit<Map, Beta...>: to iterate
* on the darts of the orbit <Beta...>
*/
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename Map,bool Const,int... Beta>
class CMap_dart_iterator_basic_of_orbit_generic;
#else
template <typename Map,bool Const,int B1=-1,int B2=-1,int B3=-1,int B4=-1,
int B5=-1,int B6=-1,int B7=-1,int B8=-1,int B9=-1>
class CMap_dart_iterator_basic_of_orbit_generic;
template <typename Map,bool Const,int B1=-1,int B2=-1,int B3=-1,int B4=-1,
int B5=-1,int B6=-1,int B7=-1,int B8=-1,int B9=-1>
struct Get_CMap_dart_iterator_basic_of_orbit;
template<typename Map,bool Const,int B1,int B2,int B3,int B4,int B5,int B6,
int B7,int B8,int B9>
struct Get_CMap_dart_iterator_basic_of_orbit
{
typedef CMap_dart_iterator_basic_of_orbit_generic<Map,Const,B1,B2,B3,B4,
B5,B6,B7,B8,B9> type;
};
template<typename Map,bool Const,int B1,int B2,int B3,int B4,int B5,int B6,
int B7,int B8>
struct Get_CMap_dart_iterator_basic_of_orbit<Map,Const,
B1,B2,B3,B4,B5,B6,B7,B8,-1>
{
typedef CMap_dart_iterator_basic_of_orbit_generic<Map,Const,B1,B2,B3,B4,B5,
B6,B7,B8> type;
};
template<typename Map,bool Const,int B1,int B2,int B3,int B4,int B5,int B6,
int B7>
struct Get_CMap_dart_iterator_basic_of_orbit<Map,Const,
B1,B2,B3,B4,B5,B6,B7,-1,-1>
{
typedef CMap_dart_iterator_basic_of_orbit_generic<Map,Const,
B1,B2,B3,B4,B5,
B6,B7> type;
};
template<typename Map,bool Const,int B1,int B2,int B3,int B4,int B5,int B6>
struct Get_CMap_dart_iterator_basic_of_orbit<Map,Const,
B1,B2,B3,B4,B5,B6,-1,-1,-1>
{
typedef CMap_dart_iterator_basic_of_orbit_generic<Map,Const,B1,B2,B3,B4,
B5,B6> type;
};
template<typename Map,bool Const,int B1,int B2,int B3,int B4,int B5>
struct Get_CMap_dart_iterator_basic_of_orbit<Map,Const,
B1,B2,B3,B4,B5,-1,-1,-1,-1>
{
typedef CMap_dart_iterator_basic_of_orbit_generic<Map,B1,B2,B3,B4,
B5,Const> type;
};
template<typename Map,bool Const,int B1,int B2,int B3,int B4>
struct Get_CMap_dart_iterator_basic_of_orbit<Map,Const,
B1,B2,B3,B4,-1,-1,-1,-1,-1>
{
typedef CMap_dart_iterator_basic_of_orbit_generic<Map,Const,B1,B2,B3,
B4> type;
};
template<typename Map, int B1,int B2,int B3,bool Const>
struct Get_CMap_dart_iterator_basic_of_orbit<Map,Const,
B1,B2,B3,-1,-1,-1,-1,-1,-1>
{
typedef CMap_dart_iterator_basic_of_orbit_generic<Map,Const,B1,B2,B3> type;
};
template<typename Map, int B1,int B2,bool Const>
struct Get_CMap_dart_iterator_basic_of_orbit<Map,Const,
B1,B2,-1,-1,-1,-1,-1,-1,-1>
{
typedef CMap_dart_iterator_basic_of_orbit_generic<Map,Const,B1,B2> type;
};
template<typename Map, int B1,bool Const>
struct Get_CMap_dart_iterator_basic_of_orbit<Map,Const,
B1,-1,-1,-1,-1,-1,-1,-1,-1>
{
typedef CMap_dart_iterator_basic_of_orbit_generic<Map,Const,B1> type;
};
template<typename Map,bool Const>
struct Get_CMap_dart_iterator_basic_of_orbit<Map,Const,
-1,-1,-1,-1,-1,-1,-1,-1,-1>
{
typedef CMap_dart_iterator_basic_of_orbit_generic<Map,Const> type;
};
#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//****************************************************************************
// Case when Beta... is empty: iterator of self
template <typename Map_,bool Const>
@ -994,7 +905,6 @@ namespace CGAL {
//****************************************************************************
/* Generic nD version.
*/
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template <typename Map_,bool Const,int Bi,int Bj, int Bk, int... Beta>
class CMap_dart_iterator_basic_of_orbit_generic<Map_,Const,Bi,Bj,Bk,Beta...>:
public CMap_extend_iterator<Map_,
@ -1024,42 +934,10 @@ namespace CGAL {
Base(amap, adart, amark)
{}
};
#else //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template <typename Map_,bool Const,int B1,int B2,int B3,int B4,int B5,int B6,
int B7,int B8,int B9>
class CMap_dart_iterator_basic_of_orbit_generic:
public CMap_extend_iterator
<Map_,typename Get_CMap_dart_iterator_basic_of_orbit
<Map_,Const,B1,B2,B4,B5,B6,B7,B8,B9>::type, B3>
{
public:
typedef typename Get_CMap_dart_iterator_basic_of_orbit
<Map_,Const,B1,B2,B3,B4,B5,B6,B7,B8,B9>::type Self;
typedef CMap_extend_iterator
<Map_,typename Get_CMap_dart_iterator_basic_of_orbit
<Map_,Const,B1,B2,B4,B5,B6,B7,B8,B9>::type, B3> Base;
typedef typename Base::Dart_handle Dart_handle;
typedef typename Base::Map Map;
typedef typename Map::size_type size_type;
/// True iff this iterator is basic
typedef Tag_true Basic_iterator;
public:
/// Main constructor.
CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart,
size_type amark):
Base(amap, adart, amark)
{}
};
#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//****************************************************************************
// TODO? we can optimize the iterators<Bi,Bj,Bk> when
// 1<Bi and Bi+2<=Bj and Bj+2<=Bk but there is no real interest...
//****************************************************************************
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename Map,int...Beta>
class CMap_dart_iterator_basic_of_orbit:
public CMap_dart_iterator_basic_of_orbit_generic<Map,false,Beta...>
@ -1080,33 +958,6 @@ namespace CGAL {
Base(amap,adart,amark)
{}
};
#else
//****************************************************************************
template<typename Map,int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
int B6=-1,int B7=-1,int B8=-1,int B9=-1>
class CMap_dart_iterator_basic_of_orbit:
public Get_CMap_dart_iterator_basic_of_orbit<Map,false,B1,B2,B3,B4,
B5,B6,B7,B8,B9>::type
{
public:
typedef CMap_dart_iterator_basic_of_orbit<Map,B1,B2,B3,B4,B5,B6,B7,B8,B9>
Self;
typedef typename Get_CMap_dart_iterator_basic_of_orbit
<Map,false,B1,B2,B3,B4,B5,B6,B7,B8,B9>::type Base;
typedef typename Map::Dart_handle Dart_handle;
typedef typename Map::size_type size_type;
/// Main constructor.
CMap_dart_iterator_basic_of_orbit(Map& amap,Dart_handle adart):
Base(amap,adart)
{}
/// Main constructor.
CMap_dart_iterator_basic_of_orbit(Map& amap,Dart_handle adart,size_type amark):
Base(amap,adart,amark)
{}
};
#endif // CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//****************************************************************************
/* Class CMap_dart_iterator_basic_of_all: to iterate onto all the
* darts of the map.
@ -1789,7 +1640,6 @@ namespace CGAL {
//*************************ITERATORS*NON*BASIC********************************
//****************************************************************************
//****************************************************************************
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename Map_,bool Const,int...Beta>
class CMap_dart_iterator_of_orbit_generic:
public CMap_non_basic_iterator<Map_,
@ -1826,54 +1676,6 @@ namespace CGAL {
Base(amap, adart)
{}
};
#else
//****************************************************************************
template<typename Map_,bool Const,int B1=-1,int B2=-1,int B3=-1,int B4=-1,
int B5=-1,int B6=-1,int B7=-1,int B8=-1,int B9=-1>
class CMap_dart_iterator_of_orbit_generic:
public CMap_non_basic_iterator<Map_,
typename
Get_CMap_dart_iterator_basic_of_orbit
<Map_,Const,B1,B2,B3,B4,B5,
B6,B7,B8,B9>::type>
{
public:
typedef CMap_dart_iterator_of_orbit_generic<Map_,Const,B1,B2,B3,B4,B5,
B6,B7,B8,B9> Self;
typedef CMap_non_basic_iterator<Map_,
typename
Get_CMap_dart_iterator_basic_of_orbit
<Map_,Const,B1,B2,B3,B4,B5,
B6,B7,B8,B9>::type> Base;
typedef typename Base::Map Map;
typedef typename Base::Dart_handle Dart_handle;
/// Main constructor.
CMap_dart_iterator_of_orbit_generic(Map& amap, Dart_handle adart1):
Base(amap, adart1)
{}
};
//****************************************************************************
template<typename Map,int B1=-1,int B2=-1,int B3=-1,int B4=-1,
int B5=-1,int B6=-1,int B7=-1,int B8=-1,int B9=-1>
class CMap_dart_iterator_of_orbit:
public CMap_dart_iterator_of_orbit_generic<Map,false,
B1,B2,B3,B4,B5,B6,B7,B8,B9>
{
public:
typedef CMap_dart_iterator_of_orbit<Map,B1,B2,B3,B4,B5,B6,B7,B8,B9> Self;
typedef CMap_dart_iterator_of_orbit_generic<Map,false,
B1,B2,B3,B4,B5,B6,B7,B8,B9> Base;
typedef typename Base::Dart_handle Dart_handle;
/// Main constructor.
CMap_dart_iterator_of_orbit(Map& amap, Dart_handle adart):
Base(amap, adart)
{}
};
#endif // CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//****************************************************************************
template<typename Map_,int i,int d=Map_::dimension,bool Const=false>
class CMap_dart_iterator_of_cell:

2
Combinatorial_map/include/CGAL/internal/Combinatorial_map_internal_functors.h
View File

@ -984,7 +984,6 @@ struct Reverse_orientation_of_connected_component_functor<CMap, CGAL::Void>
};
// ****************************************************************************
// Beta functor, used to combine several beta.
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename CMap, typename Dart_handle, typename ... Betas>
struct Beta_functor;
@ -1036,7 +1035,6 @@ struct Beta_functor_static<CMap, Dart_handle, B, Betas...>
{ return Beta_functor_static<CMap, Dart_handle, Betas...>::
run(AMap, AMap.template get_beta<B>(ADart)); }
};
#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
// ****************************************************************************
template<typename Container, class WitdId=
typename Container::value_type::Has_id>

119
Combinatorial_map/include/CGAL/internal/Combinatorial_map_utility.h
View File

@ -81,8 +81,6 @@ namespace CGAL
struct Get_attributes_tuple<T, true>
{ typedef typename T::Attributes type; };
#if ! defined(CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES) && \
! defined(CGAL_CFG_NO_CPP0X_TUPLE)
// Convert a tuple in a same tuple where each void type was replaced into
// CGAL::Void.
template<typename ... Items>
@ -377,10 +375,6 @@ namespace CGAL
template <class ... T>
static void run(T& ... ){}
};
#else
// Definitions of structs are moved to another file.
#include <CGAL/internal/Combinatorial_map_utility_novariadic.h>
#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//Apply a functor to each element of a tuple
template<class Functor,class Tuple,
@ -602,7 +596,6 @@ namespace CGAL
struct Attribute_const_range<d, CGAL::Void>
{ typedef CGAL::Void type; };
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
// To iterate onto each enabled attributes
template <class Functor>
struct Foreach_enabled_attributes
@ -619,118 +612,6 @@ namespace CGAL
static void run(Ts& ... t)
{ Foreach_static_restricted_except<Functor, j, Attributes>::run(t...); }
};
#else
// This one cannot be moved in Combinatorial_map_utility_novariadic.h
// because this is an inner struct which uses inner type Attributes.
template <class Functor>
struct Foreach_enabled_attributes
{
static void run()
{Foreach_static_restricted<Functor,Attributes >::run();}
template <class T1>
static void run(T1& t1)
{Foreach_static_restricted<Functor,Attributes >::run(t1);}
template <class T1,class T2>
static void run(T1& t1,T2& t2)
{Foreach_static_restricted<Functor,Attributes >::run(t1,t2);}
template <class T1,class T2,class T3>
static void run(T1& t1,T2& t2,T3& t3)
{Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3);}
template <class T1,class T2,class T3,class T4>
static void run(T1& t1,T2& t2,T3& t3,T4& t4)
{Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4);}
template <class T1,class T2,class T3,class T4,class T5>
static void run(T1& t1,T2& t2,T3& t3,T4& t4,
T5& t5)
{Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,t5);}
template <class T1,class T2,class T3,class T4,class T5,class T6>
static void run(T1& t1,T2& t2,T3& t3,T4& t4,
T5& t5,T6& t6)
{Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,t5,t6);}
template <class T1,class T2,class T3,class T4,class T5,class T6,class T7>
static void run(T1& t1,T2& t2,T3& t3,T4& t4,
T5& t5,T6& t6,T7& t7)
{Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,t5,
t6,t7);}
template <class T1,class T2,class T3,class T4,class T5,class T6,
class T7,class T8>
static void run(T1& t1,T2& t2,T3& t3,T4& t4,
T5& t5,T6& t6,T7& t7,T8& t8)
{Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,t5,t6,
t7,t8);}
template <class T1,class T2,class T3,class T4,class T5,class T6,
class T7,class T8,class T9>
static void run(T1& t1,T2& t2,T3& t3,T4& t4,
T5& t5,T6& t6,T7& t7,T8& t8,
T9& t9)
{Foreach_static_restricted<Functor,Attributes >::run(t1,t2,t3,t4,
t5,t6,t7,t8,t9);}
};
// This one cannot be moved in Combinatorial_map_utility_novariadic.h
// because this is an inner struct which uses inner type Attributes.
template <class Functor, unsigned int j>
struct Foreach_enabled_attributes_except
{
static void run()
{Foreach_static_restricted_except<Functor,j,Attributes>::run();}
template <class T1>
static void run(T1& t1)
{Foreach_static_restricted_except<Functor,j,Attributes>::run(t1);}
template <class T1,class T2>
static void run(T1& t1,T2& t2)
{Foreach_static_restricted_except<Functor,j,Attributes>::run(t1,t2);}
template <class T1,class T2,class T3>
static void run(T1& t1,T2& t2,T3& t3)
{Foreach_static_restricted_except<Functor,j,Attributes>::run(t1,t2,t3);}
template <class T1,class T2,class T3,class T4>
static void run(T1& t1,T2& t2,T3& t3,T4& t4)
{Foreach_static_restricted_except<Functor,j,Attributes>::run(t1,t2,t3,t4);}
template <class T1,class T2,class T3,class T4,class T5>
static void run(T1& t1,T2& t2,T3& t3,T4& t4,
T5& t5)
{Foreach_static_restricted_except<Functor,j,Attributes>::run(t1,t2,t3,t4,t5);}
template <class T1,class T2,class T3,class T4,class T5,class T6>
static void run(T1& t1,T2& t2,T3& t3,T4& t4,
T5& t5,T6& t6)
{Foreach_static_restricted_except<Functor,j,Attributes>::run(t1,t2,t3,t4,t5,t6);}
template <class T1,class T2,class T3,class T4,class T5,class T6,class T7>
static void run(T1& t1,T2& t2,T3& t3,T4& t4,
T5& t5,T6& t6,T7& t7)
{Foreach_static_restricted_except<Functor,j,Attributes>::run(t1,t2,t3,t4,t5,
t6,t7);}
template <class T1,class T2,class T3,class T4,class T5,class T6,
class T7,class T8>
static void run(T1& t1,T2& t2,T3& t3,T4& t4,
T5& t5,T6& t6,T7& t7,T8& t8)
{Foreach_static_restricted_except<Functor,j,Attributes>::run(t1,t2,t3,t4,t5,t6,
t7,t8);}
template <class T1,class T2,class T3,class T4,class T5,class T6,
class T7,class T8,class T9>
static void run(T1& t1,T2& t2,T3& t3,T4& t4,
T5& t5,T6& t6,T7& t7,T8& t8,
T9& t9)
{Foreach_static_restricted_except<Functor,j,Attributes>::run(t1,t2,t3,t4,
t5,t6,t7,t8,t9);}
};
#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
};
} //namespace internal

2574
Combinatorial_map/include/CGAL/internal/Combinatorial_map_utility_novariadic.h
View File

File diff suppressed because it is too large Load Diff

66
Generalized_map/include/CGAL/GMap_dart_const_iterators.h
View File

@ -37,7 +37,6 @@ namespace CGAL {
* - GMap_dart_const_iterator_of_involution<Map,i,d>
*/
//****************************************************************************
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename Map_,unsigned int...Alpha>
class GMap_dart_const_iterator_basic_of_orbit:
public GMap_dart_iterator_basic_of_orbit_generic<Map_,true,Alpha...>
@ -91,71 +90,6 @@ namespace CGAL {
it.get_first_dart())
{}
};
#else
//****************************************************************************
template<typename Map_,int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
int B6=-1,int B7=-1,int B8=-1,int B9=-1>
class GMap_dart_const_iterator_basic_of_orbit:
public GMap_dart_iterator_basic_of_orbit_generic<Map_,true,B1,B2,B3,B4,
B5,B6,B7,B8,B9>
{
public:
typedef GMap_dart_const_iterator_basic_of_orbit<Map_,B1,B2,B3,B4,B5,B6,
B7,B8,B9> Self;
typedef GMap_dart_iterator_basic_of_orbit_generic<Map_,true,B1,B2,B3,B4,
B5,B6,B7,B8,B9> Base;
typedef typename Map_::Dart_const_handle Dart_const_handle;
typedef typename Map_::size_type size_type;
/// Main constructor.
GMap_dart_const_iterator_basic_of_orbit(const Map_& amap,
Dart_const_handle adart):
Base(amap,adart)
{}
/// Main constructor.
GMap_dart_const_iterator_basic_of_orbit(const Map_& amap,
Dart_const_handle adart,
size_type amark):
Base(amap,adart,amark)
{}
/// Constructor from non const version.
GMap_dart_const_iterator_basic_of_orbit
(const GMap_dart_const_iterator_basic_of_orbit<Map_,B1,B2,B3,B4,B5,B6,
B7,B8,B9>& it):
Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
it.get_first_dart(),
it.mmark_number)
{}
};
//****************************************************************************
template<typename Map_,int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
int B6=-1,int B7=-1,int B8=-1,int B9=-1>
class GMap_dart_const_iterator_of_orbit:
public GMap_dart_iterator_of_orbit_generic<Map_,true,B1,B2,B3,B4,
B5,B6,B7,B8,B9>
{
public:
typedef GMap_dart_const_iterator_of_orbit<Map_,B1,B2,B3,B4,B5,B6,
B7,B8,B9> Self;
typedef GMap_dart_iterator_of_orbit_generic<Map_,true,B1,B2,B3,B4,
B5,B6,B7,B8,B9> Base;
typedef typename Map_::Dart_const_handle Dart_const_handle;
/// Main constructor.
GMap_dart_const_iterator_of_orbit(const Map_& amap,
Dart_const_handle adart):
Base(amap,adart)
{}
/// Constructor from non const version.
GMap_dart_const_iterator_of_orbit
(const GMap_dart_iterator_of_orbit<Map_,B1,B2,B3,B4,B5,B6,B7,B8,B9>& it):
Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
it.get_first_dart())
{}
};
#endif // CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//****************************************************************************
template<typename Map_>
class GMap_dart_const_iterator_basic_of_all:

204
Generalized_map/include/CGAL/GMap_dart_iterators.h
View File

@ -44,96 +44,8 @@ namespace CGAL {
/* Class GMap_dart_iterator_basic_of_orbit<Map, Alpha...>: to iterate
* on the darts of the orbit <Alpha...>
*/
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename Map,bool Const,int... Alpha>
class GMap_dart_iterator_basic_of_orbit_generic;
#else
template <typename Map,bool Const,int A1=-1,int A2=-1,int A3=-1,int A4=-1,
int A5=-1,int A6=-1,int A7=-1,int A8=-1,int A9=-1>
class GMap_dart_iterator_basic_of_orbit_generic;
template <typename Map,bool Const,int A1=-1,int A2=-1,int A3=-1,int A4=-1,
int A5=-1,int A6=-1,int A7=-1,int A8=-1,int A9=-1>
struct Get_GMap_dart_iterator_basic_of_orbit;
template<typename Map,bool Const,int A1,int A2,int A3,int A4,int A5,int A6,
int A7,int A8,int A9>
struct Get_GMap_dart_iterator_basic_of_orbit
{
typedef GMap_dart_iterator_basic_of_orbit_generic<Map,Const,A1,A2,A3,A4,
A5,A6,A7,A8,A9> type;
};
template<typename Map,bool Const,int A1,int A2,int A3,int A4,int A5,int A6,
int A7,int A8>
struct Get_GMap_dart_iterator_basic_of_orbit<Map,Const,
A1,A2,A3,A4,A5,A6,A7,A8,-1>
{
typedef GMap_dart_iterator_basic_of_orbit_generic<Map,Const,A1,A2,A3,A4,A5,
A6,A7,A8> type;
};
template<typename Map,bool Const,int A1,int A2,int A3,int A4,int A5,int A6,
int A7>
struct Get_GMap_dart_iterator_basic_of_orbit<Map,Const,
A1,A2,A3,A4,A5,A6,A7,-1,-1>
{
typedef GMap_dart_iterator_basic_of_orbit_generic<Map,Const,
A1,A2,A3,A4,A5,A6,A7> type;
};
template<typename Map,bool Const,int A1,int A2,int A3,int A4,int A5,int A6>
struct Get_GMap_dart_iterator_basic_of_orbit<Map,Const,
A1,A2,A3,A4,A5,A6,-1,-1,-1>
{
typedef GMap_dart_iterator_basic_of_orbit_generic<Map,Const,A1,A2,A3,A4,
A5,A6> type;
};
template<typename Map,bool Const,int A1,int A2,int A3,int A4,int A5>
struct Get_GMap_dart_iterator_basic_of_orbit<Map,Const,
A1,A2,A3,A4,A5,-1,-1,-1,-1>
{
typedef GMap_dart_iterator_basic_of_orbit_generic<Map,A1,A2,A3,A4,
A5,Const> type;
};
template<typename Map,bool Const,int A1,int A2,int A3,int A4>
struct Get_GMap_dart_iterator_basic_of_orbit<Map,Const,
A1,A2,A3,A4,-1,-1,-1,-1,-1>
{
typedef GMap_dart_iterator_basic_of_orbit_generic<Map,Const,A1,A2,A3,
A4> type;
};
template<typename Map, int A1,int A2,int A3,bool Const>
struct Get_GMap_dart_iterator_basic_of_orbit<Map,Const,
A1,A2,A3,-1,-1,-1,-1,-1,-1>
{
typedef GMap_dart_iterator_basic_of_orbit_generic<Map,Const,A1,A2,A3> type;
};
template<typename Map, int A1,int A2,bool Const>
struct Get_GMap_dart_iterator_basic_of_orbit<Map,Const,
A1,A2,-1,-1,-1,-1,-1,-1,-1>
{
typedef GMap_dart_iterator_basic_of_orbit_generic<Map,Const,A1,A2> type;
};
template<typename Map, int A1,bool Const>
struct Get_GMap_dart_iterator_basic_of_orbit<Map,Const,
A1,-1,-1,-1,-1,-1,-1,-1,-1>
{
typedef GMap_dart_iterator_basic_of_orbit_generic<Map,Const,A1> type;
};
template<typename Map,bool Const>
struct Get_GMap_dart_iterator_basic_of_orbit<Map,Const,
-1,-1,-1,-1,-1,-1,-1,-1,-1>
{
typedef GMap_dart_iterator_basic_of_orbit_generic<Map,Const> type;
};
#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//****************************************************************************
// Case when Alpha... is empty: iterator of self
template <typename Map_,bool Const>
@ -615,7 +527,6 @@ namespace CGAL {
{}
};
*/
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//**************************************************************************
/// Generic nD version.
template <typename Map_,bool Const,int Ai, int Aj, int... Alpha>
@ -670,70 +581,6 @@ namespace CGAL {
Base(amap,adart,amark)
{}
};
#else //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//****************************************************************************
/// Generic nD version.
template <typename Map_,bool Const,int A1,int A2,int A3,int A4,int A5,int A6,
int A7,int A8,int A9>
class GMap_dart_iterator_basic_of_orbit_generic:
public GMap_extend_iterator
<Map_,typename Get_GMap_dart_iterator_basic_of_orbit
<Map_,Const,A2,A3,A4,A5,A6,A7,A8,A9>::type, A1>
{
public:
typedef GMap_dart_iterator_basic_of_orbit_generic
<Map_,Const,A1,A2,A3,A4,A5,A6,A7,A8,A9> Self;
typedef GMap_extend_iterator
<Map_,typename Get_GMap_dart_iterator_basic_of_orbit
<Map_,Const,A2,A3,A4,A5,A6,A7,A8,A9>::type, A1> Base;
typedef typename Base::Dart_handle Dart_handle;
typedef typename Base::Map Map;
typedef typename Map::size_type size_type;
typedef Tag_true Basic_iterator; ///< True iff this iterator is basic
public:
/// Main constructor.
GMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart):
Base(amap, adart)
{}
/// Main constructor.
GMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_handle adart,
size_type amark):
Base(amap, adart, amark)
{}
};
//****************************************************************************
/// Non const basic of orbit iterator
template<typename Map,int A1=-1,int A2=-1,int A3=-1,int A4=-1,int A5=-1,
int A6=-1,int A7=-1,int A8=-1,int A9=-1>
class GMap_dart_iterator_basic_of_orbit:
public Get_GMap_dart_iterator_basic_of_orbit<Map,false,A1,A2,A3,A4,
A5,A6,A7,A8,A9>::type
{
public:
typedef GMap_dart_iterator_basic_of_orbit<Map,A1,A2,A3,A4,A5,A6,A7,A8,A9>
Self;
typedef typename Get_GMap_dart_iterator_basic_of_orbit<Map,false,A1,A2,A3,A4,
A5,A6,A7,A8,A9>::type
Base;
typedef typename Map::Dart_handle Dart_handle;
typedef typename Map::size_type size_type;
typedef Tag_true Basic_iterator; ///< True iff this iterator is basic
/// Main constructor.
GMap_dart_iterator_basic_of_orbit(Map& amap,Dart_handle adart):
Base(amap,adart)
{}
/// Main constructor.
GMap_dart_iterator_basic_of_orbit(Map& amap,Dart_handle adart,size_type amark):
Base(amap,adart,amark)
{}
};
#endif // CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//****************************************************************************
// Generic i-Cell iterator in generalized map of dimension d,
// i<=Map::dimension+1 (for i==Map::dimension+1, iterate on the connected
@ -1036,7 +883,6 @@ namespace CGAL {
//****************************************************************************
//*************************ITERATORS*NON*BASIC*********************************
//****************************************************************************
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename Map_,bool Const,int...Alpha>
class GMap_dart_iterator_of_orbit_generic:
public CMap_non_basic_iterator<Map_,
@ -1075,56 +921,6 @@ namespace CGAL {
Base(amap, adart)
{}
};
#else
//****************************************************************************
template<typename Map_,bool Const,int A1=-1,int A2=-1,int A3=-1,int A4=-1,
int A5=-1,int A6=-1,int A7=-1,int A8=-1,int A9=-1>
class GMap_dart_iterator_of_orbit_generic:
public CMap_non_basic_iterator<Map_,
typename
Get_GMap_dart_iterator_basic_of_orbit
<Map_,Const,A1,A2,A3,A4,A5,
A6,A7,A8,A9>::type>
{
public:
typedef GMap_dart_iterator_of_orbit_generic<Map_,Const,A1,A2,A3,A4,A5,
A6,A7,A8,A9> Self;
typedef CMap_non_basic_iterator<Map_,
typename
Get_GMap_dart_iterator_basic_of_orbit
<Map_,Const,A1,A2,A3,A4,A5,
A6,A7,A8,A9>::type> Base;
typedef typename Base::Map Map;
typedef typename Base::Dart_handle Dart_handle;
typedef Tag_false Basic_iterator; ///< True iff this iterator is basic
/// Main constructor.
GMap_dart_iterator_of_orbit_generic(Map& amap, Dart_handle adart1):
Base(amap, adart1)
{}
};
//****************************************************************************
template<typename Map,int A1=-1,int A2=-1,int A3=-1,int A4=-1,
int A5=-1,int A6=-1,int A7=-1,int A8=-1,int A9=-1>
class GMap_dart_iterator_of_orbit:
public GMap_dart_iterator_of_orbit_generic<Map,false,
A1,A2,A3,A4,A5,A6,A7,A8,A9>
{
public:
typedef GMap_dart_iterator_of_orbit<Map,A1,A2,A3,A4,A5,A6,A7,A8,A9> Self;
typedef GMap_dart_iterator_of_orbit_generic<Map,false,
A1,A2,A3,A4,A5,A6,A7,A8,A9> Base;
typedef typename Base::Dart_handle Dart_handle;
typedef Tag_false Basic_iterator; ///< True iff this iterator is basic
/// Main constructor.
GMap_dart_iterator_of_orbit(Map& amap, Dart_handle adart):
Base(amap, adart)
{}
};
#endif // CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//****************************************************************************
template<typename Map_,int i,int d=Map_::dimension,bool Const=false>
class GMap_dart_iterator_of_cell:

608
Generalized_map/include/CGAL/Generalized_map.h
View File

@ -403,7 +403,6 @@ namespace CGAL {
* is unmarked for all the marks.
* @return a Dart_handle on the new dart.
*/
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template < typename... Args >
Dart_handle create_dart(const Args&... args)
{
@ -411,90 +410,6 @@ namespace CGAL {
init_dart(res);
return res;
}
#else
Dart_handle create_dart()
{
Dart_handle res=mdarts.emplace();
init_dart(res);
return res;
}
template < typename T1 >
Dart_handle create_dart(const T1 &t1)
{
Dart_handle res=mdarts.emplace(t1);
init_dart(res);
return res;
}
template < typename T1, typename T2 >
Dart_handle create_dart(const T1 &t1, const T2 &t2)
{
Dart_handle res=mdarts.emplace(t1, t2);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3)
{
Dart_handle res=mdarts.emplace(t1, t2, t3);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3, typename T4 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3,
const T4 &t4)
{
Dart_handle res=mdarts.emplace(t1, t2, t3, t4);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3, typename T4, typename T5 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3,
const T4 &t4, const T5 &t5)
{
Dart_handle res=mdarts.emplace(t1, t2, t3, t4, t5);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3,
const T4 &t4, const T5 &t5, const T6 &t6)
{
Dart_handle res=mdarts.emplace(t1, t2, t3, t4, t5, t6);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3,
const T4 &t4, const T5 &t5, const T6 &t6,
const T7 &t7)
{
Dart_handle res=mdarts.emplace(t1, t2, t3, t4, t5, t6, t7);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3,
const T4 &t4, const T5 &t5, const T6 &t6,
const T7 &t7, const T8 &t8)
{
Dart_handle res=mdarts.emplace(t1, t2, t3, t4, t5, t6, t7, t8);
init_dart(res);
return res;
}
template < typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9 >
Dart_handle create_dart(const T1 &t1, const T2 &t2, const T3 &t3,
const T4 &t4, const T5 &t5, const T6 &t6,
const T7 &t7, const T8 &t8, const T9 &t9)
{
Dart_handle res=mdarts.emplace(t1, t2, t3, t4, t5, t6, t7, t8, t9);
init_dart(res);
return res;
}
#endif
/** Erase a dart from the list of darts.
* @param adart the dart to erase.
@ -634,7 +549,6 @@ namespace CGAL {
/// @return the alphas of ADart (alpha are used in the same order than
/// they are given as parameters)
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename ...Alphas>
Dart_handle alpha(Dart_handle ADart, Alphas... alphas)
{ return CGAL::internal::Alpha_functor<Self, Dart_handle, Alphas...>::
@ -651,119 +565,6 @@ namespace CGAL {
Dart_const_handle alpha(Dart_const_handle ADart) const
{ return CGAL::internal::Alpha_functor_static<const Self, Dart_const_handle, Alphas...>::
run(*this, ADart); }
#else
Dart_handle alpha(Dart_handle ADart, int B1)
{ return this->get_alpha(ADart, B1); }
Dart_handle alpha(Dart_handle ADart, int B1, int B2)
{ return alpha(alpha(ADart, B1), B2); }
Dart_handle alpha(Dart_handle ADart, int B1, int B2, int B3)
{ return alpha(alpha(ADart, B1), B2, B3); }
Dart_handle alpha(Dart_handle ADart, int B1, int B2, int B3,
int B4)
{ return alpha(alpha(ADart, B1), B2, B3, B4); }
Dart_handle alpha(Dart_handle ADart, int B1, int B2, int B3,
int B4, int B5)
{ return alpha(alpha(ADart, B1), B2, B3, B4, B5); }
Dart_handle alpha(Dart_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6)
{ return alpha(alpha(ADart, B1), B2, B3, B4, B5, B6); }
Dart_handle alpha(Dart_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6, int B7)
{ return alpha(alpha(ADart, B1), B2, B3, B4, B5, B6, B7); }
Dart_handle alpha(Dart_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6, int B7, int B8)
{ return alpha(alpha(ADart, B1), B2, B3, B4, B5, B6, B7, B8); }
Dart_handle alpha(Dart_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6, int B7, int B8, int B9)
{ return alpha(alpha(ADart, B1), B2, B3, B4, B5, B6, B7, B8, B9); }
template<int B1>
Dart_handle alpha(Dart_handle ADart)
{ return this->template get_alpha<B1>(ADart); }
template<int B1, int B2>
Dart_handle alpha(Dart_handle ADart)
{ return alpha<B2>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3>
Dart_handle alpha(Dart_handle ADart)
{ return alpha<B2, B3>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3, int B4>
Dart_handle alpha(Dart_handle ADart)
{ return alpha<B2, B3, B4>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5>
Dart_handle alpha(Dart_handle ADart)
{ return alpha<B2, B3, B4, B5>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6>
Dart_handle alpha(Dart_handle ADart)
{ return alpha<B2, B3, B4, B5, B6>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6,
int B7>
Dart_handle alpha(Dart_handle ADart)
{ return alpha<B2, B3, B4, B5, B6, B7>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6,
int B7, int B8>
Dart_handle alpha(Dart_handle ADart)
{ return alpha<B2, B3, B4, B5, B6, B7, B8>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6,
int B7, int B8, int B9>
Dart_handle alpha(Dart_handle ADart)
{ return alpha<B2, B3, B4, B5, B6, B7, B8, B9>(alpha<B1>(ADart)); }
Dart_const_handle alpha(Dart_const_handle ADart, int B1) const
{ return this->get_alpha(ADart, B1); }
Dart_const_handle alpha(Dart_const_handle ADart, int B1, int B2) const
{ return alpha(alpha(ADart, B1), B2); }
Dart_const_handle alpha(Dart_const_handle ADart, int B1, int B2, int B3) const
{ return alpha(alpha(ADart, B1), B2, B3); }
Dart_const_handle alpha(Dart_const_handle ADart, int B1, int B2, int B3,
int B4) const
{ return alpha(alpha(ADart, B1), B2, B3, B4); }
Dart_const_handle alpha(Dart_const_handle ADart, int B1, int B2, int B3,
int B4, int B5) const
{ return alpha(alpha(ADart, B1), B2, B3, B4, B5); }
Dart_const_handle alpha(Dart_const_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6) const
{ return alpha(alpha(ADart, B1), B2, B3, B4, B5, B6); }
Dart_const_handle alpha(Dart_const_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6, int B7) const
{ return alpha(alpha(ADart, B1), B2, B3, B4, B5, B6, B7); }
Dart_const_handle alpha(Dart_const_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6, int B7, int B8) const
{ return alpha(alpha(ADart, B1), B2, B3, B4, B5, B6, B7, B8); }
Dart_const_handle alpha(Dart_const_handle ADart, int B1, int B2, int B3,
int B4, int B5, int B6, int B7, int B8, int B9) const
{ return alpha(alpha(ADart, B1), B2, B3, B4, B5, B6, B7, B8, B9); }
template<int B1>
Dart_const_handle alpha(Dart_const_handle ADart) const
{ return this->template get_alpha<B1>(ADart); }
template<int B1, int B2>
Dart_const_handle alpha(Dart_const_handle ADart) const
{ return alpha<B2>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3>
Dart_const_handle alpha(Dart_const_handle ADart) const
{ return alpha<B2, B3>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3, int B4>
Dart_const_handle alpha(Dart_const_handle ADart) const
{ return alpha<B2, B3, B4>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5>
Dart_const_handle alpha(Dart_const_handle ADart) const
{ return alpha<B2, B3, B4, B5>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6>
Dart_const_handle alpha(Dart_const_handle ADart) const
{ return alpha<B2, B3, B4, B5, B6>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6,
int B7>
Dart_const_handle alpha(Dart_const_handle ADart) const
{ return alpha<B2, B3, B4, B5, B6, B7>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6,
int B7, int B8>
Dart_const_handle alpha(Dart_const_handle ADart) const
{ return alpha<B2, B3, B4, B5, B6, B7, B8>(alpha<B1>(ADart)); }
template<int B1, int B2, int B3, int B4, int B5, int B6,
int B7, int B8, int B9>
Dart_const_handle alpha(Dart_const_handle ADart) const
{ return alpha<B2, B3, B4, B5, B6, B7, B8, B9>(alpha<B1>(ADart)); }
#endif
// Generic function to iterate on CMap or GMap in a generic way
bool is_previous_exist(Dart_const_handle ADart) const
@ -1329,7 +1130,6 @@ namespace CGAL {
/// Create a new attribute.
/// @return a handle on the new attribute.
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<unsigned int i, typename ...Args>
typename Attribute_handle<i>::type create_attribute(const Args&... args)
{
@ -1343,112 +1143,6 @@ namespace CGAL {
this->template init_attribute_ref_counting<i>(res);
return res;
}
#else
template<unsigned int i>
typename Attribute_handle<i>::type
create_attribute()
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace();
}
template<unsigned int i, typename T1>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1);
this->template init_attribute_ref_counting<i>(res);
return res;
}
template<unsigned int i, typename T1, typename T2>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2);
}
template<unsigned int i, typename T1, typename T2, typename T3>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3);
}
template<unsigned int i, typename T1, typename T2, typename T3, typename T4>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3, t4);
}
template<unsigned int i, typename T1, typename T2, typename T3, typename T4,
typename T5>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3, t4, t5);
}
template<unsigned int i, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3, t4, t5, t6);
}
template<unsigned int i, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6, const T7 &t7)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3, t4, t5, t6, t7);
}
template<unsigned int i, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3, t4, t5, t6, t7, t8);
}
template<unsigned int i, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8, typename T9>
typename Attribute_handle<i>::type
create_attribute(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8,
const T9 &t9)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(t1, t2, t3, t4, t5, t6, t7, t8, t9);
}
#endif
/// Erase an attribute.
/// @param h a handle to the attribute to erase.
@ -1988,7 +1682,6 @@ namespace CGAL {
return res;
}
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//**************************************************************************
// Dart_of_orbit_basic_range
template<unsigned int ... Alpha>
@ -2067,307 +1760,6 @@ namespace CGAL {
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<Alpha...>(*this,adart,amark); }
//**************************************************************************
#else
//**************************************************************************
// Dart_of_orbit_basic_range
template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
int B6=-1,int B7=-1,int B8=-1,int B9=-1>
struct Dart_of_orbit_basic_range: public CGAL::CMap_range
<Self, CGAL::GMap_dart_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9>,
CGAL::GMap_dart_const_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9> >
{
typedef CGAL::CMap_range
<Self, CGAL::GMap_dart_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9>,
CGAL::GMap_dart_const_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,
B6,B7,B8,B9> > Base;
Dart_of_orbit_basic_range(Self &amap, Dart_handle adart,
size_type /*amark*/=INVALID_MARK):
Base(amap, adart)
{}
};
//**************************************************************************
// Dart_of_orbit_basic_const_range
template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
int B6=-1,int B7=-1,int B8=-1,int B9=-1>
struct Dart_of_orbit_basic_const_range: public CMap_const_range
<Self,
CGAL::GMap_dart_const_iterator_basic_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9> >
{
typedef CMap_const_range
<Self, CGAL::GMap_dart_const_iterator_basic_of_orbit
<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> > Base;
Dart_of_orbit_basic_const_range(const Self &amap,
Dart_const_handle adart, size_type amark=INVALID_MARK):
Base(amap, adart, amark)
{}
};
//**************************************************************************
// Dart_of_orbit_range
template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
int B6=-1,int B7=-1,int B8=-1,int B9=-1>
struct Dart_of_orbit_range: public CGAL::CMap_range
<Self, CGAL::GMap_dart_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9>,
CGAL::GMap_dart_const_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> >
{
typedef CGAL::CMap_range
<Self, CGAL::GMap_dart_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9>,
CGAL::GMap_dart_const_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9> >
Base;
Dart_of_orbit_range(Self &amap, Dart_handle adart):
Base(amap, adart)
{}
};
//**************************************************************************
// Dart_of_orbit_const_range
template<int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
int B6=-1,int B7=-1,int B8=-1,int B9=-1>
struct Dart_of_orbit_const_range: public CMap_const_range
<Self, CGAL::GMap_dart_const_iterator_of_orbit<Self,B1,B2,B3,B4,B5,B6,B7,
B8,B9> >
{
typedef CMap_const_range
<Self, CGAL::GMap_dart_const_iterator_of_orbit
<Self,B1,B2,B3,B4,B5,B6,B7,B8,B9> > Base;
Dart_of_orbit_const_range(const Self &amap, Dart_const_handle adart):
Base(amap, adart)
{}
};
//**************************************************************************
/// @return a range on all the darts of the given orbit
Dart_of_orbit_range<> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1>
Dart_of_orbit_range<B1> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2>
Dart_of_orbit_range<B1,B2> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3>
Dart_of_orbit_range<B1,B2,B3> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4>
Dart_of_orbit_range<B1,B2,B3,B4> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3,B4>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5>
Dart_of_orbit_range<B1,B2,B3,B4,B5> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3,B4,B5>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6>
Dart_of_orbit_range<B1,B2,B3,B4,B5,B6> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3,B4,B5,B6>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7>
Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7> darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7,B8> darts_of_orbit
(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7,B8>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
unsigned int B9>
Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
darts_of_orbit(Dart_handle adart)
{ return Dart_of_orbit_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>(*this,adart); }
//--------------------------------------------------------------------------
// Const versions.
Dart_of_orbit_const_range<> darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1>
Dart_of_orbit_const_range<B1> darts_of_orbit(Dart_const_handle
adart) const
{ return Dart_of_orbit_const_range<B1>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2>
Dart_of_orbit_const_range<B1,B2> darts_of_orbit(Dart_const_handle
adart) const
{ return Dart_of_orbit_const_range<B1,B2>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3>
Dart_of_orbit_const_range<B1,B2,B3> darts_of_orbit
(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4>
Dart_of_orbit_const_range<B1,B2,B3,B4>
darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3,B4>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5>
Dart_of_orbit_const_range<B1,B2,B3,B4,B5>
darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3,B4,B5>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6>
Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6>
darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7>
Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7>
darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8>
darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8>(*this,adart); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
unsigned int B9>
Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
darts_of_orbit(Dart_const_handle adart) const
{ return Dart_of_orbit_const_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
(*this,adart); }
//--------------------------------------------------------------------------
// Basic versions
Dart_of_orbit_basic_range<> darts_of_orbit_basic(Dart_handle adart,
size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<>(*this,adart,amark); }
//--------------------------------------------------------------------------
Dart_of_orbit_basic_const_range<> darts_of_orbit_basic
(Dart_const_handle adart,size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1>
Dart_of_orbit_basic_range<B1> darts_of_orbit_basic(Dart_handle adart,
size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1>
Dart_of_orbit_basic_const_range<B1> darts_of_orbit_basic
(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2>
Dart_of_orbit_basic_range<B1,B2> darts_of_orbit_basic(Dart_handle adart,
size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2>
Dart_of_orbit_basic_const_range<B1,B2> darts_of_orbit_basic
(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3>
Dart_of_orbit_basic_range<B1,B2,B3> darts_of_orbit_basic(Dart_handle adart,
size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3>
Dart_of_orbit_basic_const_range<B1,B2,B3> darts_of_orbit_basic
(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4>
Dart_of_orbit_basic_range<B1,B2,B3,B4> darts_of_orbit_basic
(Dart_handle adart, size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3,B4>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4>
Dart_of_orbit_basic_const_range<B1,B2,B3,B4>
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3,B4>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5>
Dart_of_orbit_basic_range<B1,B2,B3,B4,B5> darts_of_orbit_basic
(Dart_handle adart, size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5>
Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5>
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6>
Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6> darts_of_orbit_basic
(Dart_handle adart, size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6>(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6>
Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6>
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7>
Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7> darts_of_orbit_basic
(Dart_handle adart, size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7>
Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7>
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7,B8> darts_of_orbit
(Dart_handle adart, size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7,B8>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8>
Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7,B8>
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7,B8>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
unsigned int B9>
Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
darts_of_orbit_basic(Dart_handle adart, size_type amark=INVALID_MARK)
{ return Dart_of_orbit_basic_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
(*this,adart,amark); }
//--------------------------------------------------------------------------
template <unsigned int B1,unsigned int B2,unsigned int B3,unsigned int B4,
unsigned int B5,unsigned int B6,unsigned int B7,unsigned int B8,
unsigned int B9>
Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
darts_of_orbit_basic(Dart_const_handle adart, size_type amark=INVALID_MARK) const
{ return Dart_of_orbit_basic_const_range<B1,B2,B3,B4,B5,B6,B7,B8,B9>
(*this,adart,amark); }
//**************************************************************************
#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
//**************************************************************************
// Dart_of_cell_basic_range
template<unsigned int i,int dim=Self::dimension>
struct Dart_of_cell_basic_range: public CGAL::CMap_range

2
Generalized_map/include/CGAL/internal/Generalized_map_internal_functors.h
View File

@ -40,7 +40,6 @@ namespace internal
{
// ****************************************************************************
// Alpha functor, used to combine several alpha.
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename GMap, typename Dart_handle, typename ... Alphas>
struct Alpha_functor;
@ -92,7 +91,6 @@ struct Alpha_functor_static<GMap, Dart_handle, B, Alphas...>
{ return Alpha_functor_static<GMap, Dart_handle, Alphas...>::
run(AMap, AMap.template get_alpha<B>(ADart)); }
};
#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
// ****************************************************************************
} // namespace internal
} // namespace CGAL

60
Linear_cell_complex/include/CGAL/Linear_cell_complex_base.h
View File

@ -196,69 +196,9 @@ namespace CGAL {
/** Create a vertex attribute.
* @return an handle on the new attribute.
*/
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename ...Args>
Vertex_attribute_handle create_vertex_attribute(const Args&... args)
{ return Base::template create_attribute<0>(args...); }
#else
Vertex_attribute_handle create_vertex_attribute()
{ return Base::template create_attribute<0>(); }
template<typename T1>
Vertex_attribute_handle create_vertex_attribute(const T1& t1)
{ return Base::template create_attribute<0>(t1); }
template<typename T1, typename T2>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2)
{ return Base::template create_attribute<0>(t1, t2); }
template<typename T1, typename T2, typename T3>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3)
{ return Base::template create_attribute<0>(t1, t2, t3); }
template<typename T1, typename T2, typename T3, typename T4>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3, const T4 &t4)
{ return Base::template create_attribute<0>(t1, t2, t3, t4); }
template<typename T1, typename T2, typename T3, typename T4, typename T5>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5)
{ return Base::template create_attribute<0>(t1, t2, t3, t4, t5); }
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6)
{ return Base::template create_attribute<0>(t1, t2, t3, t4, t5, t6); }
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6, const T7 &t7)
{ return Base::template create_attribute<0>(t1, t2, t3, t4, t5, t6, t7); }
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8)
{ return Base::template create_attribute<0>(t1, t2, t3, t4, t5, t6, t7,
t8); }
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8, const T9 &t9)
{ return Base::template create_attribute<0>(t1, t2, t3, t4, t5, t6, t7,
t8, t9); }
#endif // CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
/**
* Create a new dart associated with an handle through an attribute.