base/value_iterators.cc

   1 // Copyright 2017 The Chromium Authors
   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
  16 dict_iterator::pointer::pointer(const reference& ref) : ref_(ref) {}
  17
  18 dict_iterator::pointer::pointer(const pointer& ptr) = default;
  19
  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
  30 dict_iterator::reference dict_iterator::operator*() {
  31   return {dict_iter_->first, *dict_iter_->second};
  32 }
  33
  34 dict_iterator::pointer dict_iterator::operator->() {
  35   return pointer(operator*());
  36 }
  37
  38 dict_iterator& dict_iterator::operator++() {
  39   ++dict_iter_;
  40   return *this;
  41 }
  42
  43 dict_iterator dict_iterator::operator++(int) {
  44   dict_iterator tmp(*this);
  45   ++dict_iter_;
  46   return tmp;
  47 }
  48
  49 dict_iterator& dict_iterator::operator--() {
  50   --dict_iter_;
  51   return *this;
  52 }
  53
  54 dict_iterator dict_iterator::operator--(int) {
  55   dict_iterator tmp(*this);
  56   --dict_iter_;
  57   return tmp;
  58 }
  59
  60 bool operator==(const dict_iterator& lhs, const dict_iterator& rhs) {
  61   return lhs.dict_iter_ == rhs.dict_iter_;
  62 }
  63
  64 bool operator!=(const dict_iterator& lhs, const dict_iterator& rhs) {
  65   return !(lhs == rhs);
  66 }
  67
  68 // ----------------------------------------------------------------------------
  69 // const_dict_iterator.
  70
  71 const_dict_iterator::pointer::pointer(const reference& ref) : ref_(ref) {}
  72
  73 const_dict_iterator::pointer::pointer(const pointer& ptr) = default;
  74
  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
  86 const_dict_iterator::reference const_dict_iterator::operator*() const {
  87   return {dict_iter_->first, *dict_iter_->second};
  88 }
  89
  90 const_dict_iterator::pointer const_dict_iterator::operator->() const {
  91   return pointer(operator*());
  92 }
  93
  94 const_dict_iterator& const_dict_iterator::operator++() {
  95   ++dict_iter_;
  96   return *this;
  97 }
  98
  99 const_dict_iterator const_dict_iterator::operator++(int) {
 100   const_dict_iterator tmp(*this);
 101   ++dict_iter_;
 102   return tmp;
 103 }
 104
 105 const_dict_iterator& const_dict_iterator::operator--() {
 106   --dict_iter_;
 107   return *this;
 108 }
 109
 110 const_dict_iterator const_dict_iterator::operator--(int) {
 111   const_dict_iterator tmp(*this);
 112   --dict_iter_;
 113   return tmp;
 114 }
 115
 116 bool operator==(const const_dict_iterator& lhs,
 117                 const const_dict_iterator& rhs) {
 118   return lhs.dict_iter_ == rhs.dict_iter_;
 119 }
 120
 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
 129 dict_iterator_proxy::dict_iterator_proxy(DictStorage* storage)
 130     : storage_(storage) {}
 131
 132 dict_iterator_proxy::size_type dict_iterator_proxy::size() const {
 133   return storage_->size();
 134 }
 135
 136 dict_iterator_proxy::iterator dict_iterator_proxy::begin() {
 137   return iterator(storage_->begin());
 138 }
 139
 140 dict_iterator_proxy::const_iterator dict_iterator_proxy::begin() const {
 141   return const_iterator(storage_->begin());
 142 }
 143
 144 dict_iterator_proxy::iterator dict_iterator_proxy::end() {
 145   return iterator(storage_->end());
 146 }
 147
 148 dict_iterator_proxy::const_iterator dict_iterator_proxy::end() const {
 149   return const_iterator(storage_->end());
 150 }
 151
 152 dict_iterator_proxy::reverse_iterator dict_iterator_proxy::rbegin() {
 153   return reverse_iterator(end());
 154 }
 155
 156 dict_iterator_proxy::const_reverse_iterator dict_iterator_proxy::rbegin()
 157     const {
 158   return const_reverse_iterator(end());
 159 }
 160
 161 dict_iterator_proxy::reverse_iterator dict_iterator_proxy::rend() {
 162   return reverse_iterator(begin());
 163 }
 164
 165 dict_iterator_proxy::const_reverse_iterator dict_iterator_proxy::rend() const {
 166   return const_reverse_iterator(begin());
 167 }
 168
 169 dict_iterator_proxy::const_iterator dict_iterator_proxy::cbegin() const {
 170   return const_iterator(begin());
 171 }
 172
 173 dict_iterator_proxy::const_iterator dict_iterator_proxy::cend() const {
 174   return const_iterator(end());
 175 }
 176
 177 dict_iterator_proxy::const_reverse_iterator dict_iterator_proxy::crbegin()
 178     const {
 179   return const_reverse_iterator(rbegin());
 180 }
 181
 182 dict_iterator_proxy::const_reverse_iterator dict_iterator_proxy::crend() const {
 183   return const_reverse_iterator(rend());
 184 }
 185
 186 // ----------------------------------------------------------------------------
 187 // const_dict_iterator_proxy.
 188
 189 const_dict_iterator_proxy::const_dict_iterator_proxy(const DictStorage* storage)
 190     : storage_(storage) {}
 191
 192 const_dict_iterator_proxy::const_iterator const_dict_iterator_proxy::begin()
 193     const {
 194   return const_iterator(storage_->begin());
 195 }
 196
 197 const_dict_iterator_proxy::size_type const_dict_iterator_proxy::size() const {
 198   return storage_->size();
 199 }
 200
 201 const_dict_iterator_proxy::const_iterator const_dict_iterator_proxy::end()
 202     const {
 203   return const_iterator(storage_->end());
 204 }
 205
 206 const_dict_iterator_proxy::const_reverse_iterator
 207 const_dict_iterator_proxy::rbegin() const {
 208   return const_reverse_iterator(end());
 209 }
 210
 211 const_dict_iterator_proxy::const_reverse_iterator
 212 const_dict_iterator_proxy::rend() const {
 213   return const_reverse_iterator(begin());
 214 }
 215
 216 const_dict_iterator_proxy::const_iterator const_dict_iterator_proxy::cbegin()
 217     const {
 218   return const_iterator(begin());
 219 }
 220
 221 const_dict_iterator_proxy::const_iterator const_dict_iterator_proxy::cend()
 222     const {
 223   return const_iterator(end());
 224 }
 225
 226 const_dict_iterator_proxy::const_reverse_iterator
 227 const_dict_iterator_proxy::crbegin() const {
 228   return const_reverse_iterator(rbegin());
 229 }
 230
 231 const_dict_iterator_proxy::const_reverse_iterator
 232 const_dict_iterator_proxy::crend() const {
 233   return const_reverse_iterator(rend());
 234 }
 235
 236 }  // namespace detail
 237
 238 }  // namespace base