dune-fem  2.4.1-rc
tupleutility.hh
Go to the documentation of this file.
1 #ifndef DUNE_FEM_COMMON_TUPLEUTILITY_HH
2 #define DUNE_FEM_COMMON_TUPLEUTILITY_HH
3 
4 #include <dune/common/tuples.hh>
5 #include <dune/common/tupleutility.hh>
6 #include <dune/common/std/utility.hh>
7 
8 #ifdef HAVE_TR1_TUPLE // #ifdef HAVE_TUPLE
9 #define DUNE_OPEN_TUPLE_NAMESPACE namespace std { namespace tr1 {
10 #define DUNE_CLOSE_TUPLE_NAMESPACE } }
11 #else // #if defined HAVE_TR1_TUPLE
12 #define DUNE_OPEN_TUPLE_NAMESPACE namespace std {
13 #define DUNE_CLOSE_TUPLE_NAMESPACE }
14 #endif // #ifdef HAVE_TR1_TUPLE
15 
16 
17 namespace
18 {
19 
20  // CutOutTuple
21  // -----------
22 
23  template< class Tuple,
24  int begin,
25  int length,
26  class StartType = std::tuple<>
27  >
28  class CutOutTuple
29  {
30  static_assert( (begin+length <= std::tuple_size< Tuple >::value),
31  "Can not cut out tuple of given length" );
32  typedef typename Dune::PushBackTuple< StartType, std::tuple_element< begin, Tuple > >::type NextType;
33 
34  public:
35  typedef typename CutOutTuple< Tuple, (begin+1), (length-1), NextType >::type type;
36  };
37 
38  template< class Tuple, int begin, class ResultType >
39  struct CutOutTuple< Tuple, begin, 0, ResultType >
40  {
41  typedef ResultType type;
42  };
43 
44 } // namespace
45 
46 
47 
48 namespace Dune
49 {
50 
51  // PopFrontTuple
52  // -------------
53 
54  template< class Tuple, int size = std::tuple_size< Tuple >::value >
56  {
57  static_assert( (size == std::tuple_size< Tuple >::value),
58  "The \"size\" template parameter of PopFrontTuple "
59  "is an implementation detail and should never be "
60  "set explicitly!" );
61 
62  typedef typename CutOutTuple< Tuple, 1, (std::tuple_size< Tuple >::value - 1) >::type type;
63  };
64 
65  template< class Tuple >
66  struct PopFrontTuple< Tuple, 0 >
67  {
68  typedef Tuple type;
69  };
70 
71 
72 
73  // PopBackTuple
74  // ------------
75 
76  template< class Tuple, int size = std::tuple_size< Tuple >::value >
77  struct PopBackTuple
78  {
79  static_assert( (size == std::tuple_size< Tuple >::value),
80  "The \"size\" template parameter of PopBackTuple "
81  "is an implementation detail and should never be "
82  "set explicitly!" );
83 
84  typedef typename CutOutTuple< Tuple, 0, (std::tuple_size< Tuple >::value - 1) >::type type;
85  };
86 
87  template< class Tuple >
88  struct PopBackTuple< Tuple, 0 >
89  {
90  typedef Tuple type;
91  };
92 
93 
94 
95  // tuple_push_back
96  // ---------------
97 
98  template< typename T, typename... Args >
99  inline std::tuple< Args..., T > tuple_push_back ( const std::tuple< Args... > &tup, T t )
100  {
101  return std::tuple_cat( tup, std::tuple< T > ( t ) );
102  }
103 
104 
105 
106  // tuple_push_front
107  // ----------------
108 
109  template< typename T, typename... Args >
110  inline std::tuple< T, Args... > tuple_push_front ( const std::tuple< Args... > &tup, T t )
111  {
112  return std::tuple_cat( std::tuple< T > ( t ), tup );
113  }
114 
115 
116 
117  // tuple_pop_back
118  // --------------
119 
120  template< typename Tup, std::size_t... I >
121  inline auto tuple_pop_back_impl ( const Tup &tup, const Std::index_sequence< I... >& ) ->
122  decltype ( std::make_tuple( std::get< I > ( tup )... ) )
123  {
124  return std::make_tuple ( std::get< I > ( tup )... );
125  }
126 
127  template< typename T, typename... Args >
128  inline auto tuple_pop_back ( const std::tuple< T, Args... > &tup ) ->
129  decltype ( tuple_pop_back_impl ( tup , Std::make_index_sequence< sizeof...( Args ) > ( ) ) )
130  {
131  return tuple_pop_back_impl ( tup , Std::make_index_sequence< sizeof... ( Args ) > ( ) );
132  }
133 
134 
135 
136  // tuple_pop_front
137  // ---------------
138 
139  template< typename Tup, std::size_t... I >
140  inline auto tuple_pop_front_impl ( const Tup &tup, const Std::index_sequence< I... >& ) ->
141  decltype ( std::make_tuple( std::get< I > ( tup )... ) )
142  {
143  return std::make_tuple ( std::get< I + 1 > ( tup )... );
144  }
145 
146  template< typename T, typename... Args >
147  inline auto tuple_pop_front ( const std::tuple< T, Args... > &tup ) ->
148  decltype ( tuple_pop_front_impl ( tup , Std::make_index_sequence< sizeof...( Args ) > ( ) ) )
149  {
150  return tuple_pop_front_impl ( tup , Std::make_index_sequence< sizeof... ( Args ) > ( ) );
151  }
152 
153 
154 
155  // ContainsType
156  // ------------
157 
158  /*
159  * \brief Check wheter given type is contained in tuple.
160  *
161  * \tparam Tuple tuple
162  * \tparam Type type to search for
163  */
164  template< class Tuple,
165  class Type,
166  int N = std::tuple_size< Tuple >::value
167  >
169  {
170  static const bool value = ( std::is_same< typename std::tuple_element< N-1, Tuple >::type, Type >::value
171  || ContainsType< Tuple, Type, N-1 >::value );
172  };
173 
174  template< class Tuple,
175  class Type
176  >
177  struct ContainsType< Tuple, Type, 0 >
178  {
179  static const bool value = false;
180  };
181 
182 
183 
184  // FirstTypeIndexTuple
185  // -------------------
186 
187  /*
188  * \brief Please doc me.
189  */
190  template< class Tuple,
191  class SubTuple,
192  class Seed = std::tuple<>,
193  int index = 0,
194  int size = std::tuple_size< SubTuple >::value
195  >
197  {
198  static_assert( (index == std::tuple_size< Seed >::value),
199  "The \"index\" template parameter of FirstTypeIndexTuple"
200  "is an implementation detail and should never be "
201  "set explicitly!" );
202 
203  // get element from selector
204  typedef typename std::tuple_element< index, SubTuple >::type Element;
205  // find element in pass id tuple
206  typedef typename Dune::FirstTypeIndex< Tuple, Element >::type Position;
207  // add value to seed
208  typedef typename Dune::PushBackTuple< Seed, Position >::type NextSeed;
209 
210  public:
211  // result type is a tuple of integral constants
213  };
214 
215  template< class Tuple,
216  class SubTuple,
217  class Seed,
218  int size
219  >
220  struct FirstTypeIndexTuple< Tuple, SubTuple, Seed, size, size >
221  {
222  typedef Seed type;
223  };
224 
225 
226 
227  // MakeSubTuple
228  // ------------
229 
230  /*
231  * \brief Please doc me.
232  */
233  template< class Tuple,
234  class Positions,
235  class Seed = std::tuple<>,
236  int index = 0,
237  int size = std::tuple_size< Positions >::value
238  >
240  {
241  template< class, class, class, int, int > friend class MakeSubTuple;
242 
243  // get pass number for element to append from mapping
244  static const int position = std::tuple_element< index, Positions >::type::value;
245 
246  // add type to seed
247  typedef typename std::tuple_element< position, Tuple >::type AppendType;
248 
249  typedef typename Dune::PushBackTuple< Seed, AppendType >::type AccumulatedType;
250 
252 
253  static typename NextType::type append ( Tuple &tuple, Seed &seed )
254  {
255  AppendType append = Dune::template get< position >( tuple );
256  AccumulatedType next = tuple_push_back( seed, append );
257  return NextType::append( tuple, next );
258  }
259 
260  public:
261  typedef typename NextType::type type;
262 
263  static type apply ( Tuple &tuple )
264  {
265  Seed seed;
266  return append( tuple, seed );
267  }
268  };
269 
270  template< class Tuple,
271  class Positions,
272  class Seed,
273  int size >
274  class MakeSubTuple< Tuple, Positions, Seed, size, size >
275  {
276  template< class, class, class, int, int > friend class MakeSubTuple;
277 
278  static Seed append ( Tuple &tuple, Seed &seed ) { return seed; }
279 
280  public:
281  typedef Seed type;
282 
283  static type apply ( Tuple & ) { return type(); }
284  };
285 
286 
287 
288  // TupleToVectorConverter
289  // ----------------------
290 
294  template< class VectorTupleType, int pos >
296  {
297  // no copying
299 
300  public:
301  typedef typename VectorTupleType::value_type TupleType;
302  typedef typename tuple_element< pos, TupleType >::type ValueType;
303  typedef ValueType value_type;
304 
306  explicit TupleToVectorConverter ( VectorTupleType &vector )
307  : vector_( vector )
308  {}
309 
311  ValueType &operator [] ( const size_t i )
312  {
313  assert( i < size() );
314  return get< pos >( vector_[ i ] );
315  }
316 
318  const ValueType &operator [] ( const size_t i ) const
319  {
320  assert( i < size() );
321  return get< pos >( vector_[ i ] );
322  }
323 
325  size_t size () const { return vector_.size(); }
326 
327  protected:
328  VectorTupleType &vector_;
329  };
330 
331 
332 
333  // InstantiateTuple
334  // ----------------
335 
350  template< class Tuple,
351  class Key,
352  class Seed = std::tuple<>,
353  int len = std::tuple_size< Tuple >::value
354  >
356  {
361  static Tuple apply ( const Key &key = Key() )
362  {
363  Seed seed;
364  return append( key, seed );
365  }
366 
367  private:
368  template< class, class, class, int > friend struct InstantiateTuple;
369 
370  static Tuple append ( const Key &key, Seed &seed )
371  {
372  static const int index = std::tuple_size< Tuple >::value - len;
373 
374  typedef typename std::tuple_element< index, Tuple >::type AppendType;
375  typedef typename Dune::PushBackTuple< Seed, AppendType >::type AccumulatedType;
376 
377  AccumulatedType next = Dune::tuple_push_back< AppendType >( seed, AppendType( key ) );
379  }
380  };
381 
382  template< class Tuple, class Key, class Seed >
383  struct InstantiateTuple< Tuple, Key, Seed, 0 >
384  {
385  static Tuple apply ( const Key &key = Key() ) { return Tuple(); }
386 
387  private:
388  template< class, class, class, int > friend struct InstantiateTuple;
389 
390  static Seed append ( const Key &key, Seed &seed ) { return seed; }
391  };
392 
393 } // namespace Dune
394 
395 #endif // #ifndef DUNE_FEM_COMMON_TUPLEUTILITY_HH
Tuple type
Definition: tupleutility.hh:68
CutOutTuple< Tuple, 0,(std::tuple_size< Tuple >::value-1) >::type type
Definition: tupleutility.hh:82
static Tuple apply(const Key &key=Key())
Definition: tupleutility.hh:385
auto tuple_pop_back_impl(const Tup &tup, const Std::index_sequence< I... > &) -> decltype(std::make_tuple(std::get< I >(tup)...))
Definition: tupleutility.hh:121
std::tuple< Args..., T > tuple_push_back(const std::tuple< Args... > &tup, T t)
Definition: tupleutility.hh:99
TupleToVectorConverter(VectorTupleType &vector)
constructor
Definition: tupleutility.hh:306
auto tuple_pop_front(const std::tuple< T, Args... > &tup) -> decltype(tuple_pop_front_impl(tup, Std::make_index_sequence< sizeof...(Args) >()))
Definition: tupleutility.hh:147
Tuple type
Definition: tupleutility.hh:90
Definition: tupleutility.hh:55
tuple_element< pos, TupleType >::type ValueType
Definition: tupleutility.hh:302
Instantiate a tuple of elements with identical, simple constructors.
Definition: tupleutility.hh:355
static type apply(Tuple &tuple)
Definition: tupleutility.hh:263
std::tuple< T, Args... > tuple_push_front(const std::tuple< Args... > &tup, T t)
Definition: tupleutility.hh:110
VectorTupleType & vector_
Definition: tupleutility.hh:328
size_t size() const
return size of vector
Definition: tupleutility.hh:325
Definition: tupleutility.hh:196
Definition: coordinate.hh:4
static type apply(Tuple &)
Definition: tupleutility.hh:283
Definition: tupleutility.hh:168
FirstTypeIndexTuple< Tuple, SubTuple, NextSeed,(index+1) >::type type
Definition: tupleutility.hh:212
wrapper class to convert a vector of tuples of RangeTypes into something that behaves like a vector< ...
Definition: tupleutility.hh:295
VectorTupleType::value_type TupleType
Definition: tupleutility.hh:301
Definition: tupleutility.hh:239
auto tuple_pop_back(const std::tuple< T, Args... > &tup) -> decltype(tuple_pop_back_impl(tup, Std::make_index_sequence< sizeof...(Args) >()))
Definition: tupleutility.hh:128
static Tuple apply(const Key &key=Key())
create tuple instance
Definition: tupleutility.hh:361
ValueType value_type
Definition: tupleutility.hh:303
NextType::type type
Definition: tupleutility.hh:261
Definition: tupleutility.hh:77
CutOutTuple< Tuple, 1,(std::tuple_size< Tuple >::value-1) >::type type
Definition: tupleutility.hh:60
auto tuple_pop_front_impl(const Tup &tup, const Std::index_sequence< I... > &) -> decltype(std::make_tuple(std::get< I >(tup)...))
Definition: tupleutility.hh:140