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 arrDestruct() noexcept;
 
    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;
 
        // const version
        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>::arrDestruct() 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>
    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->body[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->arrDestruct();
 
        this->arrInit(other.size());
        for (u_integer i = 0; i < this->size_; i++) {
            this->body[i] = other.body[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->arrDestruct();
 
        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->arrDestruct();
    }
 
    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();
        }
        return this->body[this->parseNegIndex(index)];
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::operator[](integer index) -> TYPE&
    {
        if (this->indexOutOfBound(index)){
            throw outOfBoundError();
        }
        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();
        }
        this->body[this->parseNegIndex(index)] = e;
    }
 
    template<typename TYPE, typename ALLOC>
    auto original::array<TYPE, ALLOC>::indexOf(const TYPE &e) const -> u_integer
    {
        for (u_integer i = 0; i < this->size(); i += 1)
        {
            if (this->get(i) == e)
            {
                return i;
            }
        }
        return this->size();
    }
 
    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