include/deal.II/grid/filtered_iterator.h

00001 //---------------------------------------------------------------------------
00002 //    @f$Id: filtered_iterator.h 25345 2012-03-31 08:37:04Z bangerth @f$
00003 //
00004 //    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2011, 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__filtered_iterator_h
00013 #define __deal2__filtered_iterator_h
00014 
00015 
00016 #include <deal.II/base/config.h>
00017 #include <deal.II/base/exceptions.h>
00018 #include <deal.II/grid/tria_iterator_base.h>
00019 
00020 DEAL_II_NAMESPACE_OPEN
00021 
00022 
00040 namespace IteratorFilters
00041 {
00050   class Active
00051   {
00052     public:
00058       template <class Iterator>
00059       bool operator () (const Iterator &i) const;
00060   };
00061 
00071   class UserFlagSet
00072   {
00073     public:
00080       template <class Iterator>
00081       bool operator () (const Iterator &i) const;
00082   };
00083 
00084 
00095   class UserFlagNotSet
00096   {
00097     public:
00104       template <class Iterator>
00105       bool operator () (const Iterator &i) const;
00106   };
00107 
00108 
00119   class LevelEqualTo
00120   {
00121     public:
00127       LevelEqualTo (const unsigned int level);
00128 
00137       template <class Iterator>
00138       bool operator () (const Iterator &i) const;
00139 
00140     protected:
00145       const unsigned int level;
00146   };
00147 
00148 
00149 
00163   class SubdomainEqualTo
00164   {
00165     public:
00172       SubdomainEqualTo (const types::subdomain_id_t subdomain_id);
00173 
00182       template <class Iterator>
00183       bool operator () (const Iterator &i) const;
00184 
00185     protected:
00190       const types::subdomain_id_t subdomain_id;
00191   };
00192 
00193 
00194 
00207   class LocallyOwnedCell
00208   {
00209     public:
00214       template <class Iterator>
00215       bool operator () (const Iterator &i) const;
00216   };
00217 }
00218 
00219 
00412 template <typename BaseIterator>
00413 class FilteredIterator : public BaseIterator
00414 {
00415   public:
00420     typedef typename BaseIterator::AccessorType AccessorType;
00421 
00429     template <typename Predicate>
00430     FilteredIterator (Predicate p);
00431 
00459     template <typename Predicate>
00460     FilteredIterator (Predicate           p,
00461                       const BaseIterator &bi);
00462 
00468     FilteredIterator (const FilteredIterator &fi);
00469 
00473     ~FilteredIterator ();
00474 
00487     FilteredIterator & operator = (const FilteredIterator &fi);
00488 
00499     FilteredIterator & operator = (const BaseIterator &fi);
00500 
00515     FilteredIterator &
00516     set_to_next_positive (const BaseIterator &bi);
00517 
00532     FilteredIterator &
00533     set_to_previous_positive (const BaseIterator &bi);
00534 
00543     bool operator == (const FilteredIterator &fi) const;
00544 
00555     bool operator == (const BaseIterator &fi) const;
00556 
00565     bool operator != (const FilteredIterator &fi) const;
00566 
00577     bool operator != (const BaseIterator &fi) const;
00578 
00587     bool operator <  (const FilteredIterator &fi) const;
00588 
00599     bool operator <  (const BaseIterator &fi) const;
00600 
00608     FilteredIterator & operator ++ ();
00609 
00617     FilteredIterator   operator ++ (int);
00618 
00626     FilteredIterator & operator -- ();
00627 
00635     FilteredIterator   operator -- (int);
00636 
00640     DeclException1 (ExcInvalidElement,
00641                     BaseIterator,
00642                     << "The element " << arg1
00643                     << " with which you want to compare or which you want to"
00644                     << " assign from is invalid since it does not satisfy the predicate.");
00645 
00646   private:
00647 
00665     class PredicateBase
00666     {
00667       public:
00675         virtual ~PredicateBase () {}
00676 
00684         virtual bool operator () (const BaseIterator &bi) const = 0;
00685 
00691         virtual PredicateBase * clone () const = 0;
00692     };
00693 
00694 
00708     template <typename Predicate>
00709     class PredicateTemplate : public PredicateBase
00710     {
00711       public:
00717         PredicateTemplate (const Predicate &predicate);
00718 
00724         virtual bool operator () (const BaseIterator &bi) const;
00725 
00731         virtual PredicateBase * clone () const;
00732 
00733       private:
00737         const Predicate predicate;
00738     };
00739 
00746     const PredicateBase * predicate;
00747 
00748 #ifdef DEAL_II_NESTED_CLASS_FRIEND_BUG
00749 #  ifdef DEAL_II_NESTED_CLASS_TEMPL_FRIEND_BUG
00750     template <typename> friend class PredicateTemplate;
00751 #  else
00752     template <typename T>
00753     template <typename>
00754     friend class FilteredIterator<T>::PredicateTemplate;
00755 #  endif
00756 #endif
00757 };
00758 
00759 
00760 
00771 template <typename BaseIterator, typename Predicate>
00772 FilteredIterator<BaseIterator>
00773 make_filtered_iterator (const BaseIterator &i,
00774                         const Predicate    &p)
00775 {
00776   FilteredIterator<BaseIterator> fi(p);
00777   fi.set_to_next_positive (i);
00778   return fi;
00779 }
00780 
00781 
00782 
00783 /* ------------------ Inline functions and templates ------------ */
00784 
00785 
00786 template <typename BaseIterator>
00787 template <typename Predicate>
00788 inline
00789 FilteredIterator<BaseIterator>::
00790 FilteredIterator (Predicate p)
00791                 :
00792                 predicate (new PredicateTemplate<Predicate>(p))
00793 {}
00794 
00795 
00796 
00797 template <typename BaseIterator>
00798 template <typename Predicate>
00799 inline
00800 FilteredIterator<BaseIterator>::
00801 FilteredIterator (Predicate          p,
00802                   const BaseIterator &bi)
00803                 :
00804                 BaseIterator (bi),
00805                 predicate (new PredicateTemplate<Predicate>(p))
00806 {
00807   if ((this->state() == IteratorState::valid) &&
00808       ! (*predicate) (*this))
00809     set_to_next_positive (bi);
00810 }
00811 
00812 
00813 
00814 template <typename BaseIterator>
00815 inline
00816 FilteredIterator<BaseIterator>::
00817 FilteredIterator (const FilteredIterator &fi)
00818                 :
00819                 BaseIterator (static_cast<BaseIterator>(fi)),
00820                 predicate (fi.predicate->clone ())
00821 {}
00822 
00823 
00824 
00825 template <typename BaseIterator>
00826 inline
00827 FilteredIterator<BaseIterator>::
00828 ~FilteredIterator ()
00829 {
00830   delete predicate;
00831   predicate = 0;
00832 }
00833 
00834 
00835 
00836 template <typename BaseIterator>
00837 inline
00838 FilteredIterator<BaseIterator> &
00839 FilteredIterator<BaseIterator>::
00840 operator = (const FilteredIterator &fi)
00841 {
00842   Assert ((fi.state() != IteratorState::valid) || (*predicate)(fi),
00843           ExcInvalidElement(fi));
00844   BaseIterator::operator = (fi);
00845   return *this;
00846 }
00847 
00848 
00849 
00850 template <typename BaseIterator>
00851 inline
00852 FilteredIterator<BaseIterator> &
00853 FilteredIterator<BaseIterator>::
00854 operator = (const BaseIterator &bi)
00855 {
00856   Assert ((bi.state() != IteratorState::valid) || (*predicate)(bi),
00857           ExcInvalidElement(bi));
00858   BaseIterator::operator = (bi);
00859   return *this;
00860 }
00861 
00862 
00863 
00864 template <typename BaseIterator>
00865 inline
00866 FilteredIterator<BaseIterator> &
00867 FilteredIterator<BaseIterator>::
00868 set_to_next_positive (const BaseIterator &bi)
00869 {
00870   BaseIterator::operator = (bi);
00871   while ((this->state() == IteratorState::valid) &&
00872          ( ! (*predicate)(*this)))
00873     BaseIterator::operator++ ();
00874 
00875   return *this;
00876 }
00877 
00878 
00879 
00880 template <typename BaseIterator>
00881 inline
00882 FilteredIterator<BaseIterator> &
00883 FilteredIterator<BaseIterator>::
00884 set_to_previous_positive (const BaseIterator &bi)
00885 {
00886   BaseIterator::operator = (bi);
00887   while ((this->state() == IteratorState::valid) &&
00888          ( ! (*predicate)(*this)))
00889     BaseIterator::operator-- ();
00890 
00891   return *this;
00892 }
00893 
00894 
00895 
00896 template <typename BaseIterator>
00897 inline
00898 bool
00899 FilteredIterator<BaseIterator>::
00900 operator == (const FilteredIterator &fi) const
00901 {
00902   return (static_cast<const BaseIterator &>(*this)
00903           ==
00904           static_cast<const BaseIterator &>(fi));
00905 }
00906 
00907 
00908 
00909 template <typename BaseIterator>
00910 inline
00911 bool
00912 FilteredIterator<BaseIterator>::
00913 operator != (const FilteredIterator &fi) const
00914 {
00915   return (static_cast<const BaseIterator &>(*this)
00916           !=
00917           static_cast<const BaseIterator &>(fi));
00918 }
00919 
00920 
00921 
00922 template <typename BaseIterator>
00923 inline
00924 bool
00925 FilteredIterator<BaseIterator>::
00926 operator < (const FilteredIterator &fi) const
00927 {
00928   return (static_cast<const BaseIterator &>(*this)
00929           <
00930           static_cast<const BaseIterator &>(fi));
00931 }
00932 
00933 
00934 
00935 
00936 template <typename BaseIterator>
00937 inline
00938 bool
00939 FilteredIterator<BaseIterator>::
00940 operator == (const BaseIterator &bi) const
00941 {
00942   return (static_cast<const BaseIterator &>(*this) == bi);
00943 }
00944 
00945 
00946 
00947 template <typename BaseIterator>
00948 inline
00949 bool
00950 FilteredIterator<BaseIterator>::
00951 operator != (const BaseIterator &bi) const
00952 {
00953   return (static_cast<const BaseIterator &>(*this) != bi);
00954 }
00955 
00956 
00957 
00958 template <typename BaseIterator>
00959 inline
00960 bool
00961 FilteredIterator<BaseIterator>::
00962 operator < (const BaseIterator &bi) const
00963 {
00964   return (static_cast<const BaseIterator &>(*this) < bi);
00965 }
00966 
00967 
00968 template <typename BaseIterator>
00969 inline
00970 FilteredIterator<BaseIterator> &
00971 FilteredIterator<BaseIterator>::
00972 operator ++ ()
00973 {
00974   if (this->state() == IteratorState::valid)
00975     do
00976       BaseIterator::operator++ ();
00977     while ((this->state() == IteratorState::valid) &&
00978            !(*predicate) (*this));
00979   return *this;
00980 }
00981 
00982 
00983 
00984 template <typename BaseIterator>
00985 inline
00986 FilteredIterator<BaseIterator>
00987 FilteredIterator<BaseIterator>::
00988 operator ++ (int)
00989 {
00990   const FilteredIterator old_state = *this;
00991 
00992   if (this->state() == IteratorState::valid)
00993     do
00994       BaseIterator::operator++ ();
00995     while ((this->state() == IteratorState::valid) &&
00996            !(*predicate) (*this));
00997   return old_state;
00998 }
00999 
01000 
01001 
01002 
01003 template <typename BaseIterator>
01004 inline
01005 FilteredIterator<BaseIterator> &
01006 FilteredIterator<BaseIterator>::
01007 operator -- ()
01008 {
01009   if (this->state() == IteratorState::valid)
01010     do
01011       BaseIterator::operator-- ();
01012     while ((this->state() == IteratorState::valid) &&
01013            !(*predicate) (*this));
01014   return *this;
01015 }
01016 
01017 
01018 
01019 template <typename BaseIterator>
01020 inline
01021 FilteredIterator<BaseIterator>
01022 FilteredIterator<BaseIterator>::
01023 operator -- (int)
01024 {
01025   const FilteredIterator old_state = *this;
01026 
01027   if (this->state() == IteratorState::valid)
01028     do
01029       BaseIterator::operator-- ();
01030     while ((this->state() == IteratorState::valid) &&
01031            !(*predicate) (*this));
01032   return old_state;
01033 }
01034 
01035 
01036 
01037 template <typename BaseIterator>
01038 template <typename Predicate>
01039 inline
01040 FilteredIterator<BaseIterator>::PredicateTemplate<Predicate>::
01041 PredicateTemplate (const Predicate &predicate)
01042                 :
01043                 predicate (predicate)
01044 {}
01045 
01046 
01047 
01048 template <typename BaseIterator>
01049 template <typename Predicate>
01050 bool
01051 FilteredIterator<BaseIterator>::PredicateTemplate<Predicate>::
01052 operator () (const BaseIterator &bi) const
01053 {
01054   return predicate(bi);
01055 }
01056 
01057 
01058 
01059 template <typename BaseIterator>
01060 template <typename Predicate>
01061 typename FilteredIterator<BaseIterator>::PredicateBase *
01062 FilteredIterator<BaseIterator>::PredicateTemplate<Predicate>::
01063 clone () const
01064 {
01065   return new PredicateTemplate (predicate);
01066 }
01067 
01068 
01069 
01070 namespace IteratorFilters
01071 {
01072 
01073 // ---------------- IteratorFilters::Active ---------
01074 
01075   template <class Iterator>
01076   inline
01077   bool
01078   Active::operator () (const Iterator &i) const
01079   {
01080     return (i->active());
01081   }
01082 
01083 
01084 // ---------------- IteratorFilters::UserFlagSet ---------
01085 
01086   template <class Iterator>
01087   inline
01088   bool
01089   UserFlagSet::operator () (const Iterator &i) const
01090   {
01091     return (i->user_flag_set());
01092   }
01093 
01094 
01095 // ---------------- IteratorFilters::UserFlagNotSet ---------
01096 
01097   template <class Iterator>
01098   inline
01099   bool
01100   UserFlagNotSet::operator () (const Iterator &i) const
01101   {
01102     return (! i->user_flag_set());
01103   }
01104 
01105 
01106 // ---------------- IteratorFilters::LevelEqualTo ---------
01107   inline
01108   LevelEqualTo::LevelEqualTo (const unsigned int level)
01109                   :
01110                   level (level)
01111   {}
01112 
01113 
01114 
01115   template <class Iterator>
01116   inline
01117   bool
01118   LevelEqualTo::operator () (const Iterator &i) const
01119   {
01120     return (static_cast<unsigned int>(i->level()) == level);
01121   }
01122 
01123 
01124 
01125 // ---------------- IteratorFilters::SubdomainEqualTo ---------
01126   inline
01127   SubdomainEqualTo::SubdomainEqualTo (const types::subdomain_id_t subdomain_id)
01128                   :
01129                   subdomain_id (subdomain_id)
01130   {}
01131 
01132 
01133 
01134   template <class Iterator>
01135   inline
01136   bool
01137   SubdomainEqualTo::operator () (const Iterator &i) const
01138   {
01139     return (i->subdomain_id() == subdomain_id);
01140   }
01141 
01142 
01143 
01144 // ---------------- IteratorFilters::LocallyOwnedCell ---------
01145 
01146   template <class Iterator>
01147   inline
01148   bool
01149   LocallyOwnedCell::operator () (const Iterator &i) const
01150   {
01151     return (i->is_locally_owned());
01152   }
01153 }
01154 
01155 
01156 DEAL_II_NAMESPACE_CLOSE
01157 
01158 /*------------------------- filtered_iterator.h ------------------------*/
01159 #endif
01160 /*------------------------- filtered_iterator.h ------------------------*/
01161 
01162 
01163 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

deal.II documentation generated on Tue May 22 2012 12:06:08 by doxygen 1.7.3