1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "base/values.h"
12 #include "base/float_util.h"
13 #include "base/json/json_writer.h"
14 #include "base/logging.h"
15 #include "base/move.h"
16 #include "base/strings/string_util.h"
17 #include "base/strings/utf_string_conversions.h"
23 // Make a deep copy of |node|, but don't include empty lists or dictionaries
24 // in the copy. It's possible for this function to return NULL and it
25 // expects |node| to always be non-NULL.
26 Value* CopyWithoutEmptyChildren(const Value* node) {
28 switch (node->GetType()) {
29 case Value::TYPE_LIST: {
30 const ListValue* list = static_cast<const ListValue*>(node);
31 ListValue* copy = new ListValue;
32 for (ListValue::const_iterator it = list->begin(); it != list->end();
34 Value* child_copy = CopyWithoutEmptyChildren(*it);
36 copy->Append(child_copy);
45 case Value::TYPE_DICTIONARY: {
46 const DictionaryValue* dict = static_cast<const DictionaryValue*>(node);
47 DictionaryValue* copy = new DictionaryValue;
48 for (DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
49 Value* child_copy = CopyWithoutEmptyChildren(&it.value());
51 copy->SetWithoutPathExpansion(it.key(), child_copy);
61 // For everything else, just make a copy.
62 return node->DeepCopy();
66 // A small functor for comparing Values for std::find_if and similar.
69 // Pass the value against which all consecutive calls of the () operator will
70 // compare their argument to. This Value object must not be destroyed while
71 // the ValueEquals is in use.
72 explicit ValueEquals(const Value* first) : first_(first) { }
74 bool operator ()(const Value* second) const {
75 return first_->Equals(second);
88 Value* Value::CreateNullValue() {
89 return new Value(TYPE_NULL);
93 FundamentalValue* Value::CreateBooleanValue(bool in_value) {
94 return new FundamentalValue(in_value);
98 FundamentalValue* Value::CreateIntegerValue(int in_value) {
99 return new FundamentalValue(in_value);
103 FundamentalValue* Value::CreateDoubleValue(double in_value) {
104 return new FundamentalValue(in_value);
108 StringValue* Value::CreateStringValue(const std::string& in_value) {
109 return new StringValue(in_value);
113 StringValue* Value::CreateStringValue(const string16& in_value) {
114 return new StringValue(in_value);
117 bool Value::GetAsBoolean(bool* out_value) const {
121 bool Value::GetAsInteger(int* out_value) const {
125 bool Value::GetAsDouble(double* out_value) const {
129 bool Value::GetAsString(std::string* out_value) const {
133 bool Value::GetAsString(string16* out_value) const {
137 bool Value::GetAsList(ListValue** out_value) {
141 bool Value::GetAsList(const ListValue** out_value) const {
145 bool Value::GetAsDictionary(DictionaryValue** out_value) {
149 bool Value::GetAsDictionary(const DictionaryValue** out_value) const {
153 Value* Value::DeepCopy() const {
154 // This method should only be getting called for null Values--all subclasses
155 // need to provide their own implementation;.
156 DCHECK(IsType(TYPE_NULL));
157 return CreateNullValue();
160 bool Value::Equals(const Value* other) const {
161 // This method should only be getting called for null Values--all subclasses
162 // need to provide their own implementation;.
163 DCHECK(IsType(TYPE_NULL));
164 return other->IsType(TYPE_NULL);
168 bool Value::Equals(const Value* a, const Value* b) {
169 if ((a == NULL) && (b == NULL)) return true;
170 if ((a == NULL) ^ (b == NULL)) return false;
174 Value::Value(Type type) : type_(type) {}
176 Value::Value(const Value& that) : type_(that.type_) {}
178 Value& Value::operator=(const Value& that) {
183 ///////////////////// FundamentalValue ////////////////////
185 FundamentalValue::FundamentalValue(bool in_value)
186 : Value(TYPE_BOOLEAN), boolean_value_(in_value) {
189 FundamentalValue::FundamentalValue(int in_value)
190 : Value(TYPE_INTEGER), integer_value_(in_value) {
193 FundamentalValue::FundamentalValue(double in_value)
194 : Value(TYPE_DOUBLE), double_value_(in_value) {
195 if (!IsFinite(double_value_)) {
196 NOTREACHED() << "Non-finite (i.e. NaN or positive/negative infinity) "
197 << "values cannot be represented in JSON";
202 FundamentalValue::~FundamentalValue() {
205 bool FundamentalValue::GetAsBoolean(bool* out_value) const {
206 if (out_value && IsType(TYPE_BOOLEAN))
207 *out_value = boolean_value_;
208 return (IsType(TYPE_BOOLEAN));
211 bool FundamentalValue::GetAsInteger(int* out_value) const {
212 if (out_value && IsType(TYPE_INTEGER))
213 *out_value = integer_value_;
214 return (IsType(TYPE_INTEGER));
217 bool FundamentalValue::GetAsDouble(double* out_value) const {
218 if (out_value && IsType(TYPE_DOUBLE))
219 *out_value = double_value_;
220 else if (out_value && IsType(TYPE_INTEGER))
221 *out_value = integer_value_;
222 return (IsType(TYPE_DOUBLE) || IsType(TYPE_INTEGER));
225 FundamentalValue* FundamentalValue::DeepCopy() const {
228 return CreateBooleanValue(boolean_value_);
231 return CreateIntegerValue(integer_value_);
234 return CreateDoubleValue(double_value_);
242 bool FundamentalValue::Equals(const Value* other) const {
243 if (other->GetType() != GetType())
249 return GetAsBoolean(&lhs) && other->GetAsBoolean(&rhs) && lhs == rhs;
253 return GetAsInteger(&lhs) && other->GetAsInteger(&rhs) && lhs == rhs;
257 return GetAsDouble(&lhs) && other->GetAsDouble(&rhs) && lhs == rhs;
265 ///////////////////// StringValue ////////////////////
267 StringValue::StringValue(const std::string& in_value)
268 : Value(TYPE_STRING),
270 DCHECK(IsStringUTF8(in_value));
273 StringValue::StringValue(const string16& in_value)
274 : Value(TYPE_STRING),
275 value_(UTF16ToUTF8(in_value)) {
278 StringValue::~StringValue() {
281 bool StringValue::GetAsString(std::string* out_value) const {
287 bool StringValue::GetAsString(string16* out_value) const {
289 *out_value = UTF8ToUTF16(value_);
293 StringValue* StringValue::DeepCopy() const {
294 return CreateStringValue(value_);
297 bool StringValue::Equals(const Value* other) const {
298 if (other->GetType() != GetType())
300 std::string lhs, rhs;
301 return GetAsString(&lhs) && other->GetAsString(&rhs) && lhs == rhs;
304 ///////////////////// BinaryValue ////////////////////
306 BinaryValue::BinaryValue()
307 : Value(TYPE_BINARY),
311 BinaryValue::BinaryValue(scoped_ptr<char[]> buffer, size_t size)
312 : Value(TYPE_BINARY),
313 buffer_(buffer.Pass()),
317 BinaryValue::~BinaryValue() {
321 BinaryValue* BinaryValue::CreateWithCopiedBuffer(const char* buffer,
323 char* buffer_copy = new char[size];
324 memcpy(buffer_copy, buffer, size);
325 scoped_ptr<char[]> scoped_buffer_copy(buffer_copy);
326 return new BinaryValue(scoped_buffer_copy.Pass(), size);
329 BinaryValue* BinaryValue::DeepCopy() const {
330 return CreateWithCopiedBuffer(buffer_.get(), size_);
333 bool BinaryValue::Equals(const Value* other) const {
334 if (other->GetType() != GetType())
336 const BinaryValue* other_binary = static_cast<const BinaryValue*>(other);
337 if (other_binary->size_ != size_)
339 return !memcmp(GetBuffer(), other_binary->GetBuffer(), size_);
342 ///////////////////// DictionaryValue ////////////////////
344 DictionaryValue::DictionaryValue()
345 : Value(TYPE_DICTIONARY) {
348 DictionaryValue::~DictionaryValue() {
352 bool DictionaryValue::GetAsDictionary(DictionaryValue** out_value) {
358 bool DictionaryValue::GetAsDictionary(const DictionaryValue** out_value) const {
364 bool DictionaryValue::HasKey(const std::string& key) const {
365 DCHECK(IsStringUTF8(key));
366 ValueMap::const_iterator current_entry = dictionary_.find(key);
367 DCHECK((current_entry == dictionary_.end()) || current_entry->second);
368 return current_entry != dictionary_.end();
371 void DictionaryValue::Clear() {
372 ValueMap::iterator dict_iterator = dictionary_.begin();
373 while (dict_iterator != dictionary_.end()) {
374 delete dict_iterator->second;
381 void DictionaryValue::Set(const std::string& path, Value* in_value) {
382 DCHECK(IsStringUTF8(path));
385 std::string current_path(path);
386 DictionaryValue* current_dictionary = this;
387 for (size_t delimiter_position = current_path.find('.');
388 delimiter_position != std::string::npos;
389 delimiter_position = current_path.find('.')) {
390 // Assume that we're indexing into a dictionary.
391 std::string key(current_path, 0, delimiter_position);
392 DictionaryValue* child_dictionary = NULL;
393 if (!current_dictionary->GetDictionary(key, &child_dictionary)) {
394 child_dictionary = new DictionaryValue;
395 current_dictionary->SetWithoutPathExpansion(key, child_dictionary);
398 current_dictionary = child_dictionary;
399 current_path.erase(0, delimiter_position + 1);
402 current_dictionary->SetWithoutPathExpansion(current_path, in_value);
405 void DictionaryValue::SetBoolean(const std::string& path, bool in_value) {
406 Set(path, CreateBooleanValue(in_value));
409 void DictionaryValue::SetInteger(const std::string& path, int in_value) {
410 Set(path, CreateIntegerValue(in_value));
413 void DictionaryValue::SetDouble(const std::string& path, double in_value) {
414 Set(path, CreateDoubleValue(in_value));
417 void DictionaryValue::SetString(const std::string& path,
418 const std::string& in_value) {
419 Set(path, CreateStringValue(in_value));
422 void DictionaryValue::SetString(const std::string& path,
423 const string16& in_value) {
424 Set(path, CreateStringValue(in_value));
427 void DictionaryValue::SetWithoutPathExpansion(const std::string& key,
429 // If there's an existing value here, we need to delete it, because
430 // we own all our children.
431 std::pair<ValueMap::iterator, bool> ins_res =
432 dictionary_.insert(std::make_pair(key, in_value));
433 if (!ins_res.second) {
434 DCHECK_NE(ins_res.first->second, in_value); // This would be bogus
435 delete ins_res.first->second;
436 ins_res.first->second = in_value;
440 void DictionaryValue::SetBooleanWithoutPathExpansion(
441 const std::string& path, bool in_value) {
442 SetWithoutPathExpansion(path, CreateBooleanValue(in_value));
445 void DictionaryValue::SetIntegerWithoutPathExpansion(
446 const std::string& path, int in_value) {
447 SetWithoutPathExpansion(path, CreateIntegerValue(in_value));
450 void DictionaryValue::SetDoubleWithoutPathExpansion(
451 const std::string& path, double in_value) {
452 SetWithoutPathExpansion(path, CreateDoubleValue(in_value));
455 void DictionaryValue::SetStringWithoutPathExpansion(
456 const std::string& path, const std::string& in_value) {
457 SetWithoutPathExpansion(path, CreateStringValue(in_value));
460 void DictionaryValue::SetStringWithoutPathExpansion(
461 const std::string& path, const string16& in_value) {
462 SetWithoutPathExpansion(path, CreateStringValue(in_value));
465 bool DictionaryValue::Get(
466 const std::string& path, const Value** out_value) const {
467 DCHECK(IsStringUTF8(path));
468 // LOG(WARNING) << "\n1\n";
469 std::string current_path(path);
470 const DictionaryValue* current_dictionary = this;
471 // LOG(WARNING) << "\n2\n";
472 for (size_t delimiter_position = current_path.find('.');
473 delimiter_position != std::string::npos;
474 delimiter_position = current_path.find('.')) {
475 const DictionaryValue* child_dictionary = NULL;
476 if (!current_dictionary->GetDictionary(
477 current_path.substr(0, delimiter_position), &child_dictionary))
480 current_dictionary = child_dictionary;
481 current_path.erase(0, delimiter_position + 1);
483 // LOG(WARNING) << "\n3\n";
485 return current_dictionary->GetWithoutPathExpansion(current_path, out_value);
488 bool DictionaryValue::Get(const std::string& path, Value** out_value) {
489 return static_cast<const DictionaryValue&>(*this).Get(
491 const_cast<const Value**>(out_value));
494 bool DictionaryValue::GetBoolean(const std::string& path,
495 bool* bool_value) const {
497 if (!Get(path, &value))
500 return value->GetAsBoolean(bool_value);
503 bool DictionaryValue::GetInteger(const std::string& path,
504 int* out_value) const {
506 if (!Get(path, &value))
509 return value->GetAsInteger(out_value);
512 bool DictionaryValue::GetDouble(const std::string& path,
513 double* out_value) const {
515 if (!Get(path, &value))
518 return value->GetAsDouble(out_value);
521 bool DictionaryValue::GetString(const std::string& path,
522 std::string* out_value) const {
524 if (!Get(path, &value))
527 return value->GetAsString(out_value);
530 bool DictionaryValue::GetString(const std::string& path,
531 string16* out_value) const {
533 if (!Get(path, &value))
536 return value->GetAsString(out_value);
539 bool DictionaryValue::GetStringASCII(const std::string& path,
540 std::string* out_value) const {
542 if (!GetString(path, &out))
545 if (!IsStringASCII(out)) {
550 out_value->assign(out);
554 bool DictionaryValue::GetBinary(const std::string& path,
555 const BinaryValue** out_value) const {
557 bool result = Get(path, &value);
558 if (!result || !value->IsType(TYPE_BINARY))
562 *out_value = static_cast<const BinaryValue*>(value);
567 bool DictionaryValue::GetBinary(const std::string& path,
568 BinaryValue** out_value) {
569 return static_cast<const DictionaryValue&>(*this).GetBinary(
571 const_cast<const BinaryValue**>(out_value));
574 bool DictionaryValue::GetDictionary(const std::string& path,
575 const DictionaryValue** out_value) const {
577 bool result = Get(path, &value);
578 if (!result || !value->IsType(TYPE_DICTIONARY))
582 *out_value = static_cast<const DictionaryValue*>(value);
587 bool DictionaryValue::GetDictionary(const std::string& path,
588 DictionaryValue** out_value) {
589 return static_cast<const DictionaryValue&>(*this).GetDictionary(
591 const_cast<const DictionaryValue**>(out_value));
594 bool DictionaryValue::GetList(const std::string& path,
595 const ListValue** out_value) const {
597 bool result = Get(path, &value);
598 if (!result || !value->IsType(TYPE_LIST))
602 *out_value = static_cast<const ListValue*>(value);
607 bool DictionaryValue::GetList(const std::string& path, ListValue** out_value) {
608 return static_cast<const DictionaryValue&>(*this).GetList(
610 const_cast<const ListValue**>(out_value));
613 bool DictionaryValue::GetWithoutPathExpansion(const std::string& key,
614 const Value** out_value) const {
615 DCHECK(IsStringUTF8(key));
616 ValueMap::const_iterator entry_iterator = dictionary_.find(key);
617 if (entry_iterator == dictionary_.end())
620 const Value* entry = entry_iterator->second;
626 bool DictionaryValue::GetWithoutPathExpansion(const std::string& key,
628 return static_cast<const DictionaryValue&>(*this).GetWithoutPathExpansion(
630 const_cast<const Value**>(out_value));
633 bool DictionaryValue::GetBooleanWithoutPathExpansion(const std::string& key,
634 bool* out_value) const {
636 if (!GetWithoutPathExpansion(key, &value))
639 return value->GetAsBoolean(out_value);
642 bool DictionaryValue::GetIntegerWithoutPathExpansion(const std::string& key,
643 int* out_value) const {
645 if (!GetWithoutPathExpansion(key, &value))
648 return value->GetAsInteger(out_value);
651 bool DictionaryValue::GetDoubleWithoutPathExpansion(const std::string& key,
652 double* out_value) const {
654 if (!GetWithoutPathExpansion(key, &value))
657 return value->GetAsDouble(out_value);
660 bool DictionaryValue::GetStringWithoutPathExpansion(
661 const std::string& key,
662 std::string* out_value) const {
664 if (!GetWithoutPathExpansion(key, &value))
667 return value->GetAsString(out_value);
670 bool DictionaryValue::GetStringWithoutPathExpansion(const std::string& key,
671 string16* out_value) const {
673 if (!GetWithoutPathExpansion(key, &value))
676 return value->GetAsString(out_value);
679 bool DictionaryValue::GetDictionaryWithoutPathExpansion(
680 const std::string& key,
681 const DictionaryValue** out_value) const {
683 bool result = GetWithoutPathExpansion(key, &value);
684 if (!result || !value->IsType(TYPE_DICTIONARY))
688 *out_value = static_cast<const DictionaryValue*>(value);
693 bool DictionaryValue::GetDictionaryWithoutPathExpansion(
694 const std::string& key,
695 DictionaryValue** out_value) {
696 const DictionaryValue& const_this =
697 static_cast<const DictionaryValue&>(*this);
698 return const_this.GetDictionaryWithoutPathExpansion(
700 const_cast<const DictionaryValue**>(out_value));
703 bool DictionaryValue::GetListWithoutPathExpansion(
704 const std::string& key,
705 const ListValue** out_value) const {
707 bool result = GetWithoutPathExpansion(key, &value);
708 if (!result || !value->IsType(TYPE_LIST))
712 *out_value = static_cast<const ListValue*>(value);
717 bool DictionaryValue::GetListWithoutPathExpansion(const std::string& key,
718 ListValue** out_value) {
720 static_cast<const DictionaryValue&>(*this).GetListWithoutPathExpansion(
722 const_cast<const ListValue**>(out_value));
725 bool DictionaryValue::Remove(const std::string& path,
726 scoped_ptr<Value>* out_value) {
727 DCHECK(IsStringUTF8(path));
728 std::string current_path(path);
729 DictionaryValue* current_dictionary = this;
730 size_t delimiter_position = current_path.rfind('.');
731 if (delimiter_position != std::string::npos) {
732 if (!GetDictionary(current_path.substr(0, delimiter_position),
733 ¤t_dictionary))
735 current_path.erase(0, delimiter_position + 1);
738 return current_dictionary->RemoveWithoutPathExpansion(current_path,
742 bool DictionaryValue::RemoveWithoutPathExpansion(const std::string& key,
743 scoped_ptr<Value>* out_value) {
744 DCHECK(IsStringUTF8(key));
745 ValueMap::iterator entry_iterator = dictionary_.find(key);
746 if (entry_iterator == dictionary_.end())
749 Value* entry = entry_iterator->second;
751 out_value->reset(entry);
754 dictionary_.erase(entry_iterator);
758 DictionaryValue* DictionaryValue::DeepCopyWithoutEmptyChildren() const {
759 Value* copy = CopyWithoutEmptyChildren(this);
760 return copy ? static_cast<DictionaryValue*>(copy) : new DictionaryValue;
763 void DictionaryValue::MergeDictionary(const DictionaryValue* dictionary) {
764 for (DictionaryValue::Iterator it(*dictionary); !it.IsAtEnd(); it.Advance()) {
765 const Value* merge_value = &it.value();
766 // Check whether we have to merge dictionaries.
767 if (merge_value->IsType(Value::TYPE_DICTIONARY)) {
768 DictionaryValue* sub_dict;
769 if (GetDictionaryWithoutPathExpansion(it.key(), &sub_dict)) {
770 sub_dict->MergeDictionary(
771 static_cast<const DictionaryValue*>(merge_value));
775 // All other cases: Make a copy and hook it up.
776 SetWithoutPathExpansion(it.key(), merge_value->DeepCopy());
780 void DictionaryValue::Swap(DictionaryValue* other) {
781 dictionary_.swap(other->dictionary_);
784 DictionaryValue::Iterator::Iterator(const DictionaryValue& target)
786 it_(target.dictionary_.begin()) {}
788 DictionaryValue* DictionaryValue::DeepCopy() const {
789 DictionaryValue* result = new DictionaryValue;
791 for (ValueMap::const_iterator current_entry(dictionary_.begin());
792 current_entry != dictionary_.end(); ++current_entry) {
793 result->SetWithoutPathExpansion(current_entry->first,
794 current_entry->second->DeepCopy());
800 bool DictionaryValue::Equals(const Value* other) const {
801 if (other->GetType() != GetType())
804 const DictionaryValue* other_dict =
805 static_cast<const DictionaryValue*>(other);
806 Iterator lhs_it(*this);
807 Iterator rhs_it(*other_dict);
808 while (!lhs_it.IsAtEnd() && !rhs_it.IsAtEnd()) {
809 if (lhs_it.key() != rhs_it.key() ||
810 !lhs_it.value().Equals(&rhs_it.value())) {
816 if (!lhs_it.IsAtEnd() || !rhs_it.IsAtEnd())
822 ///////////////////// ListValue ////////////////////
824 ListValue::ListValue() : Value(TYPE_LIST) {
827 ListValue::~ListValue() {
831 void ListValue::Clear() {
832 for (ValueVector::iterator i(list_.begin()); i != list_.end(); ++i)
837 bool ListValue::Set(size_t index, Value* in_value) {
841 if (index >= list_.size()) {
842 // Pad out any intermediate indexes with null settings
843 while (index > list_.size())
844 Append(CreateNullValue());
847 DCHECK(list_[index] != in_value);
849 list_[index] = in_value;
854 bool ListValue::Get(size_t index, const Value** out_value) const {
855 if (index >= list_.size())
859 *out_value = list_[index];
864 bool ListValue::Get(size_t index, Value** out_value) {
865 return static_cast<const ListValue&>(*this).Get(
867 const_cast<const Value**>(out_value));
870 bool ListValue::GetBoolean(size_t index, bool* bool_value) const {
872 if (!Get(index, &value))
875 return value->GetAsBoolean(bool_value);
878 bool ListValue::GetInteger(size_t index, int* out_value) const {
880 if (!Get(index, &value))
883 return value->GetAsInteger(out_value);
886 bool ListValue::GetDouble(size_t index, double* out_value) const {
888 if (!Get(index, &value))
891 return value->GetAsDouble(out_value);
894 bool ListValue::GetString(size_t index, std::string* out_value) const {
896 if (!Get(index, &value))
899 return value->GetAsString(out_value);
902 bool ListValue::GetString(size_t index, string16* out_value) const {
904 if (!Get(index, &value))
907 return value->GetAsString(out_value);
910 bool ListValue::GetBinary(size_t index, const BinaryValue** out_value) const {
912 bool result = Get(index, &value);
913 if (!result || !value->IsType(TYPE_BINARY))
917 *out_value = static_cast<const BinaryValue*>(value);
922 bool ListValue::GetBinary(size_t index, BinaryValue** out_value) {
923 return static_cast<const ListValue&>(*this).GetBinary(
925 const_cast<const BinaryValue**>(out_value));
928 bool ListValue::GetDictionary(size_t index,
929 const DictionaryValue** out_value) const {
931 bool result = Get(index, &value);
932 if (!result || !value->IsType(TYPE_DICTIONARY))
936 *out_value = static_cast<const DictionaryValue*>(value);
941 bool ListValue::GetDictionary(size_t index, DictionaryValue** out_value) {
942 return static_cast<const ListValue&>(*this).GetDictionary(
944 const_cast<const DictionaryValue**>(out_value));
947 bool ListValue::GetList(size_t index, const ListValue** out_value) const {
949 bool result = Get(index, &value);
950 if (!result || !value->IsType(TYPE_LIST))
954 *out_value = static_cast<const ListValue*>(value);
959 bool ListValue::GetList(size_t index, ListValue** out_value) {
960 return static_cast<const ListValue&>(*this).GetList(
962 const_cast<const ListValue**>(out_value));
965 bool ListValue::Remove(size_t index, scoped_ptr<Value>* out_value) {
966 if (index >= list_.size())
970 out_value->reset(list_[index]);
974 list_.erase(list_.begin() + index);
978 bool ListValue::Remove(const Value& value, size_t* index) {
979 for (ValueVector::iterator i(list_.begin()); i != list_.end(); ++i) {
980 if ((*i)->Equals(&value)) {
981 size_t previous_index = i - list_.begin();
986 *index = previous_index;
993 ListValue::iterator ListValue::Erase(iterator iter,
994 scoped_ptr<Value>* out_value) {
996 out_value->reset(*iter);
1000 return list_.erase(iter);
1003 void ListValue::Append(Value* in_value) {
1005 list_.push_back(in_value);
1008 void ListValue::AppendBoolean(bool in_value) {
1009 Append(CreateBooleanValue(in_value));
1012 void ListValue::AppendInteger(int in_value) {
1013 Append(CreateIntegerValue(in_value));
1016 void ListValue::AppendDouble(double in_value) {
1017 Append(CreateDoubleValue(in_value));
1020 void ListValue::AppendString(const std::string& in_value) {
1021 Append(CreateStringValue(in_value));
1024 void ListValue::AppendString(const string16& in_value) {
1025 Append(CreateStringValue(in_value));
1028 void ListValue::AppendStrings(const std::vector<std::string>& in_values) {
1029 for (std::vector<std::string>::const_iterator it = in_values.begin();
1030 it != in_values.end(); ++it) {
1035 void ListValue::AppendStrings(const std::vector<string16>& in_values) {
1036 for (std::vector<string16>::const_iterator it = in_values.begin();
1037 it != in_values.end(); ++it) {
1042 bool ListValue::AppendIfNotPresent(Value* in_value) {
1044 for (ValueVector::const_iterator i(list_.begin()); i != list_.end(); ++i) {
1045 if ((*i)->Equals(in_value)) {
1050 list_.push_back(in_value);
1054 bool ListValue::Insert(size_t index, Value* in_value) {
1056 if (index > list_.size())
1059 list_.insert(list_.begin() + index, in_value);
1063 ListValue::const_iterator ListValue::Find(const Value& value) const {
1064 return std::find_if(list_.begin(), list_.end(), ValueEquals(&value));
1067 void ListValue::Swap(ListValue* other) {
1068 list_.swap(other->list_);
1071 bool ListValue::GetAsList(ListValue** out_value) {
1077 bool ListValue::GetAsList(const ListValue** out_value) const {
1083 ListValue* ListValue::DeepCopy() const {
1084 ListValue* result = new ListValue;
1086 for (ValueVector::const_iterator i(list_.begin()); i != list_.end(); ++i)
1087 result->Append((*i)->DeepCopy());
1092 bool ListValue::Equals(const Value* other) const {
1093 if (other->GetType() != GetType())
1096 const ListValue* other_list =
1097 static_cast<const ListValue*>(other);
1098 const_iterator lhs_it, rhs_it;
1099 for (lhs_it = begin(), rhs_it = other_list->begin();
1100 lhs_it != end() && rhs_it != other_list->end();
1101 ++lhs_it, ++rhs_it) {
1102 if (!(*lhs_it)->Equals(*rhs_it))
1105 if (lhs_it != end() || rhs_it != other_list->end())
1111 ValueSerializer::~ValueSerializer() {
1114 std::ostream& operator<<(std::ostream& out, const Value& value) {
1116 JSONWriter::WriteWithOptions(&value,
1117 JSONWriter::OPTIONS_PRETTY_PRINT,