import java.io.*;

/** Subclass of LineNumberReader to allow reading of continued lines
 * using the readLine() method. The other Reader methods (readInt(  )) etc.)
 * must not be used.  Must subclass to provide the actual implementation
 * of readLine(  ).
 */
public abstract class ContLineReader extends LineNumberReader {
    /** Line number of first line in current (possibly continued) line */
    protected int firstLineNumber = 0;
    /** True if handling continuations, false if not; false == "PRE" mode */
    protected boolean doContinue = true;

    /** Set the continuation mode */
    public void setContinuationMode(boolean b) {
        doContinue = b;
    }

    /** Get the continuation mode */
    public boolean isContinuation(  ) {
        return doContinue;
    }

    /** Read one (possibly continued) line, stripping out the  that
     * marks the end of each line but the last in a sequence.
     */
    public abstract String readLine(  ) throws IOException;

    /** Read one real line. Provided as a convenience for the
     * subclasses, so they don't embarass themselves trying to
     * call "super.readLine(  )" which isn't very practical...
     */
    public String readPhysicalLine(  ) throws IOException {
        return super.readLine(  );
    }

    // Can NOT override getLineNumber in this class to return the # 
    // of the beginning of the continued line, since the subclasses
    // all call super.getLineNumber...
    
    /** Construct a ContLineReader with the default input-buffer size. */
    public ContLineReader(Reader in)  {
        super(in);
    }

    /** Construct a ContLineReader using the given input-buffer size. */
    public ContLineReader(Reader in, int sz)  {
        super(in, sz);
    }

    // Methods that do NOT work - redirect straight to parent

    /** Read a single character, returned as an int. */
    public int read(  ) throws IOException {
        return super.read(  );
    }

    /** Read characters into a portion of an array. */
    public int read(char[] cbuf, int off, int len) throws IOException {
        return super.read(cbuf, off, len);
    }

    public boolean markSupported(  ) {
        return false;
    }
}

import java.io.*;

/** Subclass of ContLineReader for lines continued by indentation of
 * following line (like RFC822 mail, Usenet News, etc.).
 */
public class IndentContLineReader extends ContLineReader {
    /** Line number of first line in current (possibly continued) line */
    public int getLineNumber(  ) {
        return firstLineNumber;
    }

    protected String prevLine;

    /** Read one (possibly continued) line, stripping out the ''s that
     * mark the end of all but the last.
     */
    public String readLine(  ) throws IOException {
        String s;

        // If we saved a previous line, start with it. Else,
        // read the first line of possible continuation. 
        // If non-null, put it into the StringBuffer and its line 
        // number in firstLineNumber.
        if (prevLine != null) {
            s = prevLine;
            prevLine = null;
        }
        else  {
            s = readPhysicalLine(  );
        }

        // save the line number of the first line.
        firstLineNumber = super.getLineNumber(  );

        // Now we have one line. If we are not in continuation
        // mode, or if a previous readPhysicalLine(  ) returned null,
        // we are finished, so return it.
        if (!doContinue || s == null)
            return s;

        // Otherwise, start building a stringbuffer
        StringBuffer sb = new StringBuffer(s);

        // Read as many continued lines as there are, if any.
        while (true) {
            String nextPart = readPhysicalLine(  );
            if (nextPart == null) {
                // Egad! EOF within continued line.
                // Return what we have so far.
                return sb.toString(  );
            }
            // If the next line begins with space, it's continuation
            if (nextPart.length(  ) > 0 &&
                Character.isWhitespace(nextPart.charAt(0))) {
                sb.append(nextPart);    // and add line.
            } else {
                // else we just read too far, so put in "pushback" holder
                prevLine = nextPart;
                break;
            }
        }

        return sb.toString(  );        // return what's left
    }

    /* Constructors not shown */

    // Built-in test case
    protected static String sampleTxt = 
        "From: ian today now
" +
        "Received: by foo.bar.com
" +
        "    at 12:34:56 January 1, 2000
" +
        "X-Silly-Headers: Too Many
" +
        "This line should be line 5.
" +
        "Test more indented line continues from line 6:
" +
        "    space indented.
" +
        "    tab indented;
" +
        "
" +
        "This is line 10
" + 
        "the start of a hypothetical mail/news message, 
" +
        "that is, it follows a null line.
" +
        "    Let us see how it fares if indented.
" +
        " also space-indented.
" +
        "
" +
        "How about text ending without a newline?";

    // A simple main program for testing the class.
    public static void main(String argv[]) throws IOException {
        IndentContLineReader is = new IndentContLineReader(
            new StringReader(sampleTxt));
        String aLine;
        // Print Mail/News Header
        System.out.println("----- Message Header -----");
        while ((aLine = is.readLine()) != null && aLine.length(  ) > 0) {
            System.out.println(is.getLineNumber(  ) + ": " + aLine);
        }
        // Make "is" behave like normal BufferedReader
        is.setContinuationMode(false);
        System.out.println(  );
        // Print Message Body
        System.out.println("----- Message Body -----");
        while ((aLine = is.readLine(  )) != null) {
            System.out.println(is.getLineNumber(  ) + ": " + aLine);
        }
        is.close(  );
    }
}