LightVector.hpp

Go to the documentation of this file.

/*
 * LightVector.hpp
 *   -- a lightweight vector whichs memory model is accessible from outside and thus allows 
 *      for efficient operations.
 * 
 * Time-stamp: <05/05/18 16:09:14 lars>
 */

#ifndef __LIGHT_VECTOR__
#define __LIGHT_VECTOR__

#include <iostream>
using namespace std;

#include "common/debug.hpp"

template <class TYPE>
class LightVector {
public:
#if DEBUG_LEVEL > 0

  LightVector(TYPE* const values, int& size) : m_values(values), m_size(size), m_capacity(size) {}
  LightVector(TYPE* const values, int& size, int capacity) : m_values(values), m_size(size), m_capacity(capacity) {}
#else
  LightVector(TYPE* const values, int& size) : m_values(values), m_size(size) {}
#endif

  int size() const { return m_size; }

  bool empty() const { return size == 0; }

  void resize(int size) { 
    assert(size <= m_capacity);
    m_size = size;
  }

  void clear() { m_size = 0; }

  TYPE operator[] (int index) const { 
    assert(index >= 0);
    assert(index < m_size);
    return m_values[index]; 
  }

  TYPE back() const { 
    assert(m_size > 0);
    return m_values[m_size-1];
  }

  void setEntry(int index, TYPE value) { 
    assert(index >= 0);
    assert(index < m_capacity);
    m_values[index] = value; 
  }

  void push_back(TYPE value) {
    assert(m_size < m_capacity);
    m_values[m_size++] = value;
  }

  void pop_back() { 
    assert(m_size > 0);
    m_size--; 
  }

  /*
   * There are three types of iterators:
   * (i)   iterator -- a read/write iterator for the elements 0..(size-1).
   * (ii)  const_iterator -- a read-only iterator for the elements 0..(size-1).
   * (iii) unbounded iterator -- a read/write iterator for the elements 0..(capacity-1). 
   * 
   * Methods begin/end of const objects automatically create const_iterators.
   *
   * unbounded iterators can be created by the methods beginUnbounded / endUnbounded.
   * 
   * unbounded iterators can be used for writing to a LightVector; when writing / filling the vector 
   * is finished, resizeToEndOf(iter) has to be called. 
   *
   * In debugging mode iterators check bounds, in production mode not. 
   */
#if DEBUG_LEVEL > 0
  // Define bounds checking iterators:
  class iterator : public std::iterator<std::random_access_iterator_tag, TYPE> {
  public:
    iterator(TYPE* const values, int const & size, int index) : m_values(values), m_size(size), m_index(index) {}
    iterator(const iterator& iter) : m_values(iter.m_values), m_size(iter.m_size), m_index(iter.m_index) {}
    TYPE& operator* () const { 
      assert(m_index >= 0);
      assert(m_index < m_size);
      return m_values[m_index]; 
    }
    iterator& operator++ () { 
      assert(m_index < m_size);
      m_index++;
      return *this;
    }
    iterator operator++ (int) { 
      assert(m_index < m_size);
      iterator iter = *this;
      m_index++;
      return iter;
    }
    iterator& operator-- () { 
      assert(m_index > 0);
      m_index--;
      return *this;
    }
    iterator operator-- (int) { 
      assert(m_index > 0);
      iterator iter = *this;
      m_index--;
      return iter;
    }
    void operator+= (int index) {
      assert(m_index + index <= m_size);
      m_index += index;
    } 
    void operator-= (int index) {
      assert(m_index >= index);
      m_index -= index;
    } 
    bool operator!= (iterator const & iter) const {
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index != iter.m_index;
    }
    bool operator== (iterator const & iter) const {
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index == iter.m_index;
    }
    bool operator< (iterator const & iter) const {
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index < iter.m_index;
    }
    bool operator<= (iterator const & iter) const {
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index <= iter.m_index;
    }
    bool operator> (iterator const & iter) const {
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index > iter.m_index;
    }
    bool operator>= (iterator const & iter) const {
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index >= iter.m_index;
    }
    int operator- (iterator const & iter) const { 
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index - iter.m_index;
    }
    iterator operator- (const int size) const { 
      assert(m_index - size >= 0);
      assert(m_index - size <= m_size);
      return iterator(m_values, m_size, m_index - size);
    }
    iterator operator+ (const int size) const { 
      assert(m_index + size >= 0);
      assert(m_index + size <= m_size);
      return iterator(m_values, m_size, m_index + size);
    }
    iterator& operator= (const iterator& iter) {
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      m_index = iter.m_index;
      return *this;
    }
    int index() const { return m_index; }
  private:
    TYPE * const m_values;
    int const & m_size;
    int m_index;
  };

  class const_iterator : public std::iterator<std::random_access_iterator_tag, TYPE> {
  public:
    const_iterator(TYPE const * const values, int& size, int index) : m_values(values), m_size(size), m_index(index) {}
    const_iterator(const const_iterator& iter) : m_values(iter.m_values), m_size(iter.m_size), m_index(iter.m_index) {}
    TYPE operator* () const { 
      assert(m_index >= 0);
      assert(m_index < m_size);
      return m_values[m_index]; 
    }
    const_iterator& operator++ () { 
      assert(m_index < m_size);
      m_index++;
      return *this;
    }
    const_iterator operator++ (int) { 
      assert(m_index < m_size);
      const_iterator iter = *this;
      m_index++;
      return iter;
    }
    const_iterator& operator-- () { 
      assert(m_index > 0);
      m_index--;
      return *this;
    }
    const_iterator operator-- (int) { 
      assert(m_index > 0);
      const_iterator iter = *this;
      m_index--;
      return iter;
    }
    void operator-= (int index) {
      assert(m_index >= index);
      m_index -= index;
    } 
    void operator+= (int index) {
      assert(m_index + index <= m_size);
      m_index += index;
    } 
    bool operator!= (const_iterator const & iter) const {
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index != iter.m_index;
    }
    bool operator== (const_iterator const & iter) const {
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index == iter.m_index;
    }
    bool operator< (const_iterator const & iter) const {
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index < iter.m_index;
    }
    bool operator<= (const_iterator const & iter) const {
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index <= iter.m_index;
    }
    bool operator> (const_iterator const & iter) const {
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index > iter.m_index;
    }
    bool operator>= (const_iterator const & iter) const {
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index >= iter.m_index;
    }
    int operator- (const_iterator const & iter) const { 
      assert(m_values == iter.m_values);
      assert(m_size == iter.m_size);
      return m_index - iter.m_index;
    }
    const_iterator operator- (const int size) const { 
      assert(m_index - size >= 0);
      assert(m_index - size <= m_size);
      return const_iterator(m_values, m_size, m_index - size);
    }
    const_iterator operator+ (const int size) const { 
      assert(m_index + size >= 0);
      assert(m_index + size <= m_size);
      return const_iterator(m_values, m_size, m_index + size);
    }
    int index() const { return m_index; }
  private:
    TYPE const * const m_values;
    int& m_size;
    int m_index;
  };

  iterator begin() { return iterator(m_values, m_capacity, 0); }
  iterator end() { return iterator(m_values, m_capacity, m_size); }
  // iterator begin() { return iterator(m_values, m_size, 0); }
  // iterator end() { return iterator(m_values, m_size, m_size); }
  const_iterator begin() const { return const_iterator(m_values, m_size, 0); }
  const_iterator end() const { return const_iterator(m_values, m_size, m_size); }
  // iterator beginUnbounded() { return iterator(m_values, m_capacity, 0); }
  // iterator endUnbounded() { return iterator(m_values, m_capacity, m_size); }

#else
  // Define non-bounds checkings, lightweight iterators: (stolen from Balazs)
  typedef int* iterator;
  typedef int const * const_iterator;

  iterator begin() { return m_values; }
  iterator end() { return m_values + m_size; }
  const_iterator begin() const { return m_values; }
  const_iterator end() const { return m_values + m_size; }
  // iterator beginUnbounded() { return m_values; }
  // iterator endUnbounded() { return m_values + m_size; }

#endif

  TYPE* values() const { return m_values; }
  
#if DEBUG_LEVEL > 0
  int capacity() const { return m_capacity; }
#endif

  static LightVector<TYPE>* create(int capacity, TYPE initValue = TYPE()) {
    TYPE* values = new int[capacity];
    for (int i = 0; i < capacity; i++)
      values[i] = initValue;
#if DEBUG_LEVEL > 0
    return new LightVector(values, *(new int[1]), capacity);
#else
    return new LightVector(values, *(new int[1]));
#endif
  }

  void destroy() {
    delete[] m_values;
    delete[] (&m_size);
    delete this;
  }


private:
  TYPE* const m_values;
  int& m_size;
#if DEBUG_LEVEL > 0
  int const m_capacity;
#endif
};

template <class TYPE> ostream& operator<< (ostream& out, LightVector<TYPE> const & vector) {
  if (vector.size() == 0)
    out << "[empty]";
  else {
    out << vector[0];
    for (int i = 1; i < vector.size(); i++)
      out << " " << vector[i];
  }
  return out;
}


#endif

---