1 //===-- Iterable.h ----------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef liblldb_Iterable_h_
11 #define liblldb_Iterable_h_
13 #include "lldb/Host/Mutex.h"
15 namespace lldb_private
18 template <typename I, typename E> E map_adapter(I &iter)
23 template <typename I, typename E> E vector_adapter(I &iter)
28 template <typename C, typename E, E (*A)(typename C::const_iterator &)> class AdaptedConstIterator
31 typedef typename C::const_iterator BackingIterator;
33 BackingIterator m_iter;
35 // Wrapping constructor
36 AdaptedConstIterator (BackingIterator backing_iterator) :
37 m_iter(backing_iterator)
41 // Default-constructible
42 AdaptedConstIterator () :
48 AdaptedConstIterator (const AdaptedConstIterator &rhs) :
54 AdaptedConstIterator &operator= (const AdaptedConstIterator &rhs)
61 ~AdaptedConstIterator () { }
64 bool operator== (const AdaptedConstIterator &rhs)
66 return m_iter == rhs.m_iter;
69 bool operator!= (const AdaptedConstIterator &rhs)
71 return m_iter != rhs.m_iter;
74 // Rvalue dereferenceable
85 // Offset dereferenceable
86 E operator[] (typename BackingIterator::difference_type offset)
88 return AdaptedConstIterator(m_iter + offset);
92 AdaptedConstIterator &operator++ ()
99 AdaptedConstIterator &operator-- ()
105 // Compound assignment
106 AdaptedConstIterator &operator+= (typename BackingIterator::difference_type offset)
112 AdaptedConstIterator &operator-= (typename BackingIterator::difference_type offset)
119 AdaptedConstIterator operator+ (typename BackingIterator::difference_type offset)
121 return AdaptedConstIterator(m_iter + offset);
124 AdaptedConstIterator operator- (typename BackingIterator::difference_type offset)
126 return AdaptedConstIterator(m_iter - offset);
130 bool operator< (AdaptedConstIterator &rhs)
132 return m_iter < rhs.m_iter;
135 bool operator<= (AdaptedConstIterator &rhs)
137 return m_iter <= rhs.m_iter;
140 bool operator> (AdaptedConstIterator &rhs)
142 return m_iter > rhs.m_iter;
145 bool operator>= (AdaptedConstIterator &rhs)
147 return m_iter >= rhs.m_iter;
150 template <typename C1, typename E1, E1 (*A1)(typename C1::const_iterator &)>
151 friend AdaptedConstIterator<C1, E1, A1> operator+(typename C1::const_iterator::difference_type, AdaptedConstIterator<C1, E1, A1> &);
153 template <typename C1, typename E1, E1 (*A1)(typename C1::const_iterator &)>
154 friend typename C1::const_iterator::difference_type operator-(AdaptedConstIterator<C1, E1, A1> &, AdaptedConstIterator<C1, E1, A1> &);
156 template <typename C1, typename E1, E1 (*A1)(typename C1::const_iterator &)>
157 friend void swap(AdaptedConstIterator<C1, E1, A1> &, AdaptedConstIterator<C1, E1, A1> &);
160 template <typename C, typename E, E (*A)(typename C::const_iterator &)>
161 AdaptedConstIterator<C, E, A> operator+ (typename AdaptedConstIterator<C, E, A>::BackingIterator::difference_type offset, AdaptedConstIterator<C, E, A> &rhs)
163 return rhs.operator+(offset);
166 template <typename C, typename E, E (*A)(typename C::const_iterator &)>
167 typename AdaptedConstIterator<C, E, A>::BackingIterator::difference_type operator- (AdaptedConstIterator<C, E, A> &lhs, AdaptedConstIterator<C, E, A> &rhs)
169 return(lhs.m_iter - rhs.m_iter);
172 template <typename C, typename E, E (*A)(typename C::const_iterator &)>
173 void swap (AdaptedConstIterator<C, E, A> &lhs, AdaptedConstIterator<C, E, A> &rhs)
175 std::swap(lhs.m_iter, rhs.m_iter);
178 template <typename C, typename E, E (*A)(typename C::const_iterator &)> class AdaptedIterable
181 const C &m_container;
183 AdaptedIterable (const C &container) :
184 m_container(container)
188 AdaptedConstIterator<C, E, A> begin ()
190 return AdaptedConstIterator<C, E, A>(m_container.begin());
193 AdaptedConstIterator<C, E, A> end ()
195 return AdaptedConstIterator<C, E, A>(m_container.end());
199 template <typename C, typename E, E (*A)(typename C::const_iterator &)> class LockingAdaptedIterable : public AdaptedIterable<C, E, A>
202 Mutex *m_mutex = nullptr;
204 LockingAdaptedIterable (C &container, Mutex &mutex) :
205 AdaptedIterable<C,E,A>(container),
211 LockingAdaptedIterable (LockingAdaptedIterable &&rhs) :
212 AdaptedIterable<C,E,A>(rhs),
218 ~LockingAdaptedIterable ()
225 DISALLOW_COPY_AND_ASSIGN(LockingAdaptedIterable);