Enumerable.h

 
#ifndef COSMO_ENUMERABLE_H
#define COSMO_ENUMERABLE_H
 
#include <Pt/Cosmo/IEnumerable.h>
#include <Pt/Cosmo/IAutoReleasePool.h>
 
namespace Pt {
 
namespace Cosmo {
 
template <typename Container, class T = typename Container::value_type>
class BasicEnumerable : public IEnumerable<T>
{
  public:
    class Enumeration : public IEnumeration<T>
    {
      typedef typename IEnumeration<T>::Reference Reference;
 
      public:
        Enumeration(const Container& container)
        : _container(container)
        , _it( container.begin() )
        { }
 
      protected:
        virtual bool onIsValid() const override
        {
          return _it != _container.end();
        }
 
        virtual void onAdvance() override
        {
          ++_it;
        }
 
        virtual Reference onGet() const override
        {
          return *_it;
        }
 
      private:
        const Container&                   _container;
        typename Container::const_iterator _it;
    };
 
  public:
    BasicEnumerable(IAutoReleasePool& pool, 
                    Container& container)
    : _pool(&pool)
    , _container(&container)
    { }
 
    BasicEnumerable(const BasicEnumerable& other) = delete;
 
    virtual ~BasicEnumerable()
    { }
 
    BasicEnumerable& operator=(const BasicEnumerable& other) = delete;
 
    void set(IAutoReleasePool& pool, Container& container)
    {
      _pool = &pool;
      _container = &container;
    }
 
  protected:
    virtual Cosmo::Enumerator<T> onEnumerate() const override
    {
      Enumeration* e = new Enumeration(*_container);
      return Cosmo::Enumerator<T>(*_pool, e);
    }
 
  private:
    IAutoReleasePool* _pool;
    Container*        _container;
};
 
} // namespace Cosmo
 
} // namespace Pt
 
#endif // include guard