godot/core/templates/list.h

766 lines
16 KiB
C++
Raw Normal View History

2014-02-10 09:10:30 +08:00
/*************************************************************************/
/* list.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
2014-02-10 09:10:30 +08:00
/*************************************************************************/
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
2014-02-10 09:10:30 +08: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. */
/*************************************************************************/
#ifndef LIST_H
#define LIST_H
2014-02-10 09:10:30 +08:00
#include "core/error/error_macros.h"
#include "core/os/memory.h"
#include "core/templates/sort_array.h"
2014-02-10 09:10:30 +08:00
/**
* Generic Templatized Linked List Implementation.
* The implementation differs from the STL one because
* a compatible preallocated linked list can be written
* using the same API, or features such as erasing an element
* from the iterator.
*/
template <class T, class A = DefaultAllocator>
2014-02-10 09:10:30 +08:00
class List {
struct _Data;
public:
2014-02-10 09:10:30 +08:00
class Element {
private:
friend class List<T, A>;
2014-02-10 09:10:30 +08:00
T value;
Element *next_ptr = nullptr;
Element *prev_ptr = nullptr;
_Data *data = nullptr;
2014-02-10 09:10:30 +08:00
public:
2014-02-10 09:10:30 +08:00
/**
* Get NEXT Element iterator, for constant lists.
*/
_FORCE_INLINE_ const Element *next() const {
2014-02-10 09:10:30 +08:00
return next_ptr;
}
2014-02-10 09:10:30 +08:00
/**
* Get NEXT Element iterator,
*/
_FORCE_INLINE_ Element *next() {
2014-02-10 09:10:30 +08:00
return next_ptr;
}
2014-02-10 09:10:30 +08:00
/**
* Get PREV Element iterator, for constant lists.
*/
_FORCE_INLINE_ const Element *prev() const {
2014-02-10 09:10:30 +08:00
return prev_ptr;
}
2014-02-10 09:10:30 +08:00
/**
* Get PREV Element iterator,
*/
_FORCE_INLINE_ Element *prev() {
2014-02-10 09:10:30 +08:00
return prev_ptr;
}
2014-02-10 09:10:30 +08:00
/**
* * operator, for using as *iterator, when iterators are defined on stack.
*/
_FORCE_INLINE_ const T &operator*() const {
2014-02-10 09:10:30 +08:00
return value;
}
2014-02-10 09:10:30 +08:00
/**
* operator->, for using as iterator->, when iterators are defined on stack, for constant lists.
*/
_FORCE_INLINE_ const T *operator->() const {
2014-02-10 09:10:30 +08:00
return &value;
}
2014-02-10 09:10:30 +08:00
/**
* * operator, for using as *iterator, when iterators are defined on stack,
*/
_FORCE_INLINE_ T &operator*() {
2014-02-10 09:10:30 +08:00
return value;
}
2014-02-10 09:10:30 +08:00
/**
* operator->, for using as iterator->, when iterators are defined on stack, for constant lists.
*/
_FORCE_INLINE_ T *operator->() {
2014-02-10 09:10:30 +08:00
return &value;
}
2014-02-10 09:10:30 +08:00
/**
* get the value stored in this element.
*/
_FORCE_INLINE_ T &get() {
2014-02-10 09:10:30 +08:00
return value;
}
2014-02-10 09:10:30 +08:00
/**
* get the value stored in this element, for constant lists
*/
_FORCE_INLINE_ const T &get() const {
2014-02-10 09:10:30 +08:00
return value;
}
2014-02-10 09:10:30 +08:00
/**
* set the value stored in this element.
*/
_FORCE_INLINE_ void set(const T &p_value) {
value = (T &)p_value;
}
2014-02-10 09:10:30 +08:00
void erase() {
data->erase(this);
}
_FORCE_INLINE_ Element() {}
2014-02-10 09:10:30 +08:00
};
typedef T ValueType;
struct Iterator {
_FORCE_INLINE_ T &operator*() const {
return E->get();
}
_FORCE_INLINE_ T *operator->() const { return &E->get(); }
_FORCE_INLINE_ Iterator &operator++() {
E = E->next();
return *this;
}
_FORCE_INLINE_ Iterator &operator--() {
E = E->prev();
return *this;
}
_FORCE_INLINE_ bool operator==(const Iterator &b) const { return E == b.E; }
_FORCE_INLINE_ bool operator!=(const Iterator &b) const { return E != b.E; }
Iterator(Element *p_E) { E = p_E; }
Iterator() {}
Iterator(const Iterator &p_it) { E = p_it.E; }
private:
Element *E = nullptr;
};
struct ConstIterator {
_FORCE_INLINE_ const T &operator*() const {
return E->get();
}
_FORCE_INLINE_ const T *operator->() const { return &E->get(); }
_FORCE_INLINE_ ConstIterator &operator++() {
E = E->next();
return *this;
}
_FORCE_INLINE_ ConstIterator &operator--() {
E = E->prev();
return *this;
}
_FORCE_INLINE_ bool operator==(const ConstIterator &b) const { return E == b.E; }
_FORCE_INLINE_ bool operator!=(const ConstIterator &b) const { return E != b.E; }
_FORCE_INLINE_ ConstIterator(const Element *p_E) { E = p_E; }
_FORCE_INLINE_ ConstIterator() {}
_FORCE_INLINE_ ConstIterator(const ConstIterator &p_it) { E = p_it.E; }
private:
const Element *E = nullptr;
};
_FORCE_INLINE_ Iterator begin() {
return Iterator(front());
}
_FORCE_INLINE_ Iterator end() {
return Iterator(nullptr);
}
#if 0
//to use when replacing find()
_FORCE_INLINE_ Iterator find(const K &p_key) {
return Iterator(find(p_key));
}
#endif
_FORCE_INLINE_ ConstIterator begin() const {
return ConstIterator(front());
}
_FORCE_INLINE_ ConstIterator end() const {
return ConstIterator(nullptr);
}
#if 0
//to use when replacing find()
_FORCE_INLINE_ ConstIterator find(const K &p_key) const {
return ConstIterator(find(p_key));
}
#endif
2014-02-10 09:10:30 +08:00
private:
struct _Data {
Element *first = nullptr;
Element *last = nullptr;
int size_cache = 0;
2014-02-10 09:10:30 +08:00
bool erase(const Element *p_I) {
ERR_FAIL_COND_V(!p_I, false);
ERR_FAIL_COND_V(p_I->data != this, false);
2014-02-10 09:10:30 +08:00
if (first == p_I) {
first = p_I->next_ptr;
}
2014-02-10 09:10:30 +08:00
if (last == p_I) {
last = p_I->prev_ptr;
}
2014-02-10 09:10:30 +08:00
if (p_I->prev_ptr) {
p_I->prev_ptr->next_ptr = p_I->next_ptr;
}
2014-02-10 09:10:30 +08:00
if (p_I->next_ptr) {
p_I->next_ptr->prev_ptr = p_I->prev_ptr;
}
2014-02-10 09:10:30 +08:00
memdelete_allocator<Element, A>(const_cast<Element *>(p_I));
2014-02-10 09:10:30 +08:00
size_cache--;
return true;
}
};
_Data *_data = nullptr;
2014-02-10 09:10:30 +08:00
public:
/**
2017-09-02 22:19:06 +08:00
* return a const iterator to the beginning of the list.
2014-02-10 09:10:30 +08:00
*/
_FORCE_INLINE_ const Element *front() const {
return _data ? _data->first : nullptr;
}
2014-02-10 09:10:30 +08:00
/**
* return an iterator to the beginning of the list.
2014-02-10 09:10:30 +08:00
*/
_FORCE_INLINE_ Element *front() {
return _data ? _data->first : nullptr;
}
2014-02-10 09:10:30 +08:00
/**
2017-09-02 22:19:06 +08:00
* return a const iterator to the last member of the list.
2014-02-10 09:10:30 +08:00
*/
_FORCE_INLINE_ const Element *back() const {
return _data ? _data->last : nullptr;
}
2014-02-10 09:10:30 +08:00
/**
* return an iterator to the last member of the list.
*/
_FORCE_INLINE_ Element *back() {
return _data ? _data->last : nullptr;
}
2014-02-10 09:10:30 +08:00
/**
* store a new element at the end of the list
*/
Element *push_back(const T &value) {
2014-02-10 09:10:30 +08:00
if (!_data) {
_data = memnew_allocator(_Data, A);
2020-04-02 07:20:12 +08:00
_data->first = nullptr;
_data->last = nullptr;
_data->size_cache = 0;
2014-02-10 09:10:30 +08:00
}
Element *n = memnew_allocator(Element, A);
n->value = (T &)value;
2014-02-10 09:10:30 +08:00
n->prev_ptr = _data->last;
n->next_ptr = nullptr;
n->data = _data;
2014-02-10 09:10:30 +08:00
if (_data->last) {
_data->last->next_ptr = n;
2014-02-10 09:10:30 +08:00
}
_data->last = n;
if (!_data->first) {
_data->first = n;
}
2014-02-10 09:10:30 +08:00
_data->size_cache++;
2016-03-09 07:00:52 +08:00
2014-02-10 09:10:30 +08:00
return n;
}
2014-02-10 09:10:30 +08:00
void pop_back() {
if (_data && _data->last) {
2014-02-10 09:10:30 +08:00
erase(_data->last);
}
2014-02-10 09:10:30 +08:00
}
/**
* store a new element at the beginning of the list
2014-02-10 09:10:30 +08:00
*/
Element *push_front(const T &value) {
2014-02-10 09:10:30 +08:00
if (!_data) {
_data = memnew_allocator(_Data, A);
2020-04-02 07:20:12 +08:00
_data->first = nullptr;
_data->last = nullptr;
_data->size_cache = 0;
2014-02-10 09:10:30 +08:00
}
Element *n = memnew_allocator(Element, A);
n->value = (T &)value;
n->prev_ptr = nullptr;
2014-02-10 09:10:30 +08:00
n->next_ptr = _data->first;
n->data = _data;
2014-02-10 09:10:30 +08:00
if (_data->first) {
_data->first->prev_ptr = n;
2014-02-10 09:10:30 +08:00
}
_data->first = n;
if (!_data->last) {
_data->last = n;
}
2014-02-10 09:10:30 +08:00
_data->size_cache++;
2016-03-09 07:00:52 +08:00
2014-02-10 09:10:30 +08:00
return n;
}
2014-02-10 09:10:30 +08:00
void pop_front() {
if (_data && _data->first) {
2014-02-10 09:10:30 +08:00
erase(_data->first);
}
2014-02-10 09:10:30 +08:00
}
Element *insert_after(Element *p_element, const T &p_value) {
CRASH_COND(p_element && (!_data || p_element->data != _data));
if (!p_element) {
return push_back(p_value);
}
Element *n = memnew_allocator(Element, A);
n->value = (T &)p_value;
n->prev_ptr = p_element;
n->next_ptr = p_element->next_ptr;
n->data = _data;
if (!p_element->next_ptr) {
_data->last = n;
2017-11-22 00:51:38 +08:00
} else {
p_element->next_ptr->prev_ptr = n;
}
p_element->next_ptr = n;
_data->size_cache++;
return n;
}
Element *insert_before(Element *p_element, const T &p_value) {
CRASH_COND(p_element && (!_data || p_element->data != _data));
if (!p_element) {
return push_back(p_value);
}
Element *n = memnew_allocator(Element, A);
n->value = (T &)p_value;
n->prev_ptr = p_element->prev_ptr;
n->next_ptr = p_element;
n->data = _data;
if (!p_element->prev_ptr) {
_data->first = n;
2017-11-22 00:51:38 +08:00
} else {
p_element->prev_ptr->next_ptr = n;
}
p_element->prev_ptr = n;
_data->size_cache++;
return n;
}
2014-02-10 09:10:30 +08:00
/**
* find an element in the list,
*/
template <class T_v>
Element *find(const T_v &p_val) {
Element *it = front();
2014-02-10 09:10:30 +08:00
while (it) {
if (it->value == p_val) {
return it;
}
2014-02-10 09:10:30 +08:00
it = it->next();
}
2014-02-10 09:10:30 +08:00
2020-04-02 07:20:12 +08:00
return nullptr;
}
2014-02-10 09:10:30 +08:00
/**
* erase an element in the list, by iterator pointing to it. Return true if it was found/erased.
*/
bool erase(const Element *p_I) {
if (_data && p_I) {
bool ret = _data->erase(p_I);
2014-02-10 09:10:30 +08:00
if (_data->size_cache == 0) {
memdelete_allocator<_Data, A>(_data);
2020-04-02 07:20:12 +08:00
_data = nullptr;
2014-02-10 09:10:30 +08:00
}
return ret;
}
return false;
}
2014-02-10 09:10:30 +08:00
/**
* erase the first element in the list, that contains value
*/
bool erase(const T &value) {
Element *I = find(value);
2014-02-10 09:10:30 +08:00
return erase(I);
}
2014-02-10 09:10:30 +08:00
/**
* return whether the list is empty
2014-02-10 09:10:30 +08:00
*/
2020-12-15 20:04:21 +08:00
_FORCE_INLINE_ bool is_empty() const {
2014-02-10 09:10:30 +08:00
return (!_data || !_data->size_cache);
}
/**
* clear the list
*/
void clear() {
while (front()) {
erase(front());
}
}
2014-02-10 09:10:30 +08:00
_FORCE_INLINE_ int size() const {
return _data ? _data->size_cache : 0;
2014-02-10 09:10:30 +08:00
}
void swap(Element *p_A, Element *p_B) {
2014-02-10 09:10:30 +08:00
ERR_FAIL_COND(!p_A || !p_B);
ERR_FAIL_COND(p_A->data != _data);
ERR_FAIL_COND(p_B->data != _data);
2016-03-09 07:00:52 +08:00
if (p_A == p_B) {
return;
}
Element *A_prev = p_A->prev_ptr;
Element *A_next = p_A->next_ptr;
Element *B_prev = p_B->prev_ptr;
Element *B_next = p_B->next_ptr;
2016-03-09 07:00:52 +08:00
if (A_prev) {
A_prev->next_ptr = p_B;
} else {
_data->first = p_B;
}
if (B_prev) {
B_prev->next_ptr = p_A;
} else {
_data->first = p_A;
}
if (A_next) {
A_next->prev_ptr = p_B;
} else {
_data->last = p_B;
}
if (B_next) {
B_next->prev_ptr = p_A;
} else {
_data->last = p_A;
}
p_A->prev_ptr = A_next == p_B ? p_B : B_prev;
p_A->next_ptr = B_next == p_A ? p_B : B_next;
p_B->prev_ptr = B_next == p_A ? p_A : A_prev;
p_B->next_ptr = A_next == p_B ? p_A : A_next;
2014-02-10 09:10:30 +08:00
}
/**
* copy the list
*/
void operator=(const List &p_list) {
2014-02-10 09:10:30 +08:00
clear();
const Element *it = p_list.front();
2014-02-10 09:10:30 +08:00
while (it) {
push_back(it->get());
it = it->next();
2014-02-10 09:10:30 +08:00
}
}
T &operator[](int p_index) {
CRASH_BAD_INDEX(p_index, size());
2014-02-10 09:10:30 +08:00
Element *I = front();
int c = 0;
while (c < p_index) {
I = I->next();
2014-02-10 09:10:30 +08:00
c++;
}
return I->get();
2014-02-10 09:10:30 +08:00
}
const T &operator[](int p_index) const {
CRASH_BAD_INDEX(p_index, size());
2014-02-10 09:10:30 +08:00
const Element *I = front();
int c = 0;
while (c < p_index) {
I = I->next();
2014-02-10 09:10:30 +08:00
c++;
}
return I->get();
2014-02-10 09:10:30 +08:00
}
void move_to_back(Element *p_I) {
ERR_FAIL_COND(p_I->data != _data);
if (!p_I->next_ptr) {
2014-02-10 09:10:30 +08:00
return;
}
2014-02-10 09:10:30 +08:00
if (_data->first == p_I) {
_data->first = p_I->next_ptr;
}
2014-02-10 09:10:30 +08:00
if (_data->last == p_I) {
_data->last = p_I->prev_ptr;
}
2014-02-10 09:10:30 +08:00
if (p_I->prev_ptr) {
p_I->prev_ptr->next_ptr = p_I->next_ptr;
}
2014-02-10 09:10:30 +08:00
2019-04-05 04:00:16 +08:00
p_I->next_ptr->prev_ptr = p_I->prev_ptr;
2014-02-10 09:10:30 +08:00
_data->last->next_ptr = p_I;
p_I->prev_ptr = _data->last;
2020-04-02 07:20:12 +08:00
p_I->next_ptr = nullptr;
_data->last = p_I;
2014-02-10 09:10:30 +08:00
}
void reverse() {
2014-02-10 09:10:30 +08:00
int s = size() / 2;
Element *F = front();
Element *B = back();
for (int i = 0; i < s; i++) {
SWAP(F->value, B->value);
F = F->next();
B = B->prev();
2014-02-10 09:10:30 +08:00
}
}
void move_to_front(Element *p_I) {
ERR_FAIL_COND(p_I->data != _data);
if (!p_I->prev_ptr) {
2014-02-10 09:10:30 +08:00
return;
}
2014-02-10 09:10:30 +08:00
if (_data->first == p_I) {
_data->first = p_I->next_ptr;
}
2014-02-10 09:10:30 +08:00
if (_data->last == p_I) {
_data->last = p_I->prev_ptr;
}
2014-02-10 09:10:30 +08:00
2019-04-05 04:00:16 +08:00
p_I->prev_ptr->next_ptr = p_I->next_ptr;
2014-02-10 09:10:30 +08:00
if (p_I->next_ptr) {
p_I->next_ptr->prev_ptr = p_I->prev_ptr;
}
2014-02-10 09:10:30 +08:00
_data->first->prev_ptr = p_I;
p_I->next_ptr = _data->first;
2020-04-02 07:20:12 +08:00
p_I->prev_ptr = nullptr;
_data->first = p_I;
2014-02-10 09:10:30 +08:00
}
void move_before(Element *value, Element *where) {
2014-02-10 09:10:30 +08:00
if (value->prev_ptr) {
value->prev_ptr->next_ptr = value->next_ptr;
} else {
_data->first = value->next_ptr;
}
2014-02-10 09:10:30 +08:00
if (value->next_ptr) {
value->next_ptr->prev_ptr = value->prev_ptr;
} else {
_data->last = value->prev_ptr;
}
2014-02-10 09:10:30 +08:00
value->next_ptr = where;
if (!where) {
value->prev_ptr = _data->last;
_data->last = value;
return;
}
2014-02-10 09:10:30 +08:00
value->prev_ptr = where->prev_ptr;
if (where->prev_ptr) {
where->prev_ptr->next_ptr = value;
} else {
_data->first = value;
}
2014-02-10 09:10:30 +08:00
where->prev_ptr = value;
}
2014-02-10 09:10:30 +08:00
/**
* simple insertion sort
*/
void sort() {
sort_custom<Comparator<T>>();
2014-02-10 09:10:30 +08:00
}
2016-03-09 07:00:52 +08:00
template <class C>
void sort_custom_inplace() {
if (size() < 2) {
2014-02-10 09:10:30 +08:00
return;
}
2014-02-10 09:10:30 +08:00
Element *from = front();
Element *current = from;
Element *to = from;
2016-03-09 07:00:52 +08:00
while (current) {
Element *next = current->next_ptr;
2016-03-09 07:00:52 +08:00
if (from != current) {
2020-04-02 07:20:12 +08:00
current->prev_ptr = nullptr;
current->next_ptr = from;
2016-03-09 07:00:52 +08:00
Element *find = from;
2014-02-10 09:10:30 +08:00
C less;
while (find && less(find->value, current->value)) {
current->prev_ptr = find;
current->next_ptr = find->next_ptr;
find = find->next_ptr;
2014-02-10 09:10:30 +08:00
}
2016-03-09 07:00:52 +08:00
if (current->prev_ptr) {
current->prev_ptr->next_ptr = current;
} else {
from = current;
}
2016-03-09 07:00:52 +08:00
if (current->next_ptr) {
current->next_ptr->prev_ptr = current;
} else {
to = current;
}
2014-02-10 09:10:30 +08:00
} else {
2020-04-02 07:20:12 +08:00
current->prev_ptr = nullptr;
current->next_ptr = nullptr;
2014-02-10 09:10:30 +08:00
}
2016-03-09 07:00:52 +08:00
current = next;
2014-02-10 09:10:30 +08:00
}
_data->first = from;
_data->last = to;
2014-02-10 09:10:30 +08:00
}
template <class C>
struct AuxiliaryComparator {
C compare;
_FORCE_INLINE_ bool operator()(const Element *a, const Element *b) const {
return compare(a->value, b->value);
}
};
template <class C>
void sort_custom() {
//this version uses auxiliary memory for speed.
//if you don't want to use auxiliary memory, use the in_place version
int s = size();
if (s < 2) {
return;
}
Element **aux_buffer = memnew_arr(Element *, s);
int idx = 0;
for (Element *E = front(); E; E = E->next_ptr) {
aux_buffer[idx] = E;
idx++;
}
SortArray<Element *, AuxiliaryComparator<C>> sort;
sort.sort(aux_buffer, s);
_data->first = aux_buffer[0];
2020-04-02 07:20:12 +08:00
aux_buffer[0]->prev_ptr = nullptr;
aux_buffer[0]->next_ptr = aux_buffer[1];
_data->last = aux_buffer[s - 1];
aux_buffer[s - 1]->prev_ptr = aux_buffer[s - 2];
2020-04-02 07:20:12 +08:00
aux_buffer[s - 1]->next_ptr = nullptr;
for (int i = 1; i < s - 1; i++) {
aux_buffer[i]->prev_ptr = aux_buffer[i - 1];
aux_buffer[i]->next_ptr = aux_buffer[i + 1];
}
memdelete_arr(aux_buffer);
}
const void *id() const {
return (void *)_data;
}
2014-02-10 09:10:30 +08:00
/**
* copy constructor for the list
*/
List(const List &p_list) {
const Element *it = p_list.front();
2014-02-10 09:10:30 +08:00
while (it) {
push_back(it->get());
it = it->next();
2014-02-10 09:10:30 +08:00
}
}
List() {}
2014-02-10 09:10:30 +08:00
~List() {
clear();
if (_data) {
ERR_FAIL_COND(_data->size_cache);
memdelete_allocator<_Data, A>(_data);
2014-02-10 09:10:30 +08:00
}
}
2014-02-10 09:10:30 +08:00
};
#endif // LIST_H