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