array.h

Go to the documentation of this file.

#ifndef ARRAY_H
#define ARRAY_H
#pragma once
 
#include <initializer_list>
#include "allocator.h"
#include "config.h"
#include "baseArray.h"
#include "iterationStream.h"
#include "randomAccessIterator.h"
#include "error.h"
 
namespace original {
    template<typename TYPE, typename ALLOC = allocator<TYPE>>
    class array final : public iterationStream<TYPE, array<TYPE, ALLOC>>, public baseArray<TYPE, ALLOC> {
        u_integer size_; 
        TYPE* body;    
 
        void arrInit(u_integer size);
 
        void arrDestroy() noexcept;
 
        TYPE getElem(integer pos) const;
 
        void setElem(integer pos, const TYPE &e);
    public:
 
    class Iterator final : public randomAccessIterator<TYPE, ALLOC> {
        explicit Iterator(TYPE* ptr, const array* container, integer pos);
 
    public:
        friend array;
 
        Iterator(const Iterator& other);
 
        Iterator& operator=(const Iterator& other);
 
        Iterator* clone() const override;
 
        bool atPrev(const iterator<TYPE> *other) const override;
 
        bool atNext(const iterator<TYPE> *other) const override;
 
        [[nodiscard]] std::string className() const override;
    };
 
        explicit array(u_integer size = 0, ALLOC alloc = ALLOC{});
 
        array(const std::initializer_list<TYPE>& lst);
 
        array(const array& other);
 
        array& operator=(const array& other);
 
        array(array&& other) noexcept;
 
        array& operator=(array&& other) noexcept;
 
        [[nodiscard]] u_integer size() const override;
 
        TYPE& data() const;
 
        TYPE get(integer index) const override;
 
        TYPE& operator[](integer index) override;
 
        using serial<TYPE, ALLOC>::operator[];
 
        void set(integer index, const TYPE& e) override;
 
        u_integer indexOf(const TYPE& e) const override;
 
        Iterator* begins() const override;
 
        Iterator* ends() const override;
 
        [[nodiscard]] std::string className() const override;
 
        ~array() override;
    };
 
} // namespace original
 
    template<typename TYPE, typename ALLOC>
    void original::array<TYPE, ALLOC>::arrInit(const u_integer size) {
        this->size_ = size;
        this->body = this->allocate(this->size_);
        for (u_integer i = 0; i < this->size(); ++i) {
            this->construct(&this->body[i]);
        }
    }
 
    template<typename TYPE, typename ALLOC>
    void original::array<TYPE, ALLOC>::arrDestroy() noexcept
    {
        if (this->body){
            for (u_integer i = 0; i < this->size_; ++i) {
                this->destroy(&this->body[i]);
            }
            this->deallocate(this->body, this->size_);
            this->body = nullptr;
        }
    }
 
    template <typename TYPE, typename ALLOC>
    TYPE original::array<TYPE, ALLOC>::getElem(integer pos) const
    {
        if constexpr (std::is_copy_constructible_v<TYPE>) {
            return this->body[pos];
        } else if constexpr (std::is_move_constructible_v<TYPE>) {
            return std::move(this->body[pos]);
        } else {
            staticError<unSupportedMethodError, !std::is_copy_constructible_v<TYPE> && !std::is_move_constructible_v<TYPE>>::asserts();
            return TYPE{};
        }
    }
 
    template <typename TYPE, typename ALLOC>
    void original::array<TYPE, ALLOC>::setElem(integer pos, const TYPE& e)
    {
        if constexpr (std::is_copy_assignable_v<TYPE>) {
            this->body[pos] = e;
        } else if constexpr (std::is_move_assignable_v<TYPE>) {
            this->body[pos] = std::move(const_cast<TYPE&>(e));
        } else {
            staticError<unSupportedMethodError, !std::is_copy_constructible_v<TYPE> && !std::is_move_constructible_v<TYPE>>::asserts();
        }
    }
 
    template<typename TYPE, typename ALLOC>
    original::array<TYPE, ALLOC>::Iterator::Iterator(TYPE* ptr, const array* container, integer pos)
        : randomAccessIterator<TYPE, ALLOC>(ptr, container, pos) {}
 
    template<typename TYPE, typename ALLOC>
    original::array<TYPE, ALLOC>::Iterator::Iterator(const Iterator& other)
        : randomAccessIterator<TYPE, ALLOC>(nullptr, nullptr, 0)
    {
        this->operator=(other);
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::Iterator::operator=(const Iterator& other) -> Iterator&
    {
        if (this == &other) {
            return *this;
        }
        randomAccessIterator<TYPE, ALLOC>::operator=(other);
        return *this;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::Iterator::clone() const -> Iterator* {
        return new Iterator(*this);
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::Iterator::atPrev(const iterator<TYPE> *other) const -> bool {
        auto other_it = dynamic_cast<const Iterator*>(other);
        return this->_ptr + 1 == other_it->_ptr;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::Iterator::atNext(const iterator<TYPE> *other) const -> bool {
        auto other_it = dynamic_cast<const Iterator*>(other);
        return other_it->_ptr + 1 == this->_ptr;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::Iterator::className() const -> std::string {
        return "array::Iterator";
    }
 
    template<typename TYPE, typename ALLOC>
    original::array<TYPE, ALLOC>::array(const u_integer size, ALLOC alloc)
        : baseArray<TYPE, ALLOC>(std::move(alloc)), size_(), body(nullptr) {
        this->arrInit(size);
    }
 
    template<typename TYPE, typename ALLOC>
    original::array<TYPE, ALLOC>::array(const std::initializer_list<TYPE>& lst)
        : array(lst.size()) {
        u_integer i = 0;
        for (const auto& e : lst) {
            this->setElem(i, e);
            i += 1;
        }
    }
 
    template<typename TYPE, typename ALLOC>
    original::array<TYPE, ALLOC>::array(const array& other)
        : array(other.size()) {
        this->operator=(other);
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::operator=(const array& other) -> array&
    {
        if (this == &other)
            return *this;
 
        this->arrDestroy();
 
        this->arrInit(other.size());
        for (u_integer i = 0; i < this->size_; i++) {
            this->setElem(i, other.getElem(i));
        }
        if constexpr (ALLOC::propagate_on_container_copy_assignment::value){
            this->allocator = other.allocator;
        }
        return *this;
    }
 
    template<typename TYPE, typename ALLOC>
    original::array<TYPE, ALLOC>::array(array&& other) noexcept : array() {
        this->operator=(std::move(other));
    }
 
    template<typename TYPE, typename ALLOC>
    original::array<TYPE, ALLOC>& original::array<TYPE, ALLOC>::operator=(array&& other) noexcept {
        if (this == &other)
            return *this;
 
        this->arrDestroy();
 
        this->body = other.body;
        this->size_ = other.size_;
        if constexpr (ALLOC::propagate_on_container_move_assignment::value){
            this->allocator = std::move(other.allocator);
        }
        other.arrInit(0);
        return *this;
    }
 
    template<typename TYPE, typename ALLOC>
    original::array<TYPE, ALLOC>::~array() {
        this->arrDestroy();
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::size() const -> u_integer
    {
        return this->size_;
    }
 
    template<typename TYPE, typename ALLOC>
    TYPE& original::array<TYPE, ALLOC>::data() const {
        return this->body[0];
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::get(integer index) const -> TYPE
    {
        if (this->indexOutOfBound(index)){
            throw outOfBoundError("Index " + std::to_string(this->parseNegIndex(index)) +
                                  " out of bound max index " + std::to_string(this->size() - 1) + ".");
        }
        return this->getElem(this->parseNegIndex(index));
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::operator[](integer index) -> TYPE&
    {
        if (this->indexOutOfBound(index)){
            throw outOfBoundError("Index " + std::to_string(this->parseNegIndex(index)) +
                                  " out of bound max index " + std::to_string(this->size() - 1) + ".");
        }
        return this->body[this->parseNegIndex(index)];
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::set(integer index, const TYPE &e) -> void
    {
        if (this->indexOutOfBound(index)){
            throw outOfBoundError("Index " + std::to_string(this->parseNegIndex(index)) +
                                  " out of bound max index " + std::to_string(this->size() - 1) + ".");
        }
        this->setElem(this->parseNegIndex(index), e);
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::indexOf(const TYPE &e) const -> u_integer
    {
        if constexpr (Comparable<TYPE>)
        {
            for (u_integer i = 0; i < this->size(); i += 1)
            {
                if (this->get(i) == e)
                {
                    return i;
                }
            }
            return this->size();
        } else {
            throw unSupportedMethodError("Comparison unsupported type");
        }
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::begins() const -> Iterator* {
        return new Iterator(&this->body[0], this, 0);
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::ends() const -> Iterator* {
        return new Iterator(&this->body[this->size() - 1], this, this->size() - 1);
    }
 
    template<typename TYPE, typename ALLOC>
    std::string original::array<TYPE, ALLOC>::className() const
    {
        return "array";
    }
 
#endif //ARRAY_H