Buffer.hpp

#pragma once
 
#include "../../Typing.hpp"
#include "../Exceptions/BufferOverflow.hpp"
#include "../Exceptions/OutOfRange.hpp"
 
#include <string.h>
 
namespace Melon::Memory 
{
        template<typename T>
        class Buffer
        {
                T *data;
                Typing::USize __size;
 
        public:
                Buffer()
                {
                        this->data = new T[1];
                        this->__size = 0;
                }

                Buffer(const T *data, Typing::USize size)
                        : __size(size)
                {
                        this->data = new T[size];
                        memcpy(this->data, data, size);
                }
                
                Buffer(const Buffer<T> &other)
                {
                        this->__size = other.__size;
                        this->data = new T[this->__size ? this->__size : 1];
                        memcpy(this->data, other.data, this->__size);
                }

                Buffer(Buffer<T> &&other)
                {
                        this->__size = other.__size;
                        this->data = new T[this->__size ? this->__size : 1];
                        memcpy(this->data, other.data, other.__size);
 
                        memset(other.data, 0, other.__size);
                        other.__size = 0;
                }

                ~Buffer()
                {
                        if (this->data)
                                delete[] this->data;
                }

                Buffer<T> &copy(this const Buffer<T> &self, Buffer<T> &dest, Typing::USize size)
                {
                        if (size > self.__size)
                                throw Exceptions::BufferOverflow(size, self.__size);
                        if (size > dest.__size)
                                throw Exceptions::BufferOverflow(size, dest.__size);
 
                        memcpy(dest.data, self.data, size);
 
                        return dest;
                }

                Buffer<T> &set(this Buffer<T> &self, T c, Typing::USize size)
                {
                        if (size > self.__size)
                                throw Exceptions::BufferOverflow(size, self.__size);
 
                        memset(self.data, c, size);
 
                        return self;
                }

                Buffer<T> &move(this const Buffer<T> &self, Buffer<T> &dest, Typing::USize size)
                {
                        if (size > self.__size)
                                throw Exceptions::BufferOverflow(size, self.__size);
                        if (size > dest.__size)
                                throw Exceptions::BufferOverflow(size, dest.__size);
 
                        memmove(dest.data, self.data, size);
 
                        return dest;
                }

                int compare(this const Buffer<T> &self, const Buffer<T> &other, Typing::USize size)
                {
                        if (size > self.__size)
                                throw Exceptions::BufferOverflow(size, self.__size);
                        if (size > other.__size)
                                throw Exceptions::BufferOverflow(size, other.__size);
 
                        int result = memcmp(self.data, other.data, size);
 
                        return result;
                }

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

                Typing::USize size(this const Buffer<T> &self)
                {
                        return self.__size;
                }

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

                const T *end(this const Buffer<T> &self)
                {
                        return self.data + self.__size;
                }

                void resize(this Buffer<T> &self, Typing::USize new_size)
                {
                        T *new_data = new T[new_size];
 
                        for (Typing::USize i = 0; i < self.__size; ++i)
                                new_data[i] = self.data[i];
 
                        delete[] self.data;
                        self.data = new_data;
                        self.__size = new_size;
                }

                bool operator ==(this const Buffer<T> &self, const Buffer<T> &other)
                {
                        return self.__size == other.__size and self.compare(other, self.__size) == 0;
                }

                bool operator !=(this const Buffer<T> &self, const Buffer<T> &other)
                {
                        return not (self == other);
                }

                bool operator <(this const Buffer<T> &self, const Buffer<T> &other)
                {
                        Typing::USize size = self.__size < other.__size ? self.__size : other.__size;
                        int result = self.compare(other, size);
                        if (result != 0)
                                return result < 0;
                        return self.__size < other.__size;
                }

                bool operator >(this const Buffer<T> &self, const Buffer<T> &other)
                {
                        Typing::USize size = self.__size < other.__size ? self.__size : other.__size;
                        int result = self.compare(other, size);
                        if (result != 0)
                                return result > 0;
                        return self.__size > other.__size;
                }

                bool operator <=(this const Buffer<T> &self, const Buffer<T> &other)
                {
                        return self < other or self == other;
                }

                bool operator >=(this const Buffer<T> &self, const Buffer<T> &other)
                {
                        return self > other or self == other;
                }

                T &operator [](this Buffer<T> &self, Typing::USize index)
                {
                        if (index >= self.__size)
                                throw Exceptions::OutOfRange(index, self.__size);
 
                        return self.data[index];
                }

                const T &operator [](this const Buffer<T> &self, Typing::USize index)
                {
                        if (index >= self.__size)
                                throw Exceptions::OutOfRange(index, self.__size);
 
                        return self.data[index];
                }

                Buffer<T> &operator =(this Buffer<T> &self, const Buffer<T> &other)
                {
                        if (self != other) {
                                delete[] self.data;
                                self.data = new T[other.__size ? other.__size : 1];
                                self.__size = other.__size;
                                memcpy(self.data, other.data, other.__size);
                        }
 
                        return self;
                }

                Buffer<T> &operator =(this Buffer<T> &self, Buffer<T> &&other)
                {
                        if (self != other) {
                                delete[] self.data;
                                self.data = new T[other.__size ? other.__size : 1];
                                memcpy(self.data, other.data, other.__size);
                                self.__size = other.__size;
 
                                memset(other.data, 0, other.__size);
                                other.__size = 0;
                        }
 
                        return self;
                }
        };
} // namespace Melon::Memory