Vector.hpp

#pragma once
 
#include "Internal/Memory/Buffer.hpp"
#include "Typing.hpp"

namespace Melon::Vector
{
        template<typename T>
        class Vector
        {
                Memory::Buffer<T> buf;
                Typing::USize obj_count;
                Typing::USize __capacity;
 
                void extend(this Vector<T> &self)
                {
                        self.__capacity *= 2;
                        self.buf.resize(self.__capacity);
                }
 
        public:
                Vector()
                        : obj_count(0), __capacity(1)
                {
                        this->buf = Memory::Buffer<T>(new T[this->__capacity], this->__capacity);
                }

                template<Typing::USize N>
                Vector(const T (&objects)[N])
                {
                        this->__capacity = N;
                        this->buf = Memory::Buffer<T>(new T[this->__capacity], this->__capacity);
 
                        Typing::USize i = 0;
                        for (; i < N; i++)
                                this->buf[i] = objects[i];
                        this->obj_count = i;
                }

                Vector(const Vector<T> &other)
                {
                        this->buf = other.buf;
                        this->__capacity = other.__capacity;
                        this->obj_count = other.obj_count;
                }

                Vector(Vector<T> &&other)
                {
                        this->buf = std::move(other.buf);
                        this->__capacity = other.__capacity;
                        this->obj_count = other.obj_count;
 
                        other.__capacity = 0;
                        other.obj_count = 0;
                }

                const T *begin(this const Vector<T> &self)
                {
                        return self.buf.begin();
                }

                const T *end(this const Vector<T> &self)
                {
                        return self.buf.begin() + self.obj_count;
                }

                void pushBack(this Vector<T> &self, const T &object)
                {
                        if (self.obj_count >= self.__capacity)
                                self.extend();
 
                        self.buf[self.obj_count++] = object;
                }

                template<typename... ARGS>
                void emplaceBack(this Vector<T> &self, ARGS &&...args)
                {
                        if (self.obj_count >= self.__capacity)
                                self.extend();
 
                        self.buf[self.obj_count] = T(args...);
                        ++self.obj_count;
                }

                T &popBack(this Vector<T> &self)
                {
                        if (self.obj_count > 0) {
                                --self.obj_count;
                                T &obj = self.buf[self.obj_count];
                                return obj;
                        } else {
                                throw Exceptions::OutOfRange(self.obj_count, 0);
                        }
                }

                void erase(this Vector<T> &self, Typing::USize index)
                {
                        if (index >= self.obj_count)
                                throw Exceptions::OutOfRange(index, self.obj_count);
 
                        for (Typing::USize i = index; i < self.obj_count - 1; i++)
                                self.buf[i] = self.buf[i + 1];
 
                        --self.obj_count;
                }

                void clear(this Vector<T> &self)
                {
                        self.buf.set(0, self.buf.size());
                        self.obj_count = 0;
                }

                const T *data(this const Vector<T> &self)
                {
                        return self.buf.get();
                }

                Memory::Buffer<T> toBuffer(this const Vector<T> &self)
                {
                        Memory::Buffer<T> result(self.buf.get(), self.buf.size());
                        return result;
                }

                Typing::USize length(this const Vector<T> &self)
                {
                        return self.obj_count;
                }

                Typing::USize capacity(this const Vector<T> &self)
                {
                        return self.__capacity;
                }

                bool isEmpty(this const Vector<T> &self)
                {
                        return self.obj_count == 0;
                }

                bool operator ==(this const Vector<T> &self, const Vector<T> &other)
                {
                        return self.buf == other.buf;
                }

                T &operator [](this Vector<T> &self, Typing::USize index)
                {
                        return self.buf[index];
                }

                const T &operator [](this const Vector<T> &self, Typing::USize index)
                {
                        return self.buf[index];
                }

                Vector<T> &operator =(this Vector<T> &self, const Vector<T> &other)
                {
                        if (&self != &other) {
                                self.buf = other.buf;
                                self.__capacity = other.__capacity;
                                self.obj_count = other.obj_count;
                        }
 
                        return self;
                }

                Vector<T> &operator =(this Vector<T> &self, Vector<T> &&other)
                {
                        if (&self != &other) {
                                self.buf = std::move(other.buf);
                                self.__capacity = other.__capacity;
                                self.obj_count = other.obj_count;
 
                                other.__capacity = 0;
                                other.obj_count = 0;
                        }
 
                        return self;
                }
        };
} // namespace Melon::Vector