Application: gvSIG desktop

package org.gvsig.sldsupport.impl.util;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileReader;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.sldsupport.exception.SLDReadException;

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

import org.gvsig.sldsupport.sld.SLDRoot;

import org.gvsig.sldsupport.sld.SLDTags;

import org.gvsig.sldsupport.sld.layer.SLDLayer;

import org.kxml2.io.KXmlParser;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.xmlpull.v1.XmlPullParser;

import org.xmlpull.v1.XmlPullParserException;

/**

 *

 * 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 FILE_EXTENSION = "sld";

        public static final String DEFAULT_ENCODING = "ISO-8859-1";

        public static final String VERSION_1_0_0 = "1.0.0";

        public static final String VERSION_1_1_0 = "1.1.0";

//        public static void writeSLDLayer(

//                        ISLDLayer sld_layer, File out_file, String version)

//        throws IOException, SLDWriteException {

//

//                DecimalFormatSymbols dformater_rules = new DecimalFormatSymbols ();

//                dformater_rules.setDecimalSeparator ('.');

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

//

//                HashMap<String, String> attributes = new HashMap<String, String>();

//                attributes.put("xsi:schemaLocation","http://www.opengis.net/sld StyledLayerDescriptor.xsd");

//                attributes.put("xmlns","http://www.opengis.net/sld");

//                attributes.put("xmlns:ogc","http://www.opengis.net/ogc");

//                attributes.put("xmlns:xlink","http://www.w3.org/1999/xlink");

//                attributes.put("xmlns:xsi","http://www.w3.org/2001/XMLSchema-instance");

//                attributes.put(SLDTags.VERSION_ATTR, version);

//

//                XmlBuilder xmlBuilder = new XmlBuilder();

//                xmlBuilder.setEncoding(DEFAULT_ENCODING);

//                xmlBuilder.writeHeader();

//                xmlBuilder.openTag(SLDTags.SLD_ROOT, attributes);

//                xmlBuilder.openTag(SLDTags.NAMEDLAYER);

//                xmlBuilder.writeTag(SLDTags.NAME, sld_layer.getName());

//                xmlBuilder.openTag(SLDTags.USERSTYLE);

//                xmlBuilder.openTag(SLDTags.FEATURETYPESTYLE);

//

//                xmlBuilder.writeTag(SLDTags.FEATURETYPENAME, "Feature");

//

//                ArrayList<AbstractSLDStyle> stys = sld_layer.getLayerStyles();

//                if (stys == null || stys.size() == 0) {

//                        throw new SLDWriteException(new Exception("No styles found."));

//                }

//

//                AbstractSLDStyle asty = stys.get(0);

//

//                if (!(asty instanceof SLDUserStyle)) {

//                        throw new SLDWriteException(new Exception("Style not supported: " + asty.getName()));

//                }

//

//                SLDUserStyle usty = (SLDUserStyle) asty;

//                ArrayList<SLDFeatureTypeStyle> ftstys = usty.getFeatureTypeStyle();

//

//                if (ftstys == null || ftstys.size() == 0) {

//                        throw new SLDWriteException(new Exception("No feature styles found."));

//                }

//

//                SLDFeatureTypeStyle ftsty = ftstys.get(0);

//                ArrayList<SLDRule> rules = ftsty.getRules();

//

//                if (rules == null || rules.size() == 0) {

//                        throw new SLDWriteException(new Exception("No rules found."));

//                }

//

//                SLDRule rule = null;

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

//                        rule = rules.get(i);

//                        xmlBuilder.writeRaw(rule.toXML());

//                }

//

//                // ================

//

//                xmlBuilder.closeTag();

//                xmlBuilder.closeTag();

//                xmlBuilder.closeTag();

//                xmlBuilder.closeTag();

//

//                FileOutputStream fos = new FileOutputStream(out_file);

//                OutputStreamWriter writer = new OutputStreamWriter(fos, DEFAULT_ENCODING);

////                FileWriter writer = new FileWriter(file.getAbsolutePath());

//                writer.write( xmlBuilder.getXML());

//                writer.close();

//                fos.close();

//        }

        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, "ISO-8859-1");

                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;

        }

        /**

         * 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 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;

        }

}