base_json&&value-Aet

Bingliaolong 2021-05-19 13:33 Aet | 隐藏边栏 | 抢沙发 | 2 0

文章评分 1 次，平均分 5.0 ：

json_writer

Write

写json文件。

static bool Write(const Value& node,

std::string* json,

size_t max_depth = internal::kAbsoluteMaxDepth);

WriteWithOptions

功能和上面的Write一样，都是写json文件。
不同的是，这个是带选项的，选项含义如下。

static bool WriteWithOptions(const Value& node,

int options,

std::string* json,

size_t max_depth = internal::kAbsoluteMaxDepth);

选项

此选项指示编写者，如果遇到二进制值，值（如果在字典中，则为键）将被从中省略输出，并将返回成功。否则，如果二进制值是遇到失败将被退回。
此选项指示作者编写没有小数的双打部分作为普通整数（即，不使用指数表示法）或附加“ .0”），只要该值在64位int。
返回格式更好的json字符串（带有空格的pads到帮助提高可读性）。

enum Options {

OPTIONS_OMIT_BINARY_VALUES = 1 << 0,

OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION = 1 << 1,

OPTIONS_PRETTY_PRINT = 1 << 2,

};

用法

base::DictionaryValue dict;

dict.SetInteger("last_pop_time", 1);

dict.SetInteger("time_interval", 2);

dict.SetInteger("cur_popup_count", 3);

std::string content;

base::JSONWriter::Write(dict, &content);

json_reader

Read

读取传入的json字符串并解析，返回一个Value。
如果传入的json字符串不是一个合格的json字符串格式，返回base::nullopt。

static Optional<Value> Read(StringPiece json,

int options = JSON_PARSE_RFC,

size_t max_depth = internal::kAbsoluteMaxDepth);

ReadDeprecated

static std::unique_ptr<Value> ReadDeprecated(

StringPiece json,

int options = JSON_PARSE_RFC,

size_t max_depth = internal::kAbsoluteMaxDepth);

解析选项

严格按照RFC 4627解析输入，除非另有说明
允许逗号存在于结构中的最后一个元素之后。
如果设置了解析器，则将无效字符替换为Unicode替换字符（U + FFFD）。如果未设置，则无效字符会触发硬错误，并且解析失败。

enum JSONParserOptions {

JSON_PARSE_RFC = 0,

JSON_ALLOW_TRAILING_COMMAS = 1 << 0,

JSON_REPLACE_INVALID_CHARACTERS = 1 << 1,

};

用法

std::string content;

const size_t max_size = 1 * 1024 * 1024;

{

//base::ScopedAllowBlockingForTesting scoped_io;

if (!base::ReadFileToStringWithMaxSize(path, &content, max_size) || content.

empty()) {

return data;

}

base::Optional<base::Value> root = base::JSONReader::Read(content);

if (!root.has_value() || !root->is_dict()) {

return data;

}

Value

构造

Value(Value&& that) noexcept;

Value() noexcept {} // A null value

Value Clone() const;

explicit Value(Type type);

explicit Value(bool in_bool);

explicit Value(int in_int);

explicit Value(double in_double);

explicit Value(const char* in_string);

explicit Value(StringPiece in_string);

explicit Value(std::string&& in_string) noexcept;

explicit Value(const char16* in_string16);

explicit Value(StringPiece16 in_string16);

explicit Value(const std::vector<char>& in_blob);

explicit Value(base::span<const uint8_t> in_blob);

explicit Value(BlobStorage&& in_blob) noexcept;

explicit Value(const DictStorage& in_dict);

explicit Value(DictStorage&& in_dict) noexcept;

explicit Value(span<const Value> in_list);

explicit Value(ListStorage&& in_list) noexcept;

Type

类型

enum class Type : unsigned char {

NONE = 0,

BOOLEAN,

INTEGER,

DOUBLE,

STRING,

BINARY,

DICTIONARY,

LIST,

// TODO(crbug.com/859477): Remove once root cause is found.

DEAD

// Note: Do not add more types. See the file-level comment above for why.

};

static const char* GetTypeName(Type type);

判断类型的方法

bool is_none() const { return type() == Type::NONE; }

bool is_bool() const { return type() == Type::BOOLEAN; }

bool is_int() const { return type() == Type::INTEGER; }

bool is_double() const { return type() == Type::DOUBLE; }

bool is_string() const { return type() == Type::STRING; }

bool is_blob() const { return type() == Type::BINARY; }

bool is_dict() const { return type() == Type::DICTIONARY; }

bool is_list() const { return type() == Type::LIST; }

按类型获取

bool GetBool() const;

int GetInt() const;

double GetDouble() const; // Implicitly converts from int if necessary.

const std::string& GetString() const;

std::string& GetString();

const BlobStorage& GetBlob() const;

ListStorage& GetList();

span<const Value> GetList() const;

// 将基础列表的所有权转移给调用方。随后的

// 调用GetList（）将返回一个空列表。

// 注意：这检查type（）是否为Type :: LIST。

ListStorage TakeList();

按类型添加元素

void Append(bool value);

void Append(int value);

void Append(double value);

void Append(const char* value);

void Append(StringPiece value);

void Append(std::string&& value);

void Append(const char16* value);

void Append(StringPiece16 value);

void Append(Value&& value);

操作

去掉list里面iter指向的某个元素

1 2	bool EraseListIter(ListStorage::const_iterator iter); bool EraseListIter(CheckedContiguousConstIterator<Value> iter);

去掉list里面所有值与val相等的元素，返回清掉元素的数量

1	size_t EraseListValue(const Value& val);

去掉list里面满足删除条件的元素，返回清掉元素的数量

template <typename Predicate>

size_t EraseListValueIf(Predicate pred) {

CHECK(is_list());

const size_t old_size = list_.size();

base::EraseIf(list_, pred);

return old_size - list_.size();

}

根据key在dictionary里面查找

1 2	Value* FindKey(StringPiece key); const Value* FindKey(StringPiece key) const;

// 带类型查找

Value* FindKeyOfType(StringPiece key, Type type);

const Value* FindKeyOfType(StringPiece key, Type type) const;

// eg.

//auto* found = FindKey("foo", Type::DOUBLE);

base::Optional<bool> FindBoolKey(StringPiece key) const;

base::Optional<int> FindIntKey(StringPiece key) const;

// Note FindDoubleKey() will auto-convert INTEGER keys to their double

// value, for consistency with GetDouble().

base::Optional<double> FindDoubleKey(StringPiece key) const;

// |FindStringKey| returns |nullptr| if value is not found or not a string.

const std::string* FindStringKey(StringPiece key) const;

std::string* FindStringKey(StringPiece key);

// Returns nullptr is value is not found or not a binary.

const BlobStorage* FindBlobKey(StringPiece key) const;

// Returns nullptr if value is not found or not a dictionary.

const Value* FindDictKey(StringPiece key) const;

Value* FindDictKey(StringPiece key);

// Returns nullptr if value is not found or not a list.

const Value* FindListKey(StringPiece key) const;

Value* FindListKey(StringPiece key);

根据键值在dictionary里面添加值

Value* SetKey(StringPiece key, Value&& value);

Value* SetKey(std::string&& key, Value&& value);

Value* SetKey(const char* key, Value&& value);

Value* SetBoolKey(StringPiece key, bool val);

Value* SetIntKey(StringPiece key, int val);

Value* SetDoubleKey(StringPiece key, double val);

Value* SetStringKey(StringPiece key, StringPiece val);

// NOTE: These two overloads are provided as performance / code generation

// optimizations.

Value* SetStringKey(StringPiece key, const char* val);

Value* SetStringKey(StringPiece key, std::string&& val);

Value* SetStringKey(StringPiece key, StringPiece16 val);

移除key，如果key存在，删除key，返回true。如果key不存在，不会改变dictionary，返回false。

1	bool RemoveKey(StringPiece key);

移除key，如果key存在，删除key，返回key对应的值。如果key不存在，不会改变dictionary，返回nullopt。

1	Optional<Value> ExtractKey(StringPiece key);

根据dictionary路径获取value。路径存在，返回对应的值，否则返回nullptr。

1 2	Value* FindPath(StringPiece path); const Value* FindPath(StringPiece path) const;

Value* FindPath(std::initializer_list<StringPiece> path);

Value* FindPath(span<const StringPiece> path);

const Value* FindPath(std::initializer_list<StringPiece> path) const;

const Value* FindPath(span<const StringPiece> path) const;

1 2	Value* FindPathOfType(StringPiece path, Type type); const Value* FindPathOfType(StringPiece path, Type type) const;

base::Optional<bool> FindBoolPath(StringPiece path) const;

base::Optional<int> FindIntPath(StringPiece path) const;

base::Optional<double> FindDoublePath(StringPiece path) const;

const std::string* FindStringPath(StringPiece path) const;

std::string* FindStringPath(StringPiece path);

const BlobStorage* FindBlobPath(StringPiece path) const;

Value* FindDictPath(StringPiece path);

const Value* FindDictPath(StringPiece path) const;

Value* FindListPath(StringPiece path);

const Value* FindListPath(StringPiece path) const;

Value* FindPathOfType(std::initializer_list<StringPiece> path, Type type);

Value* FindPathOfType(span<const StringPiece> path, Type type);

const Value* FindPathOfType(std::initializer_list<StringPiece> path,

Type type) const;

const Value* FindPathOfType(span<const StringPiece> path, Type type) const;

根据dictionary路径设置value。如果当前值不是dictionary，返回nullptr。如果路径不存在，创建路径。如果路径存在，并且最后一个匹配的值不是dictionary，将返回nullptr（不会覆盖该值）。如果路径存在，并且是dictionary，将无条件覆盖对应的值。

1	Value* SetPath(StringPiece path, Value&& value);

Value* SetBoolPath(StringPiece path, bool value);

Value* SetIntPath(StringPiece path, int value);

Value* SetDoublePath(StringPiece path, double value);

Value* SetStringPath(StringPiece path, StringPiece value);

Value* SetStringPath(StringPiece path, const char* value);

Value* SetStringPath(StringPiece path, std::string&& value);

Value* SetStringPath(StringPiece path, StringPiece16 value);

// Deprecated: use the ones that take a StringPiece path parameter instead.

Value* SetPath(std::initializer_list<StringPiece> path, Value&& value);

Value* SetPath(span<const StringPiece> path, Value&& value);

移除路径

bool RemovePath(StringPiece path);

// Deprecated versions

bool RemovePath(std::initializer_list<StringPiece> path);

bool RemovePath(span<const StringPiece> path);

1	Optional<Value> ExtractPath(StringPiece path);

item

1 2	dict_iterator_proxy DictItems(); const_dict_iterator_proxy DictItems() const;

size

1 2	size_t DictSize() const; bool DictEmpty() const;

合并dictionary

1	void MergeDictionary(const Value* dictionary);

转换函数

bool GetAsBoolean(bool* out_value) const;

// DEPRECATED, use GetInt() instead.

bool GetAsInteger(int* out_value) const;

// DEPRECATED, use GetDouble() instead.

bool GetAsDouble(double* out_value) const;

// DEPRECATED, use GetString() instead.

bool GetAsString(std::string* out_value) const;

bool GetAsString(string16* out_value) const;

bool GetAsString(const Value** out_value) const;

bool GetAsString(StringPiece* out_value) const;

// ListValue::From is the equivalent for std::unique_ptr conversions.

// DEPRECATED, use GetList() instead.

bool GetAsList(ListValue** out_value);

bool GetAsList(const ListValue** out_value) const;

// DictionaryValue::From is the equivalent for std::unique_ptr conversions.

bool GetAsDictionary(DictionaryValue** out_value);

bool GetAsDictionary(const DictionaryValue** out_value) const;

"深拷贝"dictionary树

// 这将创建整个“值”树的深层副本，并返回一个指针到副本。

// 当然，调用者将获得副本的所有权。

// 子类直接在其覆盖中返回自己的类型；之所以可行，是因为C ++支持协变返回类型。

// 已弃用，请改用Value :: Clone（）。

Value* DeepCopy() cosnt;

std::unique_ptr<Value> CreateDeepCopy() const;

DictionaryValue

构造

// Returns |value| if it is a dictionary, nullptr otherwise.

static std::unique_ptr<DictionaryValue> From(std::unique_ptr<Value> value);

DictionaryValue();

explicit DictionaryValue(const DictStorage& in_dict);

explicit DictionaryValue(DictStorage&& in_dict) noexcept;

方法

判断

// Returns true if the current dictionary has a value for the given key.

// DEPRECATED, use Value::FindKey(key) instead.

bool HasKey(StringPiece key) const;

// Returns the number of Values in this dictionary.

size_t size() const { return dict_.size(); }

// Returns whether the dictionary is empty.

bool empty() const { return dict_.empty(); }

清除

1 2	// Clears any current contents of this dictionary. void Clear();

设置值

Value* Set(StringPiece path, std::unique_ptr<Value> in_value);

// Convenience forms of Set(). These methods will replace any existing

// value at that path, even if it has a different type.

// DEPRECATED, use Value::SetBoolKey() or Value::SetBoolPath().

Value* SetBoolean(StringPiece path, bool in_value);

// DEPRECATED, use Value::SetIntPath().

Value* SetInteger(StringPiece path, int in_value);

// DEPRECATED, use Value::SetDoublePath().

Value* SetDouble(StringPiece path, double in_value);

// DEPRECATED, use Value::SetStringPath().

Value* SetString(StringPiece path, StringPiece in_value);

// DEPRECATED, use Value::SetStringPath().

Value* SetString(StringPiece path, const string16& in_value);

// DEPRECATED, use Value::SetPath() or Value::SetDictPath()

DictionaryValue* SetDictionary(StringPiece path,

std::unique_ptr<DictionaryValue> in_value);

// DEPRECATED, use Value::SetPath() or Value::SetListPath()

ListValue* SetList(StringPiece path, std::unique_ptr<ListValue> in_value);

// Like Set(), but without special treatment of '.'. This allows e.g. URLs to

// be used as paths.

// 已弃用, use Value::SetKey(key, value) instead.

Value* SetWithoutPathExpansion(StringPiece key,

std::unique_ptr<Value> in_value);

获取值：用FindPath代替

bool Get(StringPiece path, const Value** out_value) const;

// 已弃用, use Value::FindPath(path) instead.

bool Get(StringPiece path, Value** out_value);

bool GetBoolean(StringPiece path, bool* out_value) const;

// 已弃用, use Value::FindIntPath(path) isntead.

bool GetInteger(StringPiece path, int* out_value) const;

// Values of both type Type::INTEGER and Type::DOUBLE can be obtained as

// doubles.

// DEPRECATED, use Value::FindDoublePath(path).

bool GetDouble(StringPiece path, double* out_value) const;

// DEPRECATED, use Value::FindStringPath(path) instead.

bool GetString(StringPiece path, std::string* out_value) const;

// DEPRECATED, use Value::FindStringPath(path) instead.

bool GetString(StringPiece path, string16* out_value) const;

// DEPRECATED, use Value::FindString(path) and IsAsciiString() instead.

bool GetStringASCII(StringPiece path, std::string* out_value) const;

// DEPRECATED, use Value::FindBlobPath(path) instead.

bool GetBinary(StringPiece path, const Value** out_value) const;

// DEPRECATED, use Value::FindBlobPath(path) instead.

bool GetBinary(StringPiece path, Value** out_value);

// DEPRECATED, use Value::FindPath(path) and Value's Dictionary API instead.

bool GetDictionary(StringPiece path,

const DictionaryValue** out_value) const;

// DEPRECATED, use Value::FindPath(path) and Value's Dictionary API instead.

bool GetDictionary(StringPiece path, DictionaryValue** out_value);

// DEPRECATED, use Value::FindPath(path) and Value::GetList() instead.

bool GetList(StringPiece path, const ListValue** out_value) const;

// DEPRECATED, use Value::FindPath(path) and Value::GetList() instead.

bool GetList(StringPiece path, ListValue** out_value);

bool GetWithoutPathExpansion(StringPiece key, const Value** out_value) const;

// DEPRECATED, use Value::FindKey(key) instead.

bool GetWithoutPathExpansion(StringPiece key, Value** out_value);

// DEPRECATED, use Value::FindBoolKey(key) instead.

bool GetBooleanWithoutPathExpansion(StringPiece key, bool* out_value) const;

// DEPRECATED, use Value::FindIntKey(key) instead.

bool GetIntegerWithoutPathExpansion(StringPiece key, int* out_value) const;

// DEPRECATED, use Value::FindDoubleKey(key) instead.

bool GetDoubleWithoutPathExpansion(StringPiece key, double* out_value) const;

// DEPRECATED, use Value::FindStringKey(key) instead.

bool GetStringWithoutPathExpansion(StringPiece key,

std::string* out_value) const;

// DEPRECATED, use Value::FindStringKey(key) and UTF8ToUTF16() instead.

bool GetStringWithoutPathExpansion(StringPiece key,

string16* out_value) const;

// DEPRECATED, use Value::FindDictKey(key) instead.

bool GetDictionaryWithoutPathExpansion(

StringPiece key,

const DictionaryValue** out_value) const;

// DEPRECATED, use Value::FindDictKey(key) instead.

bool GetDictionaryWithoutPathExpansion(StringPiece key,

DictionaryValue** out_value);

// DEPRECATED, use Value::FindListKey(key) instead.

bool GetListWithoutPathExpansion(StringPiece key,

const ListValue** out_value) const;

// DEPRECATED, use Value::FindListKey(key) instead.

bool GetListWithoutPathExpansion(StringPiece key, ListValue** out_value);

bool Remove(StringPiece path, std::unique_ptr<Value>* out_value);

// Like Remove(), but without special treatment of '.'. This allows e.g. URLs

// to be used as paths.

// DEPRECATED, use Value::RemoveKey(key) or Value::ExtractKey(key) instead.

bool RemoveWithoutPathExpansion(StringPiece key,

std::unique_ptr<Value>* out_value);

// Removes a path, clearing out all dictionaries on |path| that remain empty

// after removing the value at |path|.

// DEPRECATED, use Value::RemovePath(path) or Value::ExtractPath(path)

// instead.

bool RemovePath(StringPiece path, std::unique_ptr<Value>* out_value);

ListValue

构造

static std::unique_ptr<ListValue> From(std::unique_ptr<Value> value);

ListValue();

explicit ListValue(span<const Value> in_list);

explicit ListValue(ListStorage&& in_list) noexcept;

方法

// 替代使用

// DEPRECATED, use GetList()::clear() instead.

void Clear();

// Returns the number of Values in this list.

// DEPRECATED, use GetList()::size() instead.

size_t GetSize() const { return list_.size(); }

// Returns whether the list is empty.

// DEPRECATED, use GetList()::empty() instead.

bool empty() const { return list_.empty(); }

// Reserves storage for at least |n| values.

// DEPRECATED, use GetList()::reserve() instead.

void Reserve(size_t n);

// DEPRECATED, use GetList()::operator[] instead.

bool Set(size_t index, std::unique_ptr<Value> in_value);

// DEPRECATED, use GetList()::operator[] instead.

bool Get(size_t index, const Value** out_value) const;

bool Get(size_t index, Value** out_value);

// 替代使用

// DEPRECATED, use GetList()::operator[]::GetBool() instead.

bool GetBoolean(size_t index, bool* out_value) const;

// DEPRECATED, use GetList()::operator[]::GetInt() instead.

bool GetInteger(size_t index, int* out_value) const;

// Values of both type Type::INTEGER and Type::DOUBLE can be obtained as

// doubles.

// DEPRECATED, use GetList()::operator[]::GetDouble() instead.

bool GetDouble(size_t index, double* out_value) const;

// DEPRECATED, use GetList()::operator[]::GetString() instead.

bool GetString(size_t index, std::string* out_value) const;

bool GetString(size_t index, string16* out_value) const;

bool GetDictionary(size_t index, const DictionaryValue** out_value) const;

bool GetDictionary(size_t index, DictionaryValue** out_value);

using Value::GetList;

// DEPRECATED, use GetList()::operator[]::GetList() instead.

bool GetList(size_t index, const ListValue** out_value) const;

bool GetList(size_t index, ListValue** out_value);

// DEPRECATED, use GetList()::erase() instead.

bool Remove(size_t index, std::unique_ptr<Value>* out_value);

// DEPRECATED, use GetList()::erase() instead.

bool Remove(const Value& value, size_t* index);

// DEPRECATED, use Value::Append() instead.

void Append(std::unique_ptr<Value> in_value);

// Convenience forms of Append.

// DEPRECATED, use Value::Append() instead.

void AppendBoolean(bool in_value);

void AppendInteger(int in_value);

void AppendDouble(double in_value);

void AppendString(StringPiece in_value);

void AppendString(const string16& in_value);

// DEPRECATED, use Value::Append() in a loop instead.

void AppendStrings(const std::vector<std::string>& in_values);

void AppendStrings(const std::vector<string16>& in_values);

// Appends a Value if it's not already present. Returns true if successful,

// or false if the value was already

// DEPRECATED, use std::find() with Value::Append() instead.

bool AppendIfNotPresent(std::unique_ptr<Value> in_value);

// DEPRECATED, use GetList()::insert() instead.

bool Insert(size_t index, std::unique_ptr<Value> in_value);

// DEPRECATED, use std::find() instead.

const_iterator Find(const Value& value) const;

// DEPRECATED, use GetList()::swap() instead.

void Swap(ListValue* other);

// DEPRECATED, use GetList()::begin() instead.

iterator begin() { return list_.begin(); }

// DEPRECATED, use GetList()::end() instead.

iterator end() { return list_.end(); }

// DEPRECATED, use GetList()::begin() instead.

const_iterator begin() const { return list_.begin(); }

// DEPRECATED, use GetList()::end() instead.

const_iterator end() const { return list_.end(); }

// DEPRECATED, use Value::Clone() instead.

// TODO(crbug.com/646113): Delete this and migrate callsites.

ListValue* DeepCopy() const;

// DEPRECATED, use Value::Clone() instead.

// TODO(crbug.com/646113): Delete this and migrate callsites.

std::unique_ptr<ListValue> CreateDeepCopy() const;

转换

static Value FromUniquePtrValue(std::unique_ptr<Value> val);

static std::unique_ptr<Value> ToUniquePtrValue(Value val);

static const DictionaryValue& AsDictionaryValue(const Value& val);

static const ListValue& AsListValue(const Value& val);

json_writer
Write
WriteWithOptions
选项
用法
json_reader
Read
ReadDeprecated
解析选项
用法
Value
构造
Type
操作
DictionaryValue
构造
方法
ListValue
构造
方法
转换

本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！

Bingliaolong 关注：0 粉丝：0 最后编辑于：2021-11-20

Everything will be better.

一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31

json_writer

Write

WriteWithOptions

选项

用法

json_reader

Read

ReadDeprecated

解析选项

用法

Value

构造

Type

操作

DictionaryValue

构造

方法

ListValue

构造

方法

转换

你可能也喜欢

热评文章

发表评论

标签云集