do ....while (0)

// Headers necessary for this example#include<iostream>#include<string>// My generator base class#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;  };friendclass Result;  Generator(const T& t) : m_t(t), m_r(this) {}virtual Result& begin() {return m_r;}  Result& end()   {return m_r.End();}protected:virtualvoid Proceed() =0;virtualbool NotDone() =0;typename std::remove_const<T>::type m_t;  Result m_r;};// An inheritor generating numerics// (similar to the original article)class MyGenI :public Generator<int>{public:  MyGenI(int i) : Generator<int>(i) {}virtualvoid Proceed() { --m_t;}virtualbool NotDone() {return m_t>-5;}};// An inheritor modifying a stringclass MyGenS :public Generator<std::string>{public:  MyGenS(const std::string& s) : Generator<std::string>(s) {}virtualvoid Proceed() { m_t += m_t[cntr]+1; ++cntr;}virtualbool NotDone() {return cntr <10;}private:int cntr =0;};// An inheritor generating a string from console inputclass MyGenC :public Generator<std::string>{public:  MyGenC(std::string s) : Generator<std::string>(s) {}virtualvoid Proceed()  {    std::cin >> m_c;    m_t += m_c;  }virtualbool NotDone() {return !std::cin.fail();}virtual Result& begin()  {if ( m_t.empty()) {      std::cin >> m_c;      m_t += m_c;    }return m_r;  }private:char m_c;};// The testint main(int argc,char* argv[]){  std::cout <<"numeric\n";auto genI = MyGenI{5};for(auto i: genI)    std::cout <<"next value is " << i << std::endl;  std::cout <<"\nstring\n";auto genS = MyGenS{"a"};for(auto s: genS)    std::cout <<"next value is " << s << std::endl;  std::cout <<"\nconsole\n";auto genC = MyGenC{""};for(auto s: genC)    std::cout <<"next value is " << s << std::endl;return0;}

$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:typedeftypename 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 anymorebreak;    }    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;  }virtualvoid Proceed()override  {if ( ++m_pi != m_pie) {      m_t = m_pi->first;return;// that point corresponds to your yield    }    next_collision();  }virtualbool 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;  };friendclass 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:virtualvoid Proceed() =0;virtualbool 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 objif (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) );              }          }      }elsefor (; props != VM::undefinedValue; props = CsPropertyNext(props))          {             $yield2 ( CsPropertyTag(props),CsPropertyValue(props) );          }   $stop;// stop, end of sequence. End of body of the generator.};