239 lines
7.1 KiB
C++
239 lines
7.1 KiB
C++
#ifndef __ARRAYLIST_INCLUDE_H_
|
|
#define __ARRAYLIST_INCLUDE_H_
|
|
|
|
// NOTE: I decided to implement this because I wanted some sort of dynamic array (for example for the keyeventmanager).
|
|
// Also I wanted to template the Queue (for the scheduler) but with this I can just replace the Queue and use the
|
|
// ArrayList instead, without additional effort.
|
|
// It's also cool to use the allocator a bit more and introduce realloc because I coded that thing
|
|
|
|
#include "user/lib/List.h"
|
|
#include <cstddef>
|
|
#include <memory>
|
|
|
|
// I put most of the implementation in the header because the templating makes it cumbersome to split
|
|
|
|
template<typename T>
|
|
class ArrayList : public List<T> {
|
|
public:
|
|
using Type = typename List<T>::Type; // Use this just in case T changes from the List type
|
|
using Iterator = typename List<T>::Iterator;
|
|
|
|
private:
|
|
static constexpr const std::size_t default_cap = 10; // Arbitrary but very small because this isn't a real OS :(
|
|
static constexpr const std::size_t min_cap = 5; // Slots to allocate extra when array full
|
|
|
|
std::unique_ptr<Type[]> buf; // Heap allocated as size needs to change during runtime
|
|
// Can't use Array for the same reason so we use a C Style array
|
|
// NOTE: Normally I wouldn't use smart pointers for low level data structers
|
|
// but in this case it's ok as buf doesn't change often
|
|
// and the unique_ptr basically has no overhead.
|
|
// At least I didn't have to write any of the 3 deletes that would
|
|
// be necessary otherwise ¯\_(ツ)_/¯
|
|
std::size_t buf_pos = 0;
|
|
std::size_t buf_cap = 0;
|
|
|
|
void init() {
|
|
buf = std::make_unique<Type[]>(default_cap);
|
|
buf_cap = ArrayList::default_cap;
|
|
}
|
|
|
|
std::size_t get_rem_cap() const {
|
|
return buf_cap - size();
|
|
}
|
|
|
|
// Enlarges the buffer if we run out of space
|
|
std::size_t expand() {
|
|
// Init if necessary
|
|
if (!buf) {
|
|
init();
|
|
return buf_cap; // Dont have to realloc after init
|
|
}
|
|
|
|
// Since we only ever add single elements this should never get below zero
|
|
if (get_rem_cap() < min_cap) {
|
|
std::size_t new_cap = buf_cap + min_cap;
|
|
|
|
// Alloc new array
|
|
std::unique_ptr<Type[]> new_buf = std::make_unique<Type[]>(new_cap);
|
|
|
|
// Swap current elements to new array
|
|
for (std::size_t i = 0; i < size(); ++i) {
|
|
new_buf.get()[i] = std::move(buf.get()[i]); // Should I have just used a regular pointer?
|
|
}
|
|
|
|
// Move new array to buf, deleting the old array
|
|
buf = std::move(new_buf);
|
|
buf_cap = new_cap;
|
|
}
|
|
|
|
return buf_cap;
|
|
}
|
|
|
|
// unsigned int shrink {}
|
|
|
|
// Returns new pos, both do element copying if necessary, -1 if failed
|
|
// Index is location where space should be made/removed
|
|
std::size_t copy_right(std::size_t i) {
|
|
if (i > size()) {
|
|
// Error: No elements here
|
|
return -1;
|
|
}
|
|
|
|
expand();
|
|
|
|
// Otherwise i == pos and we don't need to copy anything
|
|
if (i < size()) {
|
|
// Enough space to copy elements after pos i
|
|
// Copy to the right to make space
|
|
//
|
|
// [0 1 2 3 _], expand(0) => [_ 0 1 2 3 _]
|
|
// ^ | |
|
|
// [0 1 2 3 _], expand(1) => [0 _ 1 2 3 _]
|
|
// ^ | |
|
|
// pos = 4 pos = 5
|
|
for (std::size_t idx = size(); idx > i; --idx) { // idx > i so idx - 1 is never < 0
|
|
buf.get()[idx] = std::move(buf.get()[idx - 1]);
|
|
}
|
|
|
|
// Only change pos if elements were copied
|
|
++buf_pos;
|
|
}
|
|
|
|
return size();
|
|
}
|
|
|
|
// Don't realloc here, we don't need to shring the buffer every time
|
|
// One could introduce a limit of free space but I don't care for now
|
|
// Would be bad if the scheduler triggers realloc everytime a thread is removed (if used as readyqueue)...
|
|
std::size_t copy_left(std::size_t i) {
|
|
if (i >= size()) {
|
|
// Error: No elements here
|
|
return -1;
|
|
}
|
|
|
|
// Decrement before loop because we overwrite 1 element (1 copy less than expand)
|
|
--buf_pos;
|
|
|
|
// [0 1 2 3 _], shrink(1) => [0 2 3 _]
|
|
// ^ | |
|
|
// pos = 3 pos = 2
|
|
for (std::size_t idx = i; idx < size(); ++idx) { // idx < pos so idx + 1 is never outside of size limit
|
|
buf.get()[idx] = std::move(buf.get()[idx + 1]);
|
|
}
|
|
|
|
return size();
|
|
}
|
|
|
|
public:
|
|
Iterator begin() override {
|
|
return Iterator(&buf.get()[0]);
|
|
}
|
|
|
|
Iterator end() override {
|
|
return Iterator(&buf.get()[size()]);
|
|
}
|
|
|
|
// Returns new pos
|
|
std::size_t insert_at(Type e, std::size_t i) override {
|
|
if (i > size()) {
|
|
// Error: Space between elements
|
|
return -1;
|
|
}
|
|
|
|
if (i == size()) {
|
|
// Insert at end
|
|
return insert_last(e);
|
|
}
|
|
|
|
copy_right(i); // Changes pos
|
|
buf.get()[i] = e;
|
|
|
|
return size();
|
|
}
|
|
|
|
std::size_t insert_first(Type e) override {
|
|
return insert_at(e, 0);
|
|
}
|
|
|
|
std::size_t insert_last(Type e) override {
|
|
expand();
|
|
buf.get()[size()] = e;
|
|
++buf_pos;
|
|
|
|
return size();
|
|
}
|
|
|
|
// Returns removed element
|
|
Type remove_at(std::size_t i) override {
|
|
if (i >= size()) {
|
|
// ERROR: No element here
|
|
return NULL;
|
|
}
|
|
|
|
Type e = buf.get()[i];
|
|
copy_left(i);
|
|
return e;
|
|
}
|
|
|
|
Type remove_first() override {
|
|
return remove_at(0);
|
|
}
|
|
|
|
Type remove_last() override {
|
|
// If index -1 unsigned int will overflow and remove_at will catch that
|
|
return remove_at(size() - 1);
|
|
}
|
|
|
|
// Returns true on success
|
|
bool remove(Type e) override {
|
|
for (std::size_t i = 0; i < size(); ++i) {
|
|
if (buf.get()[i] == e) {
|
|
copy_left(i);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
Type get(std::size_t i) const override {
|
|
if (i >= size()) {
|
|
// ERROR: No element there
|
|
return NULL;
|
|
}
|
|
|
|
return buf.get()[i];
|
|
}
|
|
|
|
Type first() const override {
|
|
return get(0);
|
|
}
|
|
|
|
Type last() const override {
|
|
return get(size() - 1); // Underflow gets catched by get(unsigned int i)
|
|
}
|
|
|
|
bool empty() const override {
|
|
return !size();
|
|
}
|
|
|
|
std::size_t size() const override {
|
|
return buf_pos;
|
|
}
|
|
|
|
void print(OutStream& out) const override {
|
|
if (empty()) {
|
|
out << "Print List (0 elements)" << endl;
|
|
return;
|
|
}
|
|
|
|
out << "Print List (" << dec << size() << " elements): ";
|
|
for (std::size_t i = 0; i < size(); ++i) {
|
|
out << dec << get(i) << " ";
|
|
}
|
|
out << endl;
|
|
}
|
|
};
|
|
|
|
#endif
|