1169 lines
31 KiB
C++
1169 lines
31 KiB
C++
// 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 <cmath>
|
|
#include <ostream>
|
|
#include <utility>
|
|
|
|
#include "base/json/json_writer.h"
|
|
#include "base/logging.h"
|
|
#include "base/memory/ptr_util.h"
|
|
#include "base/strings/string_util.h"
|
|
#include "base/strings/utf_string_conversions.h"
|
|
|
|
namespace base {
|
|
|
|
namespace {
|
|
|
|
std::unique_ptr<Value> CopyWithoutEmptyChildren(const Value& node);
|
|
|
|
// 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.
|
|
std::unique_ptr<ListValue> CopyListWithoutEmptyChildren(const ListValue& list) {
|
|
std::unique_ptr<ListValue> copy;
|
|
for (const auto& entry : list) {
|
|
std::unique_ptr<Value> child_copy = CopyWithoutEmptyChildren(*entry);
|
|
if (child_copy) {
|
|
if (!copy)
|
|
copy.reset(new ListValue);
|
|
copy->Append(std::move(child_copy));
|
|
}
|
|
}
|
|
return copy;
|
|
}
|
|
|
|
std::unique_ptr<DictionaryValue> CopyDictionaryWithoutEmptyChildren(
|
|
const DictionaryValue& dict) {
|
|
std::unique_ptr<DictionaryValue> copy;
|
|
for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
|
|
std::unique_ptr<Value> child_copy = CopyWithoutEmptyChildren(it.value());
|
|
if (child_copy) {
|
|
if (!copy)
|
|
copy.reset(new DictionaryValue);
|
|
copy->SetWithoutPathExpansion(it.key(), std::move(child_copy));
|
|
}
|
|
}
|
|
return copy;
|
|
}
|
|
|
|
std::unique_ptr<Value> CopyWithoutEmptyChildren(const Value& node) {
|
|
switch (node.GetType()) {
|
|
case Value::TYPE_LIST:
|
|
return CopyListWithoutEmptyChildren(static_cast<const ListValue&>(node));
|
|
|
|
case Value::TYPE_DICTIONARY:
|
|
return CopyDictionaryWithoutEmptyChildren(
|
|
static_cast<const DictionaryValue&>(node));
|
|
|
|
default:
|
|
return node.CreateDeepCopy();
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
Value::~Value() {
|
|
}
|
|
|
|
// static
|
|
std::unique_ptr<Value> Value::CreateNullValue() {
|
|
return WrapUnique(new Value(TYPE_NULL));
|
|
}
|
|
|
|
bool Value::GetAsBinary(const BinaryValue**) const {
|
|
return false;
|
|
}
|
|
|
|
bool Value::GetAsBoolean(bool*) const {
|
|
return false;
|
|
}
|
|
|
|
bool Value::GetAsInteger(int*) const {
|
|
return false;
|
|
}
|
|
|
|
bool Value::GetAsDouble(double*) const {
|
|
return false;
|
|
}
|
|
|
|
bool Value::GetAsString(std::string*) const {
|
|
return false;
|
|
}
|
|
|
|
bool Value::GetAsString(string16*) const {
|
|
return false;
|
|
}
|
|
|
|
bool Value::GetAsString(const StringValue**) const {
|
|
return false;
|
|
}
|
|
|
|
bool Value::GetAsList(ListValue**) {
|
|
return false;
|
|
}
|
|
|
|
bool Value::GetAsList(const ListValue**) const {
|
|
return false;
|
|
}
|
|
|
|
bool Value::GetAsDictionary(DictionaryValue**) {
|
|
return false;
|
|
}
|
|
|
|
bool Value::GetAsDictionary(const DictionaryValue**) 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));
|
|
return CreateNullValue().release();
|
|
}
|
|
|
|
std::unique_ptr<Value> Value::CreateDeepCopy() const {
|
|
return WrapUnique(DeepCopy());
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
// 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) {}
|
|
|
|
Value::Value(const Value& that) : type_(that.type_) {}
|
|
|
|
Value& Value::operator=(const Value& that) {
|
|
type_ = that.type_;
|
|
return *this;
|
|
}
|
|
|
|
///////////////////// 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(double in_value)
|
|
: Value(TYPE_DOUBLE), double_value_(in_value) {
|
|
if (!std::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::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 new FundamentalValue(boolean_value_);
|
|
|
|
case TYPE_INTEGER:
|
|
return new FundamentalValue(integer_value_);
|
|
|
|
case TYPE_DOUBLE:
|
|
return new FundamentalValue(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_DOUBLE: {
|
|
double lhs, rhs;
|
|
return GetAsDouble(&lhs) && other->GetAsDouble(&rhs) && lhs == rhs;
|
|
}
|
|
default:
|
|
NOTREACHED();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
///////////////////// StringValue ////////////////////
|
|
|
|
StringValue::StringValue(const std::string& in_value)
|
|
: 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() {
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
///////////////////// BinaryValue ////////////////////
|
|
|
|
BinaryValue::BinaryValue()
|
|
: Value(TYPE_BINARY),
|
|
size_(0) {
|
|
}
|
|
|
|
BinaryValue::BinaryValue(std::unique_ptr<char[]> buffer, size_t size)
|
|
: Value(TYPE_BINARY), buffer_(std::move(buffer)), size_(size) {}
|
|
|
|
BinaryValue::~BinaryValue() {
|
|
}
|
|
|
|
// static
|
|
std::unique_ptr<BinaryValue> BinaryValue::CreateWithCopiedBuffer(
|
|
const char* buffer,
|
|
size_t size) {
|
|
std::unique_ptr<char[]> buffer_copy(new char[size]);
|
|
memcpy(buffer_copy.get(), buffer, size);
|
|
return base::MakeUnique<BinaryValue>(std::move(buffer_copy), size);
|
|
}
|
|
|
|
bool BinaryValue::GetAsBinary(const BinaryValue** out_value) const {
|
|
if (out_value)
|
|
*out_value = this;
|
|
return true;
|
|
}
|
|
|
|
BinaryValue* BinaryValue::DeepCopy() const {
|
|
return CreateWithCopiedBuffer(buffer_.get(), size_).release();
|
|
}
|
|
|
|
bool BinaryValue::Equals(const Value* other) const {
|
|
if (other->GetType() != GetType())
|
|
return false;
|
|
const BinaryValue* other_binary = static_cast<const BinaryValue*>(other);
|
|
if (other_binary->size_ != size_)
|
|
return false;
|
|
return !memcmp(GetBuffer(), other_binary->GetBuffer(), size_);
|
|
}
|
|
|
|
///////////////////// DictionaryValue ////////////////////
|
|
|
|
// static
|
|
std::unique_ptr<DictionaryValue> DictionaryValue::From(
|
|
std::unique_ptr<Value> value) {
|
|
DictionaryValue* out;
|
|
if (value && value->GetAsDictionary(&out)) {
|
|
ignore_result(value.release());
|
|
return WrapUnique(out);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
DictionaryValue::DictionaryValue()
|
|
: Value(TYPE_DICTIONARY) {
|
|
}
|
|
|
|
DictionaryValue::~DictionaryValue() {
|
|
Clear();
|
|
}
|
|
|
|
bool DictionaryValue::GetAsDictionary(DictionaryValue** out_value) {
|
|
if (out_value)
|
|
*out_value = this;
|
|
return true;
|
|
}
|
|
|
|
bool DictionaryValue::GetAsDictionary(const DictionaryValue** out_value) const {
|
|
if (out_value)
|
|
*out_value = this;
|
|
return true;
|
|
}
|
|
|
|
bool DictionaryValue::HasKey(const std::string& key) const {
|
|
DCHECK(IsStringUTF8(key));
|
|
auto current_entry = dictionary_.find(key);
|
|
DCHECK((current_entry == dictionary_.end()) || current_entry->second);
|
|
return current_entry != dictionary_.end();
|
|
}
|
|
|
|
void DictionaryValue::Clear() {
|
|
dictionary_.clear();
|
|
}
|
|
|
|
void DictionaryValue::Set(const std::string& path,
|
|
std::unique_ptr<Value> in_value) {
|
|
DCHECK(IsStringUTF8(path));
|
|
DCHECK(in_value);
|
|
|
|
std::string current_path(path);
|
|
DictionaryValue* current_dictionary = this;
|
|
for (size_t delimiter_position = current_path.find('.');
|
|
delimiter_position != std::string::npos;
|
|
delimiter_position = current_path.find('.')) {
|
|
// Assume that we're indexing into a dictionary.
|
|
std::string key(current_path, 0, delimiter_position);
|
|
DictionaryValue* child_dictionary = NULL;
|
|
if (!current_dictionary->GetDictionary(key, &child_dictionary)) {
|
|
child_dictionary = new DictionaryValue;
|
|
current_dictionary->SetWithoutPathExpansion(key, child_dictionary);
|
|
}
|
|
|
|
current_dictionary = child_dictionary;
|
|
current_path.erase(0, delimiter_position + 1);
|
|
}
|
|
|
|
current_dictionary->SetWithoutPathExpansion(current_path,
|
|
std::move(in_value));
|
|
}
|
|
|
|
void DictionaryValue::Set(const std::string& path, Value* in_value) {
|
|
Set(path, WrapUnique(in_value));
|
|
}
|
|
|
|
void DictionaryValue::SetBoolean(const std::string& path, bool in_value) {
|
|
Set(path, new FundamentalValue(in_value));
|
|
}
|
|
|
|
void DictionaryValue::SetInteger(const std::string& path, int in_value) {
|
|
Set(path, new FundamentalValue(in_value));
|
|
}
|
|
|
|
void DictionaryValue::SetDouble(const std::string& path, double in_value) {
|
|
Set(path, new FundamentalValue(in_value));
|
|
}
|
|
|
|
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::SetWithoutPathExpansion(const std::string& key,
|
|
std::unique_ptr<Value> in_value) {
|
|
dictionary_[key] = std::move(in_value);
|
|
}
|
|
|
|
void DictionaryValue::SetWithoutPathExpansion(const std::string& key,
|
|
Value* in_value) {
|
|
SetWithoutPathExpansion(key, WrapUnique(in_value));
|
|
}
|
|
|
|
void DictionaryValue::SetBooleanWithoutPathExpansion(
|
|
const std::string& path, bool in_value) {
|
|
SetWithoutPathExpansion(path, new FundamentalValue(in_value));
|
|
}
|
|
|
|
void DictionaryValue::SetIntegerWithoutPathExpansion(
|
|
const std::string& path, int in_value) {
|
|
SetWithoutPathExpansion(path, new FundamentalValue(in_value));
|
|
}
|
|
|
|
void DictionaryValue::SetDoubleWithoutPathExpansion(
|
|
const std::string& path, double in_value) {
|
|
SetWithoutPathExpansion(path, new FundamentalValue(in_value));
|
|
}
|
|
|
|
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));
|
|
}
|
|
|
|
bool DictionaryValue::Get(StringPiece path,
|
|
const Value** out_value) const {
|
|
DCHECK(IsStringUTF8(path));
|
|
StringPiece 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->GetDictionaryWithoutPathExpansion(
|
|
current_path.substr(0, delimiter_position).as_string(),
|
|
&child_dictionary)) {
|
|
return false;
|
|
}
|
|
|
|
current_dictionary = child_dictionary;
|
|
current_path = current_path.substr(delimiter_position + 1);
|
|
}
|
|
|
|
return current_dictionary->GetWithoutPathExpansion(current_path.as_string(),
|
|
out_value);
|
|
}
|
|
|
|
bool DictionaryValue::Get(StringPiece path, Value** out_value) {
|
|
return static_cast<const DictionaryValue&>(*this).Get(
|
|
path,
|
|
const_cast<const Value**>(out_value));
|
|
}
|
|
|
|
bool DictionaryValue::GetBoolean(const std::string& path,
|
|
bool* bool_value) const {
|
|
const Value* value;
|
|
if (!Get(path, &value))
|
|
return false;
|
|
|
|
return value->GetAsBoolean(bool_value);
|
|
}
|
|
|
|
bool DictionaryValue::GetInteger(const std::string& path,
|
|
int* out_value) const {
|
|
const Value* value;
|
|
if (!Get(path, &value))
|
|
return false;
|
|
|
|
return value->GetAsInteger(out_value);
|
|
}
|
|
|
|
bool DictionaryValue::GetDouble(const std::string& path,
|
|
double* out_value) const {
|
|
const Value* value;
|
|
if (!Get(path, &value))
|
|
return false;
|
|
|
|
return value->GetAsDouble(out_value);
|
|
}
|
|
|
|
bool DictionaryValue::GetString(const std::string& path,
|
|
std::string* out_value) const {
|
|
const Value* value;
|
|
if (!Get(path, &value))
|
|
return false;
|
|
|
|
return value->GetAsString(out_value);
|
|
}
|
|
|
|
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::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;
|
|
}
|
|
|
|
out_value->assign(out);
|
|
return true;
|
|
}
|
|
|
|
bool DictionaryValue::GetBinary(const std::string& path,
|
|
const BinaryValue** out_value) const {
|
|
const Value* value;
|
|
bool result = Get(path, &value);
|
|
if (!result || !value->IsType(TYPE_BINARY))
|
|
return false;
|
|
|
|
if (out_value)
|
|
*out_value = static_cast<const BinaryValue*>(value);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DictionaryValue::GetBinary(const std::string& path,
|
|
BinaryValue** out_value) {
|
|
return static_cast<const DictionaryValue&>(*this).GetBinary(
|
|
path,
|
|
const_cast<const BinaryValue**>(out_value));
|
|
}
|
|
|
|
bool DictionaryValue::GetDictionary(StringPiece path,
|
|
const DictionaryValue** out_value) const {
|
|
const Value* value;
|
|
bool result = Get(path, &value);
|
|
if (!result || !value->IsType(TYPE_DICTIONARY))
|
|
return false;
|
|
|
|
if (out_value)
|
|
*out_value = static_cast<const DictionaryValue*>(value);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DictionaryValue::GetDictionary(StringPiece path,
|
|
DictionaryValue** out_value) {
|
|
return static_cast<const DictionaryValue&>(*this).GetDictionary(
|
|
path,
|
|
const_cast<const DictionaryValue**>(out_value));
|
|
}
|
|
|
|
bool DictionaryValue::GetList(const std::string& path,
|
|
const ListValue** out_value) const {
|
|
const Value* value;
|
|
bool result = Get(path, &value);
|
|
if (!result || !value->IsType(TYPE_LIST))
|
|
return false;
|
|
|
|
if (out_value)
|
|
*out_value = static_cast<const ListValue*>(value);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DictionaryValue::GetList(const std::string& path, ListValue** out_value) {
|
|
return static_cast<const DictionaryValue&>(*this).GetList(
|
|
path,
|
|
const_cast<const ListValue**>(out_value));
|
|
}
|
|
|
|
bool DictionaryValue::GetWithoutPathExpansion(const std::string& key,
|
|
const Value** out_value) const {
|
|
DCHECK(IsStringUTF8(key));
|
|
auto entry_iterator = dictionary_.find(key);
|
|
if (entry_iterator == dictionary_.end())
|
|
return false;
|
|
|
|
if (out_value)
|
|
*out_value = entry_iterator->second.get();
|
|
return true;
|
|
}
|
|
|
|
bool DictionaryValue::GetWithoutPathExpansion(const std::string& key,
|
|
Value** out_value) {
|
|
return static_cast<const DictionaryValue&>(*this).GetWithoutPathExpansion(
|
|
key,
|
|
const_cast<const Value**>(out_value));
|
|
}
|
|
|
|
bool DictionaryValue::GetBooleanWithoutPathExpansion(const std::string& key,
|
|
bool* out_value) const {
|
|
const Value* value;
|
|
if (!GetWithoutPathExpansion(key, &value))
|
|
return false;
|
|
|
|
return value->GetAsBoolean(out_value);
|
|
}
|
|
|
|
bool DictionaryValue::GetIntegerWithoutPathExpansion(const std::string& key,
|
|
int* out_value) const {
|
|
const Value* value;
|
|
if (!GetWithoutPathExpansion(key, &value))
|
|
return false;
|
|
|
|
return value->GetAsInteger(out_value);
|
|
}
|
|
|
|
bool DictionaryValue::GetDoubleWithoutPathExpansion(const std::string& key,
|
|
double* out_value) const {
|
|
const Value* value;
|
|
if (!GetWithoutPathExpansion(key, &value))
|
|
return false;
|
|
|
|
return value->GetAsDouble(out_value);
|
|
}
|
|
|
|
bool DictionaryValue::GetStringWithoutPathExpansion(
|
|
const std::string& key,
|
|
std::string* out_value) const {
|
|
const Value* value;
|
|
if (!GetWithoutPathExpansion(key, &value))
|
|
return false;
|
|
|
|
return value->GetAsString(out_value);
|
|
}
|
|
|
|
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::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);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DictionaryValue::GetDictionaryWithoutPathExpansion(
|
|
const std::string& key,
|
|
DictionaryValue** out_value) {
|
|
const DictionaryValue& const_this =
|
|
static_cast<const DictionaryValue&>(*this);
|
|
return const_this.GetDictionaryWithoutPathExpansion(
|
|
key,
|
|
const_cast<const DictionaryValue**>(out_value));
|
|
}
|
|
|
|
bool DictionaryValue::GetListWithoutPathExpansion(
|
|
const std::string& key,
|
|
const ListValue** out_value) const {
|
|
const Value* value;
|
|
bool result = GetWithoutPathExpansion(key, &value);
|
|
if (!result || !value->IsType(TYPE_LIST))
|
|
return false;
|
|
|
|
if (out_value)
|
|
*out_value = static_cast<const ListValue*>(value);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DictionaryValue::GetListWithoutPathExpansion(const std::string& key,
|
|
ListValue** out_value) {
|
|
return
|
|
static_cast<const DictionaryValue&>(*this).GetListWithoutPathExpansion(
|
|
key,
|
|
const_cast<const ListValue**>(out_value));
|
|
}
|
|
|
|
bool DictionaryValue::Remove(const std::string& path,
|
|
std::unique_ptr<Value>* out_value) {
|
|
DCHECK(IsStringUTF8(path));
|
|
std::string current_path(path);
|
|
DictionaryValue* current_dictionary = this;
|
|
size_t delimiter_position = current_path.rfind('.');
|
|
if (delimiter_position != std::string::npos) {
|
|
if (!GetDictionary(current_path.substr(0, delimiter_position),
|
|
¤t_dictionary))
|
|
return false;
|
|
current_path.erase(0, delimiter_position + 1);
|
|
}
|
|
|
|
return current_dictionary->RemoveWithoutPathExpansion(current_path,
|
|
out_value);
|
|
}
|
|
|
|
bool DictionaryValue::RemoveWithoutPathExpansion(
|
|
const std::string& key,
|
|
std::unique_ptr<Value>* out_value) {
|
|
DCHECK(IsStringUTF8(key));
|
|
auto entry_iterator = dictionary_.find(key);
|
|
if (entry_iterator == dictionary_.end())
|
|
return false;
|
|
|
|
if (out_value)
|
|
*out_value = std::move(entry_iterator->second);
|
|
dictionary_.erase(entry_iterator);
|
|
return true;
|
|
}
|
|
|
|
bool DictionaryValue::RemovePath(const std::string& path,
|
|
std::unique_ptr<Value>* out_value) {
|
|
bool result = false;
|
|
size_t delimiter_position = path.find('.');
|
|
|
|
if (delimiter_position == std::string::npos)
|
|
return RemoveWithoutPathExpansion(path, out_value);
|
|
|
|
const std::string subdict_path = path.substr(0, delimiter_position);
|
|
DictionaryValue* subdict = NULL;
|
|
if (!GetDictionary(subdict_path, &subdict))
|
|
return false;
|
|
result = subdict->RemovePath(path.substr(delimiter_position + 1),
|
|
out_value);
|
|
if (result && subdict->empty())
|
|
RemoveWithoutPathExpansion(subdict_path, NULL);
|
|
|
|
return result;
|
|
}
|
|
|
|
std::unique_ptr<DictionaryValue> DictionaryValue::DeepCopyWithoutEmptyChildren()
|
|
const {
|
|
std::unique_ptr<DictionaryValue> copy =
|
|
CopyDictionaryWithoutEmptyChildren(*this);
|
|
if (!copy)
|
|
copy.reset(new DictionaryValue);
|
|
return copy;
|
|
}
|
|
|
|
void DictionaryValue::MergeDictionary(const DictionaryValue* dictionary) {
|
|
for (DictionaryValue::Iterator it(*dictionary); !it.IsAtEnd(); it.Advance()) {
|
|
const Value* merge_value = &it.value();
|
|
// Check whether we have to merge dictionaries.
|
|
if (merge_value->IsType(Value::TYPE_DICTIONARY)) {
|
|
DictionaryValue* sub_dict;
|
|
if (GetDictionaryWithoutPathExpansion(it.key(), &sub_dict)) {
|
|
sub_dict->MergeDictionary(
|
|
static_cast<const DictionaryValue*>(merge_value));
|
|
continue;
|
|
}
|
|
}
|
|
// All other cases: Make a copy and hook it up.
|
|
SetWithoutPathExpansion(it.key(), merge_value->DeepCopy());
|
|
}
|
|
}
|
|
|
|
void DictionaryValue::Swap(DictionaryValue* other) {
|
|
dictionary_.swap(other->dictionary_);
|
|
}
|
|
|
|
DictionaryValue::Iterator::Iterator(const DictionaryValue& target)
|
|
: target_(target),
|
|
it_(target.dictionary_.begin()) {}
|
|
|
|
DictionaryValue::Iterator::Iterator(const Iterator& other) = default;
|
|
|
|
DictionaryValue::Iterator::~Iterator() {}
|
|
|
|
DictionaryValue* DictionaryValue::DeepCopy() const {
|
|
DictionaryValue* result = new DictionaryValue;
|
|
|
|
for (const auto& current_entry : dictionary_) {
|
|
result->SetWithoutPathExpansion(current_entry.first,
|
|
current_entry.second->CreateDeepCopy());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
std::unique_ptr<DictionaryValue> DictionaryValue::CreateDeepCopy() const {
|
|
return WrapUnique(DeepCopy());
|
|
}
|
|
|
|
bool DictionaryValue::Equals(const Value* other) const {
|
|
if (other->GetType() != GetType())
|
|
return false;
|
|
|
|
const DictionaryValue* other_dict =
|
|
static_cast<const DictionaryValue*>(other);
|
|
Iterator lhs_it(*this);
|
|
Iterator rhs_it(*other_dict);
|
|
while (!lhs_it.IsAtEnd() && !rhs_it.IsAtEnd()) {
|
|
if (lhs_it.key() != rhs_it.key() ||
|
|
!lhs_it.value().Equals(&rhs_it.value())) {
|
|
return false;
|
|
}
|
|
lhs_it.Advance();
|
|
rhs_it.Advance();
|
|
}
|
|
if (!lhs_it.IsAtEnd() || !rhs_it.IsAtEnd())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
///////////////////// ListValue ////////////////////
|
|
|
|
// static
|
|
std::unique_ptr<ListValue> ListValue::From(std::unique_ptr<Value> value) {
|
|
ListValue* out;
|
|
if (value && value->GetAsList(&out)) {
|
|
ignore_result(value.release());
|
|
return WrapUnique(out);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
ListValue::ListValue() : Value(TYPE_LIST) {
|
|
}
|
|
|
|
ListValue::~ListValue() {
|
|
Clear();
|
|
}
|
|
|
|
void ListValue::Clear() {
|
|
list_.clear();
|
|
}
|
|
|
|
bool ListValue::Set(size_t index, Value* in_value) {
|
|
return Set(index, WrapUnique(in_value));
|
|
}
|
|
|
|
bool ListValue::Set(size_t index, std::unique_ptr<Value> in_value) {
|
|
if (!in_value)
|
|
return false;
|
|
|
|
if (index >= list_.size()) {
|
|
// Pad out any intermediate indexes with null settings
|
|
while (index > list_.size())
|
|
Append(CreateNullValue());
|
|
Append(std::move(in_value));
|
|
} else {
|
|
// TODO(dcheng): remove this DCHECK once the raw pointer version is removed?
|
|
DCHECK(list_[index] != in_value);
|
|
list_[index] = std::move(in_value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ListValue::Get(size_t index, const Value** out_value) const {
|
|
if (index >= list_.size())
|
|
return false;
|
|
|
|
if (out_value)
|
|
*out_value = list_[index].get();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ListValue::Get(size_t index, Value** out_value) {
|
|
return static_cast<const ListValue&>(*this).Get(
|
|
index,
|
|
const_cast<const Value**>(out_value));
|
|
}
|
|
|
|
bool ListValue::GetBoolean(size_t index, bool* bool_value) const {
|
|
const Value* value;
|
|
if (!Get(index, &value))
|
|
return false;
|
|
|
|
return value->GetAsBoolean(bool_value);
|
|
}
|
|
|
|
bool ListValue::GetInteger(size_t index, int* out_value) const {
|
|
const Value* value;
|
|
if (!Get(index, &value))
|
|
return false;
|
|
|
|
return value->GetAsInteger(out_value);
|
|
}
|
|
|
|
bool ListValue::GetDouble(size_t index, double* out_value) const {
|
|
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 {
|
|
const Value* value;
|
|
if (!Get(index, &value))
|
|
return false;
|
|
|
|
return value->GetAsString(out_value);
|
|
}
|
|
|
|
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::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;
|
|
}
|
|
|
|
bool ListValue::GetBinary(size_t index, BinaryValue** out_value) {
|
|
return static_cast<const ListValue&>(*this).GetBinary(
|
|
index,
|
|
const_cast<const BinaryValue**>(out_value));
|
|
}
|
|
|
|
bool ListValue::GetDictionary(size_t index,
|
|
const DictionaryValue** out_value) const {
|
|
const Value* value;
|
|
bool result = Get(index, &value);
|
|
if (!result || !value->IsType(TYPE_DICTIONARY))
|
|
return false;
|
|
|
|
if (out_value)
|
|
*out_value = static_cast<const DictionaryValue*>(value);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ListValue::GetDictionary(size_t index, DictionaryValue** out_value) {
|
|
return static_cast<const ListValue&>(*this).GetDictionary(
|
|
index,
|
|
const_cast<const DictionaryValue**>(out_value));
|
|
}
|
|
|
|
bool ListValue::GetList(size_t index, const ListValue** out_value) const {
|
|
const Value* value;
|
|
bool result = Get(index, &value);
|
|
if (!result || !value->IsType(TYPE_LIST))
|
|
return false;
|
|
|
|
if (out_value)
|
|
*out_value = static_cast<const ListValue*>(value);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ListValue::GetList(size_t index, ListValue** out_value) {
|
|
return static_cast<const ListValue&>(*this).GetList(
|
|
index,
|
|
const_cast<const ListValue**>(out_value));
|
|
}
|
|
|
|
bool ListValue::Remove(size_t index, std::unique_ptr<Value>* out_value) {
|
|
if (index >= list_.size())
|
|
return false;
|
|
|
|
if (out_value)
|
|
*out_value = std::move(list_[index]);
|
|
|
|
list_.erase(list_.begin() + index);
|
|
return true;
|
|
}
|
|
|
|
bool ListValue::Remove(const Value& value, size_t* index) {
|
|
for (auto it = list_.begin(); it != list_.end(); ++it) {
|
|
if ((*it)->Equals(&value)) {
|
|
size_t previous_index = it - list_.begin();
|
|
list_.erase(it);
|
|
|
|
if (index)
|
|
*index = previous_index;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
ListValue::iterator ListValue::Erase(iterator iter,
|
|
std::unique_ptr<Value>* out_value) {
|
|
if (out_value)
|
|
*out_value = std::move(*Storage::iterator(iter));
|
|
|
|
return list_.erase(iter);
|
|
}
|
|
|
|
void ListValue::Append(std::unique_ptr<Value> in_value) {
|
|
list_.push_back(std::move(in_value));
|
|
}
|
|
|
|
void ListValue::Append(Value* in_value) {
|
|
DCHECK(in_value);
|
|
Append(WrapUnique(in_value));
|
|
}
|
|
|
|
void ListValue::AppendBoolean(bool in_value) {
|
|
Append(new FundamentalValue(in_value));
|
|
}
|
|
|
|
void ListValue::AppendInteger(int in_value) {
|
|
Append(new FundamentalValue(in_value));
|
|
}
|
|
|
|
void ListValue::AppendDouble(double in_value) {
|
|
Append(new FundamentalValue(in_value));
|
|
}
|
|
|
|
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::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) {
|
|
AppendString(*it);
|
|
}
|
|
}
|
|
|
|
bool ListValue::AppendIfNotPresent(Value* in_value) {
|
|
DCHECK(in_value);
|
|
for (const auto& entry : list_) {
|
|
if (entry->Equals(in_value)) {
|
|
delete in_value;
|
|
return false;
|
|
}
|
|
}
|
|
list_.emplace_back(in_value);
|
|
return true;
|
|
}
|
|
|
|
bool ListValue::Insert(size_t index, Value* in_value) {
|
|
DCHECK(in_value);
|
|
if (index > list_.size())
|
|
return false;
|
|
|
|
list_.insert(list_.begin() + index, WrapUnique(in_value));
|
|
return true;
|
|
}
|
|
|
|
ListValue::const_iterator ListValue::Find(const Value& value) const {
|
|
return std::find_if(list_.begin(), list_.end(),
|
|
[&value](const std::unique_ptr<Value>& entry) {
|
|
return entry->Equals(&value);
|
|
});
|
|
}
|
|
|
|
void ListValue::Swap(ListValue* other) {
|
|
list_.swap(other->list_);
|
|
}
|
|
|
|
bool ListValue::GetAsList(ListValue** out_value) {
|
|
if (out_value)
|
|
*out_value = this;
|
|
return true;
|
|
}
|
|
|
|
bool ListValue::GetAsList(const ListValue** out_value) const {
|
|
if (out_value)
|
|
*out_value = this;
|
|
return true;
|
|
}
|
|
|
|
ListValue* ListValue::DeepCopy() const {
|
|
ListValue* result = new ListValue;
|
|
|
|
for (const auto& entry : list_)
|
|
result->Append(entry->CreateDeepCopy());
|
|
|
|
return result;
|
|
}
|
|
|
|
std::unique_ptr<ListValue> ListValue::CreateDeepCopy() const {
|
|
return WrapUnique(DeepCopy());
|
|
}
|
|
|
|
bool ListValue::Equals(const Value* other) const {
|
|
if (other->GetType() != GetType())
|
|
return false;
|
|
|
|
const ListValue* other_list =
|
|
static_cast<const ListValue*>(other);
|
|
Storage::const_iterator lhs_it, rhs_it;
|
|
for (lhs_it = begin(), rhs_it = other_list->begin();
|
|
lhs_it != end() && rhs_it != other_list->end();
|
|
++lhs_it, ++rhs_it) {
|
|
if (!(*lhs_it)->Equals(rhs_it->get()))
|
|
return false;
|
|
}
|
|
if (lhs_it != end() || rhs_it != other_list->end())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
ValueSerializer::~ValueSerializer() {
|
|
}
|
|
|
|
ValueDeserializer::~ValueDeserializer() {
|
|
}
|
|
|
|
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
|