Iterator_Definer.hpp

#ifndef Exc_Ruby__detail__Iterator_Definer__hpp_
#define Exc_Ruby__detail__Iterator_Definer__hpp_

#include "../rb_cpp_method_data.hpp"
#include "../call_ruby_function.hpp"
#include "../detail/ruby_hacks.hpp"

namespace Exc_Ruby
{

namespace detail
{

template<typename Derived_T>
class Iterator_Definer
{
public:
  virtual ~Iterator_Definer()
  {
  }

  class Iterator
  {
  public:
    virtual ~Iterator() { }

    virtual VALUE call_impl(VALUE self) = 0;

    static VALUE call(VALUE self)
    {
      void * data = rb_cpp_method_data();
      Iterator * iterator = static_cast<Iterator *>(data);
      return iterator->call_impl(self);
    }
  };

  template<typename T, typename Iterator_T>
  class Iterator_Impl
    : public Iterator
  {
  public:
    Iterator_Impl(
        Iterator_T (T::*begin)(),
        Iterator_T (T::*end)())
      : begin_(begin)
      , end_(end)
    {
    }

    virtual VALUE call_impl(VALUE self)
    {
      // TODO: Optimize this by not using call_ruby_function every
      // iteration.
      Ruby_Reference<T> obj(self);
      Iterator_T it = obj->begin();
      Iterator_T end = obj->end();
      for(; it != end; ++it)
      {
        call_ruby_function(rb_yield, to_ruby(*it));
      }
      return self;
    }

  private:
    Iterator_T (T::*begin_)();
    Iterator_T (T::*end_)();
  };

  template<typename T, typename Iterator_T>
  Derived_T & define_iterator(
      char const * name,
      Iterator_T (T::*begin)(),
      Iterator_T (T::*end)())
  {
    Derived_T & self = static_cast<Derived_T &>(*this);
    // TODO: memory leak!!!!!!!
    Iterator * iterator = new Iterator_Impl<T, Iterator_T>(begin, end);
    rb_cpp_define_method_with_data(
        static_cast<VALUE>(self),
        name,
        (RUBY_METHOD_FUNC)iterator->call,
        0,
        iterator);
    return self;
  }
};

} // namespac edetail

} // namespace Exc_Ruby

#endif // Exc_Ruby__detail__Iterator_Definer__hpp_

---