components/prefs/pref_value_map.cc

   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.
   4
   5 #include "components/prefs/pref_value_map.h"
   6
   7 #include <limits.h>
   8 #include <map>
   9 #include <memory>
  10 #include <utility>
  11
  12 #include "base/values.h"
  13
  14 PrefValueMap::PrefValueMap() {}
  15
  16 PrefValueMap::~PrefValueMap() {}
  17
  18 bool PrefValueMap::GetValue(const std::string& key,
  19                             const base::Value** value) const {
  20   auto it = prefs_.find(key);
  21   if (it == prefs_.end())
  22     return false;
  23
  24   if (value)
  25     *value = &it->second;
  26
  27   return true;
  28 }
  29
  30 bool PrefValueMap::GetValue(const std::string& key, base::Value** value) {
  31   auto it = prefs_.find(key);
  32   if (it == prefs_.end())
  33     return false;
  34
  35   if (value)
  36     *value = &it->second;
  37
  38   return true;
  39 }
  40
  41 bool PrefValueMap::SetValue(const std::string& key, base::Value value) {
  42   base::Value& existing_value = prefs_[key];
  43   if (value == existing_value)
  44     return false;
  45
  46   existing_value = std::move(value);
  47   return true;
  48 }
  49
  50 bool PrefValueMap::RemoveValue(const std::string& key) {
  51   return prefs_.erase(key) != 0;
  52 }
  53
  54 void PrefValueMap::Clear() {
  55   prefs_.clear();
  56 }
  57
  58 void PrefValueMap::ClearWithPrefix(const std::string& prefix) {
  59   Map::iterator low = prefs_.lower_bound(prefix);
  60   // Appending maximum possible character so that there will be no string with
  61   // prefix |prefix| that we may miss.
  62   Map::iterator high = prefs_.upper_bound(prefix + char(CHAR_MAX));
  63   prefs_.erase(low, high);
  64 }
  65
  66 void PrefValueMap::Swap(PrefValueMap* other) {
  67   prefs_.swap(other->prefs_);
  68 }
  69
  70 PrefValueMap::iterator PrefValueMap::begin() {
  71   return prefs_.begin();
  72 }
  73
  74 PrefValueMap::iterator PrefValueMap::end() {
  75   return prefs_.end();
  76 }
  77
  78 PrefValueMap::const_iterator PrefValueMap::begin() const {
  79   return prefs_.begin();
  80 }
  81
  82 PrefValueMap::const_iterator PrefValueMap::end() const {
  83   return prefs_.end();
  84 }
  85
  86 bool PrefValueMap::empty() const {
  87   return prefs_.empty();
  88 }
  89
  90 bool PrefValueMap::GetBoolean(const std::string& key, bool* value) const {
  91   const base::Value* stored_value = nullptr;
  92   if (GetValue(key, &stored_value) && stored_value->is_bool()) {
  93     *value = stored_value->GetBool();
  94     return true;
  95   }
  96   return false;
  97 }
  98
  99 void PrefValueMap::SetBoolean(const std::string& key, bool value) {
 100   SetValue(key, base::Value(value));
 101 }
 102
 103 bool PrefValueMap::GetString(const std::string& key, std::string* value) const {
 104   const base::Value* stored_value = nullptr;
 105   if (GetValue(key, &stored_value) && stored_value->is_string()) {
 106     *value = stored_value->GetString();
 107     return true;
 108   }
 109   return false;
 110 }
 111
 112 void PrefValueMap::SetString(const std::string& key, const std::string& value) {
 113   SetValue(key, base::Value(value));
 114 }
 115
 116 bool PrefValueMap::GetInteger(const std::string& key, int* value) const {
 117   const base::Value* stored_value = nullptr;
 118   if (GetValue(key, &stored_value) && stored_value->is_int()) {
 119     *value = stored_value->GetInt();
 120     return true;
 121   }
 122   return false;
 123 }
 124
 125 void PrefValueMap::SetInteger(const std::string& key, const int value) {
 126   SetValue(key, base::Value(value));
 127 }
 128
 129 void PrefValueMap::SetDouble(const std::string& key, const double value) {
 130   SetValue(key, base::Value(value));
 131 }
 132
 133 void PrefValueMap::GetDifferingKeys(
 134     const PrefValueMap* other,
 135     std::vector<std::string>* differing_keys) const {
 136   differing_keys->clear();
 137
 138   // Put everything into ordered maps.
 139   std::map<std::string, const base::Value*> this_prefs;
 140   std::map<std::string, const base::Value*> other_prefs;
 141   for (const auto& pair : prefs_)
 142     this_prefs.emplace(pair.first, &pair.second);
 143   for (const auto& pair : other->prefs_)
 144     other_prefs.emplace(pair.first, &pair.second);
 145
 146   // Walk over the maps in lockstep, adding everything that is different.
 147   auto this_pref = this_prefs.begin();
 148   auto other_pref = other_prefs.begin();
 149   while (this_pref != this_prefs.end() && other_pref != other_prefs.end()) {
 150     const int diff = this_pref->first.compare(other_pref->first);
 151     if (diff == 0) {
 152       if (*this_pref->second != *other_pref->second)
 153         differing_keys->push_back(this_pref->first);
 154       ++this_pref;
 155       ++other_pref;
 156     } else if (diff < 0) {
 157       differing_keys->push_back(this_pref->first);
 158       ++this_pref;
 159     } else if (diff > 0) {
 160       differing_keys->push_back(other_pref->first);
 161       ++other_pref;
 162     }
 163   }
 164
 165   // Add the remaining entries.
 166   for (; this_pref != this_prefs.end(); ++this_pref)
 167     differing_keys->push_back(this_pref->first);
 168   for (; other_pref != other_prefs.end(); ++other_pref)
 169     differing_keys->push_back(other_pref->first);
 170 }
 171
 172 std::unique_ptr<base::DictionaryValue> PrefValueMap::AsDictionaryValue() const {
 173   auto dictionary = std::make_unique<base::DictionaryValue>();
 174   for (const auto& value : prefs_)
 175     dictionary->SetPath(value.first, value.second.Clone());
 176
 177   return dictionary;
 178 }