Application: gvSIG desktop

/*

 * To change this license theHeader, 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.simplereaders;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.Reader;

import java.nio.charset.Charset;

import java.util.Collection;

import java.util.List;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.store.gml.GMLStoreParameters;

import org.gvsig.fmap.dal.store.gml.virtualrows.GfsFile;

import org.gvsig.fmap.dal.store.gml.virtualrows.XMLFileAsList;

import org.gvsig.fmap.dal.store.gml.virtualrows.XmlCommons;

import org.gvsig.fmap.dal.store.simplereader.SimpleReaderStoreParameters;

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

import org.gvsig.fmap.dal.store.simplereader.simplereaders.AbstractSimpleReader;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.namestranslator.NamesTranslator;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.GetItemWithSize64;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

public class GMLReader extends AbstractSimpleReader {

    private static final Logger LOGGER = LoggerFactory.getLogger(GMLReader.class);

    private XMLFileAsList gml;

    private int columns;

    private String[] header;

    private int currentElement = 0;

    private final GMLStoreParameters parameters;

    private GfsFile gfs;

    public GMLReader(Reader reader, GMLStoreParameters theParameters) throws IOException {

        File gmlFile = theParameters.getFile();

//        File gmlIdx = new File(FilenameUtils.removeExtension(gmlFile.getAbsolutePath())+".gmlidx");

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

        gfs = new GfsFile();

        if(gfsFile.exists() && isFileNewer(gfsFile, gmlFile)){

            gfs.load(gfsFile);

        } else {

            gfs.fetch(gmlFile);

            gfs.save(gfsFile);

        }

        this.gml = null;

        this.columns = -1;

        this.header = null;

        this.parameters = theParameters;

    }

    private XMLFileAsList getGml(){

        if(this.gml == null){

            this.gml = (XMLFileAsList) this.getVirtualRows(SimpleTaskStatus.FAKE_STATUS);

        }

        return this.gml;

    }

    private IProjection toProjection(String srs){

        IProjection proj;

//        http://www.opengis.net/def/crs/EPSG/0/25830

//        urn:ogc:def:crs,crs:EPSG:6.12:3068,crs:EPSG:6.12:5783

//        urn:ogc:def:crs:EPSG:6.12:3068

//        urn:ogc:def:crs:EPSG::4326

//        urn:ogc:def:crs:OGC:2:84 //Este formato no lo parseamos

        try {

            if(StringUtils.startsWithIgnoreCase(srs, "http://www.opengis.net/def/crs")){

                String[] ss = StringUtils.split(srs, "/");

                String crs = ss[ss.length-3]+":"+ss[ss.length-1];

                proj = CRSFactory.getCRS(crs);

            } else if(StringUtils.startsWithIgnoreCase(srs, "urn:ogc:def:crs,crs:")){

                String[] ss = StringUtils.split(srs, ",");

                String[] ss2 = StringUtils.split(ss[1],":");

                String crs = ss2[1]+":"+ss2[ss2.length-1];

                proj = CRSFactory.getCRS(crs);

            } else if(StringUtils.startsWithIgnoreCase(srs, "urn:ogc:def:crs:")){

                String[] ss = StringUtils.split(srs, ":");

                String crs = ss[4]+":"+ss[ss.length-1];

                proj = CRSFactory.getCRS(crs);

            } else {

                proj = CRSFactory.getCRS(srs);

            }

        } catch (Throwable th) {

            return null;

        }

        return proj;

    }

    @Override

    public String[] getHeader() throws IOException {

        if (this.header == null) {

            Collection<GfsFile.GeometryPropertyDefn> geoms = gfs.getGeometryElements();

            String[] theHeader = new String[gfs.size()+(geoms==null?0:geoms.size())];

            int i = 0;

            DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

            for (GfsFile.PropertyDefn item : gfs) {

                DataType dataType = dataTypesManager.get(item.getType());

                theHeader[i++] = item.getName()+"/"+dataType.getName();

            }

            if(geoms != null && !geoms.isEmpty()) {

                if(this.parameters.getGeometryCombineMode() == XMLFileAsList.COMBINE_FIRST_NOT_NULL){

                    String srs = null;

                    for (GfsFile.GeometryPropertyDefn geom : geoms) {

                        if(srs == null){

                            srs = geom.getSrs();

                        } else {

                            if(!StringUtils.equalsIgnoreCase(srs, geom.getSrs())){

                                srs = null;

                                break;

                            }

                        }

                    }

                    IProjection proj = null;

                    if(srs != null){

                        proj = toProjection(srs);

                    }

                    if(proj == null){

                        theHeader[i++] = getGeometryAttributeName()+"/Geometry";

                    } else {

                        theHeader[i++] = getGeometryAttributeName()+"/Geometry/set/srs="+proj.getAbrev().replace(":", "@");

                    }

                } else {

                    for (GfsFile.GeometryPropertyDefn geom : geoms) {

                        GeometryType geomType = geom.getGeometryType();

                        String geomType_s = "/set/geomtype="+GeometryUtils.getGeometryTypeName(geomType.getType())+":"+GeometryUtils.getGeometrySubtypeName(geomType.getSubType());

                        IProjection srs = toProjection(geom.getSrs());

                        if(srs == null){

                            theHeader[i++] = geom.getName()+"/Geometry"+geomType_s;

                        } else {

                            theHeader[i++] = geom.getName()+"/Geometry/set/srs="+srs.getAbrev().replace(":", "@")+geomType_s;

                        }

                    }

                }

            }

            this.header = theHeader;

        }

        return this.header;

    }

    private String getGeometryAttributeName() {

        NamesTranslator translator = NamesTranslator.createBaseTranslator();

        for (GfsFile.PropertyDefn item : gfs) {

            translator.addSource(item.getName());

        }

        String s = translator.getSuggestion("Geometry");

        return s;

    }

    @Override

    public int getColumnsCount() throws IOException {

        if (this.columns <= 0) {

            this.columns = this.getHeader().length;

        }

        return this.columns;

    }

    @Override

    public List<String> read() throws IOException {

        List<String> values = this.read(currentElement);

        if (values == null) {

            return null;

        }

        currentElement += 1;

        return values;

    }

    public List<String> read(int rowNumber) throws IOException {

        if (rowNumber < this.getGml().size64()) {

            List<String> values = this.getGml().get64(rowNumber);

            return values;

        }

        return null;

    }

    @Override

    public void close() throws IOException {

        IOUtils.closeQuietly(this.gml);

        this.gml = null;

        this.gfs = null;

    }

    @Override

    public List<String> skip(int lines) throws IOException {

        this.currentElement += lines;

        if (this.currentElement > this.getGml().size64()) {

            return null;

        }

        return read(this.currentElement);

    }

    @Override

    public int getLine() {

        if (this.getGml() == null) {

            return 0;

        }

        return this.currentElement;

    }

    @Override

    public List<String> nextRowValues() {

        try {

            return this.read();

        } catch (IOException ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    public GetItemWithSize64<List<String>> getVirtualRows(SimpleTaskStatus status) {

        try {

            File gmlFile = this.parameters.getFile();

            String charset = SimpleReaderStoreParameters.getCharset(this.parameters);

            if(StringUtils.isBlank(charset)){

                FileInputStream fis = null;

                try {

                    fis = new FileInputStream(gmlFile);

                    charset = XmlCommons.detectCharsetName(fis);

                } catch (Throwable t) {

                    charset = "UTF-8";

                } finally {

                    IOUtils.closeQuietly(fis);

                }

            }

            XMLFileAsList x = new XMLFileAsList(

                gmlFile,

                Charset.forName(charset),

                gfs.getBaseElementPath(),

                gfs.getGeometryElementPaths(),

                gfs.getPropertiesPaths()

            );

            File gmlIdx = new File(FilenameUtils.removeExtension(gmlFile.getAbsolutePath()) + ".gmlidx");

            if(!x.loadIndex(gmlIdx, status)){

                x.createIndex(gmlIdx, status);

            }

            x.setCombineMode(this.parameters.getGeometryCombineMode());

            return x;

        } catch (IOException ex) {

            throw new RuntimeException("Can't get virtual rows", ex);

        }

    }

}