Application: gvSIG desktop

package org.gvsig.fmap.dal.store.csv.virtualrows;

import java.io.BufferedReader;

import java.io.File;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.io.Reader;

import java.io.UncheckedIOException;

import java.nio.ByteBuffer;

import java.nio.CharBuffer;

import java.nio.channels.Channels;

import java.nio.charset.Charset;

import java.util.Iterator;

import java.util.NoSuchElementException;

import java.util.Spliterator;

import java.util.Spliterators;

import java.util.function.Function;

import java.util.function.Predicate;

import java.util.stream.Stream;

import java.util.stream.StreamSupport;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

/**

 *

 * @author gvSIG Team

 */

public class RandomAccessFileReader extends Reader {

    public static final Predicate<String> FILTER_NONE = (String t) -> false;

    protected static final int INDEX_HEADER_FILESIZE = 0;

    protected static final int INDEX_HEADER_INDEXCREATIONCOST = 1;

    protected static final int MAX_BUFFER_FOR_LINE = 50*1024; //50K

    protected RandomAccessFile raf;

    protected Reader reader;

    protected long currentPosition;

    protected final Charset charset;

    protected long lastModified;

    public RandomAccessFileReader(File f, String charsetName) throws IOException {

        this(new RandomAccessFile(f, "r"), Charset.forName(charsetName));

        this.lastModified = f.lastModified();

    }

    public RandomAccessFileReader(File f, Charset charset) throws IOException {

        this(new RandomAccessFile(f, "r"), charset);

        this.lastModified = f.lastModified();

    }

    public RandomAccessFileReader(RandomAccessFile raf, String charsetName) throws IOException {

        this(raf, Charset.forName(charsetName));

        this.lastModified = -1;

    }

    public RandomAccessFileReader(RandomAccessFile raf, Charset charset) throws IOException {

        this.charset = charset;

        this.raf = raf;

        this.reader = null;

        this.currentPosition = 0;

        this.lastModified = -1;

    }

    public Charset getCharset() {

        return this.charset;

    }

    @Override

    public int read(char[] cbuf, int off, int len) throws IOException {

        if (this.reader == null) {

            this.createReader();

        }

        int n = this.reader.read(cbuf, off, len);

        if (n > 0) {

            // Update current position (bytes) adding the read characters.

            CharBuffer charBuffer = CharBuffer.wrap(cbuf, off, len);

            ByteBuffer byteBuffer = this.charset.encode(charBuffer);

            this.currentPosition += byteBuffer.limit();

        }

        return n;

    }

    protected void createReader() {

        this.reader = Channels.newReader(this.raf.getChannel(), this.charset.name());

    }

//    protected InputStream is;

//    protected void createReader() {

//        if( this.is==null ) {

//            this.is = new InputStream() {

//                @Override

//                public int read() throws IOException {

//                    return raf.read();

//                }

//            };

//        }

//        this.reader = new InputStreamReader(this.is, charset);

//    }

    @Override

    public void close() throws IOException {

//        IOUtils.closeQuietly(this.is);

        IOUtils.closeQuietly(this.reader);

        IOUtils.closeQuietly(this.raf);

    }

    public long getFilePointer() throws IOException {

        return this.raf.getFilePointer();

    }

    public long getCurrentPosition() {

        return this.currentPosition;

    }

    public void rewind() throws IOException {

        this.raf.seek(0);

        this.reader = null;

        this.currentPosition = 0;

    }

    public void seek(long position) throws IOException {

        this.raf.seek(position);

        this.reader = null;

        this.currentPosition = position;

    }

    public String readLine() throws IOException {

        StringBuilder buffer = new StringBuilder();

        int c = -1;

        boolean eol = false;

        while (!eol) {

            switch (c = this.read()) {

                case -1:

                case '\n':

                    eol = true;

                    break;

                case '\r':

                    eol = true;

                    long cur = raf.getFilePointer();

                    if ((raf.read()) != '\n') {

                        raf.seek(cur);

                    }

                    break;

                default:

                    buffer.append((char) c);

                    break;

            }

        }

        if ((c == -1) && (buffer.length() == 0)) {

            return null;

        }

        return buffer.toString();

    }

    public long countLines(Predicate<String> filter, SimpleTaskStatus status) throws IOException {

        if (raf.length() == 0) {

            return 0;

        }

        long savedpos = this.getCurrentPosition();

        long count = -1;

        if (status != null) {

            I18nManager i18n = ToolsLocator.getI18nManager();

            status.message(i18n.getTranslation("_Calculating_number_of_lines"));

            status.setIndeterminate();

        }

        BufferedReader breader = new BufferedReader(this, MAX_BUFFER_FOR_LINE);

        try {

            String line;

            count = 0;

            while ((line = breader.readLine()) != null) {

                if (status != null) {

                    if (status.isCancellationRequested()) {

                        return -1;

                    }

//                    status.incrementCurrentValue();

                    if((count % 1000) == 0){

                        status.setCurValue(count);

                    }

                }

                if (filter.test(line)) {

                    continue;

                }

                count++;

            }

            if (status != null) {

                status.setCurValue(count);

                status.message("");

                status.setIndeterminate();

            }

        } finally {

            this.seek(savedpos);

        }

        return count;

    }

    public boolean isRecomemendedTheRecreationOfTheLinesIndex(File index) {

        RandomAccessFileIndex line_idx = null;

        try {

            if (this.lastModified > 0 && this.lastModified > index.lastModified()) {

                return true;

            }

            line_idx = new RandomAccessFileIndex();

            line_idx.open(index);

            if (this.raf.length() != line_idx.getHeader(INDEX_HEADER_FILESIZE)) {

                return true;

            }

            long creationCost = line_idx.getHeader(INDEX_HEADER_FILESIZE);

            if (creationCost < 2000) { // < 2 sec.

                return true;

            }

            if (line_idx.get(-1) == 0) {

                // if last index == 0, index is corrupt

                return true;

            }

//            FIXME: isValidIndexOfLines not full implemented 

//            Podria comprobarse que  una muestra de 4 o 5 bloques de datos

//            repartidas por el fichero tengan el checksum correcto

            return false;

        } catch (IOException ex) {

            return true;

        } finally {

            IOUtils.closeQuietly(line_idx);

        }

    }

    public RandomAccessFileIndex createOrOpenIndexOfLines(File index, Predicate<String> filter, SimpleTaskStatus status) throws IOException {

        return this.createOrOpenIndexOfLines(index, false, filter, status);

    }

    public RandomAccessFileIndex createOrOpenIndexOfLines(File index, boolean safe, Predicate<String> filter, SimpleTaskStatus status) throws IOException {

        return createOrOpenIndexOfLines(index, safe, filter, status, null);

    }

    public RandomAccessFileIndex createOrOpenIndexOfLines(File index, boolean safe, Predicate<String> filter, SimpleTaskStatus status, Function<BufferedReader,Integer> numberOfLines) throws IOException {

        if (this.isRecomemendedTheRecreationOfTheLinesIndex(index)) {

            return this.createIndexOfLines(index, safe, filter, status, numberOfLines);

        }

        return new RandomAccessFileIndex(index);

    }

    public RandomAccessFileIndex createIndexOfLines(File index, Predicate<String> filter, SimpleTaskStatus status) throws IOException {

        return this.createIndexOfLines(index, false, filter, status);

    }

    public RandomAccessFileIndex createIndexOfLines(File index, boolean safe, Predicate<String> filter, SimpleTaskStatus status) throws IOException {

        return createIndexOfLines(index, safe, filter, status, null);

    }

    public RandomAccessFileIndex createIndexOfLines(File index, boolean safe, Predicate<String> filter, SimpleTaskStatus status, Function<BufferedReader,Integer> numberOfLines) throws IOException {

        long countLines = this.countLines(filter, status);

        if (countLines < 1) {

            return null;

        }

        RandomAccessFileIndex line_idx = new RandomAccessFileIndex();

        line_idx.create(index, countLines);

        long savedpos = this.getCurrentPosition();

        try {

            if (status != null) {

                I18nManager i18n = ToolsLocator.getI18nManager();

                status.push();

                status.message(i18n.getTranslation("_Creating_the_index_of_the_lines"));

                status.setRangeOfValues(0, line_idx.size64());

                status.setCurValue(0);

            }

            long t1 = System.currentTimeMillis();

            String line = null;

            int lineno = 0;

            long position = 0;

//            line_idx.set(lineno++, position);

            if (safe) {

                // Don't use buffered reader, slow and safe calculate position

                int x = (int) (countLines / 100);

                while (lineno < countLines) { //true ) {

                    line = this.readLine();

                    if (line == null) {

                        break;

                    }

                    if (filter.test(line)) {

                        continue;

                    }

                    line_idx.set(lineno++, position);

                    if (status != null) {

                        if (status.isCancellationRequested()) {

                            status.cancel();

                            return null;

                        }

//                        status.incrementCurrentValue();

                        if((lineno % x) == 0){

                            status.setCurValue(lineno);

                        }

                    }

                    position = this.getCurrentPosition();

//                    line_idx.set(lineno++, position);

                }

                status.setCurValue(lineno);

            } else {

                // Use buffered reader, fast and unsafe calculate position.

                StringBuilder builder = new StringBuilder();

                MyBufferedReader breader = new MyBufferedReader(this, MAX_BUFFER_FOR_LINE);

                while (lineno < countLines) {

                    this.seek(position);

                    breader.clean();

                    if(numberOfLines == null){

                        line = breader.readLine();

                    } else {

                        breader.mark(MAX_BUFFER_FOR_LINE);

                        Integer nextLine = numberOfLines.apply(breader);

                        breader.reset();

                        builder.setLength(0);

                        for (int i = 0; i < nextLine; i++) {

                            String l = breader.readLine();

                            if(l != null){

                                builder.append(l);

                            } else {

                                break;

                            }

                        }

                        line = StringUtils.defaultIfBlank(builder.toString(), null);

                    }

                    if (line == null) {

                        break;

                    }

                    if (filter.test(line)) {

                        continue;

                    }

                    line_idx.set(lineno++, position);

                    if (status != null) {

                        if (status.isCancellationRequested()) {

                            status.cancel();

                            return null;

                        }

                        status.incrementCurrentValue();

                    }

                    CharBuffer charBuffer = null;

                    // ? Y si hay un \r\n ?

                    if(breader.isSkipLf()){

                        charBuffer = CharBuffer.wrap(line + "\r\n");

                    } else {

                        charBuffer = CharBuffer.wrap(line + "\n");

                    }

                    ByteBuffer byteBuffer = this.charset.encode(charBuffer);

                    position += byteBuffer.limit();

//                    line_idx.set(lineno++, position);

                }

            }

            long t2 = System.currentTimeMillis();

            line_idx.setNumElements(lineno);

            line_idx.setHeader(INDEX_HEADER_FILESIZE, this.raf.length());

            line_idx.setHeader(INDEX_HEADER_INDEXCREATIONCOST, t2 - t1);

            if (status != null) {

                status.message("");

                status.pop();

            }

            return line_idx;

        } finally {

            this.seek(savedpos);

        }

    }

    public long getLastLinesIndexCreationCost(RandomAccessFileIndex index) {

        return index.getHeader(INDEX_HEADER_INDEXCREATIONCOST);

    }

    public static void main(String[] args) throws Exception {

        new DefaultLibrariesInitializer().fullInitialize();

        String fname;

        fname = "/home/jjdelcerro/Descargas/test/origen_coordenadas.csv";

//        fname = "/home/jjdelcerro/Descargas/test/esp_poblaciones.csv";

//        fname = "/home/jjdelcerro/Descargas/test/esp_provincias.csv";

//        fname = "/home/jjdelcerro/Descargas/test/sigpac.csv";

        File data_file = new File(fname);

        File idx_file = new File(FilenameUtils.removeExtension(data_file.getAbsolutePath()) + ".idx");

        final TaskStatusManager taskStatusManager = ToolsLocator.getTaskStatusManager();

        taskStatusManager.addObserver((Observable observable, Object notification) -> {

            TaskStatus status = taskStatusManager.getRunningTaskStatusMostRecent();

//            System.out.print("\033[?25l\r");

//            if( status!=null && status.isRunning() ) {

//                System.out.print("\033[?25l\r");

//                System.out.print(status.getTitle()+ " - " + status.getLabel());

//                System.out.print("\033[K\033[?12l\033[?25h");

//            }

//            System.out.flush();

        });

        SimpleTaskStatus status = taskStatusManager.createDefaultSimpleTaskStatus(data_file.getName());

        status.add();

        RandomAccessFileReader reader = new RandomAccessFileReader(data_file, "UTF-8");

        System.out.println("Index '" + idx_file.getName() + "', is creation recomended: " + reader.isRecomemendedTheRecreationOfTheLinesIndex(idx_file));

        RandomAccessFileIndex lines_idx = reader.createOrOpenIndexOfLines(idx_file, FILTER_NONE, status);

        for (int linenumber = 0; linenumber < lines_idx.size(); linenumber++) {

            long lineoffset = lines_idx.get(linenumber);

            reader.seek(lineoffset);

            MyBufferedReader breader = new MyBufferedReader(reader, MAX_BUFFER_FOR_LINE);

            String line = breader.readLine();

            if (linenumber < 100) {

                System.out.println(String.format("%6d/%d: %s", lineoffset, linenumber, line));

            } else if (linenumber == 100) {

                System.out.println("More records...");

            }

        }

        System.out.println("------------------------------------");

        for (int linenumber = lines_idx.size() - 1; linenumber >= 0; linenumber--) {

            long lineoffset = lines_idx.get(linenumber);

            reader.seek(lineoffset);

            MyBufferedReader breader = new MyBufferedReader(reader, MAX_BUFFER_FOR_LINE);

            String line = breader.readLine();

            if (linenumber < 100) {

                System.out.println(String.format("%6d/%d: %s", lineoffset, linenumber, line));

            } else if (linenumber == 100) {

                System.out.println("More records...");

            }

        }

    }

    /*

        Copy of java's BufferedReader adding clean and isSkipLf methods

    */

    public static class MyBufferedReader extends BufferedReader {

        private Reader in;

        private char cb[];

        private int nChars, nextChar;

        private static final int INVALIDATED = -2;

        private static final int UNMARKED = -1;

        private int markedChar = UNMARKED;

        private int readAheadLimit = 0;

        /* Valid only when markedChar > 0 */

        /**

         * If the next character is a line feed, skip it

         */

        private boolean skipLF = false;

        /**

         * The skipLF flag when the mark was set

         */

        private boolean markedSkipLF = false;

        private static int defaultCharBufferSize = 8192;

        private static int defaultExpectedLineLength = 80;

        /**

         * Creates a buffering character-input stream that uses an input buffer

         * of the specified size.

         *

         * @param in A Reader

         * @param sz Input-buffer size

         *

         * @exception IllegalArgumentException If {@code sz <= 0}

         */

        public MyBufferedReader(Reader in, int sz) {

            super(in);

            if (sz <= 0) {

                throw new IllegalArgumentException("Buffer size <= 0");

            }

            this.in = in;

            cb = new char[sz];

            nextChar = nChars = 0;

        }

        /**

         * Creates a buffering character-input stream that uses a default-sized

         * input buffer.

         *

         * @param in A Reader

         */

        public MyBufferedReader(Reader in) {

            this(in, defaultCharBufferSize);

        }

        /**

         * Checks to make sure that the stream has not been closed

         */

        private void ensureOpen() throws IOException {

            if (in == null) {

                throw new IOException("Stream closed");

            }

        }

        /**

         * Fills the input buffer, taking the mark into account if it is valid.

         */

        private void fill() throws IOException {

            int dst;

            if (markedChar <= UNMARKED) {

                /* No mark */

                dst = 0;

            } else {

                /* Marked */

                int delta = nextChar - markedChar;

                if (delta >= readAheadLimit) {

                    /* Gone past read-ahead limit: Invalidate mark */

                    markedChar = INVALIDATED;

                    readAheadLimit = 0;

                    dst = 0;

                } else {

                    if (readAheadLimit <= cb.length) {

                        /* Shuffle in the current buffer */

                        System.arraycopy(cb, markedChar, cb, 0, delta);

                        markedChar = 0;

                        dst = delta;

                    } else {

                        /* Reallocate buffer to accommodate read-ahead limit */

                        char ncb[] = new char[readAheadLimit];

                        System.arraycopy(cb, markedChar, ncb, 0, delta);

                        cb = ncb;

                        markedChar = 0;

                        dst = delta;

                    }

                    nextChar = nChars = delta;

                }

            }

            int n;

            do {

                n = in.read(cb, dst, cb.length - dst);

            } while (n == 0);

            if (n > 0) {

                nChars = dst + n;

                nextChar = dst;

            }

        }

        /**

         * Reads a single character.

         *

         * @return The character read, as an integer in the range 0 to 65535

         * (<tt>0x00-0xffff</tt>), or -1 if the end of the stream has been

         * reached

         * @exception IOException If an I/O error occurs

         */

        @Override

        public int read() throws IOException {

            synchronized (lock) {

                ensureOpen();

                for (;;) {

                    if (nextChar >= nChars) {

                        fill();

                        if (nextChar >= nChars) {

                            return -1;

                        }

                    }

                    if (skipLF) {

                        skipLF = false;

                        if (cb[nextChar] == '\n') {

                            nextChar++;

                            continue;

                        }

                    }

                    return cb[nextChar++];

                }

            }

        }

        /**

         * Reads characters into a portion of an array, reading from the

         * underlying stream if necessary.

         */

        private int read1(char[] cbuf, int off, int len) throws IOException {

            if (nextChar >= nChars) {

                /* If the requested length is at least as large as the buffer, and

               if there is no mark/reset activity, and if line feeds are not

               being skipped, do not bother to copy the characters into the

               local buffer.  In this way buffered streams will cascade

               harmlessly. */

                if (len >= cb.length && markedChar <= UNMARKED && !skipLF) {

                    return in.read(cbuf, off, len);

                }

                fill();

            }

            if (nextChar >= nChars) {

                return -1;

            }

            if (skipLF) {

                skipLF = false;

                if (cb[nextChar] == '\n') {

                    nextChar++;

                    if (nextChar >= nChars) {

                        fill();

                    }

                    if (nextChar >= nChars) {

                        return -1;

                    }

                }

            }

            int n = Math.min(len, nChars - nextChar);

            System.arraycopy(cb, nextChar, cbuf, off, n);

            nextChar += n;

            return n;

        }

        /**

         * Reads characters into a portion of an array.

         *

         * <p>

         * This method implements the general contract of the corresponding

         * <code>{@link Reader#read(char[], int, int) read}</code> method of the

         * <code>{@link Reader}</code> class. As an additional convenience, it

         * attempts to read as many characters as possible by repeatedly

         * invoking the <code>read</code> method of the underlying stream. This

         * iterated <code>read</code> continues until one of the following

         * conditions becomes true: <ul>

         *

         * <li> The specified number of characters have been read,

         *

         * <li> The <code>read</code> method of the underlying stream returns

         * <code>-1</code>, indicating end-of-file, or

         *

         * <li> The <code>ready</code> method of the underlying stream returns

         * <code>false</code>, indicating that further input requests would

         * block.

         *

         * </ul> If the first <code>read</code> on the underlying stream returns

         * <code>-1</code> to indicate end-of-file then this method returns

         * <code>-1</code>. Otherwise this method returns the number of

         * characters actually read.

         *

         * <p>

         * Subclasses of this class are encouraged, but not required, to attempt

         * to read as many characters as possible in the same fashion.

         *

         * <p>

         * Ordinarily this method takes characters from this stream's character

         * buffer, filling it from the underlying stream as necessary. If,

         * however, the buffer is empty, the mark is not valid, and the

         * requested length is at least as large as the buffer, then this method

         * will read characters directly from the underlying stream into the

         * given array. Thus redundant <code>BufferedReader</code>s will not

         * copy data unnecessarily.

         *

         * @param cbuf Destination buffer

         * @param off Offset at which to start storing characters

         * @param len Maximum number of characters to read

         *

         * @return The number of characters read, or -1 if the end of the stream

         * has been reached

         *

         * @exception IOException If an I/O error occurs

         */

        @Override

        public int read(char cbuf[], int off, int len) throws IOException {

            synchronized (lock) {

                ensureOpen();

                if ((off < 0) || (off > cbuf.length) || (len < 0)

                        || ((off + len) > cbuf.length) || ((off + len) < 0)) {

                    throw new IndexOutOfBoundsException();

                } else if (len == 0) {

                    return 0;

                }

                int n = read1(cbuf, off, len);

                if (n <= 0) {

                    return n;

                }

                while ((n < len) && in.ready()) {

                    int n1 = read1(cbuf, off + n, len - n);

                    if (n1 <= 0) {

                        break;

                    }

                    n += n1;

                }

                return n;

            }

        }

        /**

         * Reads a line of text. A line is considered to be terminated by any

         * one of a line feed ('\n'), a carriage return ('\r'), or a carriage

         * return followed immediately by a linefeed.

         *

         * @param ignoreLF If true, the next '\n' will be skipped

         *

         * @return A String containing the contents of the line, not including

         * any line-termination characters, or null if the end of the stream has

         * been reached

         *

         * @see java.io.LineNumberReader#readLine()

         *

         * @exception IOException If an I/O error occurs

         */

        String readLine(boolean ignoreLF) throws IOException {

            StringBuilder s = null;

            int startChar;

            synchronized (lock) {

                ensureOpen();

                boolean omitLF = ignoreLF || skipLF;

                bufferLoop:

                for (;;) {

                    if (nextChar >= nChars) {

                        fill();

                    }

                    if (nextChar >= nChars) {

                        /* EOF */

                        if (s != null && s.length() > 0) {

                            return s.toString();

                        } else {

                            return null;

                        }

                    }

                    boolean eol = false;

                    char c = 0;

                    int i;

                    /* Skip a leftover '\n', if necessary */

                    if (omitLF && (cb[nextChar] == '\n')) {

                        nextChar++;

                    }

                    skipLF = false;

                    omitLF = false;

                    charLoop:

                    for (i = nextChar; i < nChars; i++) {

                        c = cb[i];

                        if ((c == '\n') || (c == '\r')) {

                            eol = true;

                            break charLoop;

                        }

                    }

                    startChar = nextChar;

                    nextChar = i;

                    if (eol) {

                        String str;

                        if (s == null) {

                            str = new String(cb, startChar, i - startChar);

                        } else {

                            s.append(cb, startChar, i - startChar);

                            str = s.toString();

                        }

                        nextChar++;

                        if (c == '\r') {

                            skipLF = true;

                        }

                        return str;

                    }

                    if (s == null) {

                        s = new StringBuilder(defaultExpectedLineLength);

                    }

                    s.append(cb, startChar, i - startChar);

                }

            }

        }

        /**

         * Reads a line of text. A line is considered to be terminated by any

         * one of a line feed ('\n'), a carriage return ('\r'), or a carriage

         * return followed immediately by a linefeed.

         *

         * @return A String containing the contents of the line, not including

         * any line-termination characters, or null if the end of the stream has

         * been reached

         *

         * @exception IOException If an I/O error occurs

         *

         * @see java.nio.file.Files#readAllLines

         */

        @Override

        public String readLine() throws IOException {

            return readLine(false);

        }

        /**

         * Skips characters.

         *

         * @param n The number of characters to skip

         *

         * @return The number of characters actually skipped

         *

         * @exception IllegalArgumentException If <code>n</code> is negative.

         * @exception IOException If an I/O error occurs

         */

        @Override

        public long skip(long n) throws IOException {

            if (n < 0L) {

                throw new IllegalArgumentException("skip value is negative");

            }

            synchronized (lock) {

                ensureOpen();

                long r = n;

                while (r > 0) {

                    if (nextChar >= nChars) {

                        fill();

                    }

                    if (nextChar >= nChars) /* EOF */ {

                        break;

                    }

                    if (skipLF) {

                        skipLF = false;

                        if (cb[nextChar] == '\n') {

                            nextChar++;

                        }

                    }

                    long d = nChars - nextChar;

                    if (r <= d) {

                        nextChar += r;

                        r = 0;

                        break;

                    } else {

                        r -= d;

                        nextChar = nChars;

                    }

                }

                return n - r;

            }

        }

        /**

         * Tells whether this stream is ready to be read. A buffered character

         * stream is ready if the buffer is not empty, or if the underlying

         * character stream is ready.

         *

         * @exception IOException If an I/O error occurs

         */

        @Override

        public boolean ready() throws IOException {

            synchronized (lock) {

                ensureOpen();

                /*

             * If newline needs to be skipped and the next char to be read

             * is a newline character, then just skip it right away.

                 */

                if (skipLF) {

                    /* Note that in.ready() will return true if and only if the next

                 * read on the stream will not block.

                     */

                    if (nextChar >= nChars && in.ready()) {

                        fill();

                    }

                    if (nextChar < nChars) {

                        if (cb[nextChar] == '\n') {

                            nextChar++;

                        }

                        skipLF = false;

                    }

                }

                return (nextChar < nChars) || in.ready();

            }

        }

        /**

         * Tells whether this stream supports the mark() operation, which it

         * does.

         */

        @Override

        public boolean markSupported() {

            return true;

        }

        /**

         * Marks the present position in the stream. Subsequent calls to reset()

         * will attempt to reposition the stream to this point.

         *

         * @param readAheadLimit Limit on the number of characters that may be

         * read while still preserving the mark. An attempt to reset the stream

         * after reading characters up to this limit or beyond may fail. A limit

         * value larger than the size of the input buffer will cause a new

         * buffer to be allocated whose size is no smaller than limit. Therefore

         * large values should be used with care.

         *

         * @exception IllegalArgumentException If {@code readAheadLimit < 0}

         * @exception IOException If an I/O error occurs

         */

        @Override

        public void mark(int readAheadLimit) throws IOException {

            if (readAheadLimit < 0) {

                throw new IllegalArgumentException("Read-ahead limit < 0");

            }

            synchronized (lock) {

                ensureOpen();

                this.readAheadLimit = readAheadLimit;

                markedChar = nextChar;

                markedSkipLF = skipLF;

            }

        }

        /**

         * Resets the stream to the most recent mark.

         *

         * @exception IOException If the stream has never been marked, or if the

         * mark has been invalidated

         */

        @Override

        public void reset() throws IOException {

            synchronized (lock) {

                ensureOpen();

                if (markedChar < 0) {

                    throw new IOException((markedChar == INVALIDATED)

                            ? "Mark invalid"

                            : "Stream not marked");

                }

                nextChar = markedChar;

                skipLF = markedSkipLF;

            }

        }

        @Override

        public void close() throws IOException {

            synchronized (lock) {

                if (in == null) {

                    return;

                }

                try {

                    in.close();

                } finally {

                    in = null;

                    cb = null;

                }

            }

        }

        /**

         * Returns a {@code Stream}, the elements of which are lines read from

         * this {@code BufferedReader}. The {@link Stream} is lazily populated,

         * i.e., read only occurs during the

         * <a href="../util/stream/package-summary.html#StreamOps">terminal

         * stream operation</a>.

         *

         * <p>

         * The reader must not be operated on during the execution of the

         * terminal stream operation. Otherwise, the result of the terminal

         * stream operation is undefined.

         *

         * <p>

         * After execution of the terminal stream operation there are no

         * guarantees that the reader will be at a specific position from which

         * to read the next character or line.

         *

         * <p>

         * If an {@link IOException} is thrown when accessing the underlying

         * {@code BufferedReader}, it is wrapped in an {@link

         * UncheckedIOException} which will be thrown from the {@code Stream}

         * method that caused the read to take place. This method will return a

         * Stream if invoked on a BufferedReader that is closed. Any operation

         * on that stream that requires reading from the BufferedReader after it

         * is closed, will cause an UncheckedIOException to be thrown.

         *

         * @return a {@code Stream<String>} providing the lines of text

         * described by this {@code BufferedReader}

         *

         * @since 1.8

         */

        @Override

        public Stream<String> lines() {

            Iterator<String> iter = new Iterator<String>() {

                String nextLine = null;

                @Override

                public boolean hasNext() {

                    if (nextLine != null) {

                        return true;

                    } else {

                        try {

                            nextLine = readLine();

                            return (nextLine != null);

                        } catch (IOException e) {

                            throw new UncheckedIOException(e);

                        }

                    }

                }

                @Override

                public String next() {

                    if (nextLine != null || hasNext()) {

                        String line = nextLine;

                        nextLine = null;

                        return line;

                    } else {

                        throw new NoSuchElementException();

                    }

                }

            };

            return StreamSupport.stream(Spliterators.spliteratorUnknownSize(

                    iter, Spliterator.ORDERED | Spliterator.NONNULL), false);

        }

        public boolean isSkipLf() {

            return this.skipLF;

        }

        public void clean() {

            nextChar = nChars = 0;

            markedChar = UNMARKED;

            readAheadLimit = 0;

            skipLF = false;

            markedSkipLF = false;

        }

    }

}