Application: gvSIG desktop

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

import java.io.File;

import java.io.IOException;

import java.io.Reader;

import java.util.List;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.text.StringEscapeUtils;

import org.gvsig.fmap.dal.store.csv.CSVStoreParameters;

import org.gvsig.fmap.dal.store.csv.virtualrows.RandomAccessFileIndex;

import org.gvsig.fmap.dal.store.csv.virtualrows.RandomAccessFileReader;

            if( data_file.length()< 10*1024*1024 ) {

                return null;

            }

            String charset = CSVStoreParameters.getCharset(params);

            File index_file = getIndexFile(data_file);

            theReader = new RandomAccessFileReader(data_file, charset);

            SuperCSVList list = new SuperCSVList(

                    theReader, 

import java.nio.MappedByteBuffer;

import java.nio.channels.FileChannel;

import java.util.AbstractList;

import org.apache.commons.io.IOUtils;

import org.gvsig.tools.util.GetItemWithSize64;

import org.gvsig.tools.util.SetItem;

        this.create(theRaf,sz);

    }

        this.raf = raf;

        this.fileByteBuffer = this.raf.getChannel().map(

                FileChannel.MapMode.READ_WRITE, 

                0, 

        this.buffer = this.fileByteBuffer.asLongBuffer();

        this.sz = buffer.limit()-HEADER_SIZE;

    }

    @Override

    public void close() throws IOException {

import java.util.NoSuchElementException;

import java.util.Spliterator;

import java.util.Spliterators;

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.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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

    protected static final int INDEX_HEADER_FILESIZE = 0;

    protected static final int INDEX_HEADER_INDEXCREATIONCOST = 1;

    protected RandomAccessFile raf;

    protected Reader reader;

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

            status.setIndeterminate();

        }

        try {

            String line;

            count = 0;

                }

                count++;

            }

            if (status != null) {

                status.message("");

                status.setIndeterminate();

            }

    }

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

        if (this.isRecomemendedTheRecreationOfTheLinesIndex(index)) {

        }

        return new RandomAccessFileIndex(index);

    }

    }

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

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

        if (countLines < 1) {

            return null;

                status.setCurValue(0);

            }

            long t1 = System.currentTimeMillis();

            int lineno = 0;

            long position = 0;

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

                status.setCurValue(lineno);

            } else {

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

                while (lineno < countLines) {

                    this.seek(position);

                    if (line == null) {

                        break;

                    }

                }

            }

            long t2 = System.currentTimeMillis();

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

            line_idx.setHeader(INDEX_HEADER_INDEXCREATIONCOST, t2 - t1);

            if (status != null) {

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

            long lineoffset = lines_idx.get(linenumber);

            reader.seek(lineoffset);

            String line = breader.readLine();

            if (linenumber < 100) {

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

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

            long lineoffset = lines_idx.get(linenumber);

            reader.seek(lineoffset);

            String line = breader.readLine();

            if (linenumber < 100) {

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

    }

    public static class MyBufferedReader extends BufferedReader {

        private Reader in;

        public MyBufferedReader(Reader in) {

            this(in, defaultCharBufferSize);

        }

        /**

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

         */

         * reached

         * @exception IOException If an I/O error occurs

         */

        public int read() throws IOException {

            synchronized (lock) {

                ensureOpen();

         *

         * @exception IOException If an I/O error occurs

         */

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

            synchronized (lock) {

                ensureOpen();

         *

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

         */

        public String readLine() throws IOException {

            return readLine(false);

        }

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

         * @exception IOException If an I/O error occurs

         */

        public long skip(long n) throws IOException {

            if (n < 0L) {

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

         *

         * @exception IOException If an I/O error occurs

         */

        public boolean ready() throws IOException {

            synchronized (lock) {

                ensureOpen();

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

         * does.

         */

        public boolean markSupported() {

            return true;

        }

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

         * @exception IOException If an I/O error occurs

         */

        public void mark(int readAheadLimit) throws IOException {

            if (readAheadLimit < 0) {

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

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

         * mark has been invalidated

         */

        public void reset() throws IOException {

            synchronized (lock) {

                ensureOpen();

            }

        }

        public void close() throws IOException {

            synchronized (lock) {

                if (in == null) {

         *

         * @since 1.8

         */

        public Stream<String> lines() {

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

                String nextLine = null;

        public boolean isSkipLf() {

            return this.skipLF;

        }

    }

}

 */

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

import java.io.File;

import java.io.IOException;

import java.nio.charset.Charset;

import java.util.Date;

import java.util.List;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.io.input.CloseShieldReader;

        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";

        });

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

        status.add();

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

        CSVList csv = new SuperCSVList(reader, index_lines, 0);

        System.out.println("Lines " + csv.size());