contrib/llvm/tools/lldb/include/lldb/Utility/Iterable.h

   1 //===-- Iterable.h ----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef liblldb_Iterable_h_
  11 #define liblldb_Iterable_h_
  12
  13 // C Includes
  14 // C++ Includes
  15 #include <utility>
  16
  17 // Other libraries and framework includes
  18 // Project includes
  19
  20 namespace lldb_private {
  21
  22 template <typename I, typename E> E map_adapter(I &iter) {
  23   return iter->second;
  24 }
  25
  26 template <typename I, typename E> E vector_adapter(I &iter) { return *iter; }
  27
  28 template <typename I, typename E> E list_adapter(I &iter) { return *iter; }
  29
  30 template <typename C, typename E, E (*A)(typename C::const_iterator &)>
  31 class AdaptedConstIterator {
  32 public:
  33   typedef typename C::const_iterator BackingIterator;
  34
  35   // Wrapping constructor
  36   AdaptedConstIterator(BackingIterator backing_iterator)
  37       : m_iter(backing_iterator) {}
  38
  39   // Default-constructible
  40   AdaptedConstIterator() : m_iter() {}
  41
  42   // Copy-constructible
  43   AdaptedConstIterator(const AdaptedConstIterator &rhs) : m_iter(rhs.m_iter) {}
  44
  45   // Copy-assignable
  46   AdaptedConstIterator &operator=(const AdaptedConstIterator &rhs) {
  47     m_iter = rhs.m_iter;
  48     return *this;
  49   }
  50
  51   // Destructible
  52   ~AdaptedConstIterator() = default;
  53
  54   // Comparable
  55   bool operator==(const AdaptedConstIterator &rhs) {
  56     return m_iter == rhs.m_iter;
  57   }
  58
  59   bool operator!=(const AdaptedConstIterator &rhs) {
  60     return m_iter != rhs.m_iter;
  61   }
  62
  63   // Rvalue dereferenceable
  64   E operator*() { return (*A)(m_iter); }
  65
  66   E operator->() { return (*A)(m_iter); }
  67
  68   // Offset dereferenceable
  69   E operator[](typename BackingIterator::difference_type offset) {
  70     return AdaptedConstIterator(m_iter + offset);
  71   }
  72
  73   // Incrementable
  74   AdaptedConstIterator &operator++() {
  75     m_iter++;
  76     return *this;
  77   }
  78
  79   // Decrementable
  80   AdaptedConstIterator &operator--() {
  81     m_iter--;
  82     return *this;
  83   }
  84
  85   // Compound assignment
  86   AdaptedConstIterator &
  87   operator+=(typename BackingIterator::difference_type offset) {
  88     m_iter += offset;
  89     return *this;
  90   }
  91
  92   AdaptedConstIterator &
  93   operator-=(typename BackingIterator::difference_type offset) {
  94     m_iter -= offset;
  95     return *this;
  96   }
  97
  98   // Arithmetic
  99   AdaptedConstIterator
 100   operator+(typename BackingIterator::difference_type offset) {
 101     return AdaptedConstIterator(m_iter + offset);
 102   }
 103
 104   AdaptedConstIterator
 105   operator-(typename BackingIterator::difference_type offset) {
 106     return AdaptedConstIterator(m_iter - offset);
 107   }
 108
 109   // Comparable
 110   bool operator<(AdaptedConstIterator &rhs) { return m_iter < rhs.m_iter; }
 111
 112   bool operator<=(AdaptedConstIterator &rhs) { return m_iter <= rhs.m_iter; }
 113
 114   bool operator>(AdaptedConstIterator &rhs) { return m_iter > rhs.m_iter; }
 115
 116   bool operator>=(AdaptedConstIterator &rhs) { return m_iter >= rhs.m_iter; }
 117
 118   template <typename C1, typename E1, E1 (*A1)(typename C1::const_iterator &)>
 119   friend AdaptedConstIterator<C1, E1, A1>
 120   operator+(typename C1::const_iterator::difference_type,
 121             AdaptedConstIterator<C1, E1, A1> &);
 122
 123   template <typename C1, typename E1, E1 (*A1)(typename C1::const_iterator &)>
 124   friend typename C1::const_iterator::difference_type
 125   operator-(AdaptedConstIterator<C1, E1, A1> &,
 126             AdaptedConstIterator<C1, E1, A1> &);
 127
 128   template <typename C1, typename E1, E1 (*A1)(typename C1::const_iterator &)>
 129   friend void swap(AdaptedConstIterator<C1, E1, A1> &,
 130                    AdaptedConstIterator<C1, E1, A1> &);
 131
 132 private:
 133   BackingIterator m_iter;
 134 };
 135
 136 template <typename C, typename E, E (*A)(typename C::const_iterator &)>
 137 AdaptedConstIterator<C, E, A> operator+(
 138     typename AdaptedConstIterator<C, E, A>::BackingIterator::difference_type
 139         offset,
 140     AdaptedConstIterator<C, E, A> &rhs) {
 141   return rhs.operator+(offset);
 142 }
 143
 144 template <typename C, typename E, E (*A)(typename C::const_iterator &)>
 145 typename AdaptedConstIterator<C, E, A>::BackingIterator::difference_type
 146 operator-(AdaptedConstIterator<C, E, A> &lhs,
 147           AdaptedConstIterator<C, E, A> &rhs) {
 148   return (lhs.m_iter - rhs.m_iter);
 149 }
 150
 151 template <typename C, typename E, E (*A)(typename C::const_iterator &)>
 152 void swap(AdaptedConstIterator<C, E, A> &lhs,
 153           AdaptedConstIterator<C, E, A> &rhs) {
 154   std::swap(lhs.m_iter, rhs.m_iter);
 155 }
 156
 157 template <typename C, typename E, E (*A)(typename C::const_iterator &)>
 158 class AdaptedIterable {
 159 private:
 160   const C &m_container;
 161
 162 public:
 163   AdaptedIterable(const C &container) : m_container(container) {}
 164
 165   AdaptedConstIterator<C, E, A> begin() {
 166     return AdaptedConstIterator<C, E, A>(m_container.begin());
 167   }
 168
 169   AdaptedConstIterator<C, E, A> end() {
 170     return AdaptedConstIterator<C, E, A>(m_container.end());
 171   }
 172 };
 173
 174 template <typename C, typename E, E (*A)(typename C::const_iterator &),
 175           typename MutexType>
 176 class LockingAdaptedIterable : public AdaptedIterable<C, E, A> {
 177 public:
 178   LockingAdaptedIterable(C &container, MutexType &mutex)
 179       : AdaptedIterable<C, E, A>(container), m_mutex(&mutex) {
 180     m_mutex->lock();
 181   }
 182
 183   LockingAdaptedIterable(LockingAdaptedIterable &&rhs)
 184       : AdaptedIterable<C, E, A>(rhs), m_mutex(rhs.m_mutex) {
 185     rhs.m_mutex = nullptr;
 186   }
 187
 188   ~LockingAdaptedIterable() {
 189     if (m_mutex)
 190       m_mutex->unlock();
 191   }
 192
 193 private:
 194   MutexType *m_mutex = nullptr;
 195
 196   LockingAdaptedIterable(const LockingAdaptedIterable &) = delete;
 197   LockingAdaptedIterable &operator=(const LockingAdaptedIterable &) = delete;
 198 };
 199
 200 } // namespace lldb_private
 201
 202 #endif // liblldb_Iterable_h_