Add TYPE_INTEGER64 type to base::Value.

base/values.cc

 // Copyright (c) 2011 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 <algorithm>
 
 #include "base/float_util.h"
 #include "base/logging.h"
@@ skipping 83 matching lines @@
 FundamentalValue* Value::CreateBooleanValue(bool in_value) {
   return new FundamentalValue(in_value);
 }
 
 // static
 FundamentalValue* Value::CreateIntegerValue(int in_value) {
   return new FundamentalValue(in_value);
 }
 
 // static
+FundamentalValue* Value::CreateInteger64Value(int64 in_value) {
+  return new FundamentalValue(in_value);
+}
+
+// static
 FundamentalValue* Value::CreateDoubleValue(double in_value) {
   return new FundamentalValue(in_value);
 }
 
 // static
 StringValue* Value::CreateStringValue(const std::string& in_value) {
   return new StringValue(in_value);
 }
 
 // static
 StringValue* Value::CreateStringValue(const string16& in_value) {
   return new StringValue(in_value);
 }
 
 bool Value::GetAsBoolean(bool* out_value) const {
   return false;
 }
 
 bool Value::GetAsInteger(int* out_value) const {
   return false;
 }
 
+bool Value::GetAsInteger64(int64* out_value) const {
+  return false;
+}
+
 bool Value::GetAsDouble(double* out_value) const {
   return false;
 }
 
 bool Value::GetAsString(std::string* out_value) const {
   return false;
 }
 
 bool Value::GetAsString(string16* out_value) const {
   return false;
@@ skipping 42 matching lines @@
 ///////////////////// FundamentalValue ////////////////////
 
 FundamentalValue::FundamentalValue(bool in_value)
     : Value(TYPE_BOOLEAN), boolean_value_(in_value) {
 }
 
 FundamentalValue::FundamentalValue(int in_value)
     : Value(TYPE_INTEGER), integer_value_(in_value) {
 }
 
+FundamentalValue::FundamentalValue(int64 in_value)
+    : Value(TYPE_INTEGER64), integer_value_(in_value) {
+}
+
 FundamentalValue::FundamentalValue(double in_value)
     : Value(TYPE_DOUBLE), double_value_(in_value) {
   if (!IsFinite(double_value_)) {
     NOTREACHED() << "Non-finite (i.e. NaN or positive/negative infinity) "
                  << "values cannot be represented in JSON";
     double_value_ = 0.0;
   }
 }
 
 FundamentalValue::~FundamentalValue() {
 }
 
 bool FundamentalValue::GetAsBoolean(bool* out_value) const {
   if (out_value && IsType(TYPE_BOOLEAN))
     *out_value = boolean_value_;
   return (IsType(TYPE_BOOLEAN));
 }
 
 bool FundamentalValue::GetAsInteger(int* out_value) const {
   if (out_value && IsType(TYPE_INTEGER))
     *out_value = integer_value_;
   return (IsType(TYPE_INTEGER));
 }
 
+bool FundamentalValue::GetAsInteger64(int64* out_value) const {
+  if (out_value && IsType(TYPE_INTEGER64))
+    *out_value = integer_value_;
+  else if (out_value && IsType(TYPE_INTEGER))
+    *out_value = integer_value_;
+  return (IsType(TYPE_INTEGER64) || IsType(TYPE_INTEGER));
+}
+
 bool FundamentalValue::GetAsDouble(double* out_value) const {
   if (out_value && IsType(TYPE_DOUBLE))
     *out_value = double_value_;
   else if (out_value && IsType(TYPE_INTEGER))
     *out_value = integer_value_;
   return (IsType(TYPE_DOUBLE) || IsType(TYPE_INTEGER));
 }
 
 FundamentalValue* FundamentalValue::DeepCopy() const {
   switch (GetType()) {
     case TYPE_BOOLEAN:
       return CreateBooleanValue(boolean_value_);
 
     case TYPE_INTEGER:
       return CreateIntegerValue(integer_value_);
 
+    case TYPE_INTEGER64:
+      return CreateInteger64Value(integer_value_);
+
     case TYPE_DOUBLE:
       return CreateDoubleValue(double_value_);
 
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 bool FundamentalValue::Equals(const Value* other) const {
   if (other->GetType() != GetType())
     return false;
 
   switch (GetType()) {
     case TYPE_BOOLEAN: {
       bool lhs, rhs;
       return GetAsBoolean(&lhs) && other->GetAsBoolean(&rhs) && lhs == rhs;
     }
-    case TYPE_INTEGER: {
-      int lhs, rhs;
-      return GetAsInteger(&lhs) && other->GetAsInteger(&rhs) && lhs == rhs;
+    case TYPE_INTEGER:
+    case TYPE_INTEGER64: {
+      int64 lhs, rhs;
+      return GetAsInteger64(&lhs) && other->GetAsInteger64(&rhs) && lhs == rhs;
     }
     case TYPE_DOUBLE: {
       double lhs, rhs;
       return GetAsDouble(&lhs) && other->GetAsDouble(&rhs) && lhs == rhs;
     }
     default:
       NOTREACHED();
       return false;
   }
 }
@@ skipping 148 matching lines @@
 }
 
 void DictionaryValue::SetBoolean(const std::string& path, bool in_value) {
   Set(path, CreateBooleanValue(in_value));
 }
 
 void DictionaryValue::SetInteger(const std::string& path, int in_value) {
   Set(path, CreateIntegerValue(in_value));
 }
 
+void DictionaryValue::SetInteger64(const std::string& path, int64 in_value) {
+  Set(path, CreateInteger64Value(in_value));
+}
+
 void DictionaryValue::SetDouble(const std::string& path, double in_value) {
   Set(path, CreateDoubleValue(in_value));
 }
 
 void DictionaryValue::SetString(const std::string& path,
                                 const std::string& in_value) {
   Set(path, CreateStringValue(in_value));
 }
 
 void DictionaryValue::SetString(const std::string& path,
@@ skipping 44 matching lines @@
 
 bool DictionaryValue::GetInteger(const std::string& path,
                                  int* out_value) const {
   Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsInteger(out_value);
 }
 
+bool DictionaryValue::GetInteger64(const std::string& path,
+                                   int64* out_value) const {
+  Value* value;
+  if (!Get(path, &value))
+    return false;
+
+  return value->GetAsInteger64(out_value);
+}
+
 bool DictionaryValue::GetDouble(const std::string& path,
                                 double* out_value) const {
   Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsDouble(out_value);
 }
 
 bool DictionaryValue::GetString(const std::string& path,
@@ skipping 83 matching lines @@
 
 bool DictionaryValue::GetIntegerWithoutPathExpansion(const std::string& key,
                                                      int* out_value) const {
   Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsInteger(out_value);
 }
 
+bool DictionaryValue::GetInteger64WithoutPathExpansion(const std::string& key,
+                                                       int64* out_value) const {
+  Value* value;
+  if (!GetWithoutPathExpansion(key, &value))
+    return false;
+
+  return value->GetAsInteger64(out_value);
+}
+
 bool DictionaryValue::GetDoubleWithoutPathExpansion(const std::string& key,
                                                     double* out_value) const {
   Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsDouble(out_value);
 }
 
 bool DictionaryValue::GetStringWithoutPathExpansion(
@@ skipping 189 matching lines @@
 }
 
 bool ListValue::GetInteger(size_t index, int* out_value) const {
   Value* value;
   if (!Get(index, &value))
     return false;
 
   return value->GetAsInteger(out_value);
 }
 
+bool ListValue::GetInteger64(size_t index, int64* out_value) const {
+  Value* value;
+  if (!Get(index, &value))
+    return false;
+
+  return value->GetAsInteger64(out_value);
+}
+
 bool ListValue::GetDouble(size_t index, double* out_value) const {
   Value* value;
   if (!Get(index, &value))
     return false;
 
   return value->GetAsDouble(out_value);
 }
 
 bool ListValue::GetString(size_t index, std::string* out_value) const {
   Value* value;
@@ skipping 142 matching lines @@
   if (lhs_it != end() || rhs_it != other_list->end())
     return false;
 
   return true;
 }
 
 ValueSerializer::~ValueSerializer() {
 }
 
 }  // namespace base