include/deal.II/base/synchronous_iterator.h

00001 //---------------------------------------------------------------------------
00002 //    @f$Id: synchronous_iterator.h 25345 2012-03-31 08:37:04Z bangerth @f$
00003 //
00004 //    Copyright (C) 2008, 2009, 2012 by the deal.II authors
00005 //
00006 //    This file is subject to QPL and may not be  distributed
00007 //    without copyright and license information. Please refer
00008 //    to the file deal.II/doc/license.html for the  text  and
00009 //    further information on this license.
00010 //
00011 //---------------------------------------------------------------------------
00012 #ifndef __deal2__synchronous_iterator_h
00013 #define __deal2__synchronous_iterator_h
00014 
00015 
00016 #include <deal.II/base/config.h>
00017 #include <deal.II/base/exceptions.h>
00018 
00019 #include <deal.II/base/std_cxx1x/tuple.h>
00020 
00021 #include <iterator>
00022 
00023 DEAL_II_NAMESPACE_OPEN
00024 
00052 template <typename Iterators>
00053 struct SynchronousIterators
00054 {
00058     SynchronousIterators (const Iterators &i);
00059 
00063     SynchronousIterators (const SynchronousIterators &i);
00064 
00069     Iterators iterators;
00070 };
00071 
00072 
00073 
00074 template <typename Iterators>
00075 inline
00076 SynchronousIterators<Iterators>::
00077 SynchronousIterators (const Iterators &i)
00078                 :
00079                 iterators (i)
00080 {}
00081 
00082 
00083 template <typename Iterators>
00084 inline
00085 SynchronousIterators<Iterators>::
00086 SynchronousIterators (const SynchronousIterators &i)
00087                 :
00088                 iterators (i.iterators)
00089 {}
00090 
00091 
00092 
00102 template <typename Iterators>
00103 inline
00104 bool
00105 operator< (const SynchronousIterators<Iterators> &a,
00106            const SynchronousIterators<Iterators> &b)
00107 {
00108   return std_cxx1x::get<0>(a.iterators) < std_cxx1x::get<0>(b.iterators);
00109 }
00110 
00111 
00112 
00121 template <typename Iterators>
00122 inline
00123 std::size_t
00124 operator- (const SynchronousIterators<Iterators> &a,
00125            const SynchronousIterators<Iterators> &b)
00126 {
00127   Assert (std::distance (std_cxx1x::get<0>(b.iterators),
00128                          std_cxx1x::get<0>(a.iterators)) >= 0,
00129           ExcInternalError());
00130   return std::distance (std_cxx1x::get<0>(b.iterators),
00131                         std_cxx1x::get<0>(a.iterators));
00132 }
00133 
00134 
00138 template <typename I1, typename I2>
00139 inline
00140 void advance (std_cxx1x::tuple<I1,I2> &t,
00141               const unsigned int       n)
00142 {
00143   std::advance (std_cxx1x::get<0>(t), n);
00144   std::advance (std_cxx1x::get<1>(t), n);
00145 }
00146 
00150 template <typename I1, typename I2, typename I3>
00151 inline
00152 void advance (std_cxx1x::tuple<I1,I2,I3> &t,
00153               const unsigned int          n)
00154 {
00155   std::advance (std_cxx1x::get<0>(t), n);
00156   std::advance (std_cxx1x::get<1>(t), n);
00157   std::advance (std_cxx1x::get<2>(t), n);
00158 }
00159 
00163 template <typename I1, typename I2,
00164           typename I3, typename I4>
00165 inline
00166 void advance (std_cxx1x::tuple<I1,I2,I3, I4> &t,
00167               const unsigned int              n)
00168 {
00169   std::advance (std_cxx1x::get<0>(t), n);
00170   std::advance (std_cxx1x::get<1>(t), n);
00171   std::advance (std_cxx1x::get<2>(t), n);
00172   std::advance (std_cxx1x::get<3>(t), n);
00173 }
00174 
00175 
00176 
00180 template <typename I1, typename I2>
00181 inline
00182 void advance_by_one (std_cxx1x::tuple<I1,I2> &t)
00183 {
00184   ++std_cxx1x::get<0>(t);
00185   ++std_cxx1x::get<1>(t);
00186 }
00187 
00191 template <typename I1, typename I2, typename I3>
00192 inline
00193 void advance_by_one (std_cxx1x::tuple<I1,I2,I3> &t)
00194 {
00195   ++std_cxx1x::get<0>(t);
00196   ++std_cxx1x::get<1>(t);
00197   ++std_cxx1x::get<2>(t);
00198 }
00199 
00203 template <typename I1, typename I2,
00204           typename I3, typename I4>
00205 inline
00206 void advance_by_one (std_cxx1x::tuple<I1,I2,I3,I4> &t)
00207 {
00208   ++std_cxx1x::get<0>(t);
00209   ++std_cxx1x::get<1>(t);
00210   ++std_cxx1x::get<2>(t);
00211   ++std_cxx1x::get<3>(t);
00212 }
00213 
00214 
00215 
00220 template <typename Iterators>
00221 inline
00222 SynchronousIterators<Iterators>
00223 operator + (const SynchronousIterators<Iterators> &a,
00224             const std::size_t                      n)
00225 {
00226   SynchronousIterators<Iterators> x (a);
00227   ::advance (x.iterators, n);
00228   return x;
00229 }
00230 
00235 template <typename Iterators>
00236 inline
00237 SynchronousIterators<Iterators>
00238 operator ++ (SynchronousIterators<Iterators> &a)
00239 {
00240   ::advance_by_one (a.iterators);
00241   return a;
00242 }
00243 
00244 
00251 template <typename Iterators>
00252 inline
00253 bool
00254 operator != (const SynchronousIterators<Iterators> &a,
00255              const SynchronousIterators<Iterators> &b)
00256 {
00257   return (std_cxx1x::get<0>(a.iterators) !=
00258           std_cxx1x::get<0>(b.iterators));
00259 }
00260 
00261 DEAL_II_NAMESPACE_CLOSE
00262 
00263 #endif
00264 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

deal.II documentation generated on Wed May 23 2012 12:03:21 by doxygen 1.7.3