linearmemory.h

#pragma once

#include <typeinfo>

#include "coredefs.h"
#include "vector.h"

namespace iu {
template<unsigned int Ndim = 1>
class LinearMemory
{
IU_ASSERT(Ndim > 0)
public:
  LinearMemory() :
      size_(), stride_()
  {
  }

  LinearMemory(const Size<Ndim>& size) :
      size_(size)
  {
    computeStride();
  }

  LinearMemory(const unsigned int& numel) :
      size_()
  {
    size_[0] = numel;
    computeStride();
  }
  bool sameType(const LinearMemory &from)
  {
    return typeid(from) == typeid(*this);
  }

  virtual ~LinearMemory()
  {
  }

  unsigned int numel() const
  {
    return size_.numel();
  }

//  /** Returns the number of elements saved in the buffer. (numel of buffer) */
//  unsigned int length() const
//  {
//#pragma message("LinearMemory::length() is deprecated and will be removed in the future. Use numel() instead.")
//    return size_.numel();
//  }

  Size<Ndim> size() const
  {
    return size_;
  }

  Size<Ndim> stride() const
  {
    return stride_;
  }

  virtual size_t bytes() const
  {
    return 0;
  }

  virtual unsigned int bitDepth() const
  {
    return 0;
  }

  virtual bool onDevice() const
  {
    return false;
  }

  friend std::ostream& operator<<(std::ostream & out,
                                  LinearMemory const& linmem)
  {
    out << "LinearMemory: size=" << linmem.size() << " strides="
        << linmem.stride() << " numel=" << linmem.numel() << " onDevice="
        << linmem.onDevice();
    return out;
  }

protected:
  Size<Ndim> size_;

  void computeStride()
  {
    for (unsigned int i = 0; i < Ndim; i++)
    {
      if (i == 0)
        stride_[i] = 1;
      else
        stride_[i] = stride_[i - 1] * size_[i - 1];
    }
  }

private:
  Size<Ndim> stride_;

private:
  LinearMemory(const LinearMemory&);
  LinearMemory& operator=(const LinearMemory&);
};
  // end of Memory Management// end of Linear Memory
}// namespace iu