Library: org.gvsig.sldtools

/*******************************************************************************

 *

 *   gvSIG. Desktop Geographic Information System.

 *  

 *   Copyright (C) 2007-2013 gvSIG Association.

 *  

 *   This program is free software; you can redistribute it and/or

 *   modify it under the terms of the GNU General Public License

 *   as published by the Free Software Foundation; either version 3

 *   of the License, or (at your option) any later version.

 *  

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU General Public License for more details.

 *  

 *   You should have received a copy of the GNU General Public License

 *   along with this program; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 *   MA  02110-1301, USA.

 *  

 *   For any additional information, do not hesitate to contact us

 *   at info AT gvsig.com, or visit our website www.gvsig.com.

 *   

 *******************************************************************************/

package org.gvsig.sldsupport.impl.util;

import java.awt.geom.Point2D;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.text.DecimalFormat;

import java.text.DecimalFormatSymbols;

import java.util.ArrayList;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.xmlpull.v1.XmlPullParser;

import org.xmlpull.v1.XmlPullParserException;

import org.gvsig.sldsupport.exception.SLDReadException;

import org.gvsig.sldsupport.impl.parser.ExtendedKXmlParser;

import org.gvsig.sldsupport.sld.SLDTags;

/**

 * 

 * Basic symbology utility methods for SLD version 1.0.0

 * 

 * @author jldominguez

 * 

 */

public class SLDUtils {

    private static Logger logger = LoggerFactory.getLogger(SLDUtils.class);

    public static final String DEFAULT_ENCODING = "utf-8";

    public static final String VERSION_1_0_0 = "1.0.0";

    public static final String VERSION_1_1_0 = "1.1.0";

    public static final String DEFAULT_VERSION = VERSION_1_0_0;

    public static DecimalFormat df = null;

    static {

        DecimalFormatSymbols dformater_rules = new DecimalFormatSymbols();

        dformater_rules.setDecimalSeparator('.');

        df = new DecimalFormat("##########.0##########", dformater_rules);

    }

    public static String detectVersion(File infile)

        throws XmlPullParserException, IOException, SLDReadException {

        XmlPullParser parser = new ExtendedKXmlParser();

        FileInputStream fis = new FileInputStream(infile);

        // xmlSchemaParser = new XMLSchemaParser();

        parser.setInput(fis, "utf-8");

        int tag = parser.getEventType();

        if (tag == XmlPullParser.START_DOCUMENT) {

            parser.nextTag();

        } else {

            if (tag != XmlPullParser.START_TAG) {

                throw new IOException(

                    "Misplaced input stream (it's not before opening tag)");

            }

        }

        String value = parser.getAttributeValue(null, SLDTags.VERSION_ATTR);

        fis.close();

        if (value == null) {

            throw new SLDReadException("Version attribute not found");

        } else {

            return value;

        }

    }

    public static String getTextUntilTag(XmlPullParser parser)

        throws XmlPullParserException, IOException {

        String resp = "";

        /*

         * This allows entering the iteratioin even if current tag is not TEXT

         */

        int t = XmlPullParser.TEXT;

        while ((t != XmlPullParser.START_TAG) && (t != XmlPullParser.END_TAG)

            && (t != XmlPullParser.END_DOCUMENT)) {

            t = parser.getEventType();

            if (t == XmlPullParser.TEXT) {

                resp = resp + parser.getText();

            }

            t = parser.next();

        }

        return resp;

    }

    public static boolean isStr(String a, String b) {

        if ((a == null) && (b == null)) {

            return true;

        } else {

            if ((a == null) || (b == null)) {

                return false;

            } else {

                return a.compareToIgnoreCase(b) == 0;

            }

        }

    }

    /**

     * Returns -1 if not parseable

     */

    public static int parseInteger(String str) {

        int resp = -1;

        try {

            resp = Integer.parseInt(str);

        } catch (Exception ex) {

            logger.info("Unable to parse integer: " + str + ", returned -1");

        }

        return resp;

    }

    public static Point2D parsePair(String str) {

        Point2D resp = null;

        try {

            String[] xy = str.split(" ");

            double x = Double.parseDouble(xy[0]);

            double y = Double.parseDouble(xy[1]);

            resp = new Point2D.Double(x, y);

        } catch (Exception ex) {

            logger.info("Unable to parse doubles: " + str + ", returned 0,0");

            resp = new Point2D.Double(0, 0);

        }

        return resp;

    }

    /**

     * Returns -1 if not parseable

     */

    public static double parseDouble(String str) {

        double resp = -1;

        try {

            resp = Double.parseDouble(str);

        } catch (Exception ex) {

            logger.info("Unable to parse double: " + str + ", returned -1");

        }

        return resp;

    }

    public static String getAsString(List<Float> list, String sep) {

        if ((list == null) || (list.size() == 0)) {

            return "";

        }

        String resp = df.format(list.get(0).floatValue());

        for (int i = 1; i < list.size(); i++) {

            resp = resp + sep + df.format(list.get(i).floatValue());

        }

        return resp;

    }

    public static List<Float> getAsFloats(String value, String sep) {

        List<Float> resp = new ArrayList<Float>();

        if (value != null) {

            String[] pp = value.split(sep);

            float fi = 0;

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

                try {

                    fi = Float.parseFloat(pp[i]);

                    resp.add(new Float(fi));

                } catch (Exception ex) {

                    logger.info("Unable to parse float in flaot array: "

                        + pp[i]);

                }

            }

        }

        return resp;

    }

}