1 // Copyright 2017 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.
4
5 #include "base/value_iterators.h"
6
7 #include "base/values.h"
8
9 namespace base {
10
11 namespace detail {
12
13 // ----------------------------------------------------------------------------
14 // dict_iterator.
15
pointer(const reference & ref)16 dict_iterator::pointer::pointer(const reference& ref) : ref_(ref) {}
17
18 dict_iterator::pointer::pointer(const pointer& ptr) = default;
19
dict_iterator(DictStorage::iterator dict_iter)20 dict_iterator::dict_iterator(DictStorage::iterator dict_iter)
21 : dict_iter_(dict_iter) {}
22
23 dict_iterator::dict_iterator(const dict_iterator& dict_iter) = default;
24
25 dict_iterator& dict_iterator::operator=(const dict_iterator& dict_iter) =
26 default;
27
28 dict_iterator::~dict_iterator() = default;
29
operator *()30 dict_iterator::reference dict_iterator::operator*() {
31 return {dict_iter_->first, *dict_iter_->second};
32 }
33
operator ->()34 dict_iterator::pointer dict_iterator::operator->() {
35 return pointer(operator*());
36 }
37
operator ++()38 dict_iterator& dict_iterator::operator++() {
39 ++dict_iter_;
40 return *this;
41 }
42
operator ++(int)43 dict_iterator dict_iterator::operator++(int) {
44 dict_iterator tmp(*this);
45 ++dict_iter_;
46 return tmp;
47 }
48
operator --()49 dict_iterator& dict_iterator::operator--() {
50 --dict_iter_;
51 return *this;
52 }
53
operator --(int)54 dict_iterator dict_iterator::operator--(int) {
55 dict_iterator tmp(*this);
56 --dict_iter_;
57 return tmp;
58 }
59
operator ==(const dict_iterator & lhs,const dict_iterator & rhs)60 bool operator==(const dict_iterator& lhs, const dict_iterator& rhs) {
61 return lhs.dict_iter_ == rhs.dict_iter_;
62 }
63
operator !=(const dict_iterator & lhs,const dict_iterator & rhs)64 bool operator!=(const dict_iterator& lhs, const dict_iterator& rhs) {
65 return !(lhs == rhs);
66 }
67
68 // ----------------------------------------------------------------------------
69 // const_dict_iterator.
70
pointer(const reference & ref)71 const_dict_iterator::pointer::pointer(const reference& ref) : ref_(ref) {}
72
73 const_dict_iterator::pointer::pointer(const pointer& ptr) = default;
74
const_dict_iterator(DictStorage::const_iterator dict_iter)75 const_dict_iterator::const_dict_iterator(DictStorage::const_iterator dict_iter)
76 : dict_iter_(dict_iter) {}
77
78 const_dict_iterator::const_dict_iterator(const const_dict_iterator& dict_iter) =
79 default;
80
81 const_dict_iterator& const_dict_iterator::operator=(
82 const const_dict_iterator& dict_iter) = default;
83
84 const_dict_iterator::~const_dict_iterator() = default;
85
operator *() const86 const_dict_iterator::reference const_dict_iterator::operator*() const {
87 return {dict_iter_->first, *dict_iter_->second};
88 }
89
operator ->() const90 const_dict_iterator::pointer const_dict_iterator::operator->() const {
91 return pointer(operator*());
92 }
93
operator ++()94 const_dict_iterator& const_dict_iterator::operator++() {
95 ++dict_iter_;
96 return *this;
97 }
98
operator ++(int)99 const_dict_iterator const_dict_iterator::operator++(int) {
100 const_dict_iterator tmp(*this);
101 ++dict_iter_;
102 return tmp;
103 }
104
operator --()105 const_dict_iterator& const_dict_iterator::operator--() {
106 --dict_iter_;
107 return *this;
108 }
109
operator --(int)110 const_dict_iterator const_dict_iterator::operator--(int) {
111 const_dict_iterator tmp(*this);
112 --dict_iter_;
113 return tmp;
114 }
115
operator ==(const const_dict_iterator & lhs,const const_dict_iterator & rhs)116 bool operator==(const const_dict_iterator& lhs,
117 const const_dict_iterator& rhs) {
118 return lhs.dict_iter_ == rhs.dict_iter_;
119 }
120
operator !=(const const_dict_iterator & lhs,const const_dict_iterator & rhs)121 bool operator!=(const const_dict_iterator& lhs,
122 const const_dict_iterator& rhs) {
123 return !(lhs == rhs);
124 }
125
126 // ----------------------------------------------------------------------------
127 // dict_iterator_proxy.
128
dict_iterator_proxy(DictStorage * storage)129 dict_iterator_proxy::dict_iterator_proxy(DictStorage* storage)
130 : storage_(storage) {}
131
begin()132 dict_iterator_proxy::iterator dict_iterator_proxy::begin() {
133 return iterator(storage_->begin());
134 }
135
begin() const136 dict_iterator_proxy::const_iterator dict_iterator_proxy::begin() const {
137 return const_iterator(storage_->begin());
138 }
139
end()140 dict_iterator_proxy::iterator dict_iterator_proxy::end() {
141 return iterator(storage_->end());
142 }
143
end() const144 dict_iterator_proxy::const_iterator dict_iterator_proxy::end() const {
145 return const_iterator(storage_->end());
146 }
147
rbegin()148 dict_iterator_proxy::reverse_iterator dict_iterator_proxy::rbegin() {
149 return reverse_iterator(end());
150 }
151
rbegin() const152 dict_iterator_proxy::const_reverse_iterator dict_iterator_proxy::rbegin()
153 const {
154 return const_reverse_iterator(end());
155 }
156
rend()157 dict_iterator_proxy::reverse_iterator dict_iterator_proxy::rend() {
158 return reverse_iterator(begin());
159 }
160
rend() const161 dict_iterator_proxy::const_reverse_iterator dict_iterator_proxy::rend() const {
162 return const_reverse_iterator(begin());
163 }
164
cbegin() const165 dict_iterator_proxy::const_iterator dict_iterator_proxy::cbegin() const {
166 return const_iterator(begin());
167 }
168
cend() const169 dict_iterator_proxy::const_iterator dict_iterator_proxy::cend() const {
170 return const_iterator(end());
171 }
172
crbegin() const173 dict_iterator_proxy::const_reverse_iterator dict_iterator_proxy::crbegin()
174 const {
175 return const_reverse_iterator(rbegin());
176 }
177
crend() const178 dict_iterator_proxy::const_reverse_iterator dict_iterator_proxy::crend() const {
179 return const_reverse_iterator(rend());
180 }
181
182 // ----------------------------------------------------------------------------
183 // const_dict_iterator_proxy.
184
const_dict_iterator_proxy(const DictStorage * storage)185 const_dict_iterator_proxy::const_dict_iterator_proxy(const DictStorage* storage)
186 : storage_(storage) {}
187
begin() const188 const_dict_iterator_proxy::const_iterator const_dict_iterator_proxy::begin()
189 const {
190 return const_iterator(storage_->begin());
191 }
192
end() const193 const_dict_iterator_proxy::const_iterator const_dict_iterator_proxy::end()
194 const {
195 return const_iterator(storage_->end());
196 }
197
198 const_dict_iterator_proxy::const_reverse_iterator
rbegin() const199 const_dict_iterator_proxy::rbegin() const {
200 return const_reverse_iterator(end());
201 }
202
203 const_dict_iterator_proxy::const_reverse_iterator
rend() const204 const_dict_iterator_proxy::rend() const {
205 return const_reverse_iterator(begin());
206 }
207
cbegin() const208 const_dict_iterator_proxy::const_iterator const_dict_iterator_proxy::cbegin()
209 const {
210 return const_iterator(begin());
211 }
212
cend() const213 const_dict_iterator_proxy::const_iterator const_dict_iterator_proxy::cend()
214 const {
215 return const_iterator(end());
216 }
217
218 const_dict_iterator_proxy::const_reverse_iterator
crbegin() const219 const_dict_iterator_proxy::crbegin() const {
220 return const_reverse_iterator(rbegin());
221 }
222
223 const_dict_iterator_proxy::const_reverse_iterator
crend() const224 const_dict_iterator_proxy::crend() const {
225 return const_reverse_iterator(rend());
226 }
227
228 } // namespace detail
229
230 } // namespace base
231