#pragma once
#ifndef _INT_ARRAY_
#define _INT_ARRAY_
#include <stdexcept>
#include <algorithm> 
 
template <typename T> class CustomVector
{
    struct storage
    {
        storage() : mas(0), capacity(0), size(0){}
        T* mas;
        size_t capacity;
        size_t size;
    };

    storage mStorage;

public:
    
    ~CustomVector()
    {
        delete [] mStorage.mas;
    }
 
    CustomVector()
    {
    }

    CustomVector(const CustomVector<T>& in)
    {
        mStorage.size = in.mStorage.size;
        mStorage.capacity = in.mStorage.capacity;
        mStorage.mas = new T[ mStorage.capacity];
        for (int i = 0; i < mStorage.size; ++i)
             mStorage.mas[i] = in.mStorage.mas[i];
    }

    explicit CustomVector(const size_t aSize, const T val = 0)
    {
        mStorage.mas = new T[aSize];
        mStorage.size = aSize;
        mStorage.capacity = aSize;
        for (int i = 0; i < mStorage.size; ++i)
             mStorage.mas[i] = val;
    }

    size_t getSize() const
    {
        return mStorage.size;
    }
 
    size_t getCapacity() const
    {
        return mStorage.capacity;
    }
 
    void reserve(size_t n)
    {
        if (n > mStorage.capacity)
        {
            T *temp = new T[n];
            mStorage.capacity = n;
            for (int i = 0; i < mStorage.size; ++i)
               temp[i] = mStorage.mas[i];
            delete []mStorage.mas;
            mStorage.mas = temp;
        }
    }
 
    void resize(size_t n)
    {
        if (mStorage.size > n)
        {
            mStorage.size = n;
            return;
        }
        if (mStorage.size < n)
        {
            reserve(n);
            for (int i = mStorage.size; i < n; ++i)
                mStorage.mas[i].~T();
        }
    }
 
    void pushBack(T val)
    {
        if (mStorage.size >= mStorage.capacity)
        {
            size_t new_size = mStorage.size + 1;
            reserve(new_size + new_size / 2);
        }
        mStorage.mas[mStorage.size++] = val;
    }
 
    void popBack()
    {
        if (mStorage.size >= 1)
            --mStorage.size;
    }
 
    int& operator[] (size_t n)
    {
        return mStorage.mas[n];
    }
 
    const int& operator[] (size_t n) const
    {
        return mStorage.mas[n];
    }
 
    int& at(size_t n)
    {
        if (n >= mStorage.size)
            throw std::out_of_range("Index out of range!");
        return mStorage.mas[n];
    }
 
    CustomVector& operator= (CustomVector<T> in)
    {
        swap(in);
        return *this;
    }
 
    void swap(CustomVector<T>& in)
    {
        storage temp(*this);
        in.mStorage = mStorage;
        mStorage = temp;
    }
 
    void clear()
    {
        for (int i = 0; i < mStorage.size; ++i)
            mStorage.mas[i].~T();
        mStorage.size = 0;
    }
 
    void erase(size_t index)
    {
        if (index >= mStorage.size) 
            throw std::out_of_range("Index out of range!");
        --mStorage.size;
        for (int i = index; i < mStorage.size; ++i)
            mStorage.mas[i] = mStorage.mas[i + 1];
    }
 
    bool empty() const
    {
        return mStorage.size == 0;
    }
 
    int front() const
    {
        return mStorage.mas[0];
    }
 
    int back() const
    {
        return mStorage.mas[size-1];
    }
 
    int& front()
    {
        return mStorage.mas[0];
    }
 
    int& back()
    {
        return mStorage.mas[size-1];
    }
};

#endif