ConstArray.hpp

Go to the documentation of this file.

#ifndef SOLIDUTILS_INCLUDE_CONSTARRAY_HPP
#define SOLIDUTILS_INCLUDE_CONSTARRAY_HPP


#include "Debug.hpp"
#include "Array.hpp"

#include <memory>


namespace sl
{

template<typename T>
class ConstArray
{
  public:
    ConstArray() :
      m_size(0),
      m_data(nullptr),
      m_isOwner(true)
    {
      // do nothing
    }

    ConstArray(
        Array<T> array) :
      m_size(array.size()), // must come before call to steal()
      m_data(array.steal()),
      m_isOwner(true)
    {
      // do nothing
    }


    ConstArray(
        T const * const ptr,
        size_t const size) :
      m_size(size),
      m_data(ptr),
      m_isOwner(false)
    {
      ASSERT_TRUE(ptr != nullptr || size == 0);
    }

    ConstArray(
        std::unique_ptr<T[]>&& ptr,
        size_t const size) :
      m_size(size),
      m_data(std::move(ptr)),
      m_isOwner(true)
    {
      // do nothing
    }


    ConstArray(
        ConstArray && rhs) noexcept :
      m_size(rhs.m_size),
      m_data(std::move(rhs.m_data)),
      m_isOwner(rhs.m_isOwner)
    {
      rhs.m_size = 0;
    }


    ConstArray(
        ConstArray const & rhs) = delete;


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


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

      lhs.m_size = 0;

      return *this;
    }

    ~ConstArray()
    {
      if (!m_isOwner) {
        // disown the unique pointer before this object is destroyed.
        m_data.release();
      }
    }


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


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


    size_t size() const noexcept
    {
      return m_size;
    }


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


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


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

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

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


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

};


}



#endif