data_types.h

Go to the documentation of this file.

 
#ifndef DATA_TYPES_H
#define DATA_TYPES_H
 
 
class DataPointer {
protected:
  class PrivateImplementation {
  public:
    virtual ~PrivateImplementation() {}
  };
public:
  //  DataPointer& operator=(const DataPointer&) = delete;
  //  DataPointer(const DataPointer&) = delete;
 
  DataPointer(unsigned char* pointer, unsigned int size,
    PrivateImplementation* private_impl = 0) :
    m_pointer(pointer), m_size(size), m_private_impl(private_impl) {
  }
  
  DataPointer(DataPointer& other) {
    m_pointer = other.m_pointer;
    m_size = other.m_size;
    // take ownership of this value, other is a temporary and will deconstruct
    m_private_impl = other.m_private_impl;
    other.m_private_impl = 0;
  };
  
  DataPointer(DataPointer&& other) {
    m_pointer = other.m_pointer;
    m_size = other.m_size;
    // take ownership of this value, other is a temporary and will deconstruct
    m_private_impl = other.m_private_impl;
    other.m_private_impl = 0;
  }
  
  ~DataPointer() {
    if(m_private_impl != 0)
      delete m_private_impl;
  }
  
  inline bool valid() {
    return m_size != 0;
  }
  
  inline unsigned char* get_raw_pointer() const { return m_pointer; }
  
protected:
  unsigned char* m_pointer;
  unsigned int m_size;
 
private:
  PrivateImplementation* m_private_impl;
};
 
 
 
template<typename T>
class SingleArray : public DataPointer {
public:
  SingleArray(DataPointer&& temp) :
    DataPointer(temp)
  {
  }
  
  SingleArray(SingleArray&& temp) :
    DataPointer(temp)
  {
  }
  
  inline T& operator[](unsigned int i) const
  {
    return *(reinterpret_cast<T*>(m_pointer) + i);
  }
  
  unsigned int size() {
    return m_size / sizeof(T);
  }
};
 
 
 
template<typename T>
class TripleArray : public DataPointer {
public:
  TripleArray(DataPointer&& temp) :
    DataPointer(temp)
  {
  }
  
  TripleArray(TripleArray&& temp) :
    DataPointer(temp)
  {
  }
  
  inline T* operator[](unsigned int i) const
  {
    return reinterpret_cast<T*>(m_pointer) + (i*3);
  }
  
  unsigned int size() const {
    return m_size / (3 * sizeof(T));
  }
};
 
 
 
template<typename T>
class SingleObject : public DataPointer {
public:
  SingleObject(DataPointer&& temp) :
    DataPointer(temp)
  {
  }
  
  SingleObject(SingleObject&& temp) :
    DataPointer(temp)
  {
  }
  
  inline T& get() const
  {
    return *reinterpret_cast<T*>(m_pointer);
  }
  
  unsigned int size() const {
    return 1;
  }
};
 
 
 
template<typename T>
class PointerArray {
public:
  PointerArray(const TripleArray<T>& data) {
    unsigned int size = data.size();
    m_array = new T*[size];
    for(unsigned int i = 0; i < size; ++i)
      m_array[i] = data[i];
  }
  
  ~PointerArray() {
    delete[] m_array;
  }
  
  inline T** get() const { return m_array; }
private:
  T** m_array;
};
  
// TODO: naming, see scan.h
typedef TripleArray<double> DataXYZ;
typedef TripleArray<float> DataXYZFloat;
typedef TripleArray<unsigned char> DataRGB;
typedef SingleArray<float> DataReflectance;
typedef SingleArray<float> DataAmplitude;
typedef SingleArray<int> DataType;
typedef SingleArray<float> DataDeviation;
 
#endif //DATA_TYPES_H