Array.hpp

Go to the documentation of this file.

#ifndef SOLIDUTILS_INCLUDE_ARRAY_HPP
#define SOLIDUTILS_INCLUDE_ARRAY_HPP


#include "Debug.hpp"

#include <memory>


namespace sl
{

template<typename T>
class Array
{
  public:
    using iterator = T *;
    using const_iterator = T const *;

    Array() :
      m_size(0),
      m_data(nullptr)
    {
      // do nothing
    }


    Array(
        size_t const size) :
      m_size(size),
      m_data(new T[size])
    {
      // do nothing
    }


    Array(
        size_t const size,
        T const value) :
      Array(size)
    {
      std::fill(m_data.get(), m_data.get()+m_size, value);
    }


    Array(
        Array && lhs) noexcept :
      m_size(lhs.m_size),
      m_data(std::move(lhs.m_data))
    {
      lhs.m_size = 0;
    }


    Array(
        Array const & rhs) = delete;


    Array & operator=(
        Array const & rhs) = delete;


    Array & operator=(
        Array && lhs)
    {
      m_size = lhs.m_size;
      m_data = std::move(lhs.m_data);

      lhs.m_size = 0;

      return *this;
    }


    void set(
        T const val) noexcept
    {
      for (size_t i = 0; i < m_size; ++i) {
        m_data[i] = val;
      }
    }


    T & operator[](
        size_t const index) noexcept
    {
      ASSERT_LESS(index, m_size);
      return m_data[index];
    }


    T const & operator[](
        size_t const index) const noexcept
    {
      ASSERT_LESS(index, m_size);
      return m_data[index];
    }


    T * data() noexcept
    {
      return m_data.get();
    }


    T const * data() const noexcept
    {
      return m_data.get();
    }


    size_t size() const noexcept
    {
      return m_size;
    }


    const_iterator begin() const noexcept
    {
      return m_data.get();
    }


    const_iterator end() const noexcept
    {
      return m_data.get() + m_size;
    }


    iterator begin() noexcept
    {
      return m_data.get();
    }


    iterator end() noexcept
    {
      return m_data.get() + m_size;
    }


    T const & front() const noexcept
    {
      return (*this)[0];
    }


    T & front() noexcept
    {
      return (*this)[0];
    }


    T const & back() const noexcept
    {
      return (*this)[m_size-1];
    }


    T & back() noexcept
    {
      return (*this)[m_size-1];
    }


    void shrink(
        size_t smallerSize)
    {
      if (smallerSize < m_size) {
        m_size = smallerSize;
      }
    }


    std::unique_ptr<T[]> steal() noexcept
    {
      m_size = 0;
      return std::unique_ptr<T[]>(std::move(m_data));
    }


    void clear()
    {
      m_size = 0;
      m_data.reset();
    }


  private:
    size_t m_size;
    std::unique_ptr<T[]> m_data;

};


}



#endif