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 }  // namespace detail
 127
 128 }  // namespace base