From 8ea30fa09153bde500322721f662481b24ea9dba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= <sloriot.ml@gmail.com>
Date: Thu, 30 Apr 2009 17:28:55 +0000
Subject: [PATCH] Expand the non-variadic version of 
 Dispatch_*_output_iterator and Is_in_tuple for up to 7 parameters

---
 STL_Extension/include/CGAL/iterator.h | 502 +++++++++++++++++++++++++-
 STL_Extension/include/CGAL/tuple.h    |  88 ++++-
 2 files changed, 577 insertions(+), 13 deletions(-)

diff --git a/STL_Extension/include/CGAL/iterator.h b/STL_Extension/include/CGAL/iterator.h
index aa2b68315ff..832c76d75f6 100644
--- a/STL_Extension/include/CGAL/iterator.h
+++ b/STL_Extension/include/CGAL/iterator.h
@@ -1311,6 +1311,7 @@ dispatch_or_drop_output(O... o)
 template < typename V, typename O >
 class Dispatch_output_iterator;
 
+// Version with 2 parameters
 template<class V1,class O1,class V2,class O2>
 class Dispatch_output_iterator<cpp0x::tuple<V1,V2>,cpp0x::tuple<O1,O2> >:public cpp0x::tuple<O1,O2>{
   typedef Dispatch_output_iterator Self;
@@ -1359,7 +1360,6 @@ dispatch_output(O1 out1,O2 out2){
   return Dispatch_output_iterator<cpp0x::tuple<V1,V2>,cpp0x::tuple<O1,O2> >(out1,out2);
 }
 
-
 //Version with DROP
 template < typename V, typename O >
 class Dispatch_or_drop_output_iterator;
@@ -1396,6 +1396,506 @@ dispatch_or_drop_output(O1 out1,O2 out2){
   return Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2>,cpp0x::tuple<O1,O2> >(out1,out2);
 }
 
+//Versio with 3 parameters
+template<class V1,class O1,class V2,class O2,class V3, class O3>
+class Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3>,cpp0x::tuple<O1,O2,O3> >:public cpp0x::tuple<O1,O2,O3>{
+  typedef Dispatch_output_iterator Self;
+  
+public:
+  typedef cpp0x::tuple<V1,V2,V3> Value_types_tuple;
+  typedef cpp0x::tuple<O1,O2,O3> Iterators_tuple;
+  typedef std::output_iterator_tag iterator_category;
+  typedef void                     value_type;
+  typedef void                     difference_type;
+  typedef void                     pointer;
+  typedef void                     reference;
+
+
+  Self& operator*(){ return *this; }
+  Self& operator++(){ return *this; } 
+  Self& operator++(int){ return *this; }  
+  
+  Dispatch_output_iterator(O1 out1,O2 out2,O3 out3):Iterators_tuple(out1,out2,out3){}
+  
+  Self& operator=(const V1& obj){
+    *cpp0x::get<0>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }
+  
+  Self& operator=(const V2& obj){
+    *cpp0x::get<1>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }
+
+  Self& operator=(const V3& obj){
+    *cpp0x::get<2>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const Self& s){
+    static_cast< Iterators_tuple& >(*this) = static_cast< const Iterators_tuple& >(s);
+    return *this;
+  }
+  
+  const Iterators_tuple& get_iterator_tuple() const
+  { return *this; }
+  
+};
+
+
+template<class V1,class V2,class V3,class O1,class O2,class O3>
+inline 
+Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3>,cpp0x::tuple<O1,O2,O3> >
+dispatch_output(O1 out1,O2 out2,O3 out3){
+  return Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3>,cpp0x::tuple<O1,O2,O3> >(out1,out2,out3);
+}
+
+//Version with DROP
+template < typename V, typename O >
+class Dispatch_or_drop_output_iterator;
+
+
+template<class V1,class O1,class V2,class O2,class V3,class O3>
+class Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3>,cpp0x::tuple<O1,O2,O3> >:
+        public Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3>,cpp0x::tuple<O1,O2,O3> >
+{
+  typedef Dispatch_or_drop_output_iterator Self;
+  typedef Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3>,cpp0x::tuple<O1,O2,O3> > Base;
+  
+public:
+
+  Self& operator*(){ return *this; }
+  Self& operator++(){ return *this; } 
+  Self& operator++(int){ return *this; }  
+  
+  Dispatch_or_drop_output_iterator(O1 out1,O2 out2,O3 out3):Base(out1,out2,out3){}
+  
+  using Base::operator=;
+  
+  
+  template <class T>
+  Self& operator=(const T&){
+    return *this;
+  }
+};
+
+template<class V1,class V2,class V3,class O1,class O2,class O3>
+inline 
+Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3>,cpp0x::tuple<O1,O2,O3> >
+dispatch_or_drop_output(O1 out1,O2 out2,O3 out3){
+  return Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3>,cpp0x::tuple<O1,O2,O3> >(out1,out2,out3);
+}
+
+//Versio with 4 parameters
+template<class V1,class O1,class V2,class O2,class V3,class O3,class V4,class O4>
+class Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4>,cpp0x::tuple<O1,O2,O3,O4> >:public cpp0x::tuple<O1,O2,O3,O4>{
+  typedef Dispatch_output_iterator Self;
+  
+public:
+  typedef cpp0x::tuple<V1,V2,V3,V4> Value_types_tuple;
+  typedef cpp0x::tuple<O1,O2,O3,O4> Iterators_tuple;
+  typedef std::output_iterator_tag iterator_category;
+  typedef void                     value_type;
+  typedef void                     difference_type;
+  typedef void                     pointer;
+  typedef void                     reference;
+
+
+  Self& operator*(){ return *this; }
+  Self& operator++(){ return *this; } 
+  Self& operator++(int){ return *this; }  
+  
+  Dispatch_output_iterator(O1 out1,O2 out2,O3 out3,O4 out4):Iterators_tuple(out1,out2,out3,out4){}
+  
+  Self& operator=(const V1& obj){
+    *cpp0x::get<0>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }
+  
+  Self& operator=(const V2& obj){
+    *cpp0x::get<1>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }
+
+  Self& operator=(const V3& obj){
+    *cpp0x::get<2>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const V4& obj){
+    *cpp0x::get<3>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const Self& s){
+    static_cast< Iterators_tuple& >(*this) = static_cast< const Iterators_tuple& >(s);
+    return *this;
+  }
+  
+  const Iterators_tuple& get_iterator_tuple() const
+  { return *this; }
+  
+};
+
+
+template<class V1,class V2,class V3,class V4,class O1,class O2,class O3,class O4>
+inline 
+Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4>,cpp0x::tuple<O1,O2,O3,O4> >
+dispatch_output(O1 out1,O2 out2,O3 out3,O4 out4){
+  return Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4>,cpp0x::tuple<O1,O2,O3,O4> >(out1,out2,out3,out4);
+}
+
+//Version with DROP
+template < typename V, typename O >
+class Dispatch_or_drop_output_iterator;
+
+
+template<class V1,class O1,class V2,class O2,class V3,class O3,class V4,class O4>
+class Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3,V4>,cpp0x::tuple<O1,O2,O3,O4> >:
+        public Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4>,cpp0x::tuple<O1,O2,O3,O4> >
+{
+  typedef Dispatch_or_drop_output_iterator Self;
+  typedef Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4>,cpp0x::tuple<O1,O2,O3,O4> > Base;
+  
+public:
+
+  Self& operator*(){ return *this; }
+  Self& operator++(){ return *this; } 
+  Self& operator++(int){ return *this; }  
+  
+  Dispatch_or_drop_output_iterator(O1 out1,O2 out2,O3 out3,O4 out4):Base(out1,out2,out3,out4){}
+  
+  using Base::operator=;
+  
+  
+  template <class T>
+  Self& operator=(const T&){
+    return *this;
+  }
+};
+
+template<class V1,class V2,class V3,class V4,class O1,class O2,class O3,class O4>
+inline 
+Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3,V4>,cpp0x::tuple<O1,O2,O3,O4> >
+dispatch_or_drop_output(O1 out1,O2 out2,O3 out3,O4 out4){
+  return Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3,V4>,cpp0x::tuple<O1,O2,O3,O4> >(out1,out2,out3,out4);
+}
+
+//Versio with 5 parameters
+template<class V1,class O1,class V2,class O2,class V3,class O3,class V4,class O4,class V5,class O5>
+class Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5>,cpp0x::tuple<O1,O2,O3,O4,O5> >:public cpp0x::tuple<O1,O2,O3,O4,O5>{
+  typedef Dispatch_output_iterator Self;
+  
+public:
+  typedef cpp0x::tuple<V1,V2,V3,V4,V5> Value_types_tuple;
+  typedef cpp0x::tuple<O1,O2,O3,O4,O5> Iterators_tuple;
+  typedef std::output_iterator_tag iterator_category;
+  typedef void                     value_type;
+  typedef void                     difference_type;
+  typedef void                     pointer;
+  typedef void                     reference;
+
+
+  Self& operator*(){ return *this; }
+  Self& operator++(){ return *this; } 
+  Self& operator++(int){ return *this; }  
+  
+  Dispatch_output_iterator(O1 out1,O2 out2,O3 out3,O4 out4,O5 out5):Iterators_tuple(out1,out2,out3,out4,out5){}
+  
+  Self& operator=(const V1& obj){
+    *cpp0x::get<0>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }
+  
+  Self& operator=(const V2& obj){
+    *cpp0x::get<1>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }
+
+  Self& operator=(const V3& obj){
+    *cpp0x::get<2>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const V4& obj){
+    *cpp0x::get<3>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const V5& obj){
+    *cpp0x::get<4>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const Self& s){
+    static_cast< Iterators_tuple& >(*this) = static_cast< const Iterators_tuple& >(s);
+    return *this;
+  }
+  
+  const Iterators_tuple& get_iterator_tuple() const
+  { return *this; }
+  
+};
+
+
+template<class V1,class V2,class V3,class V4,class V5,class O1,class O2,class O3,class O4,class O5>
+inline 
+Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5>,cpp0x::tuple<O1,O2,O3,O4,O5> >
+dispatch_output(O1 out1,O2 out2,O3 out3,O4 out4,O5 out5){
+  return Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5>,cpp0x::tuple<O1,O2,O3,O4,O5> >(out1,out2,out3,out4,out5);
+}
+
+//Version with DROP
+template < typename V, typename O >
+class Dispatch_or_drop_output_iterator;
+
+
+template<class V1,class O1,class V2,class O2,class V3,class O3,class V4,class O4,class V5,class O5>
+class Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5>,cpp0x::tuple<O1,O2,O3,O4,O5> >:
+        public Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5>,cpp0x::tuple<O1,O2,O3,O4,O5> >
+{
+  typedef Dispatch_or_drop_output_iterator Self;
+  typedef Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5>,cpp0x::tuple<O1,O2,O3,O4,O5> > Base;
+  
+public:
+
+  Self& operator*(){ return *this; }
+  Self& operator++(){ return *this; } 
+  Self& operator++(int){ return *this; }  
+  
+  Dispatch_or_drop_output_iterator(O1 out1,O2 out2,O3 out3,O4 out4,O5 out5):Base(out1,out2,out3,out4,out5){}
+  
+  using Base::operator=;
+  
+  
+  template <class T>
+  Self& operator=(const T&){
+    return *this;
+  }
+};
+
+template<class V1,class V2,class V3,class V4,class V5,class O1,class O2,class O3,class O4,class O5>
+inline 
+Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5>,cpp0x::tuple<O1,O2,O3,O4,O5> >
+dispatch_or_drop_output(O1 out1,O2 out2,O3 out3,O4 out4,O5 out5){
+  return Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5>,cpp0x::tuple<O1,O2,O3,O4,O5> >(out1,out2,out3,out4,out5);
+}
+
+//Versio with 6 parameters
+template<class V1,class O1,class V2,class O2,class V3,class O3,class V4,class O4,class V5,class O5,class V6,class O6>
+class Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6>,cpp0x::tuple<O1,O2,O3,O4,O5,O6> >:public cpp0x::tuple<O1,O2,O3,O4,O5,O6>{
+  typedef Dispatch_output_iterator Self;
+  
+public:
+  typedef cpp0x::tuple<V1,V2,V3,V4,V5,V6> Value_types_tuple;
+  typedef cpp0x::tuple<O1,O2,O3,O4,O5,O6> Iterators_tuple;
+  typedef std::output_iterator_tag iterator_category;
+  typedef void                     value_type;
+  typedef void                     difference_type;
+  typedef void                     pointer;
+  typedef void                     reference;
+
+
+  Self& operator*(){ return *this; }
+  Self& operator++(){ return *this; } 
+  Self& operator++(int){ return *this; }  
+  
+  Dispatch_output_iterator(O1 out1,O2 out2,O3 out3,O4 out4,O5 out5,O6 out6):Iterators_tuple(out1,out2,out3,out4,out5,out6){}
+  
+  Self& operator=(const V1& obj){
+    *cpp0x::get<0>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }
+  
+  Self& operator=(const V2& obj){
+    *cpp0x::get<1>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }
+
+  Self& operator=(const V3& obj){
+    *cpp0x::get<2>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const V4& obj){
+    *cpp0x::get<3>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const V5& obj){
+    *cpp0x::get<4>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const V6& obj){
+    *cpp0x::get<5>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const Self& s){
+    static_cast< Iterators_tuple& >(*this) = static_cast< const Iterators_tuple& >(s);
+    return *this;
+  }
+  
+  const Iterators_tuple& get_iterator_tuple() const
+  { return *this; }
+  
+};
+
+
+template<class V1,class V2,class V3,class V4,class V5,class V6,class O1,class O2,class O3,class O4,class O5,class O6>
+inline 
+Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6>,cpp0x::tuple<O1,O2,O3,O4,O5,O6> >
+dispatch_output(O1 out1,O2 out2,O3 out3,O4 out4,O5 out5,O6 out6){
+  return Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6>,cpp0x::tuple<O1,O2,O3,O4,O5,O6> >(out1,out2,out3,out4,out5,out6);
+}
+
+//Version with DROP
+template < typename V, typename O >
+class Dispatch_or_drop_output_iterator;
+
+
+template<class V1,class O1,class V2,class O2,class V3,class O3,class V4,class O4,class V5,class O5,class V6,class O6>
+class Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6>,cpp0x::tuple<O1,O2,O3,O4,O5,O6> >:
+        public Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6>,cpp0x::tuple<O1,O2,O3,O4,O5,O6> >
+{
+  typedef Dispatch_or_drop_output_iterator Self;
+  typedef Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6>,cpp0x::tuple<O1,O2,O3,O4,O5,O6> > Base;
+  
+public:
+
+  Self& operator*(){ return *this; }
+  Self& operator++(){ return *this; } 
+  Self& operator++(int){ return *this; }  
+  
+  Dispatch_or_drop_output_iterator(O1 out1,O2 out2,O3 out3,O4 out4,O5 out5,O6 out6):Base(out1,out2,out3,out4,out5,out6){}
+  
+  using Base::operator=;
+  
+  
+  template <class T>
+  Self& operator=(const T&){
+    return *this;
+  }
+};
+
+template<class V1,class V2,class V3,class V4,class V5,class V6,class O1,class O2,class O3,class O4,class O5,class O6>
+inline 
+Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6>,cpp0x::tuple<O1,O2,O3,O4,O5,O6> >
+dispatch_or_drop_output(O1 out1,O2 out2,O3 out3,O4 out4,O5 out5,O6 out6){
+  return Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6>,cpp0x::tuple<O1,O2,O3,O4,O5,O6> >(out1,out2,out3,out4,out5,out6);
+}
+
+//Versio with 7 parameters
+template<class V1,class O1,class V2,class O2,class V3,class O3,class V4,class O4,class V5,class O5,class V6,class O6,class V7,class O7>
+class Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6,V7>,cpp0x::tuple<O1,O2,O3,O4,O5,O6,O7> >:public cpp0x::tuple<O1,O2,O3,O4,O5,O6,O7>{
+  typedef Dispatch_output_iterator Self;
+  
+public:
+  typedef cpp0x::tuple<V1,V2,V3,V4,V5,V6,V7> Value_types_tuple;
+  typedef cpp0x::tuple<O1,O2,O3,O4,O5,O6,O7> Iterators_tuple;
+  typedef std::output_iterator_tag iterator_category;
+  typedef void                     value_type;
+  typedef void                     difference_type;
+  typedef void                     pointer;
+  typedef void                     reference;
+
+
+  Self& operator*(){ return *this; }
+  Self& operator++(){ return *this; } 
+  Self& operator++(int){ return *this; }  
+  
+  Dispatch_output_iterator(O1 out1,O2 out2,O3 out3,O4 out4,O5 out5,O6 out6,O7 out7):Iterators_tuple(out1,out2,out3,out4,out5,out6,out7){}
+  
+  Self& operator=(const V1& obj){
+    *cpp0x::get<0>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }
+  
+  Self& operator=(const V2& obj){
+    *cpp0x::get<1>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }
+
+  Self& operator=(const V3& obj){
+    *cpp0x::get<2>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const V4& obj){
+    *cpp0x::get<3>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const V5& obj){
+    *cpp0x::get<4>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const V6& obj){
+    *cpp0x::get<5>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+   Self& operator=(const V7& obj){
+    *cpp0x::get<6>(static_cast<Iterators_tuple& >(*this))++=obj;
+    return *this;
+  }  
+  
+  Self& operator=(const Self& s){
+    static_cast< Iterators_tuple& >(*this) = static_cast< const Iterators_tuple& >(s);
+    return *this;
+  }
+  
+  const Iterators_tuple& get_iterator_tuple() const
+  { return *this; }
+  
+};
+
+
+template<class V1,class V2,class V3,class V4,class V5,class V6,class V7,class O1,class O2,class O3,class O4,class O5,class O6,class O7>
+inline 
+Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6,V7>,cpp0x::tuple<O1,O2,O3,O4,O5,O6,O7> >
+dispatch_output(O1 out1,O2 out2,O3 out3,O4 out4,O5 out5,O6 out6,O7 out7){
+  return Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6,V7>,cpp0x::tuple<O1,O2,O3,O4,O5,O6,O7> >(out1,out2,out3,out4,out5,out6,out7);
+}
+
+//Version with DROP
+template < typename V, typename O >
+class Dispatch_or_drop_output_iterator;
+
+
+template<class V1,class O1,class V2,class O2,class V3,class O3,class V4,class O4,class V5,class O5,class V6,class O6,class V7,class O7>
+class Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6,V7>,cpp0x::tuple<O1,O2,O3,O4,O5,O6,O7> >:
+        public Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6,V7>,cpp0x::tuple<O1,O2,O3,O4,O5,O6,O7> >
+{
+  typedef Dispatch_or_drop_output_iterator Self;
+  typedef Dispatch_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6,V7>,cpp0x::tuple<O1,O2,O3,O4,O5,O6,O7> > Base;
+  
+public:
+
+  Self& operator*(){ return *this; }
+  Self& operator++(){ return *this; } 
+  Self& operator++(int){ return *this; }  
+  
+  Dispatch_or_drop_output_iterator(O1 out1,O2 out2,O3 out3,O4 out4,O5 out5,O6 out6,O7 out7):Base(out1,out2,out3,out4,out5,out6,out7){}
+  
+  using Base::operator=;
+  
+  
+  template <class T>
+  Self& operator=(const T&){
+    return *this;
+  }
+};
+
+template<class V1,class V2,class V3,class V4,class V5,class V6,class V7,class O1,class O2,class O3,class O4,class O5,class O6,class O7>
+inline 
+Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6,V7>,cpp0x::tuple<O1,O2,O3,O4,O5,O6,O7> >
+dispatch_or_drop_output(O1 out1,O2 out2,O3 out3,O4 out4,O5 out5,O6 out6,O7 out7){
+  return Dispatch_or_drop_output_iterator<cpp0x::tuple<V1,V2,V3,V4,V5,V6,V7>,cpp0x::tuple<O1,O2,O3,O4,O5,O6,O7> >(out1,out2,out3,out4,out5,out6,out7);
+}
+
 #endif
 
 CGAL_END_NAMESPACE
diff --git a/STL_Extension/include/CGAL/tuple.h b/STL_Extension/include/CGAL/tuple.h
index 1bdd209b361..1a48bab4340 100644
--- a/STL_Extension/include/CGAL/tuple.h
+++ b/STL_Extension/include/CGAL/tuple.h
@@ -84,33 +84,97 @@ struct Is_in_tuple <V, cpp0x::tuple<> >
 
 // Non-variadic version
 
-template <typename V, typename T>
+template <typename V,typename T>
 struct Is_in_tuple;
 
-template <typename V, typename T0, typename T1>
-struct Is_in_tuple <V, cpp0x::tuple<T0, T1> >
+template <typename V,typename T0,typename T1>
+struct Is_in_tuple <V,cpp0x::tuple<T0,T1> >
 {
-  static const bool value = Is_in_tuple<V, cpp0x::tuple<T1> >::value;
+  static const bool value = Is_in_tuple<V,cpp0x::tuple<T1> >::value;
 };
 
-template <typename V, typename T1>
-struct Is_in_tuple <V, cpp0x::tuple<V,T1> >
+template <typename V, typename T0,typename T1,typename T2>
+struct Is_in_tuple <V, cpp0x::tuple<T0,T1,T2> >
 {
-  static const bool value = true;
+  static const bool value = Is_in_tuple<V,cpp0x::tuple<T1,T2> >::value;
 };
 
-template <typename V>
-struct Is_in_tuple <V, cpp0x::tuple<V> >
+template <typename V, typename T0,typename T1,typename T2,typename T3>
+struct Is_in_tuple <V, cpp0x::tuple<T0,T1,T2,T3> >
 {
-  static const bool value = true;
+  static const bool value = Is_in_tuple<V,cpp0x::tuple<T1,T2,T3> >::value;
 };
 
-template <typename V, typename T1>
-struct Is_in_tuple <V, cpp0x::tuple<T1> >
+template <typename V, typename T0,typename T1,typename T2,typename T3,typename T4>
+struct Is_in_tuple <V, cpp0x::tuple<T0,T1,T2,T3,T4> >
+{
+  static const bool value = Is_in_tuple<V,cpp0x::tuple<T1,T2,T3,T4> >::value;
+};
+
+template <typename V, typename T0,typename T1,typename T2,typename T3,typename T4,typename T5>
+struct Is_in_tuple <V, cpp0x::tuple<T0,T1,T2,T3,T4,T5> >
+{
+  static const bool value = Is_in_tuple<V,cpp0x::tuple<T1,T2,T3,T4,T5> >::value;
+};
+
+template <typename V, typename T0,typename T1,typename T2,typename T3,typename T4,typename T5,typename T6>
+struct Is_in_tuple <V, cpp0x::tuple<T0,T1,T2,T3,T4,T5,T6> >
+{
+  static const bool value = Is_in_tuple<V,cpp0x::tuple<T1,T2,T3,T4,T5,T6> >::value;
+};
+
+
+//Conclusions
+
+template <typename V,typename T1>
+struct Is_in_tuple <V,cpp0x::tuple<T1> >
 {
   static const bool value = false;
 };
 
+template <typename V>
+struct Is_in_tuple <V,cpp0x::tuple<V> >
+{
+  static const bool value = true;
+};
+
+template <typename V,typename T1>
+struct Is_in_tuple <V,cpp0x::tuple<V,T1> >
+{
+  static const bool value = true;
+};
+
+template <typename V,typename T1,typename T2>
+struct Is_in_tuple <V,cpp0x::tuple<V,T1,T2> >
+{
+  static const bool value = true;
+};
+
+template <typename V,typename T1,typename T2,typename T3>
+struct Is_in_tuple <V,cpp0x::tuple<V,T1,T2,T3> >
+{
+  static const bool value = true;
+};
+
+template <typename V,typename T1,typename T2,typename T3,typename T4>
+struct Is_in_tuple <V,cpp0x::tuple<V,T1,T2,T3,T4> >
+{
+  static const bool value = true;
+};
+
+template <typename V,typename T1,typename T2,typename T3,typename T4,typename T5>
+struct Is_in_tuple <V,cpp0x::tuple<V,T1,T2,T3,T4,T5> >
+{
+  static const bool value = true;
+};
+
+template <typename V,typename T1,typename T2,typename T3,typename T4,typename T5,typename T6>
+struct Is_in_tuple <V,cpp0x::tuple<V,T1,T2,T3,T4,T5,T6> >
+{
+  static const bool value = true;
+};
+
+
 #endif 
 
 CGAL_END_NAMESPACE