Flesh out ListValue class.

base/values.cc

 // Copyright (c) 2006-2008 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/logging.h"
 #include "base/string_util.h"
 #include "base/values.h"
 
 ///////////////////// Value ////////////////////
 
@@ skipping 227 matching lines @@
 void DictionaryValue::Clear() {
   ValueMap::iterator dict_iterator = dictionary_.begin();
   while (dict_iterator != dictionary_.end()) {
     delete dict_iterator->second;
     ++dict_iterator;
   }
 
   dictionary_.clear();
 }
 
-bool DictionaryValue::HasKey(const std::wstring& key) {
+bool DictionaryValue::HasKey(const std::wstring& key) const {
   ValueMap::const_iterator current_entry = dictionary_.find(key);
   DCHECK((current_entry == dictionary_.end()) || current_entry->second);
   return current_entry != dictionary_.end();
 }
 
 void DictionaryValue::SetInCurrentNode(const std::wstring& key,
                                        Value* in_value) {
   // If there's an existing value here, we need to delete it, because
   // we own all our children.
   if (HasKey(key)) {
@@ skipping 266 matching lines @@
 bool ListValue::Get(size_t index, Value** out_value) const {
   if (index >= list_.size())
     return false;
 
   if (out_value)
     *out_value = list_[index];
 
   return true;
 }
 
-bool ListValue::GetDictionary(size_t index,
-                              DictionaryValue** out_value) const {
+bool ListValue::GetBoolean(size_t index, bool* bool_value) const {
+  Value* value;
+  if (!Get(index, &value))
+    return false;
+
+  return value->GetAsBoolean(bool_value);
+}
+
+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::GetReal(size_t index, double* out_value) const {
+  Value* value;
+  if (!Get(index, &value))
+    return false;
+
+  return value->GetAsReal(out_value);
+}
+
+bool ListValue::GetString(size_t index, std::string* out_value) const {
+  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))
+    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))
     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))
+    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())
     return false;
 
   if (out_value)
     *out_value = list_[index];
   else
     delete list_[index];
 
   ValueVector::iterator entry = list_.begin();
@@ skipping 32 matching lines @@
        ++lhs_it, ++rhs_it) {
     if (!(*lhs_it)->Equals(*rhs_it))
       return false;
   }
   if (lhs_it != end() || rhs_it != other_list->end())
     return false;
 
   return true;
 }