Simplify, generalize and modernize code using variadic templates

COPYING

 Copyright holders:
 
+2015          Marco Agnese
 2015          Martin Alkämper
 2003--2010    Peter Bastian
 2004--2015    Markus Blatt

dune/common/test/tuplestest.cc

@@ -17,6 +17,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <tuple>
 
 #include <dune/common/classname.hh>
 #include <dune/common/tuples.hh>
@@ -27,16 +28,16 @@ template<class T>
 void test(T& tuple)
 {
   float f DUNE_UNUSED;
-  f = get<0>(tuple);
+  f = std::get<0>(tuple);
   int i DUNE_UNUSED;
-  i = get<1>(tuple);
+  i = std::get<1>(tuple);
   double d DUNE_UNUSED;
-  d = get<2>(tuple);
+  d = std::get<2>(tuple);
   char c DUNE_UNUSED;
-  c = get<3>(tuple);
+  c = std::get<3>(tuple);
   std::string s;
-  s = get<4>(tuple);
-  typename tuple_element<4,typename remove_const<T>::type>::type s2 = get<4>(tuple);
+  s = std::get<4>(tuple);
+  typename std::tuple_element<4,typename std::remove_const<T>::type>::type s2 = std::get<4>(tuple);
 }
 
 int iteratorTupleTest()
@@ -49,35 +50,35 @@ int iteratorTupleTest()
 
   typedef std::vector<int>::iterator iterator;
   typedef std::vector<int>::const_iterator const_iterator;
-  typedef tuple<iterator,const_iterator, const_iterator> Tuple;
+  typedef std::tuple<iterator,const_iterator, const_iterator> Tuple;
 
 
   Tuple tuple_(v.begin(), v.begin(), v.end());
-  static_assert(tuple_size<Tuple>::value==3, "The tuple size should be 3!");;
+  static_assert(std::tuple_size<Tuple>::value==3, "The tuple size should be 3!");;
 
   int ret=0;
 
-  if(get<0>(tuple_)!= v.begin()) {
+  if(std::get<0>(tuple_)!= v.begin()) {
     std::cerr<<"Iterator tuple construction failed!"<<std::endl;
     ret++;
   }
-  assert(get<1>(tuple_) == v.begin());
-  assert(get<1>(tuple_) == get<0>(tuple_));
-  if(get<2>(tuple_)!= v.end()) {
+  assert(std::get<1>(tuple_) == v.begin());
+  assert(std::get<1>(tuple_) == std::get<0>(tuple_));
+  if(std::get<2>(tuple_)!= v.end()) {
     std::cerr<<"Iterator tuple construction failed!"<<std::endl;
     ret++;
   }
 
-  assert(get<2>(tuple_) == v.end());
-  assert(get<0>(tuple_) != v.end());
-  assert(get<1>(tuple_) != get<2>(tuple_));
+  assert(std::get<2>(tuple_) == v.end());
+  assert(std::get<0>(tuple_) != v.end());
+  assert(std::get<1>(tuple_) != std::get<2>(tuple_));
   return ret;
 }
 
 int lessTest()
 {
-  tuple<int,float,double> t1(1,2.0,3.0);
-  tuple<int,int,int> t2(1,2,1);
+  std::tuple<int,float,double> t1(1,2.0,3.0);
+  std::tuple<int,int,int> t2(1,2,1);
 
   int ret=0;
 
@@ -95,7 +96,7 @@ int lessTest()
 
 int copyTest()
 {
-  tuple<float,int,double,char,std::string> tuple_, tuple1(3.0,1,3.3,'c',std::string("hallo")), tuple2(tuple1);
+  std::tuple<float,int,double,char,std::string> tuple_, tuple1(3.0,1,3.3,'c',std::string("hallo")), tuple2(tuple1);
 
   std::cout<<tuple1<<std::endl;
   std::cout<<tuple2<<std::endl;
@@ -116,8 +117,8 @@ int referenceTest()
   // the member references a non-const type
   {
     int n = 0;
-    const tuple<int&> t(n);
-    get<0>(t) = 777;
+    const std::tuple<int&> t(n);
+    std::get<0>(t) = 777;
     assert(n == 777);
   }
 
@@ -127,19 +128,19 @@ int referenceTest()
   int i=50;
   double d=-3.3;
   long j=-666;
-  tuple<int,double,long> t1(100, 5.0, 10);
-  tuple<int,int,int> t2(1,5,9);
+  std::tuple<int,double,long> t1(100, 5.0, 10);
+  std::tuple<int,int,int> t2(1,5,9);
   std::cout << "i="<<i<<" d="<<d<<" j="<<j<<std::endl;
 
-  tuple<int&,double&,long&> tr(i,d,j);
+  std::tuple<int&,double&,long&> tr(i,d,j);
 
-  get<0>(tr)=3;
-  assert(get<0>(tr)==3);
+  std::get<0>(tr)=3;
+  assert(std::get<0>(tr)==3);
 
   std::cout <<"tr="<< tr<<std::endl;
 
-  tuple<int> i1(5);
-  tuple<int&> ir(i);
+  std::tuple<int> i1(5);
+  std::tuple<int&> ir(i);
   ir=i1;
 
   t1=t2;
@@ -163,19 +164,19 @@ int pointerTest()
   int i=50;
   double d=-3.3, d1=7.8;
   long j=-666, j1=-300;
-  tuple<int*,double*,long*> t1(&k, &d, &j);
-  tuple<int*,double*,long*> t2(&k1,&d1,&j1);
+  std::tuple<int*,double*,long*> t1(&k, &d, &j);
+  std::tuple<int*,double*,long*> t2(&k1,&d1,&j1);
   std::cout << "i="<<i<<" d="<<d<<" j="<<j<<std::endl;
 
-  tuple<int*,double*,long*> tr(&i,&d,&j);
+  std::tuple<int*,double*,long*> tr(&i,&d,&j);
 
-  *get<0>(tr)=3;
-  assert(*get<0>(tr)==3);
+  *std::get<0>(tr)=3;
+  assert(*std::get<0>(tr)==3);
 
   std::cout <<"tr="<< tr<<std::endl;
 
-  tuple<int> i1(5);
-  tuple<int*> ir(&i);
+  std::tuple<int> i1(5);
+  std::tuple<int*> ir(&i);
 
   t2=t1;
 
@@ -198,18 +199,18 @@ int constPointerTest()
   int i=50;
   double d=-3.3, d1=6.8;
   long j=-666, j1=-500;
-  tuple<const int*, const double*, const long*> t1(&k, &d, &j);
-  tuple<int*, double*, long*> t2(&k1,&d1,&j1);
+  std::tuple<const int*, const double*, const long*> t1(&k, &d, &j);
+  std::tuple<int*, double*, long*> t2(&k1,&d1,&j1);
   std::cout << "i="<<i<<" d="<<d<<" j="<<j<<std::endl;
 
-  tuple<const int*, const double*, const long*> tr(&i,&d,&j);
+  std::tuple<const int*, const double*, const long*> tr(&i,&d,&j);
 
-  std::cout << *get<0>(tr)<<std::endl;
+  std::cout << *std::get<0>(tr)<<std::endl;
 
   std::cout <<"tr="<< tr<<std::endl;
 
-  tuple<int> i1(5);
-  tuple<const int*> ir(&i);
+  std::tuple<int> i1(5);
+  std::tuple<const int*> ir(&i);
 
   t1=t2;
 
@@ -230,20 +231,20 @@ int tuple_tr1_test()
 {
   int ret=0;
 
-  tuple<int,double> t(1,3.14);
-  int sz = tuple_size<tuple<int, double, char> >::value;
+  std::tuple<int,double> t(1,3.14);
+  int sz = std::tuple_size<std::tuple<int, double, char> >::value;
   if(sz!=3) ++ret;
 
   // contruct a tuple
 
-  t= make_tuple(5, 10.9);
+  t= std::make_tuple(5, 10.9);
 
 
   // get the second element
-  tuple_element<1,tuple<int,double> >::type d DUNE_UNUSED;
-  d=get<1>(t);
+  std::tuple_element<1,std::tuple<int,double> >::type d DUNE_UNUSED;
+  d=std::get<1>(t);
 
-  get<0>(t)=16;
+  std::get<0>(t)=16;
 
   std::cout<<t<<std::endl;
 
@@ -277,12 +278,12 @@ int outputTest()
 
 int main(int, char**)
 {
-  tuple<float,int,double,char,std::string> tuple_;
+  std::tuple<float,int,double,char,std::string> tuple_;
   std::cout << "=== testing tuple: " << className(tuple_) << std::endl;
 
   test(tuple_);
-  test(static_cast<tuple<float,int,double,char,std::string>& >(tuple_));
-  test(static_cast<const tuple<float,int,double,char,std::string>&>(tuple_));
+  test(static_cast<std::tuple<float,int,double,char,std::string>& >(tuple_));
+  test(static_cast<const std::tuple<float,int,double,char,std::string>&>(tuple_));
   return (copyTest()+iteratorTupleTest()+referenceTest()+lessTest()
           +pointerTest()+constPointerTest()+tuple_tr1_test()+inputTest()+outputTest());
 

dune/common/test/tupleutilitytest.cc

@@ -14,7 +14,7 @@
 //
 // check FirstTypeIndex
 //
-typedef Dune::tuple<int, unsigned, double> MyTuple;
+typedef std::tuple<int, unsigned, double> MyTuple;
 static_assert((Dune::FirstTypeIndex<MyTuple, int>::value == 0),
               "FirstTypeIndex finds the wrong index for double in MyTuple!");
 static_assert((Dune::FirstTypeIndex<MyTuple, unsigned>::value == 1),
@@ -28,8 +28,8 @@ static_assert((Dune::FirstTypeIndex<MyTuple, double>::value == 2),
 //
 // check PushBackTuple
 typedef Dune::PushBackTuple<MyTuple, char>::type MyTupleAppended1;
-typedef Dune::tuple<int, unsigned, double, char> MyTupleAppended2;
-static_assert((Dune::is_same<MyTupleAppended1, MyTupleAppended2>::value),
+typedef std::tuple<int, unsigned, double, char> MyTupleAppended2;
+static_assert((std::is_same<MyTupleAppended1, MyTupleAppended2>::value),
               "PushBackTuple failed!");
 
 
@@ -38,8 +38,8 @@ static_assert((Dune::is_same<MyTupleAppended1, MyTupleAppended2>::value),
 //
 // check PushFrontTuple
 typedef Dune::PushFrontTuple<MyTuple, char>::type MyTuplePrepended1;
-typedef Dune::tuple<char, int, unsigned, double> MyTuplePrepended2;
-static_assert((Dune::is_same<MyTuplePrepended1, MyTuplePrepended2>::value),
+typedef std::tuple<char, int, unsigned, double> MyTuplePrepended2;
+static_assert((std::is_same<MyTuplePrepended1, MyTuplePrepended2>::value),
               "PushFrontTuple failed!");
 
 
@@ -48,8 +48,8 @@ static_assert((Dune::is_same<MyTuplePrepended1, MyTuplePrepended2>::value),
 //
 // check JoinTuples
 typedef Dune::JoinTuples<MyTuple, MyTuple>::type MyTupleMyTuple1;
-typedef Dune::tuple<int, unsigned, double, int, unsigned, double> MyTupleMyTuple2;
-static_assert((Dune::is_same<MyTupleMyTuple1, MyTupleMyTuple2>::value),
+typedef std::tuple<int, unsigned, double, int, unsigned, double> MyTupleMyTuple2;
+static_assert((std::is_same<MyTupleMyTuple1, MyTupleMyTuple2>::value),
               "JoinTuples failed!");
 
 
@@ -57,10 +57,10 @@ static_assert((Dune::is_same<MyTupleMyTuple1, MyTupleMyTuple2>::value),
 //////////////////////////////////////////////////////////////////////
 //
 // check FlattenTuple
-typedef Dune::tuple<char, float> MyTuple2;
-typedef Dune::tuple<MyTuple, MyTuple2> MyTupleTuple;
+typedef std::tuple<char, float> MyTuple2;
+typedef std::tuple<MyTuple, MyTuple2> MyTupleTuple;
 typedef Dune::FlattenTuple<MyTupleTuple>::type MyTupleTupleFlat1;
-typedef Dune::tuple<int, unsigned, double, char, float> MyTupleTupleFlat2;
+typedef std::tuple<int, unsigned, double, char, float> MyTupleTupleFlat2;
 static_assert((Dune::is_same<MyTupleTupleFlat1, MyTupleTupleFlat2>::value),
               "FlattenTuples failed!");
 
@@ -76,7 +76,7 @@ struct Range
 {
   typedef typename Dune::PushBackTuple<
       typename Range<start, end-1>::type,
-      typename Dune::integral_constant<int,end-1>
+      typename std::integral_constant<int,end-1>
       >::type type;
 };
 
@@ -95,7 +95,7 @@ struct DivisorAccumulator
 
   typedef typename Data::second_type OldTuple;
   typedef typename Dune::PushBackTuple<OldTuple, PotentialDivisor>::type ExtendedTuple;
-  typedef typename Dune::conditional<isDivisor, ExtendedTuple, OldTuple>::type NewTuple;
+  typedef typename std::conditional<isDivisor, ExtendedTuple, OldTuple>::type NewTuple;
 
   typedef typename std::pair<typename Data::first_type, NewTuple> type;
 };
@@ -107,10 +107,10 @@ struct Divisors
   typedef typename Dune::ReduceTuple<
       DivisorAccumulator,
       typename Range<1,X+1>::type,
-      typename std::pair<typename Dune::integral_constant<int, X>, typename Dune::tuple<> >
+      typename std::pair<typename std::integral_constant<int, X>, typename std::tuple<> >
       >::type::second_type type;
 
-  enum {value = Dune::tuple_size<type>::value};
+  enum {value = std::tuple_size<type>::value};
 };
 
 // An accumulator to build up a list of primes up to a fixed integer
@@ -119,7 +119,7 @@ struct PrimeAccumulator
 {
   enum {isPrime = (Divisors<N::value>::value==2)};
 
-  typedef typename Dune::conditional<isPrime, typename Dune::PushBackTuple<Data, N>::type, Data>::type type;
+  typedef typename std::conditional<isPrime, typename Dune::PushBackTuple<Data, N>::type, Data>::type type;
 };
 
 // Construct list primes
@@ -134,12 +134,12 @@ struct Primes
 };
 
 typedef Primes<9>::type Primes1;
-typedef Dune::tuple<
-    Dune::integral_constant<int, 2>,
-    Dune::integral_constant<int, 3>,
-    Dune::integral_constant<int, 5>,
-    Dune::integral_constant<int, 7> > Primes2;
-static_assert((Dune::is_same<Primes1, Primes2>::value),
+typedef std::tuple<
+    std::integral_constant<int, 2>,
+    std::integral_constant<int, 3>,
+    std::integral_constant<int, 5>,
+    std::integral_constant<int, 7> > Primes2;
+static_assert((std::is_same<Primes1, Primes2>::value),
               "ReduceTuple failed in primes-tmp!");
 
 

dune/common/test/utilitytest.cc

@@ -31,26 +31,26 @@ struct Counter {
 int main(int, char**)
 {
 
-  typedef Dune::tuple<int*,double*,long*,char*> PointerTuple;
+  typedef std::tuple<int*,double*,long*,char*> PointerTuple;
 
-  Dune::tuple<int*,double*,long*,char*> pointers = Dune::NullPointerInitialiser<PointerTuple>::apply();
+  std::tuple<int*,double*,long*,char*> pointers = Dune::NullPointerInitialiser<PointerTuple>::apply();
   int ret=0;
 
-  if(Dune::get<0>(pointers)!=0) {
+  if(std::get<0>(pointers)!=0) {
     std::cerr<<"First pointer not null"<<std::endl;
     ret=1;
   }
-  if(Dune::get<1>(pointers)!=0) {
+  if(std::get<1>(pointers)!=0) {
     std::cerr<<"Second pointer not null"<<std::endl;
     ret=2;
   }
 
-  if(Dune::get<2>(pointers)!=0) {
+  if(std::get<2>(pointers)!=0) {
     std::cerr<<"Third pointer not null"<<std::endl;
     ret=3;
   }
 
-  if(Dune::get<3>(pointers)!=0) {
+  if(std::get<3>(pointers)!=0) {
     std::cerr<<"Fourth pointer not null"<<std::endl;
     ret=4;
   }
@@ -59,9 +59,9 @@ int main(int, char**)
   long l = 4;
   char c = 's';
 
-  typedef Dune::tuple<int&,char&,long&,char&> RefTuple1;
-  typedef Dune::tuple<int*,char*,long*,char*> PointerTuple1;
-  static_assert((Dune::is_same<PointerTuple1,
+  typedef std::tuple<int&,char&,long&,char&> RefTuple1;
+  typedef std::tuple<int*,char*,long*,char*> PointerTuple1;
+  static_assert((std::is_same<PointerTuple1,
                           Dune::ForEachType<Dune::AddPtrTypeEvaluator,
                               RefTuple1>::Type>::value),
                      "RefTuple1 with added pointers should be the same as "
@@ -70,14 +70,14 @@ int main(int, char**)
   RefTuple1 refs(i, c, l, c);
   PointerTuple1 pointers1
     (Dune::transformTuple<Dune::AddPtrTypeEvaluator>(refs));
-  if(&i != Dune::get<0>(pointers1) || &c != Dune::get<1>(pointers1) ||
-     &l != Dune::get<2>(pointers1) || &c != Dune::get<3>(pointers1)) {
+  if(&i != std::get<0>(pointers1) || &c != std::get<1>(pointers1) ||
+     &l != std::get<2>(pointers1) || &c != std::get<3>(pointers1)) {
     std::cerr << "utilitytest: error: incorrect pointers in pointers1"
               << std::endl;
     ret = 1;
   }
 
-  if(static_cast<size_t>(Dune::tuple_size<PointerTuple>::value) != static_cast<size_t>(Dune::tuple_size<PointerTuple>::value)) {
+  if(static_cast<size_t>(std::tuple_size<PointerTuple>::value) != static_cast<size_t>(std::tuple_size<PointerTuple>::value)) {
     std::cerr<<"Length and size do not match!"<<std::endl;
   }
 
@@ -93,7 +93,7 @@ int main(int, char**)
 
   foreach1.apply(count);
 
-  if(Dune::At<2>::get(pointers)!=Dune::get<1>(pointers)) {
+  if(Dune::At<2>::get(pointers)!=std::get<1>(pointers)) {
     ret+=10;
     std::cerr<<"at inconsistent!"<<std::endl;
   }