AbstractList.hpp

Go to the documentation of this file.

#ifndef LIST_ABSTRACT_LIST_HPP
#define LIST_ABSTRACT_LIST_HPP

#include <stddef.h>

template<typename T>
class AbstractList {
  size_t size = 0;         
  bool mutableList = false;

 protected:
#define extendedIsIndexOutOfBounds(index) \
  ((index) != this->getSize() && this->isIndexOutOfBounds(index))

  class AbstractEntry {
    T immutableValue;         
    T *mutableValue = nullptr;

   public:
    T *getValue(const bool m) {
      if (m) {
        return mutableValue;
      }
      return &immutableValue;
    }

    void setValue(T &val, const bool m) {
      if (m) {
        mutableValue = &val;
      } else {
        immutableValue = val;
      }
    }
  };

  explicit AbstractList<T>(const bool mutableList) : mutableList(mutableList) {}

  virtual T *getPointer(int index) = 0;

  void increaseSize() { size++; }

  void decreaseSize() { size--; }

  void resetSize() { size = 0; }

  bool isIndexOutOfBounds(const int index) const { return index < 0 || index >= getSize(); }

 public:
  void add(T &value) { addLast(value); }

#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)

  void add(T &&value) { addLast(value); }
#endif

  virtual void addAtIndex(int index, T &value) = 0;

#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)

  virtual void addAtIndex(const int index, T &&value) {
    if (this->isMutable()) {
      return;// Mutable lists cannot save rvalues!
    }
    addAtIndex(index, value);
  }
#endif

  void addAll(int index, AbstractList<T> &list) {
    for (int i = 0; i < list.getSize(); i++) {
      addAtIndex(index++, list.get(i));
    }
  }

  void addAll(AbstractList<T> &list) { addAll(getSize(), list); }

  void addAll(int index, T *arr, const size_t arrSize) {
    for (size_t i = 0; i < arrSize; ++i) {
      addAtIndex(index++, arr[i]);
    }
  }

  void addAll(T *arr, const size_t arrSize) {
    for (size_t i = 0; i < arrSize; ++i) {
      add(arr[i]);
    }
  }

  void addFirst(T &value) { addAtIndex(0, value); }

#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)

  void addFirst(T &&value) { addAtIndex(0, value); }
#endif

  void addLast(T &value) { addAtIndex(getSize(), value); }

#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)

  void addLast(T &&value) { addAtIndex(getSize(), value); }
#endif

  T get(const int index) { return *this->getPointer(index); }

  T *getMutableValue(const int index) {
    if (!this->isMutable()) {
      return nullptr;
    }

    return this->getPointer(index);
  }

  virtual void clear() = 0;

  virtual void remove(int index) = 0;

  virtual void removeFirst() { remove(0); }

  virtual void removeLast() { remove(getSize() - 1); }

  void removeAll() { clear(); }

  int getSize() const { return size; }

  bool isMutable() const { return mutableList; }

  bool isEmpty() const { return getSize() == 0; }

  bool equals(AbstractList<T> &other) {
    if (other.isMutable() != this->isMutable()) {
      return false;
    }

    if (other.getSize() != this->getSize()) {
      return false;
    }

    for (int i = 0; i < getSize(); i++) {
      if (this->isMutable()) {
        if (other.getMutableValue(i) != this->getMutableValue(i)) {
          return false;
        }
      } else {
        if (other.get(i) != this->get(i)) {
          return false;
        }
      }
    }
    return true;
  }

  T operator[](const int index) { return get(index); }

  bool operator==(AbstractList<T> &other) { return equals(other); }

  bool operator!=(AbstractList<T> &other) { return !this->equals(other); }

  void operator+(T &value) { this->add(value); }

#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)

  void operator+(T &&value) { this->add(value); }
#endif

  void operator+(AbstractList<T> &list) { this->addAll(list); }
};

#endif// LIST_ABSTRACT_LIST_HPP