dune-common 3.0-git
indexset.hh
Go to the documentation of this file.
1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2// vi: set et ts=4 sw=2 sts=2:
3#ifndef DUNE_INDEXSET_HH
4#define DUNE_INDEXSET_HH
5
6#include <algorithm>
10#include <iostream>
11
12#include "localindex.hh"
13
14#include <stdint.h> // for uint32_t
15
16namespace Dune
17{
27 // forward declarations
28
29 template<class TG, class TL>
30 class IndexPair;
31
37 template<class TG, class TL>
38 std::ostream& operator<<(std::ostream& os, const IndexPair<TG,TL>& pair);
39
40 template<class TG, class TL>
41 bool operator==(const IndexPair<TG,TL>&, const IndexPair<TG,TL>&);
42
43 template<class TG, class TL>
44 bool operator!=(const IndexPair<TG,TL>&, const IndexPair<TG,TL>&);
45
46 template<class TG, class TL>
47 bool operator<(const IndexPair<TG,TL>&, const IndexPair<TG,TL>&);
48
49 template<class TG, class TL>
50 bool operator>(const IndexPair<TG,TL>&, const IndexPair<TG,TL>&);
51
52 template<class TG, class TL>
53 bool operator<=(const IndexPair<TG,TL>&, const IndexPair<TG,TL>&);
54
55 template<class TG, class TL>
56 bool operator >=(const IndexPair<TG,TL>&, const IndexPair<TG,TL>&);
57
58 template<class TG, class TL>
59 bool operator==(const IndexPair<TG,TL>&, const TG&);
60
61 template<class TG, class TL>
62 bool operator!=(const IndexPair<TG,TL>&, const TG&);
63
64 template<class TG, class TL>
65 bool operator<(const IndexPair<TG,TL>&, const TG&);
66
67 template<class TG, class TL>
68 bool operator>(const IndexPair<TG,TL>&, const TG&);
69
70 template<class TG, class TL>
71 bool operator<=(const IndexPair<TG,TL>&, const TG&);
72
73 template<class TG, class TL>
74 bool operator >=(const IndexPair<TG,TL>&, const TG&);
75
76 template<typename T>
77 struct MPITraits;
78
82 template<class TG, class TL>
84 {
85 friend std::ostream& operator<<<>(std::ostream&, const IndexPair<TG,TL>&);
86 friend bool operator==<>(const IndexPair<TG,TL>&, const IndexPair<TG,TL>&);
87 friend bool operator!=<>(const IndexPair<TG,TL>&, const IndexPair<TG,TL>&);
88 friend bool operator< <>(const IndexPair<TG,TL>&, const IndexPair<TG,TL>&);
89 friend bool operator><>(const IndexPair<TG,TL>&, const IndexPair<TG,TL>&);
90 friend bool operator<=<>(const IndexPair<TG,TL>&, const IndexPair<TG,TL>&);
91 friend bool operator>=<>(const IndexPair<TG,TL>&, const IndexPair<TG,TL>&);
92 friend bool operator==<>(const IndexPair<TG,TL>&, const TG &);
93 friend bool operator!=<>(const IndexPair<TG,TL>&, const TG &);
94 friend bool operator< <>(const IndexPair<TG,TL>&, const TG &);
95 friend bool operator> <>(const IndexPair<TG,TL>&, const TG &);
96 friend bool operator<=<>(const IndexPair<TG,TL>&, const TG &);
97 friend bool operator>=<>(const IndexPair<TG,TL>&, const TG &);
98 friend struct MPITraits<IndexPair<TG,TL> >;
99
100 public:
106 typedef TG GlobalIndex;
107
119 typedef TL LocalIndex;
120
128
140
146 inline const GlobalIndex& global() const;
147
153 inline LocalIndex& local();
154
160 inline const LocalIndex& local() const;
161
167 inline void setLocal(int index);
168 private:
170 GlobalIndex global_;
173 };
174
200
205
206 // Forward declaration
207 template<class I> class GlobalLookupIndexSet;
208
215 template<typename TG, typename TL, int N=100>
217 {
218 friend class GlobalLookupIndexSet<ParallelIndexSet<TG,TL,N> >;
219
220 public:
225 typedef TG GlobalIndex;
226
238 typedef TL LocalIndex;
239
244
245 enum {
252 arraySize= (N>0) ? N : 1
253 };
254
256 class iterator :
257 public ArrayList<IndexPair,N>::iterator
258 {
259 typedef typename ArrayList<IndexPair,N>::iterator
262 public:
263 iterator(ParallelIndexSet<TG,TL,N>& indexSet, const Father& father)
264 : Father(father), indexSet_(&indexSet)
265 {}
266
267 iterator(const iterator& other)
268 : Father(other), indexSet_(other.indexSet_)
269 {}
270
272 {
273 Father::operator==(other);
274 indexSet_ = other.indexSet_;
275 }
276
277 private:
285 inline void markAsDeleted() const throw(InvalidIndexSetState)
286 {
287#ifndef NDEBUG
288 if(indexSet_->state_ != RESIZE)
289 DUNE_THROW(InvalidIndexSetState, "Indices can only be removed "
290 <<"while in RESIZE state!");
291#endif
292 Father::operator*().local().setState(DELETED);
293 }
294
296 ParallelIndexSet<TG,TL,N>* indexSet_;
297
298 };
299
300
301
303 typedef typename
306
311
317 {
318 return state_;
319 }
320
327
336 inline void add(const GlobalIndex& global) throw(InvalidIndexSetState);
337
346 inline void add(const GlobalIndex& global, const LocalIndex& local)
348
356 inline void markAsDeleted(const iterator& position)
358
372
383 inline IndexPair&
384 operator[](const GlobalIndex& global);
385
395 inline IndexPair&
396 at(const GlobalIndex& global);
397
408 inline const IndexPair&
409 operator[](const GlobalIndex& global) const;
410
420 inline const IndexPair&
421 at(const GlobalIndex& global) const;
422
427 inline iterator begin();
428
433 inline iterator end();
434
439 inline const_iterator begin() const;
440
445 inline const_iterator end() const;
446
456 inline void renumberLocal();
457
464 inline int seqNo() const;
465
470 inline size_t size() const;
471
472 private:
474 ArrayList<IndexPair,N> localIndices_;
476 ArrayList<IndexPair,N> newIndices_;
480 int seqNo_;
482 bool deletedEntries_;
487 inline void merge();
488 };
489
490
496 template<class TG, class TL, int N>
497 std::ostream& operator<<(std::ostream& os, const ParallelIndexSet<TG,TL,N>& indexSet);
498
504 template<class I>
506 {
507 public:
512
517
522
527
529
536 GlobalLookupIndexSet(const ParallelIndexSet& indexset, std::size_t size);
537
544
549
559 inline const IndexPair&
560 operator[](const GlobalIndex& global) const;
561
565 inline const IndexPair*
566 pair(const std::size_t& local) const;
567
572 inline const_iterator begin() const;
573
578 inline const_iterator end() const;
579
586 inline int seqNo() const;
587
592 inline size_t size() const;
593 private:
597 const ParallelIndexSet& indexSet_;
598
602 std::size_t size_;
603
607 std::vector<const IndexPair*> indices_;
608
609 };
610
611
612 template<typename T>
614 {
615 static bool compare(const T& t1, const T& t2){
618 return false;
619 }
620 };
621
622 template<class TG, class TL>
624 {
626 {
627 return i1.global()<i2.global() || (i1.global()==i2.global() &&
629 i2.local()));
630 }
631 };
632
633
634
635 template<class TG, class TL>
636 inline std::ostream& operator<<(std::ostream& os, const IndexPair<TG,TL>& pair)
637 {
638 os<<"{global="<<pair.global_<<", local="<<pair.local_<<"}";
639 return os;
640 }
641
642 template<class TG, class TL, int N>
643 inline std::ostream& operator<<(std::ostream& os, const ParallelIndexSet<TG,TL,N>& indexSet)
644 {
645 typedef typename ParallelIndexSet<TG,TL,N>::const_iterator Iterator;
646 Iterator end = indexSet.end();
647 os<<"{";
648 for(Iterator index = indexSet.begin(); index != end; ++index)
649 os<<*index<<" ";
650 os<<"}";
651 return os;
652
653 }
654
655 template<class TG, class TL>
656 inline bool operator==(const IndexPair<TG,TL>& a, const IndexPair<TG,TL>& b)
657 {
658 return a.global_==b.global_;
659 }
660
661 template<class TG, class TL>
662 inline bool operator!=(const IndexPair<TG,TL>& a, const IndexPair<TG,TL>& b)
663 {
664 return a.global_!=b.global_;
665 }
666
667 template<class TG, class TL>
668 inline bool operator<(const IndexPair<TG,TL>& a, const IndexPair<TG,TL>& b)
669 {
670 return a.global_<b.global_;
671 }
672
673 template<class TG, class TL>
674 inline bool operator>(const IndexPair<TG,TL>& a, const IndexPair<TG,TL>& b)
675 {
676 return a.global_>b.global_;
677 }
678
679 template<class TG, class TL>
680 inline bool operator<=(const IndexPair<TG,TL>& a, const IndexPair<TG,TL>& b)
681 {
682 return a.global_<=b.global_;
683 }
684
685 template<class TG, class TL>
686 inline bool operator >=(const IndexPair<TG,TL>& a, const IndexPair<TG,TL>& b)
687 {
688 return a.global_>=b.global_;
689 }
690
691 template<class TG, class TL>
692 inline bool operator==(const IndexPair<TG,TL>& a, const TG& b)
693 {
694 return a.global_==b;
695 }
696
697 template<class TG, class TL>
698 inline bool operator!=(const IndexPair<TG,TL>& a, const TG& b)
699 {
700 return a.global_!=b;
701 }
702
703 template<class TG, class TL>
704 inline bool operator<(const IndexPair<TG,TL>& a, const TG& b)
705 {
706 return a.global_<b;
707 }
708
709 template<class TG, class TL>
710 inline bool operator>(const IndexPair<TG,TL>& a, const TG& b)
711 {
712 return a.global_>b;
713 }
714
715 template<class TG, class TL>
716 inline bool operator<=(const IndexPair<TG,TL>& a, const TG& b)
717 {
718 return a.global_<=b;
719 }
720
721 template<class TG, class TL>
722 inline bool operator >=(const IndexPair<TG,TL>& a, const TG& b)
723 {
724 return a.global_>=b;
725 }
726
727#ifndef DOXYGEN
728
729 template<class TG, class TL>
730 IndexPair<TG,TL>::IndexPair(const TG& global, const TL& local)
731 : global_(global), local_(local){}
732
733 template<class TG, class TL>
734 IndexPair<TG,TL>::IndexPair(const TG& global)
735 : global_(global), local_(){}
736
737 template<class TG, class TL>
739 : global_(), local_(){}
740
741 template<class TG, class TL>
742 inline const TG& IndexPair<TG,TL>::global() const {
743 return global_;
744 }
745
746 template<class TG, class TL>
747 inline TL& IndexPair<TG,TL>::local() {
748 return local_;
749 }
750
751 template<class TG, class TL>
752 inline const TL& IndexPair<TG,TL>::local() const {
753 return local_;
754 }
755
756 template<class TG, class TL>
757 inline void IndexPair<TG,TL>::setLocal(int local){
758 local_=local;
759 }
760
761 template<class TG, class TL, int N>
763 : state_(GROUND), seqNo_(0)
764 {}
765
766 template<class TG, class TL, int N>
767 void ParallelIndexSet<TG,TL,N>::beginResize() throw(InvalidIndexSetState)
768 {
769
770 // Checks in unproductive code
771#ifndef NDEBUG
772 if(state_!=GROUND)
773 DUNE_THROW(InvalidIndexSetState,
774 "IndexSet has to be in GROUND state, when "
775 << "beginResize() is called!");
776#endif
777
778 state_ = RESIZE;
779 deletedEntries_ = false;
780 }
781
782 template<class TG, class TL, int N>
783 inline void ParallelIndexSet<TG,TL,N>::add(const GlobalIndex& global)
784 throw(InvalidIndexSetState)
785 {
786 // Checks in unproductive code
787#ifndef NDEBUG
788 if(state_ != RESIZE)
789 DUNE_THROW(InvalidIndexSetState, "Indices can only be added "
790 <<"while in RESIZE state!");
791#endif
792 newIndices_.push_back(IndexPair(global));
793 }
794
795 template<class TG, class TL, int N>
796 inline void ParallelIndexSet<TG,TL,N>::add(const TG& global, const TL& local)
797 throw(InvalidIndexSetState)
798 {
799 // Checks in unproductive code
800#ifndef NDEBUG
801 if(state_ != RESIZE)
802 DUNE_THROW(InvalidIndexSetState, "Indices can only be added "
803 <<"while in RESIZE state!");
804#endif
805 newIndices_.push_back(IndexPair(global,local));
806 }
807
808 template<class TG, class TL, int N>
809 inline void ParallelIndexSet<TG,TL,N>::markAsDeleted(const iterator& global)
810 throw(InvalidIndexSetState){
811 // Checks in unproductive code
812#ifndef NDEBUG
813 if(state_ != RESIZE)
814 DUNE_THROW(InvalidIndexSetState, "Indices can only be removed "
815 <<"while in RESIZE state!");
816#endif
817 deletedEntries_ = true;
818
819 global.markAsDeleted();
820 }
821
822 template<class TG, class TL, int N>
823 void ParallelIndexSet<TG,TL,N>::endResize() throw(InvalidIndexSetState){
824 // Checks in unproductive code
825#ifndef NDEBUG
826 if(state_ != RESIZE)
827 DUNE_THROW(InvalidIndexSetState, "endResize called while not "
828 <<"in RESIZE state!");
829#endif
830
831 std::sort(newIndices_.begin(), newIndices_.end(), IndexSetSortFunctor<TG,TL>());
832 merge();
833 seqNo_++;
834 state_ = GROUND;
835 }
836
837
838 template<class TG, class TL, int N>
839 inline void ParallelIndexSet<TG,TL,N>::merge(){
840 if(localIndices_.size()==0)
841 {
842 localIndices_=newIndices_;
843 newIndices_.clear();
844 }
845 else if(newIndices_.size()>0 || deletedEntries_)
846 {
847 ArrayList<IndexPair,N> tempPairs;
848 typedef typename ArrayList<IndexPair,N>::iterator iterator;
849 typedef typename ArrayList<IndexPair,N>::const_iterator const_iterator;
850
851 iterator old=localIndices_.begin();
852 iterator added=newIndices_.begin();
853 const const_iterator endold=localIndices_.end();
854 const const_iterator endadded=newIndices_.end();
855
856 while(old != endold && added!= endadded)
857 {
858 if(old->local().state()==DELETED) {
859 old.eraseToHere();
860 }
861 else
862 {
863 if(old->global() < added->global() ||
864 (old->global() == added->global()
865 && LocalIndexComparator<TL>::compare(old->local(),added->local())))
866 {
867 tempPairs.push_back(*old);
868 old.eraseToHere();
869 continue;
870 }else
871 {
872 tempPairs.push_back(*added);
873 added.eraseToHere();
874 }
875 }
876 }
877
878 while(old != endold)
879 {
880 if(old->local().state()!=DELETED) {
881 tempPairs.push_back(*old);
882 }
883 old.eraseToHere();
884 }
885
886 while(added!= endadded)
887 {
888 tempPairs.push_back(*added);
889 added.eraseToHere();
890 }
891 localIndices_ = tempPairs;
892 }
893 }
894
895
896 template<class TG, class TL, int N>
897 inline const IndexPair<TG,TL>&
898 ParallelIndexSet<TG,TL,N>::at(const TG& global) const
899 {
900 // perform a binary search
901 int low=0, high=localIndices_.size()-1, probe=-1;
902
903 while(low<high)
904 {
905 probe = (high + low) / 2;
906 if(global <= localIndices_[probe].global())
907 high = probe;
908 else
909 low = probe+1;
910 }
911
912 if(probe==-1)
913 DUNE_THROW(RangeError, "No entries!");
914
915 if( localIndices_[low].global() != global)
916 DUNE_THROW(RangeError, "Could not find entry of "<<global);
917 else
918 return localIndices_[low];
919 }
920
921 template<class TG, class TL, int N>
922 inline const IndexPair<TG,TL>&
923 ParallelIndexSet<TG,TL,N>::operator[](const TG& global) const
924 {
925 // perform a binary search
926 int low=0, high=localIndices_.size()-1, probe=-1;
927
928 while(low<high)
929 {
930 probe = (high + low) / 2;
931 if(global <= localIndices_[probe].global())
932 high = probe;
933 else
934 low = probe+1;
935 }
936
937 return localIndices_[low];
938 }
939 template<class TG, class TL, int N>
940 inline IndexPair<TG,TL>& ParallelIndexSet<TG,TL,N>::at(const TG& global)
941 {
942 // perform a binary search
943 int low=0, high=localIndices_.size()-1, probe=-1;
944
945 while(low<high)
946 {
947 probe = (high + low) / 2;
948 if(localIndices_[probe].global() >= global)
949 high = probe;
950 else
951 low = probe+1;
952 }
953
954 if(probe==-1)
955 DUNE_THROW(RangeError, "No entries!");
956
957 if( localIndices_[low].global() != global)
958 DUNE_THROW(RangeError, "Could not find entry of "<<global);
959 else
960 return localIndices_[low];
961 }
962
963 template<class TG, class TL, int N>
964 inline IndexPair<TG,TL>& ParallelIndexSet<TG,TL,N>::operator[](const TG& global)
965 {
966 // perform a binary search
967 int low=0, high=localIndices_.size()-1, probe=-1;
968
969 while(low<high)
970 {
971 probe = (high + low) / 2;
972 if(localIndices_[probe].global() >= global)
973 high = probe;
974 else
975 low = probe+1;
976 }
977
978 return localIndices_[low];
979 }
980 template<class TG, class TL, int N>
981 inline typename ParallelIndexSet<TG,TL,N>::iterator
983 {
984 return iterator(*this, localIndices_.begin());
985 }
986
987
988 template<class TG, class TL, int N>
989 inline typename ParallelIndexSet<TG,TL,N>::iterator
991 {
992 return iterator(*this,localIndices_.end());
993 }
994
995 template<class TG, class TL, int N>
996 inline typename ParallelIndexSet<TG,TL,N>::const_iterator
998 {
999 return localIndices_.begin();
1000 }
1001
1002
1003 template<class TG, class TL, int N>
1004 inline typename ParallelIndexSet<TG,TL,N>::const_iterator
1006 {
1007 return localIndices_.end();
1008 }
1009
1010 template<class TG, class TL, int N>
1012#ifndef NDEBUG
1013 if(state_==RESIZE)
1014 DUNE_THROW(InvalidIndexSetState, "IndexSet has to be in "
1015 <<"GROUND state for renumberLocal()");
1016#endif
1017
1018 typedef typename ArrayList<IndexPair,N>::iterator iterator;
1019 const const_iterator end_ = end();
1020 uint32_t index=0;
1021
1022 for(iterator pair=begin(); pair!=end_; index++, ++pair)
1023 pair->local()=index;
1024 }
1025
1026 template<class TG, class TL, int N>
1027 inline int ParallelIndexSet<TG,TL,N>::seqNo() const
1028 {
1029 return seqNo_;
1030 }
1031
1032 template<class TG, class TL, int N>
1033 inline size_t ParallelIndexSet<TG,TL,N>::size() const
1034 {
1035 return localIndices_.size();
1036 }
1037
1038 template<class I>
1040 std::size_t size)
1041 : indexSet_(indexset), size_(size),
1042 indices_(size_, static_cast<const IndexPair*>(0))
1043 {
1044 const_iterator end_ = indexSet_.end();
1045
1046 for(const_iterator pair = indexSet_.begin(); pair!=end_; ++pair) {
1047 assert(pair->local()<size_);
1048 indices_[pair->local()] = &(*pair);
1049 }
1050 }
1051
1052 template<class I>
1054 : indexSet_(indexset), size_(0)
1055 {
1056 const_iterator end_ = indexSet_.end();
1057 for(const_iterator pair = indexSet_.begin(); pair!=end_; ++pair)
1058 size_=std::max(size_,static_cast<std::size_t>(pair->local()));
1059
1060 indices_.resize(++size_, 0);
1061
1062 for(const_iterator pair = indexSet_.begin(); pair!=end_; ++pair)
1063 indices_[pair->local()] = &(*pair);
1064 }
1065
1066 template<class I>
1068 {}
1069
1070 template<class I>
1071 inline const IndexPair<typename I::GlobalIndex, typename I::LocalIndex>*
1072 GlobalLookupIndexSet<I>::pair(const std::size_t& local) const
1073 {
1074 return indices_[local];
1075 }
1076
1077 template<class I>
1078 inline const IndexPair<typename I::GlobalIndex, typename I::LocalIndex>&
1079 GlobalLookupIndexSet<I>::operator[](const GlobalIndex& global) const
1080 {
1081 return indexSet_[global];
1082 }
1083
1084 template<class I>
1085 typename I::const_iterator GlobalLookupIndexSet<I>::begin() const
1086 {
1087 return indexSet_.begin();
1088 }
1089
1090 template<class I>
1091 typename I::const_iterator GlobalLookupIndexSet<I>::end() const
1092 {
1093 return indexSet_.end();
1094 }
1095
1096 template<class I>
1097 inline size_t GlobalLookupIndexSet<I>::size() const
1098 {
1099 return size_;
1100 }
1101
1102 template<class I>
1103 inline int GlobalLookupIndexSet<I>::seqNo() const
1104 {
1105 return indexSet_.seqNo();
1106 }
1107
1108 template<typename TG, typename TL, int N, typename TG1, typename TL1, int N1>
1109 bool operator==(const ParallelIndexSet<TG,TL,N>& idxset,
1110 const ParallelIndexSet<TG1,TL1,N1>& idxset1)
1111 {
1112 if(idxset.size()!=idxset1.size())
1113 return false;
1114 typedef typename ParallelIndexSet<TG,TL,N>::const_iterator Iter;
1115 typedef typename ParallelIndexSet<TG1,TL1,N1>::const_iterator Iter1;
1116 Iter iter=idxset.begin();
1117 for(Iter1 iter1=idxset1.begin(); iter1 != idxset1.end(); ++iter, ++iter1) {
1118 if(iter1->global()!=iter->global())
1119 return false;
1120 typedef typename ParallelIndexSet<TG,TL,N>::LocalIndex PI;
1121 const PI& pi=iter->local(), pi1=iter1->local();
1122
1123 if(pi!=pi1)
1124 return false;
1125 }
1126 return true;
1127 }
1128
1129 template<typename TG, typename TL, int N, typename TG1, typename TL1, int N1>
1130 bool operator!=(const ParallelIndexSet<TG,TL,N>& idxset,
1131 const ParallelIndexSet<TG1,TL1,N1>& idxset1)
1132 {
1133 return !(idxset==idxset1);
1134 }
1135
1136
1137#endif // DOXYGEN
1138
1139}
1140#endif
Implements a random-access container that can efficiently change size (similar to std::deque)
Provides classes for use as the local index in ParallelIndexSet.
A few common exception classes.
Definition of the DUNE_UNUSED macro for the case that config.h is not available.
#define DUNE_UNUSED_PARAMETER(parm)
A macro to mark intentionally unused function parameters with.
Definition unused.hh:18
std::ostream & operator<<(std::ostream &s, const std::array< T, N > &e)
Output operator for array.
Definition array.hh:28
#define DUNE_THROW(E, m)
Definition exceptions.hh:216
EnableIfInterOperable< T1, T2, bool >::type operator<(const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
Comparison operator.
Definition iteratorfacades.hh:629
EnableIfInterOperable< T1, T2, bool >::type operator>(const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
Comparison operator.
Definition iteratorfacades.hh:675
EnableIfInterOperable< T1, T2, bool >::type operator<=(const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
Comparison operator.
Definition iteratorfacades.hh:652
EnableIfInterOperable< T1, T2, bool >::type operator==(const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
Checks for equality.
Definition iteratorfacades.hh:233
EnableIfInterOperable< T1, T2, bool >::type operator>=(const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
Comparison operator.
Definition iteratorfacades.hh:697
EnableIfInterOperable< T1, T2, bool >::type operator!=(const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
Checks for inequality.
Definition iteratorfacades.hh:255
IndexPair & operator[](const GlobalIndex &global)
Find the index pair with a specific global id.
void beginResize()
Indicate that the index set is to be resized.
ParallelIndexSetState
The states the index set can be in.
Definition indexset.hh:180
void renumberLocal()
Renumbers the local index numbers.
size_t size() const
Get the total number (public and nonpublic) indices.
ArrayList< IndexPair, N >::const_iterator const_iterator
The constant iterator over the pairs.
Definition indexset.hh:305
bool operator()(const IndexPair< TG, TL > &i1, const IndexPair< TG, TL > &i2)
Definition indexset.hh:625
void add(const GlobalIndex &global)
Add an new index to the set.
const_iterator end() const
Get an iterator over the indices positioned after the last index.
const LocalIndex & local() const
Get the local index.
GlobalLookupIndexSet(const ParallelIndexSet &indexset)
Constructor.
TL LocalIndex
the type of the local index.
Definition indexset.hh:119
int seqNo() const
Get the internal sequence number.
static bool compare(const T &t1, const T &t2)
Definition indexset.hh:615
iterator begin()
Get an iterator over the indices positioned at the first index.
Dune::IndexPair< typename I::GlobalIndex, typename I::LocalIndex > IndexPair
Definition indexset.hh:528
iterator end()
Get an iterator over the indices positioned after the last index.
ParallelIndexSet::const_iterator const_iterator
The iterator over the index pairs.
Definition indexset.hh:526
const_iterator begin() const
Get an iterator over the indices positioned at the first index.
const ParallelIndexSetState & state()
Get the state the index set is in.
Definition indexset.hh:316
const IndexPair & operator[](const GlobalIndex &global) const
Find the index pair with a specific global id.
IndexPair()
Construct a new Pair.
I ParallelIndexSet
The type of the index set.
Definition indexset.hh:511
TL LocalIndex
The type of the local index, e.g. ParallelLocalIndex.
Definition indexset.hh:238
void markAsDeleted(const iterator &position)
Mark an index as deleted.
ParallelIndexSet::LocalIndex LocalIndex
The type of the local index.
Definition indexset.hh:516
iterator & operator==(const iterator &other)
Definition indexset.hh:271
IndexPair(const GlobalIndex &global, const LocalIndex &local)
Constructs a new Pair.
void setLocal(int index)
Set the local index.
const GlobalIndex & global() const
Get the global index.
IndexPair & at(const GlobalIndex &global)
Find the index pair with a specific global id.
ParallelIndexSet()
Constructor.
void endResize()
Indicate that the resizing finishes.
~GlobalLookupIndexSet()
Destructor.
const IndexPair * pair(const std::size_t &local) const
Get the index pair corresponding to a local index.
LocalIndex & local()
Get the local index.
size_t size() const
Get the total number (public and nonpublic) indices.
IndexPair(const GlobalIndex &global)
Constructs a new Pair.
TG GlobalIndex
the type of the global index. This type has to provide at least a operator< for sorting.
Definition indexset.hh:225
TG GlobalIndex
the type of the global index.
Definition indexset.hh:106
int seqNo() const
Get the internal sequence number.
iterator(ParallelIndexSet< TG, TL, N > &indexSet, const Father &father)
Definition indexset.hh:263
iterator(const iterator &other)
Definition indexset.hh:267
GlobalLookupIndexSet(const ParallelIndexSet &indexset, std::size_t size)
Constructor.
ParallelIndexSet::GlobalIndex GlobalIndex
The type of the global index.
Definition indexset.hh:521
Dune::IndexPair< GlobalIndex, LocalIndex > IndexPair
The type of the pair stored.
Definition indexset.hh:243
@ RESIZE
Indicates that the index set is currently being resized.
Definition indexset.hh:189
@ GROUND
The default mode. Indicates that the index set is ready to be used.
Definition indexset.hh:185
@ DELETED
Definition localindex.hh:26
@ arraySize
The size of the individual arrays in the underlying ArrayList.
Definition indexset.hh:252
STL namespace.
Dune namespace.
Definition alignment.hh:11
constexpr auto size(const Dune::FieldVector< T, i > *, const PriorityTag< 5 > &) -> decltype(std::integral_constant< std::size_t, i >())
Definition hybridutilities.hh:22
A random access iterator for the Dune::ArrayList class.
Definition arraylist.hh:258
A dynamically growing random access list.
Definition arraylist.hh:60
ArrayListIterator< MemberType, N, A > iterator
A random access iterator.
Definition arraylist.hh:106
ConstArrayListIterator< MemberType, N, A > const_iterator
A constant random access iterator.
Definition arraylist.hh:111
A traits class describing the mapping of types onto MPI_Datatypes.
Definition mpitraits.hh:39
Default exception if a function was called while the object is not in a valid state for that function...
Definition exceptions.hh:279
Reference operator*() const
Dereferencing operator.
Definition iteratorfacades.hh:492
A pair consisting of a global and local index.
Definition indexset.hh:84
Exception indicating that the index set is not in the expected state.
Definition indexset.hh:204
Decorates an index set with the possibility to find a global index that is mapped to a specific local...
Definition indexset.hh:506
Manager class for the mapping between local indices and globally unique indices.
Definition indexset.hh:217
The iterator over the pairs.
Definition indexset.hh:258
Definition indexset.hh:614
Definition indexset.hh:624