base: Add Is* functions to Value class.

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 "base/float_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 79 matching lines @@
 // 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::IsNull() const {
+  return type_ == TYPE_NULL;
+}
+
+bool Value::IsBoolean() const {
+  return type_ == TYPE_BOOLEAN;
+}
+
+bool Value::IsInteger() const {
+  return type_ == TYPE_INTEGER;
+}
+
+bool Value::IsDouble() const {
+  return type_ == TYPE_DOUBLE;
+}
+
+bool Value::IsString() const {
+  return type_ == TYPE_STRING;
+}
+
+bool Value::IsBinary() const {
+  return type_ == TYPE_BINARY;
+}
+
+bool Value::IsDictionary() const {
+  return type_ == TYPE_DICTIONARY;
+}
+
+bool Value::IsList() const {
+  return type_ == TYPE_LIST;
+}
+
 bool Value::GetAsBoolean(bool* out_value) const {
   return false;
 }
 
 bool Value::GetAsInteger(int* out_value) const {
   return false;
 }
 
 bool Value::GetAsDouble(double* out_value) const {
   return false;
@@ skipping 11 matching lines @@
   return false;
 }
 
 bool Value::GetAsList(const ListValue** out_value) const {
   return false;
 }
 
 Value* Value::DeepCopy() const {
   // This method should only be getting called for null Values--all subclasses
   // need to provide their own implementation;.
-  DCHECK(IsType(TYPE_NULL));
+  DCHECK(IsNull());
   return CreateNullValue();
 }
 
 bool Value::Equals(const Value* other) const {
   // This method should only be getting called for null Values--all subclasses
   // need to provide their own implementation;.
-  DCHECK(IsType(TYPE_NULL));
-  return other->IsType(TYPE_NULL);
+  DCHECK(IsNull());
+  return other->IsNull();
 }
 
 // static
 bool Value::Equals(const Value* a, const Value* b) {
   if ((a == NULL) && (b == NULL)) return true;
   if ((a == NULL) ^  (b == NULL)) return false;
   return a->Equals(b);
 }
 
 Value::Value(Type type) : type_(type) {
@@ skipping 12 matching lines @@
 FundamentalValue::FundamentalValue(double in_value)
     : Value(TYPE_DOUBLE), double_value_(in_value) {
   // JSON doesn't support NaN or positive or negative infinity.
   DCHECK(IsFinite(in_value));
 }
 
 FundamentalValue::~FundamentalValue() {
 }
 
 bool FundamentalValue::GetAsBoolean(bool* out_value) const {
-  if (out_value && IsType(TYPE_BOOLEAN))
+  if (out_value && IsBoolean())
     *out_value = boolean_value_;
-  return (IsType(TYPE_BOOLEAN));
+  return (IsBoolean());
 }
 
 bool FundamentalValue::GetAsInteger(int* out_value) const {
-  if (out_value && IsType(TYPE_INTEGER))
+  if (out_value && IsInteger())
     *out_value = integer_value_;
-  return (IsType(TYPE_INTEGER));
+  return (IsInteger());
 }
 
 bool FundamentalValue::GetAsDouble(double* out_value) const {
-  if (out_value && IsType(TYPE_DOUBLE))
+  if (out_value && IsDouble())
     *out_value = double_value_;
-  else if (out_value && IsType(TYPE_INTEGER))
+  else if (out_value && IsInteger())
     *out_value = integer_value_;
-  return (IsType(TYPE_DOUBLE) || IsType(TYPE_INTEGER));
+  return (IsDouble() || IsInteger());
 }
 
 FundamentalValue* FundamentalValue::DeepCopy() const {
   switch (GetType()) {
     case TYPE_BOOLEAN:
       return CreateBooleanValue(boolean_value_);
 
     case TYPE_INTEGER:
       return CreateIntegerValue(integer_value_);
 
@@ skipping 276 matching lines @@
   }
 
   out_value->assign(out);
   return true;
 }
 
 bool DictionaryValue::GetBinary(const std::string& path,
                                 BinaryValue** out_value) const {
   Value* value;
   bool result = Get(path, &value);
-  if (!result || !value->IsType(TYPE_BINARY))
+  if (!result || !value->IsBinary())
     return false;
 
   if (out_value)
     *out_value = static_cast<BinaryValue*>(value);
 
   return true;
 }
 
 bool DictionaryValue::GetDictionary(const std::string& path,
                                     DictionaryValue** out_value) const {
   Value* value;
   bool result = Get(path, &value);
-  if (!result || !value->IsType(TYPE_DICTIONARY))
+  if (!result || !value->IsDictionary())
     return false;
 
   if (out_value)
     *out_value = static_cast<DictionaryValue*>(value);
 
   return true;
 }
 
 bool DictionaryValue::GetList(const std::string& path,
                               ListValue** out_value) const {
   Value* value;
   bool result = Get(path, &value);
-  if (!result || !value->IsType(TYPE_LIST))
+  if (!result || !value->IsList())
     return false;
 
   if (out_value)
     *out_value = static_cast<ListValue*>(value);
 
   return true;
 }
 
 bool DictionaryValue::GetWithoutPathExpansion(const std::string& key,
                                               Value** out_value) const {
@@ skipping 44 matching lines @@
     return false;
 
   return value->GetAsString(out_value);
 }
 
 bool DictionaryValue::GetDictionaryWithoutPathExpansion(
     const std::string& key,
     DictionaryValue** out_value) const {
   Value* value;
   bool result = GetWithoutPathExpansion(key, &value);
-  if (!result || !value->IsType(TYPE_DICTIONARY))
+  if (!result || !value->IsDictionary())
     return false;
 
   if (out_value)
     *out_value = static_cast<DictionaryValue*>(value);
 
   return true;
 }
 
 bool DictionaryValue::GetListWithoutPathExpansion(const std::string& key,
                                                   ListValue** out_value) const {
   Value* value;
   bool result = GetWithoutPathExpansion(key, &value);
-  if (!result || !value->IsType(TYPE_LIST))
+  if (!result || !value->IsList())
     return false;
 
   if (out_value)
     *out_value = static_cast<ListValue*>(value);
 
   return true;
 }
 
 bool DictionaryValue::Remove(const std::string& path, Value** out_value) {
   DCHECK(IsStringUTF8(path));
@@ skipping 31 matching lines @@
   Value* copy = CopyWithoutEmptyChildren(this);
   return copy ? static_cast<DictionaryValue*>(copy) : new DictionaryValue;
 }
 
 void DictionaryValue::MergeDictionary(const DictionaryValue* dictionary) {
   for (DictionaryValue::key_iterator key(dictionary->begin_keys());
        key != dictionary->end_keys(); ++key) {
     Value* merge_value;
     if (dictionary->GetWithoutPathExpansion(*key, &merge_value)) {
       // Check whether we have to merge dictionaries.
-      if (merge_value->IsType(Value::TYPE_DICTIONARY)) {
+      if (merge_value->IsDictionary()) {
         DictionaryValue* sub_dict;
         if (GetDictionaryWithoutPathExpansion(*key, &sub_dict)) {
           sub_dict->MergeDictionary(
               static_cast<const DictionaryValue*>(merge_value));
           continue;
         }
       }
       // All other cases: Make a copy and hook it up.
       SetWithoutPathExpansion(*key, merge_value->DeepCopy());
     }
@@ skipping 116 matching lines @@
   Value* value;
   if (!Get(index, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
 bool ListValue::GetBinary(size_t index, BinaryValue** out_value) const {
   Value* value;
   bool result = Get(index, &value);
-  if (!result || !value->IsType(TYPE_BINARY))
+  if (!result || !value->IsBinary())
     return false;
 
   if (out_value)
     *out_value = static_cast<BinaryValue*>(value);
 
   return true;
 }
 
 bool ListValue::GetDictionary(size_t index, DictionaryValue** out_value) const {
   Value* value;
   bool result = Get(index, &value);
-  if (!result || !value->IsType(TYPE_DICTIONARY))
+  if (!result || !value->IsDictionary())
     return false;
 
   if (out_value)
     *out_value = static_cast<DictionaryValue*>(value);
 
   return true;
 }
 
 bool ListValue::GetList(size_t index, ListValue** out_value) const {
   Value* value;
   bool result = Get(index, &value);
-  if (!result || !value->IsType(TYPE_LIST))
+  if (!result || !value->IsList())
     return false;
 
   if (out_value)
     *out_value = static_cast<ListValue*>(value);
 
   return true;
 }
 
 bool ListValue::Remove(size_t index, Value** out_value) {
   if (index >= list_.size())
@@ skipping 86 matching lines @@
   if (lhs_it != end() || rhs_it != other_list->end())
     return false;
 
   return true;
 }
 
 ValueSerializer::~ValueSerializer() {
 }
 
 }  // namespace base