linearhostmemory.h

#pragma once

#include <stdio.h>
#include <assert.h>
#include <cstdlib>
#include <string.h>         // memcpy
#include <thrust/memory.h>
#include <type_traits>

#include "linearmemory.h"

template<typename, int> class ndarray_ref;

namespace boost
{
    namespace python
    {
        namespace api
        {
            class object;
        }
    }
}

class mxArray_tag;

namespace iu {

template<typename PixelType, unsigned int Ndim>
class LinearHostMemory: public LinearMemory<Ndim>
{
public:
  typedef PixelType pixel_type;

  LinearHostMemory() :
      LinearMemory<Ndim>(), data_(0), ext_data_pointer_(false)
  {
  }

  virtual ~LinearHostMemory()
  {
    if ((!ext_data_pointer_) && (data_ != NULL))
    {
      free(data_);
      data_ = 0;
    }
  }

  LinearHostMemory(const Size<Ndim>& size) :
      LinearMemory<Ndim>(size), data_(0), ext_data_pointer_(false)
  {
    data_ = (PixelType*) malloc(this->numel() * sizeof(PixelType));
    if (data_ == 0)
      throw std::bad_alloc();
  }

  LinearHostMemory(const unsigned int& numel) :
      LinearMemory<Ndim>(numel), data_(0), ext_data_pointer_(false)
  {
    data_ = (PixelType*) malloc(this->numel() * sizeof(PixelType));
    if (data_ == 0)
      throw std::bad_alloc();
  }

  LinearHostMemory(PixelType* host_data, const Size<Ndim>& size,
                   bool ext_data_pointer = false) :
      LinearMemory<Ndim>(size), data_(0), ext_data_pointer_(ext_data_pointer)
  {
    if (host_data == 0)
      throw IuException("input data not valid", __FILE__, __FUNCTION__,
      __LINE__);
    if (ext_data_pointer_)
    {
      // This uses the external data pointer as internal data pointer.
      data_ = host_data;
    }
    else
    {
      // allocates an internal data pointer and copies the external data onto it.
      data_ = (PixelType*) malloc(this->numel() * sizeof(PixelType));
      if (data_ == 0)
        throw std::bad_alloc();
      memcpy(data_, host_data, this->numel() * sizeof(PixelType));
    }
  }

  LinearHostMemory(PixelType* host_data, const unsigned int& numel,
                   bool ext_data_pointer = false) :
      LinearMemory<Ndim>(numel), data_(0), ext_data_pointer_(ext_data_pointer)
  {
    if (host_data == 0)
      throw IuException("input data not valid", __FILE__, __FUNCTION__,
      __LINE__);
    if (ext_data_pointer_)
    {
      // This uses the external data pointer as internal data pointer.
      data_ = host_data;
    }
    else
    {
      // allocates an internal data pointer and copies the external data onto it.
      data_ = (PixelType*) malloc(this->numel() * sizeof(PixelType));
      if (data_ == 0)
        throw std::bad_alloc();
      memcpy(data_, host_data, this->numel() * sizeof(PixelType));
    }
  }

  PixelType* data(unsigned int offset = 0)
  {
    if (offset >= this->numel())
    {
      std::stringstream msg;
      msg << "Index (" << offset << ") out of range (" << this->numel() << ").";
      throw IuException(msg.str(), __FILE__, __FUNCTION__, __LINE__);
    }
    return &(data_[offset]);
  }

  const PixelType* data(unsigned int offset = 0) const
  {
    if (offset >= this->numel())
    {
      std::stringstream msg;
      msg << "Offset (" << offset << ") out of range (" << this->numel() << ").";
      throw IuException(msg.str(), __FILE__, __FUNCTION__, __LINE__);
    }
    return reinterpret_cast<const PixelType*>(&(data_[offset]));
  }

  virtual size_t bytes() const
  {
    return this->numel() * sizeof(PixelType);
  }

  virtual unsigned int bitDepth() const
  {
    return 8 * sizeof(PixelType);
  }

  thrust::pointer<PixelType, thrust::host_system_tag> begin(void)
  {
    return thrust::pointer<PixelType, thrust::host_system_tag>(data());
  }

  thrust::pointer<PixelType, thrust::host_system_tag> end(void)
  {
    return thrust::pointer<PixelType, thrust::host_system_tag>(
        data() + this->numel());
  }

  virtual bool onDevice() const
  {
    return false;
  }

  PixelType& getPixel(const unsigned int& idx)
  {
    if (idx >= this->numel())
    {
      std::stringstream msg;
      msg << "Index (" << idx << ") out of range (" << this->numel() << ").";
      throw IuException(msg.str(), __FILE__, __FUNCTION__, __LINE__);
    }

    return this->data_[idx];
  }

  template<typename ResultType = PixelType>
  typename std::enable_if<(Ndim > 1), ResultType&>::type getPixel(
      const unsigned int& idx0, const unsigned int& idx1)
  {
    return data_[getLinearIndex(idx0, idx1)];
  }

  template<typename ResultType = PixelType>
  typename std::enable_if<(Ndim > 2), ResultType&>::type getPixel(
      const unsigned int& idx0, const unsigned int& idx1,
      const unsigned int& idx2)
  {
    return data_[getLinearIndex(idx0, idx1, idx2)];
  }

  template<typename ResultType = PixelType>
  typename std::enable_if<(Ndim > 3), ResultType&>::type getPixel(
      const unsigned int& idx0, const unsigned int& idx1,
      const unsigned int& idx2, const unsigned int& idx3)
  {
    return data_[getLinearIndex(idx0, idx1, idx2, idx3)];
  }

  template<typename ResultType = PixelType>
  typename std::enable_if<(Ndim > 4), ResultType&>::type getPixel(
      const unsigned int& idx0, const unsigned int& idx1,
      const unsigned int& idx2, const unsigned int& idx3,
      const unsigned int& idx4)
  {
    return data_[getLinearIndex(idx0, idx1, idx2, idx3, idx4)];
  }

  ndarray_ref<PixelType, Ndim> ref() const;

  LinearHostMemory(const ndarray_ref<PixelType, Ndim> &x);

  LinearHostMemory(boost::python::api::object& py_arr);

  LinearHostMemory(const mxArray_tag& mex_arr);

private:
  PixelType* data_;
  bool ext_data_pointer_;

private:
  LinearHostMemory(const LinearHostMemory&);
  LinearHostMemory& operator=(const LinearHostMemory&);

  template<typename ResultType = unsigned int>
  typename std::enable_if<(Ndim > 1), ResultType>::type getLinearIndex(
      const unsigned int& idx0, const unsigned int& idx1)
  {
    if (idx0 >= this->size()[0] || idx1 >= this->size()[1])
    {
      std::stringstream msg;
      msg <<  "Index (" << idx0 << ", " << idx1 << ") out of range ("
          << this->size() << ").";
      throw IuException(msg.str(), __FILE__, __FUNCTION__, __LINE__);
    }

    unsigned int linear_idx = idx0;
    linear_idx += this->stride()[1] * idx1;
    return linear_idx;
  }

  template<typename ResultType = unsigned int>
  typename std::enable_if<(Ndim > 2), ResultType>::type getLinearIndex(
      const unsigned int& idx0, const unsigned int& idx1,
      const unsigned int& idx2)
  {
    if (idx0 >= this->size()[0] || idx1 >= this->size()[1]
        || idx2 >= this->size()[2])
    {
      std::stringstream msg;
      msg <<  "Index (" << idx0 << ", " << idx1 << ", " << idx2
          << ") out of range (" << this->size() << ").";
      throw IuException(msg.str(), __FILE__, __FUNCTION__, __LINE__);
    }

    unsigned int linear_idx = idx0;
    linear_idx += this->stride()[1] * idx1;
    linear_idx += this->stride()[2] * idx2;
    return linear_idx;
  }

  template<typename ResultType = unsigned int>
  typename std::enable_if<(Ndim > 3), ResultType>::type getLinearIndex(
      const unsigned int& idx0, const unsigned int& idx1,
      const unsigned int& idx2, const unsigned int& idx3)
  {
    if (idx0 >= this->size()[0] || idx1 >= this->size()[1]
        || idx2 >= this->size()[2] || idx3 >= this->size()[3])
    {
      std::stringstream msg;
      msg << "Index (" << idx0 << ", " << idx1 << ", " << idx2 << ", " << idx3
          << ") out of range (" << this->size() << ").";
      throw IuException(msg.str(), __FILE__, __FUNCTION__, __LINE__);
    }

    unsigned int linear_idx = idx0;
    linear_idx += this->stride()[1] * idx1;
    linear_idx += this->stride()[2] * idx2;
    linear_idx += this->stride()[3] * idx3;
    return linear_idx;
  }

  template<typename ResultType = unsigned int>
  typename std::enable_if<(Ndim > 4), ResultType>::type getLinearIndex(
      const unsigned int& idx0, const unsigned int& idx1,
      const unsigned int& idx2, const unsigned int& idx3,
      const unsigned int& idx4)
  {
    if (idx0 >= this->size()[0] || idx1 >= this->size()[1]
        || idx2 >= this->size()[2] || idx3 >= this->size()[3]
        || idx4 >= this->size()[4])

    {
      std::stringstream msg;
      msg << "Index (" << idx0 << ", " << idx1 << ", " << idx2 << ", " << idx3
          << ", " << idx4 << ") out of range (" << this->size() << ").";
      throw IuException(msg.str(), __FILE__, __FUNCTION__, __LINE__);
    }

    unsigned int linear_idx = idx0;
    linear_idx += this->stride()[1] * idx1;
    linear_idx += this->stride()[2] * idx2;
    linear_idx += this->stride()[3] * idx3;
    linear_idx += this->stride()[4] * idx4;
    return linear_idx;
  }
};

template<> LinearHostMemory<float, 1>::LinearHostMemory(const ndarray_ref<float, 1> &x);

}  // namespace iu