tpl_dynarray_set.H

# ifndef TPL_DYNARRAY_SET_H
# define TPL_DYNARRAY_SET_H

# include <tpl_dynArray.H>
# include <tpl_sort_utils.H>

   template <typename T, class Equal = Aleph::equal_to<T>>
class DynArray_Set : public DynArray<T>
{
public:

  DynArray_Set(const size_t & dim = 0) 
    : DynArray<T>(dim)
  {
    // empty
  }

  DynArray_Set(size_t pow_dir, size_t pow_seg, size_t pow_block)
    :  DynArray<T>(pow_dir, pow_seg, pow_block)
  {
    // empty
  }

  T & put(const T & item) { return this->append(item); }

  T * search(const T & item) 
  {
    int i = 
      Aleph::sequential_search<T, Equal>(*this, item, 0, this->size() - 1);
      //Aleph::random_search<T, Equal>(*this, item, 0, this->size() - 1);
    return (i >= 0 and i < this->size()) ? &this->access(i) : NULL;
  }

  void remove(T & item)
  {
    std::swap(item, this->access(this->size() - 1));
    this->cut(this->size() - 1);
  }

  void erase(T & item) { remove(item); }

  class Iterator
  {
    DynArray_Set & array;
    size_t curr;

  public:
    Iterator(DynArray_Set & _array)
      : array(_array), curr(0)
    {
      // Empty
    }

    bool has_current() const
    {
      return curr < array.size();
    }  

    bool has_curr() const
    {
      return has_current();
    }

    T & get_current()
    {
      if (not has_current())
        throw std::overflow_error("Iterator is at the end of array");

      return array(curr);
    }

    T & get_curr()
    {
      return get_current();
    }

    void next()
    {
      if (not has_current())
        throw std::overflow_error("Iterator is at the end of array");
      ++curr;
    }

    void prev()
    {
      if (curr == 0)
        throw std::underflow_error("Iterator is at the begin of array");
      --curr;
    }

    void reset_first()
    {
      curr = 0;
    }

    void reset_last()
    {
      curr = array.size() - 1;
    }
  };
};

# endif // TPL_DYNARRAY_SET_H