SimpleArray.h

Go to the documentation of this file.

#ifndef __SimpleArray_h__
#define __SimpleArray_h__
 
#include <cstddef>
#include <string.h> /* for memcpy and memmov */
#include "message.h"
 
template<typename T>
class SimpleArray {
protected:
  T* data;
  size_t size;
public:
  SimpleArray() : data(NULL), size(0){}
  SimpleArray(T* data, size_t size) : data(data), size(size){}
  /* virtual ~SimpleArray(){} No virtual destructor to prevent adding a vtable to the object size */
  
  T* getData(){
    return data;
  }
    
  size_t getSize() const {
    return size;
  }
    
  bool isEmpty() const {
    return size == 0;
  }
 
  T getElement(size_t index){
    return data[index];
  }
 
  void setElement(size_t index, T value){
    data[index] = value;
  }
    
  bool equals(const SimpleArray<T>& other) const {
    if(size != other.size)
      return false;
    for(size_t n=0; n<size; n++){
      if(data[n] != other.data[n])
        return false;
    }
    return true;
  }
  
  void copyTo(SimpleArray<T> destination){
    ASSERT(destination.size >= size, "Array too small");
    memcpy((void*)destination.data, (void*)data, size*sizeof(T));
  }
 
  void copyFrom(SimpleArray<T> source){
    ASSERT(size >= source.size, "Array too small");
    memcpy((void*)data, (void*)source.data, source.size*sizeof(T));
  }
 
  void insert(SimpleArray<T> source, int destinationOffset, size_t len){
    insert(source, 0, destinationOffset, len);
  }
 
  void insert(SimpleArray<T> source, int sourceOffset, int destinationOffset, size_t len){
    ASSERT(size >= destinationOffset+len, "Array too small");
    ASSERT(source.size >= sourceOffset+len, "Array too small");
    memcpy((void*)(data+destinationOffset), (void*)(source.data+sourceOffset), len*sizeof(T));
  }
 
  void move(int fromIndex, int toIndex, size_t len){
    ASSERT(size >= toIndex+len, "Array too small");
    memmove((void*)(data+toIndex), (void*)(data+fromIndex), len*sizeof(T));
  }
    
  static void copy(T* dst, T* src, size_t len){
    size_t blocks = len >> 2u;
    T a, b, c, d;
    while(blocks--){
      a = *src++;
      b = *src++;
      c = *src++;
      d = *src++;
      *dst++ = a;
      *dst++ = b;
      *dst++ = c;
      *dst++ = d;
    }
    blocks = len & 0x3;
    while(blocks--){
      *dst++ = *src++;
    }
  }
 
  operator T*(){
    return data;
  }
 
  // /**
  //  * Allows to index the array using array-style brackets.
  //  * @param index the index of the element
  //  * @return the value of the **index** element of the array
  // */
  // T& operator [](size_t index){
  //   return data[index];
  // }
  
  // /**
  //  * Allows to index the array using array-style brackets.
  //  * **const** version of operator[]
  // */
  // const T& operator [](size_t index) const {
  //   return data[index];
  // }
 
};
 
 
#endif // __SimpleArray_h__