Add support for int64 and uint64 in values.h's API.

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 <ostream>
 
 #include "base/float_util.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/move.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 
 namespace base {
 
 namespace {
 
 // Make a deep copy of |node|, but don't include empty lists or dictionaries
 // in the copy. It's possible for this function to return NULL and it
 // expects |node| to always be non-NULL.
@@ skipping 105 matching lines @@
 }
 
 bool Value::GetAsString(string16* out_value) const {
   return false;
 }
 
 bool Value::GetAsString(const StringValue** out_value) const {
   return false;
 }
 
+bool Value::GetAsInt64(int64* out_value) const {
+  return false;
+}
+
+bool Value::GetAsUint64(uint64* out_value) const {
+  return false;
+}
+
 bool Value::GetAsList(ListValue** out_value) {
   return false;
 }
 
 bool Value::GetAsList(const ListValue** out_value) const {
   return false;
 }
 
 bool Value::GetAsDictionary(DictionaryValue** out_value) {
   return false;
@@ skipping 121 matching lines @@
     : Value(TYPE_STRING),
       value_(in_value) {
   DCHECK(IsStringUTF8(in_value));
 }
 
 StringValue::StringValue(const string16& in_value)
     : Value(TYPE_STRING),
       value_(UTF16ToUTF8(in_value)) {
 }
 
+StringValue::StringValue(int64 in_value)
+    : Value(TYPE_STRING), value_(Int64ToString(in_value)) {
+}
+
+StringValue::StringValue(uint64 in_value)
+    : Value(TYPE_STRING), value_(Uint64ToString(in_value)) {
+}
+
 StringValue::~StringValue() {
 }
 
 std::string* StringValue::GetString() {
   return &value_;
 }
 
 const std::string& StringValue::GetString() const {
   return value_;
 }
 
 bool StringValue::GetAsString(std::string* out_value) const {
   if (out_value)
     *out_value = value_;
   return true;
 }
 
 bool StringValue::GetAsString(string16* out_value) const {
   if (out_value)
     *out_value = UTF8ToUTF16(value_);
   return true;
 }
 
 bool StringValue::GetAsString(const StringValue** out_value) const {
   if (out_value)
     *out_value = this;
   return true;
 }
 
+bool StringValue::GetAsInt64(int64* out_value) const {
+  int64 stored_value;
+  bool valid = StringToInt64(value_, &stored_value);
+  if (valid && out_value)
+    *out_value = stored_value;
+  return valid;
+}
+
+bool StringValue::GetAsUint64(uint64* out_value) const {
+  uint64 stored_value;
+  bool valid = base::StringToUint64(value_, &stored_value);
+  if (valid && out_value)
+    *out_value = stored_value;
+  return valid;
+}
+
 StringValue* StringValue::DeepCopy() const {
   return new StringValue(value_);
 }
 
 bool StringValue::Equals(const Value* other) const {
   if (other->GetType() != GetType())
     return false;
   std::string lhs, rhs;
   return GetAsString(&lhs) && other->GetAsString(&rhs) && lhs == rhs;
 }
@@ skipping 114 matching lines @@
 void DictionaryValue::SetString(const std::string& path,
                                 const std::string& in_value) {
   Set(path, new StringValue(in_value));
 }
 
 void DictionaryValue::SetString(const std::string& path,
                                 const string16& in_value) {
   Set(path, new StringValue(in_value));
 }
 
+void DictionaryValue::SetInt64(const std::string& path, int64 in_value) {
+  Set(path, new StringValue(in_value));
+}
+
+void DictionaryValue::SetUint64(const std::string& path, uint64 in_value) {
+  Set(path, new StringValue(in_value));
+}
+
 void DictionaryValue::SetWithoutPathExpansion(const std::string& key,
                                               Value* in_value) {
   // If there's an existing value here, we need to delete it, because
   // we own all our children.
   std::pair<ValueMap::iterator, bool> ins_res =
       dictionary_.insert(std::make_pair(key, in_value));
   if (!ins_res.second) {
     DCHECK_NE(ins_res.first->second, in_value);  // This would be bogus
     delete ins_res.first->second;
     ins_res.first->second = in_value;
@@ skipping 18 matching lines @@
 void DictionaryValue::SetStringWithoutPathExpansion(
     const std::string& path, const std::string& in_value) {
   SetWithoutPathExpansion(path, new StringValue(in_value));
 }
 
 void DictionaryValue::SetStringWithoutPathExpansion(
     const std::string& path, const string16& in_value) {
   SetWithoutPathExpansion(path, new StringValue(in_value));
 }
 
+void DictionaryValue::SetInt64WithoutPathExpansion(const std::string& path,
+                                                   int64 in_value) {
+  SetWithoutPathExpansion(path, new StringValue(in_value));
+}
+
+void DictionaryValue::SetUint64WithoutPathExpansion(const std::string& path,
+                                                    uint64 in_value) {
+  SetWithoutPathExpansion(path, new StringValue(in_value));
+}
+
 bool DictionaryValue::Get(const std::string& path,
                           const Value** out_value) const {
   DCHECK(IsStringUTF8(path));
   std::string 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('.')) {
     const DictionaryValue* child_dictionary = NULL;
     if (!current_dictionary->GetDictionary(
@@ skipping 51 matching lines @@
 
 bool DictionaryValue::GetString(const std::string& path,
                                 string16* out_value) const {
   const Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
+bool DictionaryValue::GetInt64(const std::string& path,
+                               int64* out_value) const {
+  const Value* value;
+  if (!Get(path, &value))
+    return false;
+
+  return value->GetAsInt64(out_value);
+}
+
+bool DictionaryValue::GetUint64(const std::string& path,
+                                uint64* out_value) const {
+  const Value* value;
+  if (!Get(path, &value))
+    return false;
+
+  return value->GetAsUint64(out_value);
+}
+
 bool DictionaryValue::GetStringASCII(const std::string& path,
                                      std::string* out_value) const {
   std::string out;
   if (!GetString(path, &out))
     return false;
 
   if (!IsStringASCII(out)) {
     NOTREACHED();
     return false;
   }
@@ skipping 120 matching lines @@
 
 bool DictionaryValue::GetStringWithoutPathExpansion(const std::string& key,
                                                     string16* out_value) const {
   const Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
+bool DictionaryValue::GetInt64WithoutPathExpansion(const std::string& key,
+                                                   int64* out_value) const {
+  const Value* value;
+  if (!GetWithoutPathExpansion(key, &value))
+    return false;
+
+  return value->GetAsInt64(out_value);
+}
+
+bool DictionaryValue::GetUint64WithoutPathExpansion(const std::string& key,
+                                                    uint64* out_value) const {
+  const Value* value;
+  if (!GetWithoutPathExpansion(key, &value))
+    return false;
+
+  return value->GetAsUint64(out_value);
+}
+
 bool DictionaryValue::GetDictionaryWithoutPathExpansion(
     const std::string& key,
     const DictionaryValue** out_value) const {
   const Value* value;
   bool result = GetWithoutPathExpansion(key, &value);
   if (!result || !value->IsType(TYPE_DICTIONARY))
     return false;
 
   if (out_value)
     *out_value = static_cast<const DictionaryValue*>(value);
@@ skipping 233 matching lines @@
 }
 
 bool ListValue::GetString(size_t index, string16* out_value) const {
   const Value* value;
   if (!Get(index, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
+bool ListValue::GetInt64(size_t index, int64* out_value) const {
+  const Value* value;
+  if (!Get(index, &value))
+    return false;
+
+  return value->GetAsInt64(out_value);
+}
+
+bool ListValue::GetUint64(size_t index, uint64* out_value) const {
+  const Value* value;
+  if (!Get(index, &value))
+    return false;
+
+  return value->GetAsUint64(out_value);
+}
+
 bool ListValue::GetBinary(size_t index, const BinaryValue** out_value) const {
   const Value* value;
   bool result = Get(index, &value);
   if (!result || !value->IsType(TYPE_BINARY))
     return false;
 
   if (out_value)
     *out_value = static_cast<const BinaryValue*>(value);
 
   return true;
@@ skipping 98 matching lines @@
 }
 
 void ListValue::AppendString(const std::string& in_value) {
   Append(new StringValue(in_value));
 }
 
 void ListValue::AppendString(const string16& in_value) {
   Append(new StringValue(in_value));
 }
 
+void ListValue::AppendInt64(int64 in_value) {
+  Append(new StringValue(in_value));
+}
+
+void ListValue::AppendUint64(uint64 in_value) {
+  Append(new StringValue(in_value));
+}
+
 void ListValue::AppendStrings(const std::vector<std::string>& in_values) {
   for (std::vector<std::string>::const_iterator it = in_values.begin();
        it != in_values.end(); ++it) {
     AppendString(*it);
   }
 }
 
 void ListValue::AppendStrings(const std::vector<string16>& in_values) {
   for (std::vector<string16>::const_iterator it = in_values.begin();
        it != in_values.end(); ++it) {
@@ skipping 75 matching lines @@
 
 std::ostream& operator<<(std::ostream& out, const Value& value) {
   std::string json;
   JSONWriter::WriteWithOptions(&value,
                                JSONWriter::OPTIONS_PRETTY_PRINT,
                                &json);
   return out << json;
 }
 
 }  // namespace base