Application: gvSIG desktop

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

import java.io.File;

import java.io.FileInputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.nio.ByteBuffer;

import java.nio.CharBuffer;

import java.nio.charset.Charset;

import java.nio.charset.StandardCharsets;

import java.sql.Timestamp;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.mutable.MutableLong;

import org.apache.tika.config.TikaConfig;

import org.apache.tika.detect.DefaultEncodingDetector;

import org.apache.tika.detect.EncodingDetector;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.util.ListBuilder;

import org.xml.sax.Attributes;

import org.xml.sax.InputSource;

import org.xml.sax.Locator;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

public class TestXML {

    private static final String XMLFILE1 = "/home/jjdelcerro/datos/geodata/vector/sigpac/2018/Declaracion.xml";

    private static final String XMLFILE2 = "/home/jjdelcerro/datos/geodata/vector/ARENA2/quincenas-0/TV_03_2019_01_Q1/victimas.xml";

    private static final String XMLFILE_BIG = "/home/jjdelcerro/datos/geodata/vector/RSUPAC/2020/BDA_RSU_PAC20_1713052020_001.XML";

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

        TestXML t = new TestXML();

        Set<String> tags = t.extractTags(XMLFILE1);

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

        for (String tag : tags) {

            System.out.println(tag);

        }

        List<List<String>> records = t.getRecords1(

                XMLFILE1, 

                "DECLARACION/LINEA_DECLARACION", 

                ListBuilder.create(

                    "DECLARACION/LINEA_DECLARACION/PROV",

//                    "DECLARACION/LINEA_DECLARACION/MUN_INE",

//                    "DECLARACION/LINEA_DECLARACION/MUN_CAT",

//                    "DECLARACION/LINEA_DECLARACION/AGREGADO",

                    "DECLARACION/LINEA_DECLARACION/ZONA",

                    "DECLARACION/LINEA_DECLARACION/POLIGONO",

                    "DECLARACION/LINEA_DECLARACION/PARCELA",

                    "DECLARACION/LINEA_DECLARACION/RECINTO",

                    "DECLARACION/LINEA_DECLARACION/PARCELA_AGRICOLA",

                    "DECLARACION/LINEA_DECLARACION/CULTIVO",

//                    "DECLARACION/LINEA_DECLARACION/WKT",

                    "DECLARACION/LINEA_DECLARACION/DN_SURFACE",

                    "DECLARACION/LINEA_DECLARACION/SUPERFICIE_DECLARADA"

//                    "DECLARACION/LINEA_DECLARACION/FC_ALMENDROS",

//                    "DECLARACION/LINEA_DECLARACION/FC_ALGARROBOS",

//                    "DECLARACION/LINEA_DECLARACION/FC_AVELLANOS",

//                    "DECLARACION/LINEA_DECLARACION/FC_NOGALES",

//                    "DECLARACION/LINEA_DECLARACION/FC_PISTACHOS",

//                    "DECLARACION/LINEA_DECLARACION/FC_TOTAL"

                )

        );

        for (List<String> record : records) {

            System.out.println(StringUtils.join(record, ","));

        }

    }

    private Reader openFileReader(File xmlfile) throws Exception  {

        FileInputStream fis = new FileInputStream(xmlfile);

//        EncodingDetector encodingDetector = TikaConfig.getDefaultConfig().getEncodingDetector();

//        Charset encoding = encodingDetector.detect(fis, null);

        Charset encoding = StandardCharsets.UTF_8;

        InputStreamReader reader = new InputStreamReader(fis, encoding);

        return reader;

    }

    private Set<String> extractTags(String xmlfile) throws Exception {

        SAXParserFactory spf = SAXParserFactory.newInstance();

        spf.setNamespaceAware(true);

        SAXParser saxParser = spf.newSAXParser();

//        RandomAccessFileReader reader = new RandomAccessFileReader(new File(xmlfile), StandardCharsets.UTF_8);

        Reader reader = openFileReader(new File(xmlfile));

        InputSource is = new InputSource(reader);

        List<String> path = new ArrayList<>();

        Set<String> tags = new LinkedHashSet<>();

        System.out.println("Parse (extract-tags): -------------------------");

        saxParser.parse(is, new DefaultHandler() {

            private Locator locator;

            @Override

            public void setDocumentLocator(Locator locator) {

                this.locator = locator;

            }

            @Override

            public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {

                    path.add(localName);

                    int line = this.locator.getLineNumber();

                    int column = this.locator.getColumnNumber()-2-localName.length();

                    String path_s = StringUtils.join(path, "/");

                    tags.add(path_s);

                    for (int i = 0; i < attributes.getLength(); i++) {

                        String name = attributes.getLocalName(i);

                        tags.add(path_s+"/#"+name);

                    }

                    if( "DECLARACION/LINEA_DECLARACION".equals(StringUtils.join(path, "/")) ) {

                        System.out.println(path_s+": "+line+":"+column);

                    }

                    if( "DECLARACION".equals(StringUtils.join(path, "/")) ) {

                        System.out.println(path_s+": "+line+":"+column);

                    }

            }

            @Override

            public void endElement(String uri, String localName, String qName) throws SAXException {

                    path.remove(path.size()-1);

            }

        });

        return tags;

    }

    private List<List<String>> getRecords1(String xmlfile, String recordPath, List<String>fieldPaths) throws Exception {

        class ParseRecordsHandler extends DefaultHandler {

            Locator locator;

            List<String> path = new ArrayList<>();

            List<List<String>> records = new ArrayList<>();

            Map<String,String> record = new HashMap<>();

            StringBuilder value = new StringBuilder();

            @Override

            public void setDocumentLocator(Locator locator) {

                this.locator = locator;

            }

            @Override

            public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {

                    path.add(localName);

                    int line = this.locator.getLineNumber();

                    int column = this.locator.getColumnNumber()-2-localName.length();

                    String path_s = StringUtils.join(path, "/");

                    if( StringUtils.equalsIgnoreCase(path_s, recordPath) ) {

                        return;

                    }

                    this.value.setLength(0);

//                    this.value.trimToSize();

            }

            @Override

            public void characters(char[] ch, int start, int length) throws SAXException {

                value.append(new String(ch, start, length));

            }

            @Override

            public void endElement(String uri, String localName, String qName) throws SAXException {

                    int line = this.locator.getLineNumber();

                    int column = this.locator.getColumnNumber()-2-localName.length();

                    String path_s = StringUtils.join(path, "/");

                    if( StringUtils.equalsIgnoreCase(path_s, recordPath) ) {

                        List<String> values = new ArrayList<>();

                        for (String fieldPath : fieldPaths) {

                            values.add(record.get(fieldPath));

                        }

                        records.add(values);

                        record.clear();

                    } else {

                        for (String fieldPath : fieldPaths) {

                            if( StringUtils.equalsIgnoreCase(path_s, fieldPath) ) {

                                record.put(fieldPath, this.value.toString());

                                // No break to handle repeated columns

                            }

                        }

                    }

                    path.remove(path.size()-1);

            }

        }

        SAXParserFactory spf = SAXParserFactory.newInstance();

        spf.setNamespaceAware(true);

        SAXParser saxParser = spf.newSAXParser();

//        RandomAccessFileReader reader = new RandomAccessFileReader(new File(xmlfile), StandardCharsets.UTF_8);

        Reader reader = openFileReader(new File(xmlfile));

        InputSource is = new InputSource(reader);

        ParseRecordsHandler handler = new ParseRecordsHandler();

        System.out.println("Parse (getRecords): -------------------------");

        saxParser.parse(is, handler);

        return handler.records;

    }

    private long getRecordCount(String xmlfile, String recordPath) throws Exception {

        SAXParserFactory spf = SAXParserFactory.newInstance();

        spf.setNamespaceAware(true);

        SAXParser saxParser = spf.newSAXParser();

        Reader reader = openFileReader(new File(xmlfile));

        InputSource is = new InputSource(reader);

        List<String> path = new ArrayList<>();

        MutableLong numRecords = new MutableLong(0);

        System.out.println("Parse (countRecords)");

        saxParser.parse(is, new DefaultHandler() {

            @Override

            public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {

                    path.add(localName);

                    String path_s = StringUtils.join(path, "/");

                    if( StringUtils.equalsIgnoreCase(path_s, recordPath) ) {

                        numRecords.increment();

                    }

            }

            @Override

            public void endElement(String uri, String localName, String qName) throws SAXException {

                    path.remove(path.size()-1);

            }

        });

        return numRecords.longValue();

    }

//    private void createIndex(String xmlfile, String recordPath) throws Exception {

//        

//        long countRecords = getRecordCount(xmlfile, recordPath);

//        if (countRecords < 1) {

//            return;

//        }

//        RandomAccessFileIndex record_idx = new RandomAccessFileIndex();

//        record_idx.create(fileIndex, countRecords);

//

//        SAXParserFactory spf = SAXParserFactory.newInstance();

//        spf.setNamespaceAware(true);

//        SAXParser saxParser = spf.newSAXParser();

//        Reader reader = openFileReader(new File(xmlfile));

//        InputSource is = new InputSource(reader);

//        List<String> path = new ArrayList<>();

//

//        System.out.println("Parse (createIndex)");

//        saxParser.parse(is, new DefaultHandler() {

//            Locator locator;

//            

//            @Override

//            public void setDocumentLocator(Locator locator) {

//                this.locator = locator;

//            }

//            @Override

//            public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {

//                    path.add(localName);

//                    int line = this.locator.getLineNumber();

//                    int column = this.locator.getColumnNumber()-2-localName.length();

//                    String path_s = StringUtils.join(path, "/");

//

//                    if( StringUtils.equalsIgnoreCase(path_s, recordPath) ) {

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

//                    }

//            }

//

//            @Override

//            public void endElement(String uri, String localName, String qName) throws SAXException {

//                    path.remove(path.size()-1);

//            }

//        });

//

//        return numRecords.longValue();

//    }

    private void test() {

    }

}

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

import java.io.Closeable;

import java.io.File;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.ByteBuffer;

import java.sql.Timestamp;

import java.util.List;

import org.gvsig.fmap.dal.store.csv.RecordsFile.Record;

import org.gvsig.tools.util.GetItem;

import org.gvsig.tools.util.GetItem64;

import org.gvsig.tools.util.Size;

import org.gvsig.tools.util.Size64;

/**

 *

 * @author gvSIG Team

 */

public interface RecordsFile extends List<Record>, Size, Size64, GetItem<Record>, GetItem64<Record>, Closeable {

    public static final byte TYPE_BYTE = 0;

    public static final byte TYPE_SHORT = 1;

    public static final byte TYPE_INTEGER = 2;

    public static final byte TYPE_LONG = 3;

    public static final byte TYPE_DOUBLE = 4;

    public static final byte TYPE_TIMESTAMP = 5;

    public static final byte TYPE_STRING = 6;

    public static final byte TYPE_BYTES = 7;

    public interface Record {

        public RecordType getType();

        public byte[] getBytes();

        public void setBytes(byte[] bytes);

        public ByteBuffer getBuffer();

        public int getByte(int n);

        public int getShort(int n);

        public int getInt(int n);

        public long getLong(int n);

        public double getDouble(int n);

        public Timestamp getTimestamp(int n);

        public String getString(int n);        

        public byte[] getBytes(int n);        

        public void setByte(int n, byte v);

        public void setShort(int n, short v);

        public void setInt(int n, int v);

        public void setLong(int n, long v);

        public void setDouble(int n, double v);

        public void setTimestamp(int n, Timestamp v);

        public void setString(int n, String v);        

        public void setBytes(int n, byte[] v);        

    }

    public interface RecordType {

        public int getSize();

        public int getFieldCount();

        public int getFieldType(int n);

        public int getFieldSize(int n);

        public int getFieldOffset(int n);

        public Record createRecord();

        public byte[] toBytes();

        public static RecordType from(byte[] bytes) {

            return RecordsFileImpl.RecordTypeImpl.from(bytes);

        }

        public static RecordType from(ByteBuffer bytes) {

            return RecordsFileImpl.RecordTypeImpl.from(bytes);

        }

    }

    public interface RecordTypeBuilder {

        public RecordTypeBuilder addbyte();

        public RecordTypeBuilder addShort();

        public RecordTypeBuilder addInteger();

        public RecordTypeBuilder addLong();

        public RecordTypeBuilder addDouble();

        public RecordTypeBuilder addTimestamp();

        public RecordTypeBuilder addString(int size);

        public RecordTypeBuilder addBytes(int size);

        public RecordType build();

        public static RecordTypeBuilder recordTypeBuilder() {

            return RecordsFileImpl.RecordTypeBuilderImpl.recordTypeBuilder();

        }

    }

    public RecordType getRecordType();

    public void open(File f) throws IOException;

    public void open(RandomAccessFile raf) throws IOException;

    public void create(File f, RecordType recordType, long sz) throws IOException;

    public void create(RandomAccessFile raf, RecordType recordType, long sz) throws IOException ;

    public boolean isOpen();

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

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

import java.io.BufferedReader;

import java.io.Closeable;

import java.io.File;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.nio.CharBuffer;

import java.nio.charset.Charset;

import java.util.AbstractList;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.store.csv.RecordsFile.Record;

import org.gvsig.fmap.dal.store.csv.RecordsFile.RecordType;

import static org.gvsig.fmap.dal.store.csv.RecordsFile.RecordTypeBuilder.recordTypeBuilder;

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

import org.gvsig.tools.util.GetItemWithSize64;

import org.xml.sax.Attributes;

import org.xml.sax.InputSource;

import org.xml.sax.Locator;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class XMLFileAsList

        extends AbstractList<List<String>>

        implements Closeable, GetItemWithSize64<List<String>> {

    private static final int IDXFIELD_LINE = 0;

    private static final int IDXFIELD_COLUMN = 1;

    private static final int IDXFIELD_LINEPOS = 2;

    private static final int IDXFIELD_RECORDPOS = 3;

    private final RandomAccessFileReader reader;

    private final String recordPath;

    private RecordsFile index;

    private List<String> fieldPaths;

    public XMLFileAsList(File text, Charset charset, String recordPath, List<String> fieldPaths) throws IOException {

        this.reader = new RandomAccessFileReader(text, charset);

        this.index = null;

        this.recordPath = recordPath;

    }

    public XMLFileAsList(File text, File index, Charset charset, String recordPath, List<String> fieldPaths) throws IOException {

        this.reader = new RandomAccessFileReader(text, charset);

        if (index.exists()) {

            // TODO: Force to create index if text newer than index

            this.index = new RecordsFileImpl(index);

        } else {

            this.createIndex(index);

        }

        this.recordPath = recordPath;

    }

    public XMLFileAsList(RandomAccessFileReader reader, RecordsFile index, String recordPath, List<String> fieldPaths) throws IOException {

        this.reader = reader;

        this.index = index;

        this.recordPath = recordPath;

    }

    @Override

    public void close() {

        IOUtils.closeQuietly(this.reader);

        IOUtils.closeQuietly(this.index);

    }

    private List<String> getRecord(long position, List<String> fieldPaths) {

        class StopParserSAXException extends SAXException {

        }

        class ParseRecordsHandler extends DefaultHandler {

            Locator locator;

            List<String> path = new ArrayList<>();

            Map<String, String> record = new HashMap<>();

            StringBuilder value = new StringBuilder();

            List<String> values = new ArrayList<>();

            @Override

            public void setDocumentLocator(Locator locator) {

                this.locator = locator;

            }

            @Override

            public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {

                path.add(localName);

                String path_s = StringUtils.join(path, "/");

                if (StringUtils.equalsIgnoreCase(path_s, recordPath)) {

                    return;

                }

                this.value.setLength(0);

//                    this.value.trimToSize();

            }

            @Override

            public void characters(char[] ch, int start, int length) throws SAXException {

                value.append(new String(ch, start, length));

            }

            @Override

            public void endElement(String uri, String localName, String qName) throws SAXException {

                String path_s = StringUtils.join(path, "/");

                if (StringUtils.equalsIgnoreCase(path_s, recordPath)) {

                    for (String fieldPath : fieldPaths) {

                        values.add(record.get(fieldPath));

                    }

                    throw new StopParserSAXException();

                } else {

                    for (String fieldPath : fieldPaths) {

                        if (StringUtils.equalsIgnoreCase(path_s, fieldPath)) {

                            record.put(fieldPath, this.value.toString());

                            // No break to handle repeated columns

                        }

                    }

                }

                path.remove(path.size() - 1);

            }

        }

        ParseRecordsHandler handler = null;

        try {

            Record record = this.index.get64(position);

            long recordPosition = record.getLong(IDXFIELD_RECORDPOS);

            this.reader.seek(recordPosition);

            BufferedReader breader = new BufferedReader(this.reader, 1024 * 8);

            InputSource is = new InputSource(breader);

            SAXParserFactory spf = SAXParserFactory.newInstance();

            spf.setNamespaceAware(true);

            SAXParser saxParser = spf.newSAXParser();

            handler = new ParseRecordsHandler();

            saxParser.parse(is, handler);

        } catch (StopParserSAXException ex) {

            if (handler != null) {

                return handler.values;

            }

        } catch (Exception ex) {

            throw new RuntimeException("Can't parse record " + position, ex);

        }

        return null; // ?????

    }

    @Override

    public List<String> get(int index) {

        return this.getRecord(index, fieldPaths);

    }

    @Override

    public List<String> get64(long position) {

        return this.getRecord(position, fieldPaths);

    }

    @Override

    public int size() {

        return this.index.size();

    }

    @Override

    public long size64() {

        return this.index.size64();

    }

    final public void createIndex(File indexFile) throws IOException {

        try {

            // 1. Creamos el indice vacio

            RecordType recordType = recordTypeBuilder()

                    .addLong() // IDXFIELD_LINE

                    .addLong() // IDXFIELD_COLUMN

                    .addLong() // IDXFIELD_LINEPOS

                    .addLong() // IDXFIELD_RECORDPOS

                    .build();

            Record record = recordType.createRecord();

            final RecordsFile theIndex = new RecordsFileImpl();

            theIndex.create(indexFile, recordType, 0);

            // 2. Rellenamos los campos numero de linea y columna de cada registro 

            //    en el indice.

            // Para ello nos recorremos el XML y vamos escribiendo en el indice.

            this.reader.rewind();

            InputSource is = new InputSource(reader);

            SAXParserFactory spf = SAXParserFactory.newInstance();

            spf.setNamespaceAware(true);

            SAXParser saxParser = spf.newSAXParser();

            List<String> path = new ArrayList<>();

            // TODO: Aqui habria que quedarse con la primera aparicion de

            // los campos solicitados que no pertenezcan al registro principal.

            // Probablemente habria que guardar esos valores en disco junto al

            // fichero de indice.

            saxParser.parse(is, new DefaultHandler() {

                Locator locator;

                @Override

                public void setDocumentLocator(Locator locator) {

                    this.locator = locator;

                }

                @Override

                public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {

                    path.add(localName);

                    String path_s = StringUtils.join(path, "/");

                    if (StringUtils.equalsIgnoreCase(path_s, recordPath)) {

                        record.setLong(IDXFIELD_LINE, locator.getLineNumber() - 1);

                        record.setLong(IDXFIELD_COLUMN, locator.getColumnNumber() - 1);

                        record.setLong(IDXFIELD_LINEPOS, 0);

                        record.setLong(IDXFIELD_RECORDPOS, 0);

                        theIndex.add(record);

                    }

                }

                @Override

                public void endElement(String uri, String localName, String qName) throws SAXException {

                    path.remove(path.size() - 1);

                }

            });

            // 3. Nos recorremos el indice y calculamos la posicion de la linea

            //    para cada registro.

            this.reader.rewind();

            PositionCalculator positionCalculator = new PositionCalculator(reader);

            for (int i = 0; i < theIndex.size(); i++) {

                Record r = theIndex.get(i);

                positionCalculator.next(r.getLong(IDXFIELD_LINE), r.getLong(IDXFIELD_COLUMN));

                r.setLong(IDXFIELD_LINEPOS, positionCalculator.getLinePosition());

                r.setLong(IDXFIELD_RECORDPOS, positionCalculator.getColumnPosition());

                theIndex.set(i, record);

            }

            this.index = new RecordsFileImpl(indexFile);

        } catch (Exception ex) {

            throw new IOException("Can't create index " + Objects.toString(indexFile), ex);

        }

    }

    private static class CharacterSize {

        private final Charset charset;

        private final CharBuffer charBuffer;

        public CharacterSize(Charset charset) {

            this.charset = charset;

            this.charBuffer = CharBuffer.allocate(1);

        }

        public int size(char ch) {

            this.charBuffer.put(0, ch);

            this.charBuffer.position(0);

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

            return buffer.limit();

        }

        public int size(char[] cbuf, int off, int len) {

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

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

            return byteBuffer.limit();

        }

        public int size(char[] cbuf) {

            CharBuffer cb = CharBuffer.wrap(cbuf, 0, cbuf.length);

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

            return byteBuffer.limit();

        }

        public int size(String s) {

            CharBuffer cb = CharBuffer.wrap(s);

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

            return byteBuffer.limit();

        }

    }

    private static class PositionCalculator {

        private final RandomAccessFileReader reader;

        private final BufferedReader breader;

        private long currentPosition;

        private long currentColumn;

        private long currentLine;

        private long currentColumnPosition;

        private long currentLinePosition;

        private final char[] ch;

        private final CharacterSize characterSize;

        public PositionCalculator(RandomAccessFileReader reader) {

            this.reader = reader;

            this.breader = new BufferedReader(this.reader, 1024 * 8);

            this.currentPosition = this.reader.getCurrentPosition();

            this.currentLine = 0;

            this.currentColumn = 0;

            this.ch = new char[1];

            this.characterSize = new CharacterSize(this.reader.getCharset());

        }

        public boolean next(long line, long column) throws IOException {

            while (this.currentLine < line) {

                if (breader.read(this.ch, 0, 1) < 1) {

                    return false;

                }

                char c = ch[0];

                this.currentPosition += characterSize.size(c);

                if (c == '\n') {

                    this.currentLine++;

                    this.currentColumn = 0;

                }

            }

            this.currentLinePosition = this.currentPosition;

            while (this.currentColumn < column) {

                if (breader.read(this.ch, 0, 1) < 1) {

                    return false;

                }

                char c = ch[0];

                this.currentPosition += characterSize.size(c);

                if (c == '\n') {

                    // Uff, esto seria un error, ya que la linea corriente no

                    // tiene tantas columnas.

                    throw new IOException("Illegal column number " + column + " for line " + line);

                }

                this.currentColumn++;

            }

            this.currentColumnPosition = this.currentPosition;

            return true;

        }

        public long getLinePosition() {

            return this.currentLinePosition;

        }

        public long getColumnPosition() {

            return this.currentColumnPosition;

        }

    }

}

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

import java.io.File;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.ByteBuffer;

import java.nio.MappedByteBuffer;

import java.nio.channels.FileChannel;

import java.sql.Timestamp;

import java.util.AbstractList;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.io.IOUtils;

import org.gvsig.fmap.dal.store.csv.RecordsFile.Record;

import static org.gvsig.fmap.dal.store.csv.RecordsFile.TYPE_BYTE;

import static org.gvsig.fmap.dal.store.csv.RecordsFile.TYPE_STRING;

import static org.gvsig.fmap.dal.store.csv.RecordsFile.TYPE_TIMESTAMP;

/**

 *

 * @author jjdelcerro

 */

public class RecordsFileImpl 

        extends AbstractList<Record>

        implements RecordsFile 

    {

    public static class RecordImpl implements Record {

        private final RecordType type;

        private final ByteBuffer buffer;

        public RecordImpl(RecordType type) {

            this.type = type;

            this.buffer = ByteBuffer.allocateDirect(this.type.getSize());

        }

        @Override

        public RecordType getType() {

            return this.type;

        }

        @Override

        public byte[] getBytes() {

            return this.buffer.array();

        }

        @Override

        public ByteBuffer getBuffer() {

            return this.buffer;

        }

        @Override

        public void setBytes(byte[] bytes) {

            this.buffer.position(0);

            this.buffer.put(bytes);

        }

        @Override

        public int getInt(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            return this.buffer.getInt();

        }

        @Override

        public long getLong(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            return this.buffer.getLong();

        }

        @Override

        public double getDouble(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            return this.buffer.getDouble();

        }

        @Override

        public Timestamp getTimestamp(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            long l = this.buffer.getLong();

            return new Timestamp(l);

        }

        @Override

        public String getString(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            short sz = this.buffer.getShort();

            char[] chars = new char[sz];

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

                chars[i] = this.buffer.getChar(i);

            }

            return new String(chars);

        }

        @Override

        public byte[] getBytes(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            int sz = this.buffer.getInt();

            byte[] bytes = new byte[sz];

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

                bytes[i] = this.buffer.get(i);

            }

            return bytes;

        }

        @Override

        public int getByte(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            return this.buffer.get();

        }

        @Override

        public int getShort(int n) {

            this.buffer.position(this.type.getFieldOffset(n));

            return this.buffer.getShort();

        }

        @Override

        public void setByte(int n, byte v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.put(v);

        }

        @Override

        public void setShort(int n, short v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putShort(v);

        }

        @Override

        public void setInt(int n, int v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putInt(v);

        }

        @Override

        public void setLong(int n, long v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putLong(v);

        }

        @Override

        public void setDouble(int n, double v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putDouble(v);

        }

        @Override

        public void setTimestamp(int n, Timestamp v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putLong(v.getTime());

        }

        @Override

        public void setString(int n, String v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putShort((short) v.length());

            for (int i = 0; i < v.length(); i++) {

                this.buffer.putChar(v.charAt(i));

            }

        }

        @Override

        public void setBytes(int n, byte[] v) {

            this.buffer.position(this.type.getFieldOffset(n));

            this.buffer.putInt(v.length);

            for (int i = 0; i < v.length; i++) {

                this.buffer.put(v[i]);

            }

        }

    }

    public static class RecordTypeImpl implements RecordType {

        private static class FieldType {

            public byte type;

            public int size;

            public int offset;

        }

        private final List<FieldType> fields;

        private int size;

        public RecordTypeImpl() {

            this.fields = new ArrayList<>();

            this.size = -1;

        }

        public void add(int type, int size) {

            FieldType field = new FieldType();

            field.size = size;

            field.type = (byte) type;

            this.size = -1;

            field.offset = this.getSize();

            this.fields.add(field);

        }

        @Override

        public int getSize() {

            if( this.size<0 ) {

                int sz = 0;

                for (FieldType field : fields) {

                    switch(field.type) {

                        case TYPE_BYTE:

                            sz += 1;

                            break;

                        case TYPE_SHORT:

                            sz += 2;

                            break;

                        case TYPE_INTEGER:

                            sz += 4;

                            break;

                        case TYPE_TIMESTAMP:

                        case TYPE_LONG:

                            sz += 8;

                            break;

                        case TYPE_DOUBLE:

                            sz += 8;

                            break;

                        case TYPE_STRING:

                            sz += 2 + (field.size*2);

                            break;

                        case TYPE_BYTES:

                            sz += 4 + field.size;

                            break;

                    }

                }

                this.size = sz;

            }

            return this.size;

        }

        @Override

        public int getFieldCount() {

            return this.fields.size();

        }

        @Override

        public int getFieldType(int n) {

            return this.fields.get(n).type;

        }

        @Override

        public int getFieldSize(int n) {

            return this.fields.get(n).size;

        }

        @Override

        public int getFieldOffset(int n) {

            return this.fields.get(n).offset;

        }

        @Override

        public Record createRecord() {

            return new RecordImpl(this);

        }

        @Override

        public byte[] toBytes() {

            ByteBuffer buffer = ByteBuffer.allocateDirect(this.fields.size()*(1+4));

            for (FieldType field : fields) {

                buffer.put(field.type);

                buffer.putInt(field.size);

            }

            return buffer.array();

        }

        public static RecordType from(ByteBuffer bytes) {

            RecordTypeImpl recordType = new RecordTypeImpl();

            bytes.position(0);

            int len = bytes.limit()/(1+4);

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

                int type = bytes.get();

                int size = bytes.getInt();

                recordType.add(type, size);

            }

            return recordType;

        }

        public static RecordType from(byte[] bytes) {

            ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.length);

            buffer.put(bytes);

            return from(buffer);

        }

    }

    public static class RecordTypeBuilderImpl implements RecordTypeBuilder {

        private final RecordTypeImpl recordType;

        public RecordTypeBuilderImpl() {

            this.recordType = new RecordTypeImpl();

        }

        @Override

        public RecordTypeBuilder addbyte() {

            this.recordType.add(TYPE_BYTE, 0);

            return this;

        }

        @Override

        public RecordTypeBuilder addShort() {

            this.recordType.add(TYPE_SHORT, 0);

            return this;

        }

        @Override

        public RecordTypeBuilder addInteger() {

            this.recordType.add(TYPE_INTEGER, 0);

            return this;

        }

        @Override

        public RecordTypeBuilder addLong() {

            this.recordType.add(TYPE_LONG, 0);

            return this;

        }

        @Override

        public RecordTypeBuilder addDouble() {

            this.recordType.add(TYPE_DOUBLE, 0);

            return this;

        }

        @Override

        public RecordTypeBuilder addTimestamp() {

            this.recordType.add(TYPE_TIMESTAMP, 0);

            return this;

        }

        @Override

        public RecordTypeBuilder addString(int size) {

            this.recordType.add(TYPE_STRING, size);

            return this;

        }

        @Override

        public RecordTypeBuilder addBytes(int size) {

            this.recordType.add(TYPE_BYTES, size);

            return this;

        }

        @Override

        public RecordType build() {

            return this.recordType;

        }

        public static RecordTypeBuilder recordTypeBuilder() {

            return new RecordTypeBuilderImpl();

        }

    }

    private static final int HEADER_SIZE = 1024;

    private RandomAccessFile raf;

    private MappedByteBuffer fileByteBuffer;

    private long sz;

    private int header_size;

    private int type_size;

    private RecordType recordType;

    public RecordsFileImpl() {

    }

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public RecordsFileImpl(File f) throws IOException {

        this.open(f);

    }

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public RecordsFileImpl(RandomAccessFile raf) throws IOException {

        this.open(raf);

    }

    @Override

    public RecordType getRecordType() {

        return this.recordType;

    }

    @Override

    public void open(File f) throws IOException {

        RandomAccessFile theRaf = new RandomAccessFile(f,"r");

        this.open(theRaf);

    }

    @Override

    public void open(RandomAccessFile raf) throws IOException {

        this.raf = raf;

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

                FileChannel.MapMode.READ_ONLY, 

                0, 

                this.raf.length()

        );

        this.header_size = this.fileByteBuffer.getInt();

        this.type_size = this.fileByteBuffer.getInt();

        this.recordType = RecordType.from(this.fileByteBuffer.get(new byte[type_size]));

        this.sz = (fileByteBuffer.limit()-this.header_size) / this.recordType.getSize();

        // TODO: meter en la cabecera el numero de registros para poder escribir datos al final

    }

    @Override

    public void create(File f, RecordType recordType, long sz) throws IOException {

        RandomAccessFile theRaf = new RandomAccessFile(f,"rw");

        this.create(theRaf,recordType, sz);

    }

    @Override

    public void create(RandomAccessFile raf, RecordType recordType, long sz) throws IOException {

        this.raf = raf;

        this.recordType = recordType;

        this.header_size = HEADER_SIZE;

        this.raf.setLength(this.header_size +(sz*this.recordType.getSize()));

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

                FileChannel.MapMode.READ_WRITE, 

                0, 

                this.raf.length()

        );

        this.sz = (fileByteBuffer.limit()-this.header_size) / this.recordType.getSize();

        byte[] recordTypeBytes = this.recordType.toBytes();

        this.fileByteBuffer.position(0);

        this.fileByteBuffer.putLong(this.header_size);

        this.fileByteBuffer.putLong(recordTypeBytes.length);

        this.fileByteBuffer.put(recordTypeBytes);

    }

    @Override

    public void close() throws IOException {

        this.fileByteBuffer.force();

        IOUtils.closeQuietly(this.raf);

        this.raf = null;

        this.fileByteBuffer = null;

        this.sz = -1;

    }

    @Override

    public boolean isOpen() {

        return this.fileByteBuffer!=null;

    }

    @Override

    public Record get(int position) {

        position = checkIndex(position);

        Record record = this.recordType.createRecord();

        this.fileByteBuffer.position(this.header_size+(position*this.recordType.getSize()));

        this.fileByteBuffer.get(record.getBytes());

        return record;

    }

    @Override

    public Record get64(long position) {

        position = checkIndex(position);

        Record record = this.recordType.createRecord();

        this.fileByteBuffer.position((int) (this.header_size+(position*this.recordType.getSize())));

        this.fileByteBuffer.get(record.getBytes());

        return record;

    }

    @Override

    public int size() {

        return (int) this.sz;

    }

    @Override

    public long size64() {

        return this.sz;

    }

    @Override

    public Record set(int position, Record record) {

        position = checkIndex(position);

        this.fileByteBuffer.position((int) (this.header_size+(position*this.recordType.getSize())));

        this.fileByteBuffer.put(record.getBytes());

        return record;

    }

    private int checkIndex(long index) {

        if (this.fileByteBuffer == null) {

            throw new IllegalStateException("Index not open");

        }

        if( index < 0 ) {

            index = ((int)this.sz) + index;

        }

        if( index<0 || index>=this.sz) {

            throw new IllegalArgumentException("Index out of range ("+index+")");

        }

        return (int) index;

    }

    @Override

    public void add(int index, Record record) {

        // TODO: implement add method

        throw new UnsupportedOperationException();

    }

}