00001
00002
00003
00004
00005
00006
00007
00008
00009
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
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
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
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
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
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
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
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
01159 #endif
01160
01161
01162
01163