fennec-org/fennec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- PrettyPrinters working, added cstring/wcstring, string/wstring, optional, allocation, list

Browse Source
This commit is contained in:
Medusa Slockbower
2025-08-08 01:54:39 -04:00
parent 2cb41e1437
commit b7d8426e86
6 changed files with 158 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
include/fennec/containers/list.h
View File

@@ -87,7 +87,7 @@ public:
/// \brief Destructor, destructs all elements then releases the allocation.
constexpr ~list() {
for (size_t i = 0; i < capacity(); ++i) {
_table[i].data = nullopt;
_table[i].value = nullopt;
}
}
@@ -119,7 +119,7 @@ public:
assertd(i >= 0 && size_t(i) < _size, "Index out of Bounds");
size_t n = _walk(i);
assertd(n != npos, "Index out of Bounds");
return *_table[n].data;
return *_table[n].value;
}
///
@@ -132,35 +132,35 @@ public:
assertd(i >= 0 && size_t(i) < _size, "Index out of Bounds");
size_t n = _walk(i);
assertd(n != npos, "Index out of Bounds");
return *_table[n].data;
return *_table[n].value;
}
///
/// \brief Access Front Element
/// \returns A reference to the first element in the list
constexpr value_t& front() {
return *_table[_root].data;
return *_table[_root].value;
}
///
/// \brief Const Access Front Element
/// \returns A const-qualified reference to the first element in the list
constexpr const value_t& front() const {
return *_table[_root].data;
return *_table[_root].value;
}
///
/// \brief Access Back Element
/// \returns A reference to the last element in the list
constexpr value_t& back() {
return *_table[_last].data;
return *_table[_last].value;
}
///
/// \brief Const Access Back Element
/// \returns A const-qualified reference to the last element in the list
constexpr const value_t& back() const {
return *_table[_last].data;
return *_table[_last].value;
}
@@ -327,11 +327,11 @@ public:
}
constexpr value_t& operator*() {
return *(_list->_table[_n].data);
return *(_list->_table[_n].value);
}
constexpr value_t* operator->() {
return &*(_list->_table[_n].data);
return &*(_list->_table[_n].value);
}
constexpr bool operator==(const iterator& it) {
@@ -377,11 +377,11 @@ public:
}
constexpr const value_t& operator*() {
return *(_list->_table[_n].data);
return *(_list->_table[_n].value);
}
constexpr const value_t* operator->() {
return &*(_list->_table[_n].data);
return &*(_list->_table[_n].value);
}
constexpr bool operator==(const const_iterator& it) {
@@ -439,23 +439,23 @@ private:
}
struct node {
optional<value_t> data;
optional<value_t> value;
size_t prev, next;
constexpr node()
: data()
: value()
, prev(npos)
, next(npos) {
}
constexpr node(size_t p, size_t n)
: data()
: value()
, prev(p)
, next(n) {
}
constexpr node(size_t p, size_t n, value_t&& val)
: data(fennec::forward<value_t>(val))
: value(fennec::forward<value_t>(val))
, prev(p)
, next(n) {
}
@@ -463,7 +463,7 @@ private:
constexpr ~node() = default;
constexpr void clear() {
data = nullopt;
value = nullopt;
prev = npos;
next = npos;
}
@@ -503,7 +503,7 @@ private:
size_t i = _next_free();
++_size;
fennec::construct(&_table[i].data, fennec::forward<ArgsT>(args)...);
fennec::construct(&_table[i].value, fennec::forward<ArgsT>(args)...);
if (_root == npos) {
_table[i].prev = npos;
@@ -530,7 +530,7 @@ private:
constexpr void _erase(size_t n) {
if (n == npos) return;
fennec::destruct(&_table[n].data);
fennec::destruct(&_table[n].value);
_freed.push_back(n);
--_size;

50
include/fennec/containers/rdtree.h
View File

@@ -68,37 +68,37 @@ public:
template<typename...ArgsT>
explicit constexpr rdtree(ArgsT&&...args)
: _data(), _freed(), _size(1) {
_data.callocate(8);
fennec::construct(&_data[0], npos, npos, npos, npos, fennec::forward<ArgsT>(args)...);
: _table(), _freed(), _size(1) {
_table.callocate(8);
fennec::construct(&_table[0], npos, npos, npos, npos, fennec::forward<ArgsT>(args)...);
}
constexpr rdtree(const rdtree& tree)
: _data(tree._data), _freed(tree._freed), _size(tree._size) {
: _table(tree._table), _freed(tree._freed), _size(tree._size) {
}
constexpr rdtree(rdtree&& tree) noexcept
: _data(fennec::move(tree._data)), _freed(fennec::move(tree._freed)), _size(tree._size) {
: _table(fennec::move(tree._table)), _freed(fennec::move(tree._freed)), _size(tree._size) {
}
// Assignment ==========================================================================================================
constexpr rdtree& operator=(const rdtree& rhs) {
for (value_t* it : this->_data) {
for (value_t* it : this->_table) {
fennec::destruct(it);
}
_data = rhs._data;
_table = rhs._table;
_freed = rhs._freed;
_size = rhs._size;
return *this;
}
constexpr rdtree& operator=(rdtree&& rhs) noexcept {
for (value_t* it : _data) {
for (value_t* it : _table) {
fennec::destruct(it);
}
_data = fennec::move(rhs._data);
_table = fennec::move(rhs._table);
_freed = fennec::move(rhs._freed);
_size = rhs._size;
return *this;
@@ -112,7 +112,7 @@ public:
}
constexpr size_t capacity() const {
return _data.capacity();
return _table.capacity();
}
constexpr bool empty() const {
@@ -126,42 +126,42 @@ public:
/// \param i The id of the node to check
/// \returns The id of the parent node
constexpr size_t parent(size_t i) const {
return i == npos ? npos : _data[i].parent;
return i == npos ? npos : _table[i].parent;
}
///
/// \param i The id of the node to check
/// \returns The id of the child node
constexpr size_t child(size_t i) const {
return i == npos ? npos : _data[i].child;
return i == npos ? npos : _table[i].child;
}
///
/// \param i The id of the node to check
/// \returns The id of the next node
constexpr size_t next(size_t i) const {
return i == npos ? npos : _data[i].next;
return i == npos ? npos : _table[i].next;
}
///
/// \param i The id of the node to check
/// \returns The id of the previous node
constexpr size_t prev(size_t i) const {
return i == npos ? npos : _data[i].prev;
return i == npos ? npos : _table[i].prev;
}
///
/// \param i The id of the node to access
/// \returns A reference to the value of the node wrapped in an optional
constexpr optional<value_t>& operator[](size_t i) {
return _data[i].value;
return _table[i].value;
}
///
/// \param i The id of the node to access
/// \returns A const-qualified reference to the value of the node wrapped in an optional
constexpr const optional<value_t>& operator[](size_t i) const {
return _data[i].value;
return _table[i].value;
}
@@ -194,12 +194,12 @@ public:
protected:
allocation<node, alloc_t> _data;
allocation<node, alloc_t> _table;
list<size_t> _freed;
size_t _size;
void _expand() {
_data.creallocate(_data.capacity() * 2);
_table.creallocate(_table.capacity() * 2);
}
size_t _next_free() {
@@ -217,21 +217,21 @@ protected:
template<typename...ArgsT>
constexpr size_t _insert(size_t p, ArgsT&&...args) {
if (_size == 0) {
fennec::construct(&_data[root], npos, npos, npos, npos, fennec::forward<ArgsT>(args)...);
fennec::construct(&_table[root], npos, npos, npos, npos, fennec::forward<ArgsT>(args)...);
_size = 1;
return root;
}
if (p == npos) {
_data[root].value = value_t(fennec::forward<ArgsT>(args)...);
_table[root].value = value_t(fennec::forward<ArgsT>(args)...);
return root;
}
size_t i = _next_free();
size_t n = child(p);
_data[p].child = i;
if (n != npos) _data[n].prev = i;
fennec::construct(&_data[i], p, npos, npos, n, fennec::forward<ArgsT>(args)...);
_table[p].child = i;
if (n != npos) _table[n].prev = i;
fennec::construct(&_table[i], p, npos, npos, n, fennec::forward<ArgsT>(args)...);
return i;
}
@@ -244,13 +244,13 @@ protected:
if (n == npos) continue;
queue.push_back(next(n));
queue.push_back(child(n));
fennec::destruct(&_data[n]);
fennec::destruct(&_table[n]);
_freed.push_back(n);
--_size;
++j;
}
fennec::destruct(&_data[i]);
fennec::destruct(&_table[i]);
_freed.push_back(i);
--_size;
}