Ticket #553: LineIteratorEnhanced.d

module tango.io.LineIteratorEnhanced;

public  import tango.io.Buffer;
private import Text = tango.text.Util;
private import tango.util.collection.CircularSeq;

class LineIteratorEnhanced(T)
{

    protected T[]           slice,
                            pushed;
    protected IBuffer       buffer;
    private long            _position = 0,
                            _pushLength = 0;


    this (InputStream stream = null)
    {
        if (stream)
            set(stream);
    }

    final LineIteratorEnhanced set (InputStream stream)
    {
        auto b = cast(IBuffer) stream;
        if (b)
            buffer = b;
        else
            if (buffer)
                buffer.clear, buffer.setConduit (stream.conduit);
            else
                buffer = new Buffer (stream.conduit);

        this._position = 0;

        return this;
    }

    /***********************************************************************

      Resets the iterator using the passed stream

     ***********************************************************************/

    void reset(InputStream stream, long newPosition = -1)
    {
        this.buffer.clear;
        this.buffer.setConduit(stream.conduit);
        this.pushed = null;
        this._pushLength = 0;
        if (newPosition >= 0)
            this._position = newPosition;
    }


    /***********************************************************************

      Return the size of data read so far

     ***********************************************************************/
    final uint position()
    {
        return this._position;
    }

    /***********************************************************************

      Return the current token as a slice of the content

     ***********************************************************************/

    final T[] get ()
    {
        return slice;
    }

    /***********************************************************************

      Push one token back into the stream, to be returned by a
      subsequent call to next()

      Push null to cancel a prior assignment

     ***********************************************************************/
    final LineIteratorEnhanced push(T[] token, long previousPosition = -1)
    {
        pushed = token;
        if (token is null)
        {
            if (pushed.ptr)
                this._position += this._pushLength;
        }
        else        
        {
            pushed = token;
            if (previousPosition >= 0)
            {
                this._pushLength = this._position - previousPosition;
                this._position = previousPosition;
                if (this._position < 0)
                    this._position = 0;
            }
        }
        
        return this;
    }

    /**********************************************************************

      Iterate over the set of tokens. This should really
      provide read-only access to the tokens, but D does
      not support that at this time

     **********************************************************************/

    int opApply (int delegate(inout T[]) dg)
    {
        T[]     token;
        int     result;

        while ((token = next).ptr)
        {
            result = dg (token);
            if (result)
                break;
        }
        return result;
    }

    /***********************************************************************

      Locate the next token. Returns the token if found, null
      otherwise. Null indicates an end of stream condition. To
      sweep a conduit for lines using method next():
      ---
      auto lines = new LineIterator!(char) (new FileConduit("myfile"));
      while (lines.next)
      Cout (lines.get).newline;
      ---

      Alternatively, we can extract one line from a conduit:
      ---
      auto line = (new LineIterator!(char) (new FileConduit("myfile"))).next;
      ---

      The difference between next() and foreach() is that the
      latter processes all tokens in one go, whereas the former
      processes in a piecemeal fashion. To wit:
      ---
      foreach (line; new LineIterator!(char) (new FileConduit("myfile"))
      Cout(line).newline;
      ---

      Note that tokens returned via push() are returned immediately
      when available, taking priority over the input stream itself

     ***********************************************************************/

    final T[] next ()
    {
        T[] rtn = pushed;

        if (rtn.ptr)
        {
            this._position += this._pushLength;
            pushed = null;
        }
        else
            if (buffer.next (&scan) || slice.length > 0)
                rtn = get ();

        return rtn;
    }

    /***********************************************************************

      Set the content of the current slice

     ***********************************************************************/

    protected final uint set (T* content, uint start, uint end)
    {
        slice = content [start .. end];
        return end;
    }

    /***********************************************************************

      Convert void[] from buffer into an appropriate array

     ***********************************************************************/

    protected final T[] convert (void[] data)
    {
        return cast(T[]) data [0 .. data.length & ~(T.sizeof-1)];
    }

    /***********************************************************************

      Called when a scanner fails to find a matching pattern.
      This may cause more content to be loaded, and a rescan
      initiated
     ***********************************************************************/

    protected final uint notFound (T[] content)
    {
        slice = content;
        return IConduit.Eof;
    }

    /***********************************************************************

      Invoked when a scanner matches a pattern. The provided
      value should be the index of the last element of the
      matching pattern, which is converted back to a void[]
      index.

     ***********************************************************************/

    protected final uint found (uint i)
    {
        return (i + 1) * T.sizeof;
    }

    /***********************************************************************

      See if set of characters holds a particular instance

     ***********************************************************************/

    protected final bool has (T[] set, T match)
    {
        foreach (T c; set)
            if (match is c)
                return true;
        return false;
    }

    protected uint scan(void[] data)
    {
        T[] content = convert (data);

        foreach (int i, T c; content)
            if (c is '\n')
            {
                this._position += i+1;
                int slice = i;
                if (i && content[i-1] is '\r')
                    --slice;
                set (content.ptr, 0, slice);
                return found (i);
            }

        return notFound (content);

    }
}