IRArray.h

#pragma once
/******************************************************************************
 * Copyright (c) 2012-2019 All Rights Reserved, http://www.evocortex.com      *
 *  Evocortex GmbH                                                            *
 *  Emilienstr. 10                                                            *
 *  90489 Nuremberg                                                           *
 *  Germany                                                                   *
 *****************************************************************************/
#include <cstddef>
#include <stdexcept>
#include <sstream>
 
namespace evo
{
 
template <class T>
class IRArray
{
private:
    //Array pointer
    T* _data;
 
    //Size of array
    std::size_t _size;
public:
 
 
    IRArray(std::size_t size);
 
    IRArray(std::size_t size, const T* const data);
 
    IRArray(const IRArray<T> &obj);
 
    ~IRArray();
 
    IRArray<T>& operator=(const IRArray<T>& obj);
    
    IRArray<T>& operator=(IRArray<T>&& obj);
 
    T& operator[](const std::size_t index);
 
  const T& operator[](const std::size_t index) const;
 
    std::size_t size() const;
 
    T* const data() const;
};
 
} //namespace evo
 
template <class T>
evo::IRArray<T>::IRArray(std::size_t size)
{
    _size = size;
    if(_size > 0)
    {
        _data = new T[_size];
    }
    else
    {
        _data = nullptr;
    }
}
 
template <class T>
evo::IRArray<T>::IRArray(std::size_t size, const T* const data)
{
    _size = size;
    if(_size > 0)
    {
        _data = (T*)(new char[size * sizeof(T)]);
        std::copy(data, data + _size, _data);
    }
    else
    {
        _data = nullptr;
    }
}
 
template <class T>
evo::IRArray<T>::IRArray(const evo::IRArray<T> &obj) : IRArray(obj._size, obj._data)
{
}
 
template <class T>
evo::IRArray<T>::~IRArray()
{
    if(_data != nullptr)
    {
        delete[] _data;
        _data = nullptr;
    }
}
 
template <class T>
evo::IRArray<T>& evo::IRArray<T>::operator=(const evo::IRArray<T>& obj)
{
    IRArray<T> tmp(obj);
    _size = tmp._size;
    _data = tmp._data;
 
    tmp._size = 0;
    tmp._data = nullptr;
    return *this;
}
 
template <class T>
evo::IRArray<T>& evo::IRArray<T>::operator=(evo::IRArray<T>&& obj)
{
    _size = obj._size;
    _data = obj._data;
 
    obj._size = 0;
    obj._data = nullptr;
    return *this;
}
 
template <class T>
T& evo::IRArray<T>::operator[](const std::size_t index) 
{ 
    if (index < 0 || index >= _size) 
    { 
        std::stringstream ss;
        ss << "Index " << index << " out of range. [0.." << _size << "[";
        throw std::out_of_range(ss.str());
    }
    return _data[index]; 
}
 
template <class T>
const T& evo::IRArray<T>::operator[](const std::size_t index) const
{
    if (index < 0 || index >= _size) 
  {
    std::stringstream ss;
    ss << "Index " << index << " out of range. [0.." << _size << "[";
    throw std::out_of_range(ss.str());
  }
  return _data[index];
}
 
template <class T>
std::size_t evo::IRArray<T>::size() const
{
    return _size;
}
 
template <class T>
T* const evo::IRArray<T>::data() const
{
    return _data;
}