/*
 * UnobservedIterator.hpp
 *
 *  Created on: Dec 13, 2015
 *      Author: heber
 */


#ifndef UNOBSERVEDITERATOR_HPP_
#define UNOBSERVEDITERATOR_HPP_

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iterator>

class Observable;

/** This is a mock of UnobservedIterator that does not observe.
 *
 * The only thing we need to add here is another cstor to be signature compatible
 * for use in ObservedContainer.
 */
template<class _Set>
class UnobservedIterator
    : public std::iterator<typename std::iterator_traits<typename _Set::iterator>::iterator_category,
                           typename std::iterator_traits<typename _Set::iterator>::value_type,
                           typename std::iterator_traits<typename _Set::iterator>::difference_type,
                           typename std::iterator_traits<typename _Set::iterator>::pointer,
                           typename std::iterator_traits<typename _Set::iterator>::reference>
{
public:
  // Some typedefs to conform to STL-Iterator structure
  typedef typename _Set::iterator _Iter;
  typedef typename _Iter::value_type value_type;
  typedef typename _Iter::difference_type difference_type;
  typedef typename _Iter::pointer pointer;
  typedef typename _Iter::reference reference;
  typedef typename _Iter::iterator_category iterator_category;

  UnobservedIterator()
  {}

  UnobservedIterator(_Iter iter,Observable *obs) :
    iter(iter)
  {}

  UnobservedIterator(const UnobservedIterator &dest) :
    iter(dest.iter)
  {}

  // standard Iterator methods
  UnobservedIterator& operator=(const UnobservedIterator& dest){
    if(&dest !=this)
      iter = dest.iter;
    return *this;
  }

  virtual ~UnobservedIterator() {}

  UnobservedIterator& operator++()   // prefix
  {
    ++iter;
    return *this;
  }

  UnobservedIterator operator++(int) // postfix with the dummy int parameter
  {
    UnobservedIterator ret(*this);
    ++(*this);
    return ret;
  }

  UnobservedIterator& operator--()   // prefix
  {
    --iter;
    return *this;
  }

  UnobservedIterator  operator--(int) // postfix with the dummy int parameter
  {
    UnobservedIterator ret(*this);
    --(*this);
    return ret;
  }

  bool operator==(const UnobservedIterator &rhs) const
  {
    return iter==rhs.iter;
  }

  bool operator!=(const UnobservedIterator &rhs) const
  {
    return iter!=rhs.iter;
  }

  /** Returns the value_type this iterator represents.
   *
   * @return value_type of iterator
   */
  value_type operator*() const {
    return (*iter);
  }

  /** Returns pointer to value_type this iterator represents.
   *
   * @return pointer to value_type of iterator
   */
  value_type *operator->() const {
    return &(*iter);
  }

  operator typename _Set::const_iterator() {
    return iter;
  }

//  bool operator==(const UnobservedIterator &dest)
//  { return static_cast<_Iter>(*this) == static_cast<_Iter>(dest); }
//
//  bool operator!=(const UnobservedIterator &dest)
//  { return !(*this == dest); }

private:
  _Iter iter;
};

#endif /* UNOBSERVEDITERATOR_HPP_ */