Make base::DictionaryValue::Set* return pointers

base/values.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/values.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 593 matching lines @@
   DCHECK(IsStringUTF8(key));
   auto current_entry = dict_->find(key.as_string());
   DCHECK((current_entry == dict_->end()) || current_entry->second);
   return current_entry != dict_->end();
 }
 
 void DictionaryValue::Clear() {
   dict_->clear();
 }
 
-void DictionaryValue::Set(StringPiece path, std::unique_ptr<Value> in_value) {
+Value* DictionaryValue::Set(StringPiece path, std::unique_ptr<Value> in_value) {
   DCHECK(IsStringUTF8(path));
   DCHECK(in_value);
 
   StringPiece current_path(path);
   DictionaryValue* current_dictionary = this;
   for (size_t delimiter_position = current_path.find('.');
        delimiter_position != StringPiece::npos;
        delimiter_position = current_path.find('.')) {
     // Assume that we're indexing into a dictionary.
     StringPiece key = current_path.substr(0, delimiter_position);
     DictionaryValue* child_dictionary = nullptr;
     if (!current_dictionary->GetDictionary(key, &child_dictionary)) {
       child_dictionary = new DictionaryValue;
       current_dictionary->SetWithoutPathExpansion(
           key, base::WrapUnique(child_dictionary));
     }
 
     current_dictionary = child_dictionary;
     current_path = current_path.substr(delimiter_position + 1);
   }
 
-  current_dictionary->SetWithoutPathExpansion(current_path,
-                                              std::move(in_value));
+  return current_dictionary->SetWithoutPathExpansion(current_path,
+                                                     std::move(in_value));
 }
 
-void DictionaryValue::Set(StringPiece path, Value* in_value) {
-  Set(path, WrapUnique(in_value));
+Value* DictionaryValue::Set(StringPiece path, Value* in_value) {
+  return Set(path, WrapUnique(in_value));
 }
 
-void DictionaryValue::SetBoolean(StringPiece path, bool in_value) {
-  Set(path, new Value(in_value));
+Value* DictionaryValue::SetBoolean(StringPiece path, bool in_value) {
+  return Set(path, new Value(in_value));
 }
 
-void DictionaryValue::SetInteger(StringPiece path, int in_value) {
-  Set(path, new Value(in_value));
+Value* DictionaryValue::SetInteger(StringPiece path, int in_value) {
+  return Set(path, new Value(in_value));
 }
 
-void DictionaryValue::SetDouble(StringPiece path, double in_value) {
-  Set(path, new Value(in_value));
+Value* DictionaryValue::SetDouble(StringPiece path, double in_value) {
+  return Set(path, new Value(in_value));
 }
 
-void DictionaryValue::SetString(StringPiece path, StringPiece in_value) {
-  Set(path, new Value(in_value));
+Value* DictionaryValue::SetString(StringPiece path, StringPiece in_value) {
+  return Set(path, new Value(in_value));
 }
 
-void DictionaryValue::SetString(StringPiece path, const string16& in_value) {
-  Set(path, new Value(in_value));
+Value* DictionaryValue::SetString(StringPiece path, const string16& in_value) {
+  return Set(path, new Value(in_value));
 }
 
-void DictionaryValue::SetWithoutPathExpansion(StringPiece key,
-                                              std::unique_ptr<Value> in_value) {
-  (*dict_)[key.as_string()] = std::move(in_value);
+DictionaryValue* DictionaryValue::SetDictionary(
+    StringPiece path,
+    std::unique_ptr<DictionaryValue> in_value) {
+  return static_cast<DictionaryValue*>(Set(path, std::move(in_value)));
 }
 
-void DictionaryValue::SetWithoutPathExpansion(StringPiece key,
-                                              Value* in_value) {
-  SetWithoutPathExpansion(key, WrapUnique(in_value));
+ListValue* DictionaryValue::SetList(StringPiece path,
+                                    std::unique_ptr<ListValue> in_value) {
+  return static_cast<ListValue*>(Set(path, std::move(in_value)));
 }
 
-void DictionaryValue::SetBooleanWithoutPathExpansion(StringPiece path,
-                                                     bool in_value) {
-  SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
+Value* DictionaryValue::SetWithoutPathExpansion(
+    StringPiece key,
+    std::unique_ptr<Value> in_value) {
+  return ((*dict_)[key.as_string()] = std::move(in_value)).get();
 }
 
-void DictionaryValue::SetIntegerWithoutPathExpansion(StringPiece path,
-                                                     int in_value) {
-  SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
+Value* DictionaryValue::SetWithoutPathExpansion(StringPiece key,
+                                                Value* in_value) {
+  return SetWithoutPathExpansion(key, WrapUnique(in_value));
 }
 
-void DictionaryValue::SetDoubleWithoutPathExpansion(StringPiece path,
-                                                    double in_value) {
-  SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
+Value* DictionaryValue::SetBooleanWithoutPathExpansion(StringPiece path,
+                                                       bool in_value) {
+  return SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
 }
 
-void DictionaryValue::SetStringWithoutPathExpansion(StringPiece path,
-                                                    StringPiece in_value) {
-  SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
+Value* DictionaryValue::SetIntegerWithoutPathExpansion(StringPiece path,
+                                                       int in_value) {
+  return SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
 }
 
-void DictionaryValue::SetStringWithoutPathExpansion(StringPiece path,
-                                                    const string16& in_value) {
-  SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
+Value* DictionaryValue::SetDoubleWithoutPathExpansion(StringPiece path,
+                                                      double in_value) {
+  return SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
+}
+
+Value* DictionaryValue::SetStringWithoutPathExpansion(StringPiece path,
+                                                      StringPiece in_value) {
+  return SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
+}
+
+Value* DictionaryValue::SetStringWithoutPathExpansion(
+    StringPiece path,
+    const string16& in_value) {
+  return SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
+}
+
+DictionaryValue* DictionaryValue::SetDictionaryWithoutPathExpansion(
+    StringPiece path,
+    std::unique_ptr<DictionaryValue> in_value) {
+  return static_cast<DictionaryValue*>(
+      SetWithoutPathExpansion(path, std::move(in_value)));
+}
+
+ListValue* DictionaryValue::SetListWithoutPathExpansion(
+    StringPiece path,
+    std::unique_ptr<ListValue> in_value) {
+  return static_cast<ListValue*>(
+      SetWithoutPathExpansion(path, std::move(in_value)));
 }
 
 bool DictionaryValue::Get(StringPiece path,
                           const Value** out_value) const {
   DCHECK(IsStringUTF8(path));
   StringPiece current_path(path);
   const DictionaryValue* current_dictionary = this;
   for (size_t delimiter_position = current_path.find('.');
        delimiter_position != std::string::npos;
        delimiter_position = current_path.find('.')) {
@@ skipping 602 matching lines @@
 }
 
 std::ostream& operator<<(std::ostream& out, const Value::Type& type) {
   if (static_cast<int>(type) < 0 ||
       static_cast<size_t>(type) >= arraysize(kTypeNames))
     return out << "Invalid Type (index = " << static_cast<int>(type) << ")";
   return out << Value::GetTypeName(type);
 }
 
 }  // namespace base