Re: Scanner Bug?

John B. Matthews wrote:


\Z works correctly for me also, but it does discard the final newline,
which is undesired. (I have a larger program with different tests, which
fails testing due to the missing newline, even though the SSCCE I posted
succeeds). \00 works ("\\00") but seems dangerous, if a NUL happens to
appear in the input stream. Same for \e.

I think that \z should work the same as \Z, except for the final
newline. That it doesn't seems to be a bug.

Incidentally, my current solution is below. ;)

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;

/**
  *
  * @author Brenden
  */
public final class UnboundedCharSeq
         implements CharSequence
{

     private static final int BUF_SIZE = 1024;
     final ArrayList<char[]> buffers;
     final int startOffset;
     final int endOffset;

     int hashcode;

     public UnboundedCharSeq( File f )
             throws FileNotFoundException, IOException
     {
         this( new FileInputStream( f ) );
     }

     public UnboundedCharSeq( InputStream ins )
             throws IOException
     {
         InputStreamReader inr = new InputStreamReader( ins );
         int totlaBytes = 0;
         ArrayList<char[]> buf = new ArrayList<char[]>();

         try
         {
             char[] charBuf = new char[BUF_SIZE];
             buf.add( charBuf );
             int retVal;
             int pos = 0;
             int len = charBuf.length;

             while( (retVal = inr.read( charBuf, pos, len )) >= 0 )
             {
                 totlaBytes += retVal;
                 pos += retVal;
                 len -= retVal;
                 if( len == 0 )
                 {
                     charBuf = new char[BUF_SIZE];
                     buf.add( charBuf );
                     pos = 0;
                     len = charBuf.length;
                 }
             }
         }finally
         {
             inr.close();
         }

         buffers = buf;
         startOffset = 0;
         endOffset = totlaBytes;
     }

     private UnboundedCharSeq( ArrayList<char[]> buf, int start, int end )
     {
         buffers = buf;
         startOffset = start;
         endOffset = end;
     }

     public int length()
     {
         return endOffset - startOffset;
     }

     public char charAt( int index )
     {
         checkIndex( index );
         index += startOffset;
         return buffers.get( index / BUF_SIZE )[index % BUF_SIZE];
     }

     @Override
     public CharSequence subSequence( int start, int end )
     {
         checkIndex( start );
         if( end < start || end > length() ) {
             throw new IndexOutOfBoundsException( "end index: " + end
                     + " must be ["+start+".." + length() + "]" );
         }
         start += startOffset;
         end += startOffset;
         return new UnboundedCharSeq( buffers, start, end );
     }

     private void checkIndex( int index )
     {
         if( index >= length() || index < 0 )
         {
             throw new IndexOutOfBoundsException( "index: " + index
                     + " must be [0.." + length() + ")" );
         }
     }

     @Override
     public boolean equals( Object obj )
     {
         if( !(obj instanceof UnboundedCharSeq ) ) {
             return false;
         }
         return contentEquals( (CharSequence) obj );
     }

     @Override
     public int hashCode()
     {
         if( hashcode == 0 ) {
             hashcode = length() * 31 + 17;
             for( int i = 0; i < length(); i++ ) {
                 hashcode = hashcode * 37 + charAt( i );
             }
         }
         return hashcode;
     }

     @Override
     public String toString()
     {
         char[] temp = new char[length()];

         for( int i = 0; i < length(); i++ ) {
             temp[i] = charAt( i );
         }
         return new String( temp );
     }

     public boolean contentEquals( CharSequence cs ) {
         if( cs.length() != length() ) {
             return false;
         }

         for( int i = 0; i < length(); i++ ) {
             if( charAt( i ) != cs.charAt( i ) ) {
                 return false;
             }
         }
         return true;
     }
}