Application: gvSIG desktop

/*

 * 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.gml.virtualrows;

import java.io.BufferedReader;

import java.io.Closeable;

import java.io.File;

import java.io.IOException;

import java.io.Reader;

import java.nio.ByteBuffer;

import java.nio.CharBuffer;

import java.nio.charset.Charset;

import java.nio.charset.StandardCharsets;

import java.util.AbstractList;

import java.util.ArrayList;

import java.util.Arrays;

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.collections4.CollectionUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

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

import org.apache.commons.lang3.StringUtils;

import static org.gvsig.fmap.dal.store.simplereader.SimpleReaderUtils.isFileNewer;

import org.gvsig.fmap.dal.store.simplereader.virtualrows.LimitedReader;

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

import org.gvsig.fmap.dal.store.simplereader.virtualrows.RecordsFile;

import org.gvsig.fmap.dal.store.simplereader.virtualrows.RecordsFile.Record;

import org.gvsig.fmap.dal.store.simplereader.virtualrows.RecordsFile.RecordType;

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

import org.gvsig.fmap.dal.store.simplereader.virtualrows.RecordsFileImpl;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

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

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.UserCancelTaskException;

import org.gvsig.tools.util.GetItemWithSize64;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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 Logger LOGGER = LoggerFactory.getLogger(XMLFileAsList.class);

    public static final int COMBINE_NONE = 0;

    public static final int COMBINE_FIRST_NOT_NULL = 1;

    private static final int IDXFIELD_BEGINLINE = 0; //INTEGER

    private static final int IDXFIELD_BEGINCOLUMN = 1; //INTEGER

    private static final int IDXFIELD_BEGINRECORDPOS = 2; //LONG

    private static final int IDXFIELD_ENDLINE = 3; //INTEGER

    private static final int IDXFIELD_ENDCOLUMN = 4; //INTEGER

    private static final int IDXFIELD_BEGINGEOMLINE = 5; //INTEGER

    private static final int IDXFIELD_BEGINGEOMCOLUMN = 6; //INTEGER

    private static final int IDXFIELD_BEGINGEOMPOS = 7; //LONG

    private static final int IDXFIELD_ENDGEOMLINE = 8; //INTEGER

    private static final int IDXFIELD_ENDGEOMCOLUMN = 9; //INTEGER

    private static final int IDXFIELD_ENDGEOMPOS = 10; //LONG

    private final RandomAccessFileReader reader;

    private final String recordPath;

    private RecordsFile index;

    private List<String> fieldPaths;

    private final List<String> geomPaths;

    private int combineMode;

    private long lastModified;

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

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

        this.index = null;

        this.recordPath = recordPath;

        this.geomPaths = geomPath;

        this.fieldPaths = fieldPaths;

        this.lastModified = text.lastModified();

    }

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

        this.reader = reader;

        this.index = index;

        this.recordPath = recordPath;

        this.geomPaths = geomPath;

        this.fieldPaths = fieldPaths;

        this.lastModified = -1;

    }

    @Override

    public void close() {

        IOUtils.closeQuietly(this.reader);

        IOUtils.closeQuietly(this.index);

    }

    private synchronized 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<>();

            private int endLineNumber;

            private int endColumnNumber;

            @Override

            public void setDocumentLocator(Locator locator) {

                this.locator = locator;

            }

            @Override

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

                localName = removeNamespace(qName);

                path.add(localName);

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

//                System.out.println("start path_s "+path_s);

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

                    return;

                }

                this.value.setLength(0);

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

                    String attrPath = path_s+"/"+removeNamespace(attributes.getQName(i));

                    for (String fieldPath : fieldPaths) {

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

                            record.put(fieldPath, attributes.getValue(i));

                            // No break to handle repeated columns

                        }

                    }

                }

            }

            @Override

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

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

            }

            private String removeNamespace(String s){

                if(s.indexOf(':') < 0){

                    return s;

                }

                String[] ss = s.split(":");

                return ss[1];

            }

            @Override

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

                localName = removeNamespace(qName);

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

//                System.out.println("end   path_s "+path_s);

                for (String fieldPath : fieldPaths) {

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

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

                        // No break to handle repeated columns

                    }

                }

                if (this.locator.getLineNumber() >= this.endLineNumber

                        && this.locator.getColumnNumber() >= this.endColumnNumber) {

                    for (String fieldPath : fieldPaths) {

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

                    }

                    throw new StopParserSAXException();

                }

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

            }

        }

//        System.out.println("RECORD "+position);

        ParseRecordsHandler handler = null;

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

        int recordLine = record.getInt(IDXFIELD_BEGINLINE);

        int recordColumn = record.getInt(IDXFIELD_BEGINCOLUMN);

        long recordPosition = record.getLong(IDXFIELD_BEGINRECORDPOS);

        try {

            this.reader.seek(recordPosition);

            // TODO: guardarse el tama?o del registro en el indice y en funcion de eso usar un buffersize mas peque?o aqui si procede

            int bufferSize = 1024*8; 

            BufferedReader breader = new BufferedReader(this.reader, bufferSize);

            InputSource is = new InputSource(CloseShieldReader.wrap(breader));

            SAXParserFactory spf = SAXParserFactory.newInstance();

            spf.setNamespaceAware(false);

            SAXParser saxParser = spf.newSAXParser();

            handler = new ParseRecordsHandler();

            handler.endLineNumber=(int) (record.getInt(IDXFIELD_ENDLINE)-record.getInt(IDXFIELD_BEGINLINE)+1);

            handler.endColumnNumber=(int) record.getInt(IDXFIELD_ENDCOLUMN);

            saxParser.parse(is, handler);

        } catch (StopParserSAXException ex) {

            //Do nothing

        } catch (Exception ex) {

            throw new RuntimeException("Can't parse record " + position +" recordPosition "+recordPosition+ " line "+recordLine+ " column "+recordColumn, ex);

        }

        if (handler == null) {

            return null;

        }

        try {

            Geometry geom = null;

            if(CollectionUtils.isNotEmpty(this.geomPaths)) {

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

                    Reader limitedReader = null;

                    BufferedReader breader = null;

                    try {

                        geom = null;

                        long geomPosition = record.getLong(IDXFIELD_BEGINGEOMPOS+i*6);

                        long endGeomPosition = record.getLong(IDXFIELD_ENDGEOMPOS+i*6);

                        if(geomPosition == 0 || endGeomPosition == 0){

                            if(this.combineMode != COMBINE_FIRST_NOT_NULL){

                                handler.values.add(null);

                            }

                            continue;

                        }

                        this.reader.seek(geomPosition);

                        if(position == 0){

                            char[] cbuff = new char[(int)(endGeomPosition-geomPosition)];

                            this.reader.read(cbuff);

    //                        System.out.println("["+new String(cbuff)+"]");

                            this.reader.seek(geomPosition);

                        }

                        limitedReader = new LimitedReader(reader, (int)(endGeomPosition-geomPosition));

                        // TODO: calcular el buffersize como el min(8k,endGeomPosition-geomPosition+1)

                        int bufferSize = 1024*8; 

                        breader = new BufferedReader(limitedReader, bufferSize);

                        geom = GeometryLocator.getGeometryManager().createFrom(breader, null);

                    } catch (Throwable t) {

                        //Do nothing

                        LOGGER.debug("Can't load geometry", t);

                    }

                    if(this.combineMode == COMBINE_FIRST_NOT_NULL){

                        if(geom != null){

                            handler.values.add(geom.convertToHexWKB());

                            break;

                        }

                    } else {

                        handler.values.add(geom==null?null:geom.convertToHexWKB());

                    }

                }

                if(this.combineMode == COMBINE_FIRST_NOT_NULL && geom == null){

                    handler.values.add(null);

                }

            }

        } catch (Exception ex) {

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

        }

        return handler.values;

    }

    @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();

    }

    public int getCombineMode() {

        return combineMode;

    }

    public void setCombineMode(int combineMode) {

        this.combineMode = combineMode;

    }

    public boolean loadIndex(File fileIndex, SimpleTaskStatus status) throws IOException{

        if (!fileIndex.exists()) {

            return false;

        }

        if(this.lastModified > 0 && isFileNewer(fileIndex, this.lastModified)){

            this.index = new RecordsFileImpl(fileIndex);

            return true;

        }

        return false;

    }

    final public synchronized void createIndex(File indexFile, SimpleTaskStatus status) throws IOException {

        try {

            // 1. Creamos el indice vacio

            RecordsFile.RecordTypeBuilder builder = recordTypeBuilder()

                    .addInteger()

                    .addInteger()

                    .addLong()

                    .addInteger()

                    .addInteger();

            if (CollectionUtils.isNotEmpty(geomPaths)) {

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

                    builder.addInteger()

                            .addInteger()

                            .addLong()

                            .addInteger()

                            .addInteger()

                            .addLong();

                }

            }

            RecordType recordType = builder.build();

            Record record = recordType.createRecord();

            final RecordsFile theIndex = new RecordsFileImpl();

            theIndex.create(indexFile, recordType);

            // 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(CloseShieldReader.wrap(reader));

            SAXParserFactory spf = SAXParserFactory.newInstance();

            spf.setNamespaceAware(true);

            SAXParser saxParser = spf.newSAXParser();

            if (status != null) {

                I18nManager i18n = ToolsLocator.getI18nManager();

                status.push();

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

                status.setIndeterminate();

            }

            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;

                private int beginLineNumber;

                private int beginColumnNumber;

                private int lastTagLineNumber;

                private int lastTagColumnNumber;

                @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.setInt(IDXFIELD_BEGINLINE, locator.getLineNumber());

                        record.setInt(IDXFIELD_BEGINCOLUMN, locator.getColumnNumber());

                        record.setInt(IDXFIELD_ENDLINE, 0);

                        record.setInt(IDXFIELD_ENDCOLUMN, 0);

                        if (CollectionUtils.isNotEmpty(geomPaths)) {

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

                                record.setInt(IDXFIELD_BEGINGEOMLINE + 6 * i, 0);

                                record.setInt(IDXFIELD_BEGINGEOMCOLUMN + 6 * i, 0);

                                record.setLong(IDXFIELD_BEGINGEOMPOS + 6 * i, 0);

                                record.setInt(IDXFIELD_ENDGEOMLINE + 6 * i, 0);

                                record.setInt(IDXFIELD_ENDGEOMCOLUMN + 6 * i, 0);

                                record.setLong(IDXFIELD_ENDGEOMPOS + 6 * i, 0);

                            }

                        }

                        this.beginLineNumber = locator.getLineNumber();

                        this.beginColumnNumber = locator.getColumnNumber();

                    }

                    if (CollectionUtils.isNotEmpty(geomPaths)) {

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

                            String geomPath = geomPaths.get(i);

                            if (StringUtils.equalsIgnoreCase(path_s, recordPath + "/" + geomPath)) {

                                record.setInt(IDXFIELD_BEGINGEOMLINE + 6 * i, locator.getLineNumber());

                                record.setInt(IDXFIELD_BEGINGEOMCOLUMN + 6 * i, locator.getColumnNumber());

                                record.setLong(IDXFIELD_BEGINGEOMPOS + 6 * i, 0);

                                break;

                            }

                        }

                    }

                    if (status != null) {

                        if (status.isCancellationRequested()) {

                            throw new UserCancelTaskException();

                        }

                    }

                }

                @Override

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

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

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

                        int line = lastTagLineNumber;//-this.beginLineNumber;

                        int column = this.lastTagColumnNumber;

                        if (line == 0) {

                            column = column - this.beginColumnNumber;

                        }

                        record.setInt(IDXFIELD_ENDLINE, line);

                        record.setInt(IDXFIELD_ENDCOLUMN, column);

                        theIndex.add(record);

                    }

                    if (CollectionUtils.isNotEmpty(geomPaths)) {

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

                            String geomPath = geomPaths.get(i);

                            if (StringUtils.equalsIgnoreCase(path_s, recordPath + "/" + geomPath)) {

                                record.setInt(IDXFIELD_ENDGEOMLINE + 6 * i, this.lastTagLineNumber);

                                record.setInt(IDXFIELD_ENDGEOMCOLUMN + 6 * i, this.lastTagColumnNumber);

                                break;

                            }

                        }

                    }

                    this.lastTagLineNumber = locator.getLineNumber();

                    this.lastTagColumnNumber = locator.getColumnNumber();

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

                    if (status != null) {

                        if (status.isCancellationRequested()) {

                            throw new UserCancelTaskException();

                        }

                    }

                }

            });

            if (status != null) {

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

                status.setCurValue(0);

            }

            // 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 j = 0; j < theIndex.size(); j++) {

                Record r = theIndex.get(j);

//                if(i==0){

//                    System.out.println("RECO BEGIN: "+r.getLong(IDXFIELD_BEGINLINE) + " " + r.getLong(IDXFIELD_BEGINCOLUMN));

//                    if(CollectionUtils.isNotEmpty(geomPaths)) {

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

//                            System.out.println("GEOM"+i+"BEGIN: "+r.getLong(IDXFIELD_BEGINGEOMLINE+i*6) + " " + r.getLong(IDXFIELD_BEGINGEOMCOLUMN+i*6));

//                            System.out.println("GEOM"+i+"END  : "+r.getLong(IDXFIELD_ENDGEOMLINE+i*6) + " " +  r.getLong(IDXFIELD_ENDGEOMCOLUMN+i*6));

//                        }

//                    }

//                    System.out.println("RECO END  : "+r.getLong(IDXFIELD_ENDLINE) + " " +  r.getLong(IDXFIELD_ENDCOLUMN));

//                }

                positionCalculator.next(r.getInt(IDXFIELD_BEGINLINE), r.getInt(IDXFIELD_BEGINCOLUMN));

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

//                System.out.println("RPOS      : " + r.getLong(IDXFIELD_BEGINRECORDPOS));

                //Todo esto es porque los campos de geometrias pueden tener distinta ordenacion en cada uno de los registros del XML

                if(CollectionUtils.isNotEmpty(geomPaths)) {

                    class Element implements Comparable<Element> {

                        final int index;

                        final long beginGeomLine;

                        final long endGeomLine;

                        final long beginGeomColumn;

                        final long endGeomColumn;

                        long beginGeomPos;

                        long endGeomPos;

                        Element(int index, long beginGeomLine, long endGeomLine, long beginGeomColumn, long endGeomColumn){

                            this.index = index;

                            this.beginGeomLine = beginGeomLine;

                            this.endGeomLine = endGeomLine;

                            this.beginGeomColumn = beginGeomColumn;

                            this.endGeomColumn = endGeomColumn;

                        }

                        @Override

                        public int compareTo(Element o) {

                            return Long.compare(beginGeomLine, o.beginGeomLine);

                        }

                    }

                    Element[] elements = new Element[geomPaths.size()];

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

                        long beginGeomLine = r.getInt(IDXFIELD_BEGINGEOMLINE + i * 6);

                        long endGeomLine = r.getInt(IDXFIELD_ENDGEOMLINE + i * 6);

                        elements[i] = new Element(

                            i, 

                            beginGeomLine, 

                            endGeomLine,

                            r.getInt(IDXFIELD_BEGINGEOMCOLUMN + i * 6),

                            r.getInt(IDXFIELD_ENDGEOMCOLUMN + i * 6)

                        );

                    }

                    Arrays.sort(elements);

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

                        Element e = elements[i];

                        if (e.beginGeomLine == 0 || e.endGeomLine == 0) {

                            continue;

                        }

                        positionCalculator.next(e.beginGeomLine, e.beginGeomColumn);

                        e.beginGeomPos = positionCalculator.getColumnPosition();

                        positionCalculator.next(e.endGeomLine, e.endGeomColumn);

                        e.endGeomPos = positionCalculator.getColumnPosition();

                    }

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

                        Element e = elements[i];

                        r.setLong(IDXFIELD_BEGINGEOMPOS + e.index * 6, e.beginGeomPos);

                        r.setLong(IDXFIELD_ENDGEOMPOS + e.index * 6, e.endGeomPos);

                    }

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

//                        long beginGeomLine = r.getInt(IDXFIELD_BEGINGEOMLINE + i * 6);

//                        long endGeomLine = r.getInt(IDXFIELD_ENDGEOMLINE + i * 6);

//                        if (beginGeomLine == 0 || endGeomLine == 0) {

//                            continue;

//                        }

//                        positionCalculator.next(beginGeomLine, r.getInt(IDXFIELD_BEGINGEOMCOLUMN + i * 6));

//                        r.setLong(IDXFIELD_BEGINGEOMPOS + i * 6, positionCalculator.getColumnPosition());

//                        positionCalculator.next(endGeomLine, r.getInt(IDXFIELD_ENDGEOMCOLUMN + i * 6));

//                        r.setLong(IDXFIELD_ENDGEOMPOS + i * 6, positionCalculator.getColumnPosition());

////                        System.out.println("GPOS" + i + "     : " + r.getLong(IDXFIELD_BEGINGEOMPOS + i * 6) + " " + r.getLong(IDXFIELD_ENDGEOMPOS + i * 6));

//                    }

                }

                theIndex.set(j, r);

                if (status != null) {

                    if (status.isCancellationRequested()) {

                        status.cancel();

                        removeIndex(indexFile);

                        return;

                    }

                    status.incrementCurrentValue();

                }

            }

            this.index = new RecordsFileImpl(indexFile);

            if (status != null) {

                status.terminate();

            }

        } catch (UserCancelTaskException ex) {

            if (status != null) {

                if (status.isCancellationRequested()) {

                    status.cancel();

                }

            }

            removeIndex(indexFile);

            throw ex;

        } catch (Exception ex) {

            if (status != null) {

                status.abort();

            }

            removeIndex(indexFile);

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

        } finally {

            if (status != null) {

                status.pop();

            }

        }

    }

    private void removeIndex(File indexFile) {

        indexFile.delete();

    }

    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 = 1;

            this.currentColumn = 1;

            this.ch = new char[1];

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

        }

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

//            System.out.println();

//            System.out.println("----"+line+" "+column);

            if(this.currentLine>line){

                throw new IOException("Illegal column number " + column + " ("+this.currentColumn+") for line " + line+ " ("+this.currentLine+")");

            }

            if(this.currentLine==line && this.currentColumn > column){

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

            }

//            System.out.print(this.currentLine+":");

            while (this.currentLine < line) {

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

                    return false;

                }

                char c = ch[0];

//                System.out.print(String.valueOf(c));

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

                if (c == '\n') {

                    this.currentLine++;

                    this.currentColumn = 1;

//                    System.out.print(this.currentLine+":");

                }

            }

            this.currentLinePosition = this.currentPosition;

            while (true) {

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

                    return false;

                }

                char c = ch[0];

//                System.out.print(String.valueOf(c));

                this.currentColumn++;

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

                if(this.currentColumn >= column){

                    break;

                }

                if (c == '\n') {

                    throw new IOException("Illegal column number " + column + " ("+this.currentColumn+") for line " + line+ " ("+this.currentLine+")");

                }

            }

            this.currentColumnPosition = this.currentPosition;

//            System.out.println();

            return true;

        }

        public long getLinePosition() {

            return this.currentLinePosition;

        }

        public long getColumnPosition() {

            return this.currentColumnPosition;

        }

    }

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

        new DefaultLibrariesInitializer().fullInitialize();

//        final String XMLFILE1 = "/home/jjdelcerro/datos/geodata/vector/gml/navarra.gml";

//        final String XMLFILE2 = "/home/jjdelcerro/datos/geodata/vector/gml/Municipis/Municipis.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/1075305YJ2717N.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/Recinto.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/FG-GML-543863-AdmBdry-20190101-0001.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/Municipis.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/navarra.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/Falls.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/AerodromeArea.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/AerodromeType.gml"; //No tiene geometr?as

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/BuildingP.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/CablewayLink.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/ConditionOfFacility.gml"; //No tiene geometr?as

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/CrossingS.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/CrossingP.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/DamOrWeirL.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/EmbankmentL.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/EmbankmentS.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/FordP.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/FormOfWay.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/FunctionalRoadClass.gml"; //No tiene geometr?as

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/INSPIRE_GN.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/INSPIRE_AU.gml"; //Hay 3 geometr?as, LineString, Surface y MultiSurface

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/RunwayArea.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/RailwayStationArea.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/DamOrWeirS.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/NominalTrackGauge.gml"; //No tiene geometr?as

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/NumberOfTracks.gml"; //No tiene geometr?as

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/Road.gml"; //No tiene geometr?as

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/RoadServiceType.gml"; //No tiene geometr?as

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/RailwayArea.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/RailwayElectrification.gml"; //No tiene geometr?as

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/RailwayType.gml"; //No tiene geometr?as

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/RailwayLink.gml"; //Added Multicurve Strategy (ojo, en los registros, tras la geometr?a aparece otro atributo a null

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/RailwayYardArea.gml";

        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/RoadArea.gml"; //NO VA

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/RoadLink.gml"; //Hay 2 geometr?as, Curve y Multicurve

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/RoadServiceArea.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/RoadSurfaceCategory.gml"; //No tiene geometr?as

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/RoadWidth.gml"; //No tiene geometr?as

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/ShorelineConstructionL.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/StandingWater.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/SurfaceComposition.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/VerticalPosition.gml"; //No tiene geometr?as

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/Watercourse.gml"; //Hay 2 geometr?as, Curve y Multicurve

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/WatercourseLink.gml";

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/WatercourseLinkSequence.gml"; //No tiene geometr?as

//        final String XMLFILE1 = "/home/fdiaz/projects/GMLS/sk/Wetland.gml";

        String gmlfile = XMLFILE1;

        File idxFile = new File(FilenameUtils.removeExtension(gmlfile)+".gmlidx");

        if(idxFile.exists()){

            idxFile.delete();

        }

        File gfsFile = new File(FilenameUtils.removeExtension(gmlfile)+".gfs");

        if(gfsFile.exists()){

            gfsFile.delete();

        }

        GfsFile gfs = new GfsFile();

        gfs.fetch(new File(gmlfile));

        gfs.save(gfsFile);

//        return;

        XMLFileAsList gml = new XMLFileAsList(

                new File(gmlfile), 

//                StandardCharsets.ISO_8859_1, 

                StandardCharsets.UTF_8, 

                gfs.getBaseElementPath(),

                gfs.getGeometryElementPaths(),

                gfs.getPropertiesPaths()

        );

        gml.createIndex(new File(FilenameUtils.removeExtension(gmlfile)+".gmlidx"), SimpleTaskStatus.FAKE_STATUS);

        System.out.println("File: "+gmlfile);

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

            List<String> item = gml.get(i);

            System.out.println("RECORD "+i+":"+item);

        }

        System.out.println(StringUtils.join(gfs.getPropertiesPaths(), "\n"));

        System.out.println("Geometries:\n"+StringUtils.join(gfs.getGeometryElementPaths(), "\n"));

    }

}