Use scoped_ptr::Pass instead of scoped_ptr::PassAs<T>.
[chromium-blink-merge.git] / base / observer_list.h
blobc77ec15b1db6b692da42e091556fffe618c4d5a5
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef BASE_OBSERVER_LIST_H__
6 #define BASE_OBSERVER_LIST_H__
8 #include <algorithm>
9 #include <limits>
10 #include <vector>
12 #include "base/basictypes.h"
13 #include "base/logging.h"
14 #include "base/memory/weak_ptr.h"
16 ///////////////////////////////////////////////////////////////////////////////
18 // OVERVIEW:
20 // A container for a list of observers. Unlike a normal STL vector or list,
21 // this container can be modified during iteration without invalidating the
22 // iterator. So, it safely handles the case of an observer removing itself
23 // or other observers from the list while observers are being notified.
25 // TYPICAL USAGE:
27 // class MyWidget {
28 // public:
29 // ...
31 // class Observer {
32 // public:
33 // virtual void OnFoo(MyWidget* w) = 0;
34 // virtual void OnBar(MyWidget* w, int x, int y) = 0;
35 // };
37 // void AddObserver(Observer* obs) {
38 // observer_list_.AddObserver(obs);
39 // }
41 // void RemoveObserver(Observer* obs) {
42 // observer_list_.RemoveObserver(obs);
43 // }
45 // void NotifyFoo() {
46 // FOR_EACH_OBSERVER(Observer, observer_list_, OnFoo(this));
47 // }
49 // void NotifyBar(int x, int y) {
50 // FOR_EACH_OBSERVER(Observer, observer_list_, OnBar(this, x, y));
51 // }
53 // private:
54 // ObserverList<Observer> observer_list_;
55 // };
58 ///////////////////////////////////////////////////////////////////////////////
60 template <typename ObserverType>
61 class ObserverListThreadSafe;
63 template <class ObserverType>
64 class ObserverListBase
65 : public base::SupportsWeakPtr<ObserverListBase<ObserverType> > {
66 public:
67 // Enumeration of which observers are notified.
68 enum NotificationType {
69 // Specifies that any observers added during notification are notified.
70 // This is the default type if non type is provided to the constructor.
71 NOTIFY_ALL,
73 // Specifies that observers added while sending out notification are not
74 // notified.
75 NOTIFY_EXISTING_ONLY
78 // An iterator class that can be used to access the list of observers. See
79 // also the FOR_EACH_OBSERVER macro defined below.
80 class Iterator {
81 public:
82 Iterator(ObserverListBase<ObserverType>& list);
83 ~Iterator();
84 ObserverType* GetNext();
86 private:
87 base::WeakPtr<ObserverListBase<ObserverType> > list_;
88 size_t index_;
89 size_t max_index_;
92 ObserverListBase() : notify_depth_(0), type_(NOTIFY_ALL) {}
93 explicit ObserverListBase(NotificationType type)
94 : notify_depth_(0), type_(type) {}
96 // Add an observer to the list. An observer should not be added to
97 // the same list more than once.
98 void AddObserver(ObserverType* obs);
100 // Remove an observer from the list if it is in the list.
101 void RemoveObserver(ObserverType* obs);
103 bool HasObserver(ObserverType* observer) const;
105 void Clear();
107 protected:
108 size_t size() const { return observers_.size(); }
110 void Compact();
112 private:
113 friend class ObserverListThreadSafe<ObserverType>;
115 typedef std::vector<ObserverType*> ListType;
117 ListType observers_;
118 int notify_depth_;
119 NotificationType type_;
121 friend class ObserverListBase::Iterator;
123 DISALLOW_COPY_AND_ASSIGN(ObserverListBase);
126 template <class ObserverType>
127 ObserverListBase<ObserverType>::Iterator::Iterator(
128 ObserverListBase<ObserverType>& list)
129 : list_(list.AsWeakPtr()),
130 index_(0),
131 max_index_(list.type_ == NOTIFY_ALL ?
132 std::numeric_limits<size_t>::max() :
133 list.observers_.size()) {
134 ++list_->notify_depth_;
137 template <class ObserverType>
138 ObserverListBase<ObserverType>::Iterator::~Iterator() {
139 if (list_.get() && --list_->notify_depth_ == 0)
140 list_->Compact();
143 template <class ObserverType>
144 ObserverType* ObserverListBase<ObserverType>::Iterator::GetNext() {
145 if (!list_.get())
146 return NULL;
147 ListType& observers = list_->observers_;
148 // Advance if the current element is null
149 size_t max_index = std::min(max_index_, observers.size());
150 while (index_ < max_index && !observers[index_])
151 ++index_;
152 return index_ < max_index ? observers[index_++] : NULL;
155 template <class ObserverType>
156 void ObserverListBase<ObserverType>::AddObserver(ObserverType* obs) {
157 if (std::find(observers_.begin(), observers_.end(), obs)
158 != observers_.end()) {
159 NOTREACHED() << "Observers can only be added once!";
160 return;
162 observers_.push_back(obs);
165 template <class ObserverType>
166 void ObserverListBase<ObserverType>::RemoveObserver(ObserverType* obs) {
167 typename ListType::iterator it =
168 std::find(observers_.begin(), observers_.end(), obs);
169 if (it != observers_.end()) {
170 if (notify_depth_) {
171 *it = 0;
172 } else {
173 observers_.erase(it);
178 template <class ObserverType>
179 bool ObserverListBase<ObserverType>::HasObserver(ObserverType* observer) const {
180 for (size_t i = 0; i < observers_.size(); ++i) {
181 if (observers_[i] == observer)
182 return true;
184 return false;
187 template <class ObserverType>
188 void ObserverListBase<ObserverType>::Clear() {
189 if (notify_depth_) {
190 for (typename ListType::iterator it = observers_.begin();
191 it != observers_.end(); ++it) {
192 *it = 0;
194 } else {
195 observers_.clear();
199 template <class ObserverType>
200 void ObserverListBase<ObserverType>::Compact() {
201 observers_.erase(
202 std::remove(observers_.begin(), observers_.end(),
203 static_cast<ObserverType*>(NULL)), observers_.end());
206 template <class ObserverType, bool check_empty = false>
207 class ObserverList : public ObserverListBase<ObserverType> {
208 public:
209 typedef typename ObserverListBase<ObserverType>::NotificationType
210 NotificationType;
212 ObserverList() {}
213 explicit ObserverList(NotificationType type)
214 : ObserverListBase<ObserverType>(type) {}
216 ~ObserverList() {
217 // When check_empty is true, assert that the list is empty on destruction.
218 if (check_empty) {
219 ObserverListBase<ObserverType>::Compact();
220 DCHECK_EQ(ObserverListBase<ObserverType>::size(), 0U);
224 bool might_have_observers() const {
225 return ObserverListBase<ObserverType>::size() != 0;
229 #define FOR_EACH_OBSERVER(ObserverType, observer_list, func) \
230 do { \
231 if ((observer_list).might_have_observers()) { \
232 ObserverListBase<ObserverType>::Iterator \
233 it_inside_observer_macro(observer_list); \
234 ObserverType* obs; \
235 while ((obs = it_inside_observer_macro.GetNext()) != NULL) \
236 obs->func; \
238 } while (0)
240 #endif // BASE_OBSERVER_LIST_H__