title: Java Iterator equivalent in C++? (with code)
body: <p>Hey all. A friend wrote up some Java code for me and I am easily able to convert it to C++ but I am very curious as to the equivalent for a Java iterator in C++. Here is the code and I would most likely want the data to returned into a vector. Any help is appreciated</p>
  
  <pre><code>public class RLEIterator
  extends RegionIterator
  {
      public int reg = 0;
      public int mode = 0;
      public int skip = 0;
          // mode is the number of IDs that are valid still (count down)
          // skip is used after we run out of mode IDs, and move forward
          //   The goal is, to always have a valid 'hasNext' state, after
          // an ID is read via 'next'. Thus, the initial search, and then
          // the reading forward if mode == 0, after the ID is found.
      public int i;
  
      public RLEIterator()
      {
          // Need to set up the skip of an initial part, so we can
          // correctly handle there not being anything, despite there
          // being data encoded.
  
          int comp;
          i = 0;
  
          while ((mode == 0) &amp;&amp; (i&lt;nearRLE.length))
          {
              // set up the next code
              comp = ((int)nearRLE[i]) &amp; 0xff;
  
              if ((comp &gt; 0) &amp;&amp; (comp &lt;= 0x3e))
              {
                  // skip forward by comp;
                  reg += comp;
                  i++;
                  mode = 0; // have to keep on reading
              }
              else if (comp == 0x3f)
              {
                  // skip forward by the following 16 bit word;
                  // second byte is hi-byte of the word
                  reg += ((int)nearRLE[i+1]) &amp; 0xff;
                  reg += (((int)nearRLE[i+2]) &amp; 0xff) &lt;&lt; 8;
  
                  i+=3;
              }
              else if (comp == 0xff)
              {
                  // include the following WORD of regions
                  mode = ((int)nearRLE[i+1]) &amp; 0xff;
                  mode += (((int)nearRLE[i+2]) &amp; 0xff) &lt;&lt; 8;
                  i += 3;
              }
              else if ((comp &gt;= 0xc0) &amp;&amp; (comp &lt;= 0xfe))
              {
                  // comp - 0xc0 regions are nearby
                  mode = comp - 0xc0;  // +1 perhaps?
                  i++;
              }
              else if ((comp &gt;= 0x40) &amp;&amp; (comp &lt;= 0x7f))
              {
                  // skip bits 3-5 IDs and then include bits 0-2
                  reg += (comp &amp; 0x38) &gt;&gt; 3;
                  mode = (comp &amp; 0x7);
                  i++;
              }
              else if ((comp &gt;= 0x80) &amp;&amp; (comp &lt;= 0xbf))
              {
                  // include IDs bits 3-5, then skip bits 0-2
                  mode = (comp &amp; 0x38) &gt;&gt; 3;
                  skip = (comp &amp; 0x7);
                  i++;
              }
          }
      }
  
      public boolean hasNext()
      {
          // not at the end of the RLE, and not currently processing a
          // directive. (mode)
          return (mode &gt; 0);
      }
  
      public int next()
      {
          int ret = -1;
          int comp;
  
          // sanity check first. Shouldn't truthfully get called if mode
          // isn't &gt;0
          if (mode &lt;= 0)
              return -1;
  
          ret = reg;
          reg++;
          mode--;
  
          if (mode == 0)
          {
              // skip forward
              reg += skip;
              skip = 0;
  
              while ((mode == 0) &amp;&amp; (i&lt;nearRLE.length))
              {
                  // set up the next code
                  comp = ((int)nearRLE[i]) &amp; 0xff;
  
                  if ((comp &gt; 0) &amp;&amp; (comp &lt;= 0x3e))
                  {
                      // skip forward by comp;
                      reg += comp;
                      i++;
                      mode = 0; // have to keep on reading
                  }
                  else if (comp == 0x3f)
                  {
                      // skip forward by the following 16 bit word;
                      // second byte is hi-byte of the word
                      reg += ((int)nearRLE[i+1]) &amp; 0xff;
                      reg += (((int)nearRLE[i+2]) &amp; 0xff) &lt;&lt; 8;
  
                      i+=3;
                  }
                  else if (comp == 0xff)
                  {
                      // include the following WORD of regions
                      mode = ((int)nearRLE[i+1]) &amp; 0xff;
                      mode += (((int)nearRLE[i+2]) &amp; 0xff) &lt;&lt; 8;
                      i += 3;
                  }
                  else if ((comp &gt;= 0xc0) &amp;&amp; (comp &lt;= 0xfe))
                  {
                      // comp - 0xc0 regions are nearby
                      mode = comp - 0xc0;  // +1 perhaps?
                      i++;
                  }
                  else if ((comp &gt;= 0x40) &amp;&amp; (comp &lt;= 0x7f))
                  {
                      // skip bits 3-5 IDs and then include bits 0-2
                      reg += (comp &amp; 0x38) &gt;&gt; 3;
                      mode = (comp &amp; 0x7);
                      i++;
                  }
                  else if ((comp &gt;= 0x80) &amp;&amp; (comp &lt;= 0xbf))
                  {
                      // include IDs bits 3-5, then skip bits 0-2
                      mode = (comp &amp; 0x38) &gt;&gt; 3;
                      skip = (comp &amp; 0x7);
                      i++;
                  }
              }
          }
  
          return ret;
      }
  }
  </code></pre>
  
  <p>Again, any help on how this would fit into the scheme of a single function (if possible) in C++ would be fantastic. Thanks!</p>