seedlingattempt/godot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement typed dictionaries

Browse Source
This commit is contained in:
Thaddeus Crews
2023-06-24 13:03:28 -05:00
parent 906a4e9db9
commit 9853a69144
86 changed files with 3071 additions and 193 deletions
Download Patch File Download Diff File Expand all files Collapse all files

276
core/variant/dictionary.cpp
View File

@ -32,6 +32,7 @@
#include "core/templates/hash_map.h"
#include "core/templates/safe_refcount.h"
#include "core/variant/container_type_validate.h"
#include "core/variant/variant.h"
// required in this order by VariantInternal, do not remove this comment.
#include "core/object/class_db.h"
@ -43,6 +44,9 @@ struct DictionaryPrivate {
SafeRefCount refcount;
Variant *read_only = nullptr; // If enabled, a pointer is used to a temporary value that is used to return read-only values.
HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator> variant_map;
ContainerTypeValidate typed_key;
ContainerTypeValidate typed_value;
Variant *typed_fallback = nullptr; // Allows a typed dictionary to return dummy values when attempting an invalid access.
};
void Dictionary::get_key_list(List<Variant> *p_keys) const {
@ -120,7 +124,9 @@ Variant *Dictionary::getptr(const Variant &p_key) {
}
Variant Dictionary::get_valid(const Variant &p_key) const {
HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::ConstIterator E(_p->variant_map.find(p_key));
Variant key = p_key;
ERR_FAIL_COND_V(!_p->typed_key.validate(key, "get_valid"), Variant());
HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::ConstIterator E(_p->variant_map.find(key));
if (!E) {
return Variant();
@ -129,7 +135,9 @@ Variant Dictionary::get_valid(const Variant &p_key) const {
}
Variant Dictionary::get(const Variant &p_key, const Variant &p_default) const {
const Variant *result = getptr(p_key);
Variant key = p_key;
ERR_FAIL_COND_V(!_p->typed_key.validate(key, "get"), p_default);
const Variant *result = getptr(key);
if (!result) {
return p_default;
}
@ -138,10 +146,14 @@ Variant Dictionary::get(const Variant &p_key, const Variant &p_default) const {
}
Variant Dictionary::get_or_add(const Variant &p_key, const Variant &p_default) {
const Variant *result = getptr(p_key);
Variant key = p_key;
ERR_FAIL_COND_V(!_p->typed_key.validate(key, "get"), p_default);
const Variant *result = getptr(key);
if (!result) {
operator[](p_key) = p_default;
return p_default;
Variant value = p_default;
ERR_FAIL_COND_V(!_p->typed_value.validate(value, "add"), value);
operator[](key) = value;
return value;
}
return *result;
}
@ -155,12 +167,16 @@ bool Dictionary::is_empty() const {
}
bool Dictionary::has(const Variant &p_key) const {
Variant key = p_key;
ERR_FAIL_COND_V(!_p->typed_key.validate(key, "use 'has'"), false);
return _p->variant_map.has(p_key);
}
bool Dictionary::has_all(const Array &p_keys) const {
for (int i = 0; i < p_keys.size(); i++) {
if (!has(p_keys[i])) {
Variant key = p_keys[i];
ERR_FAIL_COND_V(!_p->typed_key.validate(key, "use 'has_all'"), false);
if (!has(key)) {
return false;
}
}
@ -168,8 +184,10 @@ bool Dictionary::has_all(const Array &p_keys) const {
}
Variant Dictionary::find_key(const Variant &p_value) const {
Variant value = p_value;
ERR_FAIL_COND_V(!_p->typed_value.validate(value, "find_key"), Variant());
for (const KeyValue<Variant, Variant> &E : _p->variant_map) {
if (E.value == p_value) {
if (E.value == value) {
return E.key;
}
}
@ -177,8 +195,10 @@ Variant Dictionary::find_key(const Variant &p_value) const {
}
bool Dictionary::erase(const Variant &p_key) {
Variant key = p_key;
ERR_FAIL_COND_V(!_p->typed_key.validate(key, "erase"), false);
ERR_FAIL_COND_V_MSG(_p->read_only, false, "Dictionary is in read-only state.");
return _p->variant_map.erase(p_key);
return _p->variant_map.erase(key);
}
bool Dictionary::operator==(const Dictionary &p_dictionary) const {
@ -238,8 +258,12 @@ void Dictionary::clear() {
void Dictionary::merge(const Dictionary &p_dictionary, bool p_overwrite) {
ERR_FAIL_COND_MSG(_p->read_only, "Dictionary is in read-only state.");
for (const KeyValue<Variant, Variant> &E : p_dictionary._p->variant_map) {
if (p_overwrite || !has(E.key)) {
operator[](E.key) = E.value;
Variant key = E.key;
Variant value = E.value;
ERR_FAIL_COND(!_p->typed_key.validate(key, "merge"));
ERR_FAIL_COND(!_p->typed_key.validate(value, "merge"));
if (p_overwrite || !has(key)) {
operator[](key) = value;
}
}
}
@ -256,6 +280,9 @@ void Dictionary::_unref() const {
if (_p->read_only) {
memdelete(_p->read_only);
}
if (_p->typed_fallback) {
memdelete(_p->typed_fallback);
}
memdelete(_p);
}
_p = nullptr;
@ -284,6 +311,9 @@ uint32_t Dictionary::recursive_hash(int recursion_count) const {
Array Dictionary::keys() const {
Array varr;
if (is_typed_key()) {
varr.set_typed(get_typed_key_builtin(), get_typed_key_class_name(), get_typed_key_script());
}
if (_p->variant_map.is_empty()) {
return varr;
}
@ -301,6 +331,9 @@ Array Dictionary::keys() const {
Array Dictionary::values() const {
Array varr;
if (is_typed_value()) {
varr.set_typed(get_typed_value_builtin(), get_typed_value_class_name(), get_typed_value_script());
}
if (_p->variant_map.is_empty()) {
return varr;
}
@ -316,6 +349,146 @@ Array Dictionary::values() const {
return varr;
}
void Dictionary::assign(const Dictionary &p_dictionary) {
const ContainerTypeValidate &typed_key = _p->typed_key;
const ContainerTypeValidate &typed_key_source = p_dictionary._p->typed_key;
const ContainerTypeValidate &typed_value = _p->typed_value;
const ContainerTypeValidate &typed_value_source = p_dictionary._p->typed_value;
if ((typed_key == typed_key_source || typed_key.type == Variant::NIL || (typed_key_source.type == Variant::OBJECT && typed_key.can_reference(typed_key_source))) &&
(typed_value == typed_value_source || typed_value.type == Variant::NIL || (typed_value_source.type == Variant::OBJECT && typed_value.can_reference(typed_value_source)))) {
// From same to same or,
// from anything to variants or,
// from subclasses to base classes.
_p->variant_map = p_dictionary._p->variant_map;
return;
}
int size = p_dictionary._p->variant_map.size();
HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator> variant_map = HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>(size);
Vector<Variant> key_array;
key_array.resize(size);
Variant *key_data = key_array.ptrw();
Vector<Variant> value_array;
value_array.resize(size);
Variant *value_data = value_array.ptrw();
if (typed_key == typed_key_source || typed_key.type == Variant::NIL || (typed_key_source.type == Variant::OBJECT && typed_key.can_reference(typed_key_source))) {
// From same to same or,
// from anything to variants or,
// from subclasses to base classes.
int i = 0;
for (const KeyValue<Variant, Variant> &E : p_dictionary._p->variant_map) {
const Variant *key = &E.key;
key_data[i++] = *key;
}
} else if ((typed_key_source.type == Variant::NIL && typed_key.type == Variant::OBJECT) || (typed_key_source.type == Variant::OBJECT && typed_key_source.can_reference(typed_key))) {
// From variants to objects or,
// from base classes to subclasses.
int i = 0;
for (const KeyValue<Variant, Variant> &E : p_dictionary._p->variant_map) {
const Variant *key = &E.key;
if (key->get_type() != Variant::NIL && (key->get_type() != Variant::OBJECT || !typed_key.validate_object(*key, "assign"))) {
ERR_FAIL_MSG(vformat(R"(Unable to convert key from "%s" to "%s".)", Variant::get_type_name(key->get_type()), Variant::get_type_name(typed_key.type)));
}
key_data[i++] = *key;
}
} else if (typed_key.type == Variant::OBJECT || typed_key_source.type == Variant::OBJECT) {
ERR_FAIL_MSG(vformat(R"(Cannot assign contents of "Dictionary[%s, %s]" to "Dictionary[%s, %s]".)", Variant::get_type_name(typed_key_source.type), Variant::get_type_name(typed_value_source.type),
Variant::get_type_name(typed_key.type), Variant::get_type_name(typed_value.type)));
} else if (typed_key_source.type == Variant::NIL && typed_key.type != Variant::OBJECT) {
// From variants to primitives.
int i = 0;
for (const KeyValue<Variant, Variant> &E : p_dictionary._p->variant_map) {
const Variant *key = &E.key;
if (key->get_type() == typed_key.type) {
key_data[i++] = *key;
continue;
}
if (!Variant::can_convert_strict(key->get_type(), typed_key.type)) {
ERR_FAIL_MSG(vformat(R"(Unable to convert key from "%s" to "%s".)", Variant::get_type_name(key->get_type()), Variant::get_type_name(typed_key.type)));
}
Callable::CallError ce;
Variant::construct(typed_key.type, key_data[i++], &key, 1, ce);
ERR_FAIL_COND_MSG(ce.error, vformat(R"(Unable to convert key from "%s" to "%s".)", Variant::get_type_name(key->get_type()), Variant::get_type_name(typed_key.type)));
}
} else if (Variant::can_convert_strict(typed_key_source.type, typed_key.type)) {
// From primitives to different convertible primitives.
int i = 0;
for (const KeyValue<Variant, Variant> &E : p_dictionary._p->variant_map) {
const Variant *key = &E.key;
Callable::CallError ce;
Variant::construct(typed_key.type, key_data[i++], &key, 1, ce);
ERR_FAIL_COND_MSG(ce.error, vformat(R"(Unable to convert key from "%s" to "%s".)", Variant::get_type_name(key->get_type()), Variant::get_type_name(typed_key.type)));
}
} else {
ERR_FAIL_MSG(vformat(R"(Cannot assign contents of "Dictionary[%s, %s]" to "Dictionary[%s, %s].)", Variant::get_type_name(typed_key_source.type), Variant::get_type_name(typed_value_source.type),
Variant::get_type_name(typed_key.type), Variant::get_type_name(typed_value.type)));
}
if (typed_value == typed_value_source || typed_value.type == Variant::NIL || (typed_value_source.type == Variant::OBJECT && typed_value.can_reference(typed_value_source))) {
// From same to same or,
// from anything to variants or,
// from subclasses to base classes.
int i = 0;
for (const KeyValue<Variant, Variant> &E : p_dictionary._p->variant_map) {
const Variant *value = &E.value;
value_data[i++] = *value;
}
} else if (((typed_value_source.type == Variant::NIL && typed_value.type == Variant::OBJECT) || (typed_value_source.type == Variant::OBJECT && typed_value_source.can_reference(typed_value)))) {
// From variants to objects or,
// from base classes to subclasses.
int i = 0;
for (const KeyValue<Variant, Variant> &E : p_dictionary._p->variant_map) {
const Variant *value = &E.value;
if (value->get_type() != Variant::NIL && (value->get_type() != Variant::OBJECT || !typed_value.validate_object(*value, "assign"))) {
ERR_FAIL_MSG(vformat(R"(Unable to convert value at key "%s" from "%s" to "%s".)", key_data[i], Variant::get_type_name(value->get_type()), Variant::get_type_name(typed_value.type)));
}
value_data[i++] = *value;
}
} else if (typed_value.type == Variant::OBJECT || typed_value_source.type == Variant::OBJECT) {
ERR_FAIL_MSG(vformat(R"(Cannot assign contents of "Dictionary[%s, %s]" to "Dictionary[%s, %s]".)", Variant::get_type_name(typed_key_source.type), Variant::get_type_name(typed_value_source.type),
Variant::get_type_name(typed_key.type), Variant::get_type_name(typed_value.type)));
} else if (typed_value_source.type == Variant::NIL && typed_value.type != Variant::OBJECT) {
// From variants to primitives.
int i = 0;
for (const KeyValue<Variant, Variant> &E : p_dictionary._p->variant_map) {
const Variant *value = &E.value;
if (value->get_type() == typed_value.type) {
value_data[i++] = *value;
continue;
}
if (!Variant::can_convert_strict(value->get_type(), typed_value.type)) {
ERR_FAIL_MSG(vformat(R"(Unable to convert value at key "%s" from "%s" to "%s".)", key_data[i], Variant::get_type_name(value->get_type()), Variant::get_type_name(typed_value.type)));
}
Callable::CallError ce;
Variant::construct(typed_value.type, value_data[i++], &value, 1, ce);
ERR_FAIL_COND_MSG(ce.error, vformat(R"(Unable to convert value at key "%s" from "%s" to "%s".)", key_data[i - 1], Variant::get_type_name(value->get_type()), Variant::get_type_name(typed_value.type)));
}
} else if (Variant::can_convert_strict(typed_value_source.type, typed_value.type)) {
// From primitives to different convertible primitives.
int i = 0;
for (const KeyValue<Variant, Variant> &E : p_dictionary._p->variant_map) {
const Variant *value = &E.value;
Callable::CallError ce;
Variant::construct(typed_value.type, value_data[i++], &value, 1, ce);
ERR_FAIL_COND_MSG(ce.error, vformat(R"(Unable to convert value at key "%s" from "%s" to "%s".)", key_data[i - 1], Variant::get_type_name(value->get_type()), Variant::get_type_name(typed_value.type)));
}
} else {
ERR_FAIL_MSG(vformat(R"(Cannot assign contents of "Dictionary[%s, %s]" to "Dictionary[%s, %s].)", Variant::get_type_name(typed_key_source.type), Variant::get_type_name(typed_value_source.type),
Variant::get_type_name(typed_key.type), Variant::get_type_name(typed_value.type)));
}
for (int i = 0; i < size; i++) {
variant_map.insert(key_data[i], value_data[i]);
}
_p->variant_map = variant_map;
}
const Variant *Dictionary::next(const Variant *p_key) const {
if (p_key == nullptr) {
// caller wants to get the first element
@ -324,7 +497,9 @@ const Variant *Dictionary::next(const Variant *p_key) const {
}
return nullptr;
}
HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::Iterator E = _p->variant_map.find(*p_key);
Variant key = *p_key;
ERR_FAIL_COND_V(!_p->typed_key.validate(key, "next"), nullptr);
HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator>::Iterator E = _p->variant_map.find(key);
if (!E) {
return nullptr;
@ -354,6 +529,8 @@ bool Dictionary::is_read_only() const {
Dictionary Dictionary::recursive_duplicate(bool p_deep, int recursion_count) const {
Dictionary n;
n._p->typed_key = _p->typed_key;
n._p->typed_value = _p->typed_value;
if (recursion_count > MAX_RECURSION) {
ERR_PRINT("Max recursion reached");
@ -374,6 +551,76 @@ Dictionary Dictionary::recursive_duplicate(bool p_deep, int recursion_count) con
return n;
}
void Dictionary::set_typed(uint32_t p_key_type, const StringName &p_key_class_name, const Variant &p_key_script, uint32_t p_value_type, const StringName &p_value_class_name, const Variant &p_value_script) {
ERR_FAIL_COND_MSG(_p->read_only, "Dictionary is in read-only state.");
ERR_FAIL_COND_MSG(_p->variant_map.size() > 0, "Type can only be set when dictionary is empty.");
ERR_FAIL_COND_MSG(_p->refcount.get() > 1, "Type can only be set when dictionary has no more than one user.");
ERR_FAIL_COND_MSG(_p->typed_key.type != Variant::NIL || _p->typed_value.type != Variant::NIL, "Type can only be set once.");
ERR_FAIL_COND_MSG((p_key_class_name != StringName() && p_key_type != Variant::OBJECT) || (p_value_class_name != StringName() && p_value_type != Variant::OBJECT), "Class names can only be set for type OBJECT.");
Ref<Script> key_script = p_key_script;
ERR_FAIL_COND_MSG(key_script.is_valid() && p_key_class_name == StringName(), "Script class can only be set together with base class name.");
Ref<Script> value_script = p_value_script;
ERR_FAIL_COND_MSG(value_script.is_valid() && p_value_class_name == StringName(), "Script class can only be set together with base class name.");
_p->typed_key.type = Variant::Type(p_key_type);
_p->typed_key.class_name = p_key_class_name;
_p->typed_key.script = key_script;
_p->typed_key.where = "TypedDictionary.Key";
_p->typed_value.type = Variant::Type(p_value_type);
_p->typed_value.class_name = p_value_class_name;
_p->typed_value.script = value_script;
_p->typed_value.where = "TypedDictionary.Value";
}
bool Dictionary::is_typed() const {
return is_typed_key() || is_typed_value();
}
bool Dictionary::is_typed_key() const {
return _p->typed_key.type != Variant::NIL;
}
bool Dictionary::is_typed_value() const {
return _p->typed_value.type != Variant::NIL;
}
bool Dictionary::is_same_typed(const Dictionary &p_other) const {
return is_same_typed_key(p_other) && is_same_typed_value(p_other);
}
bool Dictionary::is_same_typed_key(const Dictionary &p_other) const {
return _p->typed_key == p_other._p->typed_key;
}
bool Dictionary::is_same_typed_value(const Dictionary &p_other) const {
return _p->typed_value == p_other._p->typed_value;
}
uint32_t Dictionary::get_typed_key_builtin() const {
return _p->typed_key.type;
}
uint32_t Dictionary::get_typed_value_builtin() const {
return _p->typed_value.type;
}
StringName Dictionary::get_typed_key_class_name() const {
return _p->typed_key.class_name;
}
StringName Dictionary::get_typed_value_class_name() const {
return _p->typed_value.class_name;
}
Variant Dictionary::get_typed_key_script() const {
return _p->typed_key.script;
}
Variant Dictionary::get_typed_value_script() const {
return _p->typed_value.script;
}
void Dictionary::operator=(const Dictionary &p_dictionary) {
if (this == &p_dictionary) {
return;
@ -385,6 +632,13 @@ const void *Dictionary::id() const {
return _p;
}
Dictionary::Dictionary(const Dictionary &p_base, uint32_t p_key_type, const StringName &p_key_class_name, const Variant &p_key_script, uint32_t p_value_type, const StringName &p_value_class_name, const Variant &p_value_script) {
_p = memnew(DictionaryPrivate);
_p->refcount.init();
set_typed(p_key_type, p_key_class_name, p_key_script, p_value_type, p_value_class_name, p_value_script);
assign(p_base);
}
Dictionary::Dictionary(const Dictionary &p_from) {
_p = nullptr;
_ref(p_from);