Application: gvSIG desktop

package org.gvsig.xml2db.lib.impl;

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.task.SimpleTaskStatus;

import org.xml.sax.InputSource;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class Xml2dbCommons {

    public static Charset detectCharset(InputStream is) {   

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

        BufferedInputStream bis = null;

        try {

            bis = new BufferedInputStream(CloseShieldInputStream.wrap(is));

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

            return charset;

        } catch (Exception ex) {

            return null;

        } finally {

            IOUtils.closeQuietly(bis);

        }

    }

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

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

                    status.message("Calculating lines...");

                    status.incrementCurrentValue();

                    count++;

                }

            } finally {

                IOUtils.closeQuietly(br);

            }

            return count;

        } catch(Throwable t) {

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

        }

    }    

}