Application: gvSIG desktop

package org.gvsig.xml2db.lib.impl;

import static com.vividsolutions.jts.geom.CoordinateSequence.M;

import java.io.BufferedInputStream;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.nio.charset.Charset;

import java.nio.charset.IllegalCharsetNameException;

import java.nio.charset.UnsupportedCharsetException;

import org.apache.commons.io.IOUtils;

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

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

import org.apache.commons.lang3.StringUtils;

import org.apache.tika.config.TikaConfig;

import org.apache.tika.detect.AutoDetectReader;

import org.apache.tika.detect.EncodingDetector;

import org.apache.tika.metadata.Metadata;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.xml.sax.InputSource;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class Xml2dbCommons {

    public static Charset detectCharset(InputStream is) { 

        try {            

            AutoDetectReader reader = new AutoDetectReader(is);

            return reader.getCharset();

        } catch(Throwable t) {

            return null;

        }

    }

    public static String detectCharsetName(InputStream is) {        

        Charset charset = detectCharset(is);

        if( charset==null ) {

            return null;

        }

        return charset.name();

    }

    public static InputSource openReader(File xmlfile, Charset charset) {

        try {

            FileInputStream fis = new FileInputStream(xmlfile);

            InputSource is = new InputSource();

            is.setPublicId(xmlfile.getAbsolutePath());

            is.setByteStream(fis);

            if( charset!=null ) {

                is.setEncoding(charset.name());

            }            

            return openReader(is);

        } catch(Throwable t) {

            throw new RuntimeException("Can't open xml input stream.",t);

        }

    }

    public static InputSource openReader(InputStream xml, Charset charset) {

            InputSource is = new InputSource();

            is.setByteStream(xml);

            if( charset!=null ) {

                is.setEncoding(charset.name());

            }            

            return openReader(is);

    }

    public static InputSource openReader(InputSource is) {

        try {            

            if(StringUtils.isBlank(is.getEncoding())){

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

//                BufferedInputStream bis = new BufferedInputStream(is.getByteStream());

//                Charset charset = encodingDetector.detect(bis, new Metadata());

//                is.setEncoding(charset.name());

//                is.setByteStream(bis);

                AutoDetectReader reader = new AutoDetectReader(is.getByteStream());

                is.setCharacterStream(reader);

                is.setEncoding(reader.getCharset().name());

            } else {

                BOMInputStream bomIs = new BOMInputStream(is.getByteStream());

                is.setByteStream(bomIs);

                InputStreamReader reader = new InputStreamReader(

                        is.getByteStream(),

                        is.getEncoding()

                );

                is.setCharacterStream(reader);

            }

            return is;

        } catch(Throwable t) {

            throw new RuntimeException("Can't open xml input stream.",t);

        }

    }

    public static long countLines(File xml, Charset charset, SimpleTaskStatus status) {

        try {

            FileInputStream fis = new FileInputStream(xml);

            return countLines(fis, charset, status);

        } catch(Throwable t) {

            throw new RuntimeException("Can't count lines.",t);

        }

    }

    public static long countLines(InputStream xml, Charset charset, SimpleTaskStatus status) {

        try {

            long count = 0;

//            Reader reader = null;

            BufferedReader br = null;

            status.setIndeterminate();

            status.setCurValue(0);

            try {

                InputSource is = new InputSource(xml);

                if( charset!=null ) {

                    is.setEncoding(charset.name());

                }

                is = openReader(is);

                br = new BufferedReader(is.getCharacterStream());

                int n = 1;

                I18nManager i18n = ToolsLocator.getI18nManager();

                while( br.readLine()!=null ) {

                    if(count%n == 0){

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

                        status.setCurValue(count);

                    }

//                    status.incrementCurrentValue();

                    count++;

                    if(count > 100){

                        n = 100;

                    } else if(count > 1000){

                        n = 1000;

                    } else if(count > 10000){

                        n = 10000;

                    } else if(count > 100000){

                        n = 100000;

                    }

                }

            } finally {

                IOUtils.closeQuietly(br);

            }

            return count;

        } catch(Throwable t) {

            throw new RuntimeException("Can't count lines.",t);

        }

    }    

}