virtualx-engine/core/dictionary.cpp

252 lines
6.6 KiB
C++
Raw Normal View History

2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* dictionary.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */
2014-02-10 02:10:30 +01:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
2014-02-10 02:10:30 +01:00
#include "dictionary.h"
2017-11-05 15:27:28 +01:00
#include "ordered_hash_map.h"
2014-02-10 02:10:30 +01:00
#include "safe_refcount.h"
#include "variant.h"
struct DictionaryPrivate {
SafeRefCount refcount;
OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator> variant_map;
};
2014-02-10 02:10:30 +01:00
void Dictionary::get_key_list(List<Variant> *p_keys) const {
2014-02-10 02:10:30 +01:00
if (_p->variant_map.empty())
return;
for (OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator>::Element E = _p->variant_map.front(); E; E = E.next()) {
2017-11-05 15:27:28 +01:00
p_keys->push_back(E.key());
}
2014-02-10 02:10:30 +01:00
}
Variant &Dictionary::operator[](const Variant &p_key) {
2014-02-10 02:10:30 +01:00
2017-11-05 15:27:28 +01:00
return _p->variant_map[p_key];
2014-02-10 02:10:30 +01:00
}
const Variant &Dictionary::operator[](const Variant &p_key) const {
2014-02-10 02:10:30 +01:00
2017-11-07 17:49:16 +01:00
return _p->variant_map[p_key];
2014-02-10 02:10:30 +01:00
}
const Variant *Dictionary::getptr(const Variant &p_key) const {
2014-02-10 02:10:30 +01:00
OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator>::ConstElement E = ((const OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator> *)&_p->variant_map)->find(p_key);
2017-11-05 15:27:28 +01:00
if (!E)
return NULL;
2017-11-05 15:27:28 +01:00
return &E.get();
2014-02-10 02:10:30 +01:00
}
Variant *Dictionary::getptr(const Variant &p_key) {
2014-02-10 02:10:30 +01:00
OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator>::Element E = _p->variant_map.find(p_key);
2017-11-05 15:27:28 +01:00
if (!E)
return NULL;
2017-11-05 15:27:28 +01:00
return &E.get();
2014-02-10 02:10:30 +01:00
}
Variant Dictionary::get_valid(const Variant &p_key) const {
2014-02-10 02:10:30 +01:00
OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator>::ConstElement E = ((const OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator> *)&_p->variant_map)->find(p_key);
2017-11-05 15:27:28 +01:00
if (!E)
2014-02-10 02:10:30 +01:00
return Variant();
2017-11-05 15:27:28 +01:00
return E.get();
2014-02-10 02:10:30 +01:00
}
int Dictionary::size() const {
return _p->variant_map.size();
}
bool Dictionary::empty() const {
return !_p->variant_map.size();
}
bool Dictionary::has(const Variant &p_key) const {
2014-02-10 02:10:30 +01:00
return _p->variant_map.has(p_key);
}
2016-04-04 18:37:43 +02:00
bool Dictionary::has_all(const Array &p_keys) const {
for (int i = 0; i < p_keys.size(); i++) {
if (!has(p_keys[i])) {
2016-04-04 18:37:43 +02:00
return false;
}
}
return true;
}
void Dictionary::erase(const Variant &p_key) {
2014-02-10 02:10:30 +01:00
_p->variant_map.erase(p_key);
}
bool Dictionary::erase_checked(const Variant &p_key) {
return _p->variant_map.erase(p_key);
}
bool Dictionary::operator==(const Dictionary &p_dictionary) const {
2014-02-10 02:10:30 +01:00
return _p == p_dictionary._p;
2014-02-10 02:10:30 +01:00
}
void Dictionary::_ref(const Dictionary &p_from) const {
2014-02-10 02:10:30 +01:00
//make a copy first (thread safe)
if (!p_from._p->refcount.ref())
return; // couldn't copy
//if this is the same, unreference the other one
if (p_from._p == _p) {
2014-02-10 02:10:30 +01:00
_p->refcount.unref();
return;
}
if (_p)
_unref();
_p = p_from._p;
2014-02-10 02:10:30 +01:00
}
void Dictionary::clear() {
_p->variant_map.clear();
}
void Dictionary::_unref() const {
ERR_FAIL_COND(!_p);
if (_p->refcount.unref()) {
memdelete(_p);
}
_p = NULL;
2014-02-10 02:10:30 +01:00
}
uint32_t Dictionary::hash() const {
uint32_t h = hash_djb2_one_32(Variant::DICTIONARY);
List<Variant> keys;
get_key_list(&keys);
for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
h = hash_djb2_one_32(E->get().hash(), h);
h = hash_djb2_one_32(operator[](E->get()).hash(), h);
}
return h;
2014-02-10 02:10:30 +01:00
}
Array Dictionary::keys() const {
Array varr;
varr.resize(size());
if (_p->variant_map.empty())
return varr;
2017-11-05 15:27:28 +01:00
int i = 0;
for (OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator>::Element E = _p->variant_map.front(); E; E = E.next()) {
2017-11-05 15:27:28 +01:00
varr[i] = E.key();
i++;
}
return varr;
2014-02-10 02:10:30 +01:00
}
2016-06-05 14:20:52 +02:00
Array Dictionary::values() const {
Array varr;
varr.resize(size());
if (_p->variant_map.empty())
return varr;
2017-11-05 15:27:28 +01:00
int i = 0;
for (OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator>::Element E = _p->variant_map.front(); E; E = E.next()) {
2017-11-05 15:27:28 +01:00
varr[i] = E.get();
i++;
2016-06-05 14:20:52 +02:00
}
2016-06-05 14:20:52 +02:00
return varr;
}
const Variant *Dictionary::next(const Variant *p_key) const {
2014-02-10 02:10:30 +01:00
2017-11-05 15:27:28 +01:00
if (p_key == NULL) {
// caller wants to get the first element
2017-12-05 20:00:44 +01:00
if (_p->variant_map.front())
return &_p->variant_map.front().key();
return NULL;
2017-11-05 15:27:28 +01:00
}
OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator>::Element E = _p->variant_map.find(*p_key);
2017-11-05 15:27:28 +01:00
if (E && E.next())
return &E.next().key();
return NULL;
2014-02-10 02:10:30 +01:00
}
2017-12-17 23:07:15 +01:00
Dictionary Dictionary::duplicate() const {
Dictionary n;
List<Variant> keys;
get_key_list(&keys);
for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
n[E->get()] = operator[](E->get());
}
return n;
}
void Dictionary::operator=(const Dictionary &p_dictionary) {
2014-02-10 02:10:30 +01:00
_ref(p_dictionary);
}
Dictionary::Dictionary(const Dictionary &p_from) {
_p = NULL;
2014-02-10 02:10:30 +01:00
_ref(p_from);
}
Dictionary::Dictionary() {
2014-02-10 02:10:30 +01:00
_p = memnew(DictionaryPrivate);
2014-02-10 02:10:30 +01:00
_p->refcount.init();
}
Dictionary::~Dictionary() {
_unref();
}