/*************************************************************************/ /* packed_data_container.cpp */ /*************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* https://godotengine.org */ /*************************************************************************/ /* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ /* */ /* 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. */ /*************************************************************************/ #include "packed_data_container.h" #include "core_string_names.h" #include "io/marshalls.h" Variant PackedDataContainer::getvar(const Variant &p_key, bool *r_valid) const { bool err = false; Variant ret = _key_at_ofs(0, p_key, err); if (r_valid) *r_valid = !err; return ret; } int PackedDataContainer::size() const { return _size(0); }; Variant PackedDataContainer::_iter_init_ofs(const Array &p_iter, uint32_t p_offset) { Array ref = p_iter; uint32_t size = _size(p_offset); if (size == 0 || ref.size() != 1) return false; else { ref[0] = 0; return true; } } Variant PackedDataContainer::_iter_next_ofs(const Array &p_iter, uint32_t p_offset) { Array ref = p_iter; int size = _size(p_offset); if (ref.size() != 1) return false; int pos = ref[0]; if (pos < 0 || pos >= size) return false; pos += 1; ref[0] = pos; return pos != size; } Variant PackedDataContainer::_iter_get_ofs(const Variant &p_iter, uint32_t p_offset) { int size = _size(p_offset); int pos = p_iter; if (pos < 0 || pos >= size) return Variant(); PoolVector<uint8_t>::Read rd = data.read(); const uint8_t *r = &rd[p_offset]; uint32_t type = decode_uint32(r); bool err = false; if (type == TYPE_ARRAY) { uint32_t vpos = decode_uint32(rd.ptr() + p_offset + 8 + pos * 4); return _get_at_ofs(vpos, rd.ptr(), err); } else if (type == TYPE_DICT) { uint32_t vpos = decode_uint32(rd.ptr() + p_offset + 8 + pos * 12 + 4); return _get_at_ofs(vpos, rd.ptr(), err); } else { ERR_FAIL_V(Variant()); } } Variant PackedDataContainer::_get_at_ofs(uint32_t p_ofs, const uint8_t *p_buf, bool &err) const { uint32_t type = decode_uint32(p_buf + p_ofs); if (type == TYPE_ARRAY || type == TYPE_DICT) { Ref<PackedDataContainerRef> pdcr = memnew(PackedDataContainerRef); Ref<PackedDataContainer> pdc = Ref<PackedDataContainer>((PackedDataContainer *)this); pdcr->from = pdc; pdcr->offset = p_ofs; return pdcr; } else { Variant v; Error rerr = decode_variant(v, p_buf + p_ofs, datalen - p_ofs, NULL); if (rerr != OK) { err = true; ERR_FAIL_COND_V(err != OK, Variant()); } return v; } } uint32_t PackedDataContainer::_type_at_ofs(uint32_t p_ofs) const { PoolVector<uint8_t>::Read rd = data.read(); const uint8_t *r = &rd[p_ofs]; uint32_t type = decode_uint32(r); return type; }; int PackedDataContainer::_size(uint32_t p_ofs) const { PoolVector<uint8_t>::Read rd = data.read(); const uint8_t *r = &rd[p_ofs]; uint32_t type = decode_uint32(r); if (type == TYPE_ARRAY) { uint32_t len = decode_uint32(r + 4); return len; } else if (type == TYPE_DICT) { uint32_t len = decode_uint32(r + 4); return len; }; return -1; }; Variant PackedDataContainer::_key_at_ofs(uint32_t p_ofs, const Variant &p_key, bool &err) const { PoolVector<uint8_t>::Read rd = data.read(); const uint8_t *r = &rd[p_ofs]; uint32_t type = decode_uint32(r); if (type == TYPE_ARRAY) { if (p_key.is_num()) { int idx = p_key; int len = decode_uint32(r + 4); if (idx < 0 || idx >= len) { err = true; return Variant(); } uint32_t ofs = decode_uint32(r + 8 + 4 * idx); return _get_at_ofs(ofs, rd.ptr(), err); } else { err = true; return Variant(); } } else if (type == TYPE_DICT) { uint32_t hash = p_key.hash(); uint32_t len = decode_uint32(r + 4); bool found = false; for (uint32_t i = 0; i < len; i++) { uint32_t khash = decode_uint32(r + 8 + i * 12 + 0); if (khash == hash) { Variant key = _get_at_ofs(decode_uint32(r + 8 + i * 12 + 4), rd.ptr(), err); if (err) return Variant(); if (key == p_key) { //key matches, return value return _get_at_ofs(decode_uint32(r + 8 + i * 12 + 8), rd.ptr(), err); } found = true; } else { if (found) break; } } err = true; return Variant(); } else { err = true; return Variant(); } } uint32_t PackedDataContainer::_pack(const Variant &p_data, Vector<uint8_t> &tmpdata, Map<String, uint32_t> &string_cache) { switch (p_data.get_type()) { case Variant::STRING: { String s = p_data; if (string_cache.has(s)) { return string_cache[s]; } string_cache[s] = tmpdata.size(); }; //fallthrough case Variant::NIL: case Variant::BOOL: case Variant::INT: case Variant::REAL: case Variant::VECTOR2: case Variant::RECT2: case Variant::VECTOR3: case Variant::TRANSFORM2D: case Variant::PLANE: case Variant::QUAT: case Variant::RECT3: case Variant::BASIS: case Variant::TRANSFORM: case Variant::POOL_BYTE_ARRAY: case Variant::POOL_INT_ARRAY: case Variant::POOL_REAL_ARRAY: case Variant::POOL_STRING_ARRAY: case Variant::POOL_VECTOR2_ARRAY: case Variant::POOL_VECTOR3_ARRAY: case Variant::POOL_COLOR_ARRAY: case Variant::NODE_PATH: { uint32_t pos = tmpdata.size(); int len; encode_variant(p_data, NULL, len); tmpdata.resize(tmpdata.size() + len); encode_variant(p_data, &tmpdata[pos], len); return pos; } break; // misc types case Variant::_RID: case Variant::OBJECT: { return _pack(Variant(), tmpdata, string_cache); } break; case Variant::DICTIONARY: { Dictionary d = p_data; //size is known, use sort uint32_t pos = tmpdata.size(); int len = d.size(); tmpdata.resize(tmpdata.size() + len * 12 + 8); encode_uint32(TYPE_DICT, &tmpdata[pos + 0]); encode_uint32(len, &tmpdata[pos + 4]); List<Variant> keys; d.get_key_list(&keys); List<DictKey> sortk; for (List<Variant>::Element *E = keys.front(); E; E = E->next()) { DictKey dk; dk.hash = E->get().hash(); dk.key = E->get(); sortk.push_back(dk); } sortk.sort(); int idx = 0; for (List<DictKey>::Element *E = sortk.front(); E; E = E->next()) { encode_uint32(E->get().hash, &tmpdata[pos + 8 + idx * 12 + 0]); uint32_t ofs = _pack(E->get().key, tmpdata, string_cache); encode_uint32(ofs, &tmpdata[pos + 8 + idx * 12 + 4]); ofs = _pack(d[E->get().key], tmpdata, string_cache); encode_uint32(ofs, &tmpdata[pos + 8 + idx * 12 + 8]); idx++; } return pos; } break; case Variant::ARRAY: { Array a = p_data; //size is known, use sort uint32_t pos = tmpdata.size(); int len = a.size(); tmpdata.resize(tmpdata.size() + len * 4 + 8); encode_uint32(TYPE_ARRAY, &tmpdata[pos + 0]); encode_uint32(len, &tmpdata[pos + 4]); for (int i = 0; i < len; i++) { uint32_t ofs = _pack(a[i], tmpdata, string_cache); encode_uint32(ofs, &tmpdata[pos + 8 + i * 4]); } return pos; } break; default: {} } return OK; } Error PackedDataContainer::pack(const Variant &p_data) { Vector<uint8_t> tmpdata; Map<String, uint32_t> string_cache; _pack(p_data, tmpdata, string_cache); datalen = tmpdata.size(); data.resize(tmpdata.size()); PoolVector<uint8_t>::Write w = data.write(); copymem(w.ptr(), tmpdata.ptr(), tmpdata.size()); return OK; } void PackedDataContainer::_set_data(const PoolVector<uint8_t> &p_data) { data = p_data; datalen = data.size(); } PoolVector<uint8_t> PackedDataContainer::_get_data() const { return data; } Variant PackedDataContainer::_iter_init(const Array &p_iter) { return _iter_init_ofs(p_iter, 0); } Variant PackedDataContainer::_iter_next(const Array &p_iter) { return _iter_next_ofs(p_iter, 0); } Variant PackedDataContainer::_iter_get(const Variant &p_iter) { return _iter_get_ofs(p_iter, 0); } void PackedDataContainer::_bind_methods() { ClassDB::bind_method(D_METHOD("_set_data"), &PackedDataContainer::_set_data); ClassDB::bind_method(D_METHOD("_get_data"), &PackedDataContainer::_get_data); ClassDB::bind_method(D_METHOD("_iter_init"), &PackedDataContainer::_iter_init); ClassDB::bind_method(D_METHOD("_iter_get"), &PackedDataContainer::_iter_get); ClassDB::bind_method(D_METHOD("_iter_next"), &PackedDataContainer::_iter_next); ClassDB::bind_method(D_METHOD("pack", "value"), &PackedDataContainer::pack); ClassDB::bind_method(D_METHOD("size"), &PackedDataContainer::size); ADD_PROPERTY(PropertyInfo(Variant::POOL_BYTE_ARRAY, "__data__"), "_set_data", "_get_data"); } PackedDataContainer::PackedDataContainer() { datalen = 0; } ////////////////// Variant PackedDataContainerRef::_iter_init(const Array &p_iter) { return from->_iter_init_ofs(p_iter, offset); } Variant PackedDataContainerRef::_iter_next(const Array &p_iter) { return from->_iter_next_ofs(p_iter, offset); } Variant PackedDataContainerRef::_iter_get(const Variant &p_iter) { return from->_iter_get_ofs(p_iter, offset); } bool PackedDataContainerRef::_is_dictionary() const { return from->_type_at_ofs(offset) == PackedDataContainer::TYPE_DICT; }; void PackedDataContainerRef::_bind_methods() { ClassDB::bind_method(D_METHOD("size"), &PackedDataContainerRef::size); ClassDB::bind_method(D_METHOD("_iter_init"), &PackedDataContainerRef::_iter_init); ClassDB::bind_method(D_METHOD("_iter_get"), &PackedDataContainerRef::_iter_get); ClassDB::bind_method(D_METHOD("_iter_next"), &PackedDataContainerRef::_iter_next); ClassDB::bind_method(D_METHOD("_is_dictionary"), &PackedDataContainerRef::_is_dictionary); } Variant PackedDataContainerRef::getvar(const Variant &p_key, bool *r_valid) const { bool err = false; Variant ret = from->_key_at_ofs(offset, p_key, err); if (r_valid) *r_valid = !err; return ret; } int PackedDataContainerRef::size() const { return from->_size(offset); }; PackedDataContainerRef::PackedDataContainerRef() { }