Generators in C++

$generator(each_key)
{
   const hash_map<string,int>& ht;
   int n;
   hash_map<string,int>::chain_item* pi;
 
   each_key(hash_map<string,int>& ht_):ht(ht_) {}
 
   $emit(string) 
     for( n = 0; n < ht.collision_table.size(); ++n )
     {
        pi = ht.collision_table[n];
        while(pi) {
          $yield(pi->key);
          pi = pi->next;
        }
     }
   $stop; // stop, end of sequence. End of body of the generator.
};

c-smile wrote:

You have missed the main point of generators.

c-smile wrote:

Body of generator is a code with normal flow where $yield allows you to return the value from the middle of algorithm.

c-smile wrote:

Try to write the same using your approach.

class each_key :public Generator<std::string>
{
public:
  typedef std::unordered_map<std::string,int> tMap;
private:
  typedef typename tMap::const_local_iterator tChainIt;

  const tMap&     m_ht;
  size_t          m_n;
  tChainIt        m_pi;
  tChainIt        m_pie;

  void next_collision()
  {
    for ( ;m_n < m_ht.bucket_count(); ++m_n ) {
      if ( m_ht.bucket_size(m_n) <= 1)
          continue;
      m_pi = m_ht.begin(m_n);
      m_pie = m_ht.end(m_n++); // because we do not pass the for inc anymore
      break;
    }
    m_t = NotDone() ? m_pi->first : std::string{};
  }

public:
  each_key( tMap& ht_): m_ht(ht_), m_n(0)
  {}

  virtual Result& begin() override
  {
    m_n = 0;
    m_pi=m_pie=m_ht.end(0);
    next_collision();
    return m_r;
  }

  virtual void Proceed() override
  {
    if ( ++m_pi != m_pie) {
      m_t = m_pi->first;
      return; // that point corresponds to your yield
    }
    next_collision();
  }

  virtual bool NotDone() override
  { return m_pi != m_pie;}
};

#include <type_traits>
#include <iterator>

template <typename T>
class Generator
{
public:
  class Result: public std::iterator<std::forward_iterator_tag,T> {
  public:
    Result( Generator* g): m_g(g) {}
    T& operator *() { return m_g->m_t;}
    Result& operator++() { m_g->Proceed(); return *this;}
    static Result& End() { static Result r(0); return r;}
    bool operator!= (const Result& rhs) { return m_g->NotDone();}
  private:
    Generator* m_g;
  };
  friend class Result;

  Generator() : m_r(this) {}
  Generator(const T& t) : m_t(t), m_r(this) {}

  virtual Result& begin() { return m_r;}
  Result& end()   { return m_r.End();}

protected:
  virtual void Proceed() = 0;
  virtual bool NotDone() = 0;
  typename std::remove_const<T>::type m_t;
  Result m_r;
};

c-smile wrote:

You will need to write full state machine in order to do that.

That is a bit cryptic, but if you would read the original article of Simon Tatham, then you will get an idea of what is going on here.

Here's a brief case: generators let you factor a complex loop,
dividing the value-producing part from the value-consuming part.
Neither part has to be transformed in a non-obvious way. With
iterators alone, you do this by rewriting the value-producing part as
an Iterator class. This obfuscates the iterator implementation.

$generator(each_property)
{
   int    i,cnt;
   pvalue props;
   value  prop;

   each_property(VM *c, value obj):props(c) 
   { 
      props = CsObjectProperties( obj ); 
   }

   $emit2(value,value) // will emit key/value pair of the obj

     if (CsHashTableP(props)) 
     {
          cnt = CsHashTableSize(props);
          for (i = 0; i < cnt; ++i) 
          {
              prop = CsHashTableElement(props,i);
              for (; prop != VM::undefinedValue; prop = CsPropertyNext(prop))
              {
                $yield2 ( CsPropertyTag(prop),CsPropertyValue(prop) );
              }
          }
      }
      else
          for (; props != VM::undefinedValue; props = CsPropertyNext(props))
          {
             $yield2 ( CsPropertyTag(props),CsPropertyValue(props) );
          }
   $stop; // stop, end of sequence. End of body of the generator.
};