xref: /third_party/gn/src/base/values.cc

29 static_assert(std::size(kTypeNames) ==
33 std::unique_ptr<Value> CopyWithoutEmptyChildren(const Value& node);
38 std::unique_ptr<Value> CopyListWithoutEmptyChildren(const Value& list) {
41     std::unique_ptr<Value> child_copy = CopyWithoutEmptyChildren(entry);
43       copy.GetList().push_back(std::move(*child_copy));
46                                 : std::make_unique<Value>(std::move(copy));
49 std::unique_ptr<DictionaryValue> CopyDictionaryWithoutEmptyChildren(
51   std::unique_ptr<DictionaryValue> copy;
53     std::unique_ptr<Value> child_copy = CopyWithoutEmptyChildren(it.value());
56         copy = std::make_unique<DictionaryValue>();
57       copy->SetWithoutPathExpansion(it.key(), std::move(child_copy));
63 std::unique_ptr<Value> CopyWithoutEmptyChildren(const Value& node) {
73       return std::make_unique<Value>(node.Clone());
80 std::unique_ptr<Value> Value::CreateWithCopiedBuffer(const char* buffer,
82   return std::make_unique<Value>(BlobStorage(buffer, buffer + size));
86 Value Value::FromUniquePtrValue(std::unique_ptr<Value> val) {
87   return std::move(*val);
91 std::unique_ptr<Value> Value::ToUniquePtrValue(Value val) {
92   return std::make_unique<Value>(std::move(val));
96   InternalMoveConstructFrom(std::move(that));
114       new (&string_value_) std::string();
132 Value::Value(const char* in_string) : Value(std::string(in_string)) {}
134 Value::Value(std::string_view in_string) : Value(std::string(in_string)) {}
136 Value::Value(std::string&& in_string) noexcept
137     : type_(Type::STRING), string_value_(std::move(in_string)) {
142     : Value(std::u16string_view(in_string16)) {}
144 Value::Value(std::u16string_view in_string16)
151     : type_(Type::BINARY), binary_value_(std::move(in_blob)) {}
157                       std::make_unique<Value>(it.second->Clone()));
162     : type_(Type::DICTIONARY), dict_(std::move(in_dict)) {}
171     : type_(Type::LIST), list_(std::move(in_list)) {}
175   InternalMoveConstructFrom(std::move(that));
209   DCHECK_LT(static_cast<size_t>(type), std::size(kTypeNames));
223 const std::string& Value::GetString() const {
243 Value* Value::FindKey(std::string_view key) {
247 const Value* Value::FindKey(std::string_view key) const {
255 Value* Value::FindKeyOfType(std::string_view key, Type type) {
260 const Value* Value::FindKeyOfType(std::string_view key, Type type) const {
267 bool Value::RemoveKey(std::string_view key) {
273 Value* Value::SetKey(std::string_view key, Value value) {
276   // an explicit conversion from std::string_view to std::string if necessary.
277   auto val_ptr = std::make_unique<Value>(std::move(value));
278   auto result = dict_.try_emplace(key, std::move(val_ptr));
281     result.first->second = std::move(val_ptr);
286 Value* Value::SetKey(std::string&& key, Value value) {
289       .insert_or_assign(std::move(key),
290                         std::make_unique<Value>(std::move(value)))
295   return SetKey(std::string_view(key), std::move(value));
298 Value* Value::FindPath(std::initializer_list<std::string_view> path) {
302 Value* Value::FindPath(span<const std::string_view> path) {
307     std::initializer_list<std::string_view> path) const {
312 const Value* Value::FindPath(span<const std::string_view> path) const {
314   for (const std::string_view& component : path) {
321 Value* Value::FindPathOfType(std::initializer_list<std::string_view> path,
327 Value* Value::FindPathOfType(span<const std::string_view> path, Type type) {
332 const Value* Value::FindPathOfType(std::initializer_list<std::string_view> path,
338 const Value* Value::FindPathOfType(span<const std::string_view> path,
346 Value* Value::SetPath(std::initializer_list<std::string_view> path,
349   return SetPath(make_span(path.begin(), path.size()), std::move(value));
352 Value* Value::SetPath(span<const std::string_view> path, Value value) {
358   const std::string_view* cur_path = path.begin();
364     const std::string_view path_component = *cur_path;
369           found, path_component, std::make_unique<Value>(Type::DICTIONARY));
379   return cur->SetKey(*cur_path, std::move(value));
382 bool Value::RemovePath(std::initializer_list<std::string_view> path) {
387 bool Value::RemovePath(span<const std::string_view> path) {
441 bool Value::GetAsString(std::string* out_value) const {
449 bool Value::GetAsString(std::u16string* out_value) const {
465 bool Value::GetAsString(std::string_view* out_value) const {
509 std::unique_ptr<Value> Value::CreateDeepCopy() const {
510   return std::make_unique<Value>(Clone());
533       return std::equal(
534           std::begin(lhs.dict_), std::end(lhs.dict_), std::begin(rhs.dict_),
536             return std::tie(u.first, *u.second) == std::tie(v.first, *v.second);
568       return std::lexicographical_compare(
569           std::begin(lhs.dict_), std::end(lhs.dict_), std::begin(rhs.dict_),
570           std::end(rhs.dict_),
573             return std::tie(u.first, *u.second) < std::tie(v.first, *v.second);
613       new (&string_value_) std::string(std::move(that.string_value_));
616       new (&binary_value_) BlobStorage(std::move(that.binary_value_));
619       new (&dict_) DictStorage(std::move(that.dict_));
622       new (&list_) ListStorage(std::move(that.list_));
653 std::unique_ptr<DictionaryValue> DictionaryValue::From(
654     std::unique_ptr<Value> value) {
666     : Value(std::move(in_dict)) {}
668 bool DictionaryValue::HasKey(std::string_view key) const {
679 Value* DictionaryValue::Set(std::string_view path,
680                             std::unique_ptr<Value> in_value) {
684   std::string_view current_path(path);
687        delimiter_position != std::string_view::npos;
690     std::string_view key = current_path.substr(0, delimiter_position);
703       ->SetWithoutPathExpansion(current_path, std::move(in_value));
706 Value* DictionaryValue::SetBoolean(std::string_view path, bool in_value) {
707   return Set(path, std::make_unique<Value>(in_value));
710 Value* DictionaryValue::SetInteger(std::string_view path, int in_value) {
711   return Set(path, std::make_unique<Value>(in_value));
714 Value* DictionaryValue::SetString(std::string_view path,
715                                   std::string_view in_value) {
716   return Set(path, std::make_unique<Value>(in_value));
719 Value* DictionaryValue::SetString(std::string_view path,
720                                   const std::u16string& in_value) {
721   return Set(path, std::make_unique<Value>(in_value));
725     std::string_view path,
726     std::unique_ptr<DictionaryValue> in_value) {
727   return static_cast<DictionaryValue*>(Set(path, std::move(in_value)));
730 ListValue* DictionaryValue::SetList(std::string_view path,
731                                     std::unique_ptr<ListValue> in_value) {
732   return static_cast<ListValue*>(Set(path, std::move(in_value)));
736     std::string_view key,
737     std::unique_ptr<Value> in_value) {
739   // an explicit conversion from std::string_view to std::string if necessary.
740   auto result = dict_.try_emplace(key, std::move(in_value));
743     result.first->second = std::move(in_value);
748 bool DictionaryValue::Get(std::string_view path,
751   std::string_view current_path(path);
754        delimiter_position != std::string::npos;
769 bool DictionaryValue::Get(std::string_view path, Value** out_value) {
774 bool DictionaryValue::GetBoolean(std::string_view path,
783 bool DictionaryValue::GetInteger(std::string_view path, int* out_value) const {
791 bool DictionaryValue::GetString(std::string_view path,
792                                 std::string* out_value) const {
800 bool DictionaryValue::GetString(std::string_view path,
801                                 std::u16string* out_value) const {
809 bool DictionaryValue::GetStringASCII(std::string_view path,
810                                      std::string* out_value) const {
811   std::string out;
824 bool DictionaryValue::GetBinary(std::string_view path,
837 bool DictionaryValue::GetBinary(std::string_view path, Value** out_value) {
842 bool DictionaryValue::GetDictionary(std::string_view path,
855 bool DictionaryValue::GetDictionary(std::string_view path,
861 bool DictionaryValue::GetList(std::string_view path,
874 bool DictionaryValue::GetList(std::string_view path, ListValue** out_value) {
879 bool DictionaryValue::GetWithoutPathExpansion(std::string_view key,
891 bool DictionaryValue::GetWithoutPathExpansion(std::string_view key,
897 bool DictionaryValue::GetBooleanWithoutPathExpansion(std::string_view key,
906 bool DictionaryValue::GetIntegerWithoutPathExpansion(std::string_view key,
916     std::string_view key,
917     std::string* out_value) const {
926     std::string_view key,
927     std::u16string* out_value) const {
936     std::string_view key,
950     std::string_view key,
959     std::string_view key,
972 bool DictionaryValue::GetListWithoutPathExpansion(std::string_view key,
978 bool DictionaryValue::Remove(std::string_view path,
979                              std::unique_ptr<Value>* out_value) {
981   std::string_view current_path(path);
984   if (delimiter_position != std::string_view::npos) {
996     std::string_view key,
997     std::unique_ptr<Value>* out_value) {
1004     *out_value = std::move(entry_iterator->second);
1009 bool DictionaryValue::RemovePath(std::string_view path,
1010                                  std::unique_ptr<Value>* out_value) {
1014   if (delimiter_position == std::string::npos)
1017   std::string_view subdict_path = path.substr(0, delimiter_position);
1028 std::unique_ptr<DictionaryValue> DictionaryValue::DeepCopyWithoutEmptyChildren()
1030   std::unique_ptr<DictionaryValue> copy =
1033     copy = std::make_unique<DictionaryValue>();
1071 std::unique_ptr<DictionaryValue> DictionaryValue::CreateDeepCopy() const {
1072   return std::make_unique<DictionaryValue>(dict_);
1078 std::unique_ptr<ListValue> ListValue::From(std::unique_ptr<Value> value) {
1090     : Value(std::move(in_list)) {}
1100 bool ListValue::Set(size_t index, std::unique_ptr<Value> in_value) {
1107   list_[index] = std::move(*in_value);
1142 bool ListValue::GetString(size_t index, std::string* out_value) const {
1150 bool ListValue::GetString(size_t index, std::u16string* out_value) const {
1193 bool ListValue::Remove(size_t index, std::unique_ptr<Value>* out_value) {
1198     *out_value = std::make_unique<Value>(std::move(list_[index]));
1205   auto it = std::find(list_.begin(), list_.end(), value);
1211     *index = std::distance(list_.begin(), it);
1218                                      std::unique_ptr<Value>* out_value) {
1220     *out_value = std::make_unique<Value>(std::move(*iter));
1225 void ListValue::Append(std::unique_ptr<Value> in_value) {
1226   list_.push_back(std::move(*in_value));
1237 void ListValue::AppendString(std::string_view in_value) {
1241 void ListValue::AppendString(const std::u16string& in_value) {
1245 void ListValue::AppendStrings(const std::vector<std::string>& in_values) {
1251 void ListValue::AppendStrings(const std::vector<std::u16string>& in_values) {
1257 bool ListValue::AppendIfNotPresent(std::unique_ptr<Value> in_value) {
1262   list_.push_back(std::move(*in_value));
1266 bool ListValue::Insert(size_t index, std::unique_ptr<Value> in_value) {
1271   list_.insert(list_.begin() + index, std::move(*in_value));
1276   return std::find(list_.begin(), list_.end(), value);
1288 std::unique_ptr<ListValue> ListValue::CreateDeepCopy() const {
1289   return std::make_unique<ListValue>(list_);
1296 std::ostream& operator<<(std::ostream& out, const Value& value) {
1297   std::string json;
1302 std::ostream& operator<<(std::ostream& out, const Value::Type& type) {
1304       static_cast<size_t>(type) >= std::size(kTypeNames))

Indexes created Thu Nov 07 10:32:03 CST 2024