IEnumerable.h

 
#ifndef COSMO_ENUMERABLE_INTERFACE_H
#define COSMO_ENUMERABLE_INTERFACE_H
 
#include <Pt/Cosmo/AutoPtr.h>
#include <Pt/Cosmo/IAutoReleasePool.h>
#include <utility>
 
namespace Pt {
 
namespace Cosmo {
 
class IEnumerationBase;
 
template <typename T>
class IEnumeration;
 
class EnumeratorBase;
 
template <typename T>
class Enumerator;

template <typename T>
class IEnumerable
{
  public:
    virtual ~IEnumerable()
    { }
 
    Enumerator<T> enumerate() const
    {
      return onEnumerate();
    }
 
  protected:
    virtual Enumerator<T> onEnumerate() const = 0;
};
 
 
template <typename T>
Enumerator<T> begin(const IEnumerable<T>& e)
{
  return e.enumerate();
}
 
 
template <typename T>
Enumerator<T> end(const IEnumerable<T>& e)
{
  return Enumerator<T>();
}

class IEnumerationBase
{
  public:
    virtual ~IEnumerationBase()
    {}
 
    bool isValid() const
    {
      return onIsValid();
    }
 
    void advance()
    {
      return onAdvance();
    }
 
  protected:
    virtual bool onIsValid() const = 0;
 
    virtual void onAdvance() = 0;
};

template <typename T>
class IEnumeration : public IEnumerationBase
{
  public:
    typedef T Value;
    typedef const T& Reference;
 
  public:
    virtual ~IEnumeration()
    {}
 
    const T& get() const
    {
      return onGet();
    }
 
  protected:
    virtual const T& onGet() const = 0;
};

template <typename T>
class IEnumeration<T*> : public IEnumerationBase
{
  public:
    typedef T* Value;
    typedef const T* Reference;
 
  public:
    virtual ~IEnumeration()
    {}
 
    const T* get() const
    {
      return onGet();
    }
 
  protected:
    virtual const T* onGet() const = 0;
};

class EnumeratorBase : public AutoReleasable
{
  public:
    EnumeratorBase()
    : AutoReleasable()
    , _e(&_invalid)
    , _res()
    { }
 
    EnumeratorBase(IAutoReleasePool& pool,
                   IEnumerationBase* e)
    : AutoReleasable(pool)
    , _e(&_invalid)
    , _res(e)
    {
      if(e)
        _e = e;
    }
 
    template <typename Enumeration, typename Deleter>
    EnumeratorBase(IAutoReleasePool& pool,
                   Enumeration* e,
                   Deleter d)
    : AutoReleasable(pool)
    , _e(&_invalid)
    , _res(e, d)
    {     
      if(e)
        _e = e;
    }
 
    EnumeratorBase(EnumeratorBase&& other) noexcept
    : AutoReleasable( std::move(other) )
    , _e(&_invalid)
    , _res( std::move(other._res) )
    { 
      if(other._e == &other._invalid)
        _e = &_invalid;
      else
        _e = other._e;
    }
 
    virtual ~EnumeratorBase()
    { }
 
    EnumeratorBase& operator=(EnumeratorBase&& other) noexcept
    {
      if(this == &other)
        return *this;
 
      if(other._e == &other._invalid)
        _e = &_invalid;
      else
        _e = other._e;
 
      _res = std::move(other._res);
 
      return *this;
    }
 
    bool isValid() const
    {
      return _e->isValid();
    }
 
    void advance()
    {
      _e->advance();
    }
 
    explicit operator bool() const
    {
      return this->isValid();
    }
 
    bool operator !() const
    {
      return ! this->isValid();
    }
 
    bool operator ==(const EnumeratorBase& other) const
    {
      return ! operator !=(other);
    }
 
    bool operator !=(const EnumeratorBase& other) const
    {
      const bool isValid = this->isValid() || other.isValid();
      return _e != other._e && isValid;
    }
 
  protected:
    virtual void onRelease() override
    {
      _e = &_invalid;
      _res.reset();
    }
 
  private:
    EnumeratorBase(const EnumeratorBase& other) = delete;
 
    EnumeratorBase& operator=(const EnumeratorBase& other) = delete;
    
  private:
    class Invalid : public IEnumerationBase
    {
      protected:
        virtual bool onIsValid() const
        { return false; }
 
        virtual void onAdvance()
        { }
    } _invalid;
 
  private:
    IEnumerationBase* _e;
    AutoPtr<IEnumerationBase> _res;
};

template <typename T>
class Enumerator : public EnumeratorBase
{
  public:
    template <typename P>
    struct Proxy
    {
      typedef const P& Reference;
 
      Proxy(IEnumeration<T>& e)
      : _ref(&e.get() )
      { }
 
      const P& operator*() const
      {
        return _ref;
      }
 
      const P& _ref;
    };
 
    template <typename P>
    struct Proxy<P*>
    {
      typedef const P* Reference;
 
      Proxy(IEnumeration<T>& e)
      : _ptr( e.get() )
      { }
 
      const P* operator*() const
      {
        return _ptr;
      }
 
      const P* _ptr;
    };
 
    typedef long difference_type;
    typedef typename Proxy<T>::Reference Reference;
 
  public:
    Enumerator()
    : _e(0)
    { }
 
    Enumerator(IAutoReleasePool& pool,
               IEnumeration<T>* e)
    : EnumeratorBase(pool, e)
    , _e(e)
    { }
 
    template <typename Enumeration, typename Deleter>
    Enumerator(IAutoReleasePool& pool,
               Enumeration* e,
               Deleter d)
    : EnumeratorBase(pool, e, d)
    , _e(e)
    { }
 
    Enumerator(Enumerator&& other) noexcept
    : EnumeratorBase( std::move(other) )
    , _e(0)
    { 
      _e = other._e;
    }
 
    Enumerator& operator=(Enumerator&& other) noexcept
    {
      _e = other._e;
      EnumeratorBase::operator=(other);
      return *this;
    }
 
    ~Enumerator()
    { }
 
    Reference get() const
    {
      return _e->get();
    }
 
    Reference operator*() const
    {
      return get();
    }
 
    const T* operator->() const
    {
      return &get();
    }
 
    Enumerator& operator++()
    {
      advance();
      return *this;
    }
 
    Proxy<T> operator++(int) 
    { 
      Proxy<T> r(*_e);
      advance();
      return r;
    }
 
  protected:
    virtual void onRelease() override
    {
      _e = 0;
      EnumeratorBase::onRelease();
    }
 
  private:
    IEnumeration<T>* _e;
};
 
} // namespace Cosmo
 
} // namespace Pt
 
#endif // include guard