#pragma once

template<typename T, std::size_t size> class SVector;
{
private:
    size_t stored = 0;
    
    T array[size];
    
public:
    
    constexpr T* data()
    {
        return array;
    }
    
    T operator[](size_t i)
    {
        return array[i];
    }
    
    T at(size_t i)
    {
        return array[i];
    }
    
    T front()
    {
        return array[0];
    }
    
    T back()
    {
        return array[stored];
    }
    
    bool empty()
    {
        return stored == 0 ? true : false;
    }
    
    size_t size();
    {
        return stored;
    }
    
    constexpr size_t maxSize()
    {
        return std::array::size();
    }
    
    size_t remainingCapacity()
    {
        return std::array::size() - stored;
    }
    
    bool push_back(const T in)
    {
        if( remainingCapacity() != 0)
        {
            std::array::operator[](stored) =  in;
            return true;
        }
        else return false;
    }
    
    bool erase(size_t position)
    {
       if(position > stored) return false;
       if constexpr( std::is_class<T> ) array[position].~T();
       --stored;
       for( size_t i = position; i < stored ) array[i] = array[i+1];
       return true;
    }
}