dune-common  2.5.1
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>
9 #include <dune/common/unused.hh>
10 #include <iostream>
11 
12 #include "localindex.hh"
13 
14 #include <stdint.h> // for uint32_t
15 
16 namespace 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>
83  class IndexPair
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 
127  IndexPair(const GlobalIndex& global, const LocalIndex& local);
128 
132  IndexPair();
139  IndexPair(const GlobalIndex& global);
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_;
172  LocalIndex local_;
173  };
174 
180  {
199  };
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
260  Father;
261  friend class ParallelIndexSet<GlobalIndex,LocalIndex,N>;
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 
271  iterator& operator==(const iterator& other)
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 
316  inline const ParallelIndexSetState& state()
317  {
318  return state_;
319  }
320 
326  void beginResize() throw(InvalidIndexSetState);
327 
336  inline void add(const GlobalIndex& global) throw(InvalidIndexSetState);
337 
346  inline void add(const GlobalIndex& global, const LocalIndex& local)
347  throw(InvalidIndexSetState);
348 
356  inline void markAsDeleted(const iterator& position)
357  throw(InvalidIndexSetState);
358 
371  void endResize() throw(InvalidIndexSetState);
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_;
478  ParallelIndexSetState state_;
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:
511  typedef I ParallelIndexSet;
512 
517 
522 
527 
529 
536  GlobalLookupIndexSet(const ParallelIndexSet& indexset, std::size_t size);
537 
543  GlobalLookupIndexSet(const ParallelIndexSet& indexset);
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  {
625  bool operator()(const IndexPair<TG,TL>& i1, const IndexPair<TG,TL>& i2)
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>
768  {
769 
770  // Checks in unproductive code
771 #ifndef NDEBUG
772  if(state_!=GROUND)
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>
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>
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>
983  {
984  return iterator(*this, localIndices_.begin());
985  }
986 
987 
988  template<class TG, class TL, int N>
991  {
992  return iterator(*this,localIndices_.end());
993  }
994 
995  template<class TG, class TL, int N>
998  {
999  return localIndices_.begin();
1000  }
1001 
1002 
1003  template<class TG, class TL, int N>
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>
1072  GlobalLookupIndexSet<I>::pair(const std::size_t& local) const
1073  {
1074  return indices_[local];
1075  }
1076 
1077  template<class I>
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
friend bool operator>=(const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
Definition: indexset.hh:686
bool operator==(const IndexPair< TG, TL > &, const TG &)
Definition: indexset.hh:692
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
friend bool operator==(const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
Definition: indexset.hh:656
TL LocalIndex
The type of the local index, e.g. ParallelLocalIndex.
Definition: indexset.hh:238
GlobalLookupIndexSet(const ParallelIndexSet &indexset, std::size_t size)
Constructor.
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.
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
const GlobalIndex & global() const
Get the global index.
A constant random access iterator for the Dune::ArrayList class.
Definition: arraylist.hh:20
ParallelIndexSet::const_iterator const_iterator
The iterator over the index pairs.
Definition: indexset.hh:526
IndexPair & at(const GlobalIndex &global)
Find the index pair with a specific global id.
void markAsDeleted(const iterator &position)
Mark an index as deleted.
Provides classes for use as the local index in ParallelIndexSet.
The default mode. Indicates that the index set is ready to be used.
Definition: indexset.hh:185
const_iterator begin() const
Get an iterator over the indices positioned at the first index.
LocalIndex & local()
Get the local index.
ParallelIndexSet::LocalIndex LocalIndex
The type of the local index.
Definition: indexset.hh:516
Default exception if a function was called while the object is not in a valid state for that function...
Definition: exceptions.hh:279
A traits class describing the mapping of types onto MPI_Datatypes.
Definition: bigunsignedint.hh:25
Definition: localindex.hh:26
iterator end()
Get an iterator over the indices positioned after the last index.
ParallelIndexSetState
The states the index set can be in.
Definition: indexset.hh:179
bool operator()(const IndexPair< TG, TL > &i1, const IndexPair< TG, TL > &i2)
Definition: indexset.hh:625
void beginResize()
Indicate that the index set is to be resized.
const IndexPair * pair(const std::size_t &local) const
Get the index pair corresponding to a local index.
void endResize()
Indicate that the resizing finishes.
A pair consisting of a global and local index.
Definition: indexset.hh:30
Indicates that the index set is currently being resized.
Definition: indexset.hh:189
Dune namespace.
Definition: alignment.hh:10
size_t size() const
Get the total number (public and nonpublic) indices.
A random access iterator for the Dune::ArrayList class.
Definition: arraylist.hh:17
TG GlobalIndex
the type of the global index. This type has to provide at least a operator< for sorting.
Definition: indexset.hh:225
Implements a random-access container that can efficiently change size (similar to std::deque) ...
Definition: indexset.hh:613
Decorates an index set with the possibility to find a global index that is mapped to a specific local...
Definition: indexset.hh:207
TL LocalIndex
the type of the local index.
Definition: indexset.hh:119
int seqNo() const
Get the internal sequence number.
A few common exception classes.
void push_back(const_reference entry)
Append an entry to the list.
Definition: arraylist.hh:491
void setLocal(int index)
Set the local index.
Dune::IndexPair< GlobalIndex, LocalIndex > IndexPair
The type of the pair stored.
Definition: indexset.hh:243
A dynamically growing random access list.
Definition: arraylist.hh:59
const ParallelIndexSetState & state()
Get the state the index set is in.
Definition: indexset.hh:316
Default exception class for range errors.
Definition: exceptions.hh:252
#define DUNE_THROW(E, m)
Definition: exceptions.hh:216
Definition of the DUNE_UNUSED macro for the case that config.h is not available.
size_t size() const
Get the total number (public and nonpublic) indices.
ParallelIndexSet::GlobalIndex GlobalIndex
The type of the global index.
Definition: indexset.hh:521
iterator begin()
Get an iterator over the indices positioned at the first index.
IndexPair & operator[](const GlobalIndex &global)
Find the index pair with a specific global id.
Dune::IndexPair< typename I::GlobalIndex, typename I::LocalIndex > IndexPair
Definition: indexset.hh:528
static bool compare(const T &t1, const T &t2)
Definition: indexset.hh:615
int seqNo() const
Get the internal sequence number.
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
void renumberLocal()
Renumbers the local index numbers.
TG GlobalIndex
the type of the global index.
Definition: indexset.hh:106
ParallelIndexSet()
Constructor.
The iterator over the pairs.
Definition: indexset.hh:256
Exception indicating that the index set is not in the expected state.
Definition: indexset.hh:204
iterator(ParallelIndexSet< TG, TL, N > &indexSet, const Father &father)
Definition: indexset.hh:263
iterator & operator==(const iterator &other)
Definition: indexset.hh:271
#define DUNE_UNUSED_PARAMETER(parm)
A macro to mark intentionally unused function parameters with.
Definition: unused.hh:18
I ParallelIndexSet
The type of the index set.
Definition: indexset.hh:511
Definition: indexset.hh:623
IndexPair()
Construct a new Pair.
iterator(const iterator &other)
Definition: indexset.hh:267
constexpr auto size(const Dune::FieldVector< T, i > *, const PriorityTag< 5 > &) -> decltype(std::integral_constant< std::size_t, i >())
Definition: hybridutilities.hh:22
friend bool operator!=(const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
Definition: indexset.hh:662
Manager class for the mapping between local indices and globally unique indices.
Definition: indexset.hh:216
ArrayList< IndexPair, N >::const_iterator const_iterator
The constant iterator over the pairs.
Definition: indexset.hh:305
bigunsignedint< k > operator*(const bigunsignedint< k > &x, std::uintmax_t y)
Definition: bigunsignedint.hh:527
~GlobalLookupIndexSet()
Destructor.
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
friend bool operator>(const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
Definition: indexset.hh:674
const IndexPair & operator[](const GlobalIndex &global) const
Find the index pair with a specific global id.