root/tools/routingservice/branches/wrs-2.0/src/util/format/TemplateFiller.java

/*  WRS 2.0
 *  Copyright (C) 2009 Anton Patrushev
 *
 * 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, see <http://www.gnu.org/licenses/>.
 */

package util.format;

import geometry.Point;
import handler.ResourceHandler;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Map.Entry;

import org.antlr.stringtemplate.StringTemplate;
import org.opengis.geometry.MismatchedDimensionException;
import org.opengis.referencing.FactoryException;
import org.opengis.referencing.NoSuchAuthorityCodeException;
import org.opengis.referencing.operation.TransformException;

import com.vividsolutions.jts.io.ParseException;

import util.IOHelper;
import util.Log;
import util.Parameter;
import util.ServiceRequest;

public abstract class TemplateFiller
{
        protected HashMap<String, Double> max = new HashMap<String, Double>();
        protected HashMap<String, Double> min = new HashMap<String, Double>();
        protected HashMap<String, Double> avg = new HashMap<String, Double>();
        protected HashMap<String, Double> sum = new HashMap<String, Double>();
        protected int count;

        protected String srid_in;
        protected String srid_out;
        
        protected enum Units
        {
                DD, METERS, MILES;
        }

        protected enum DataTypes
        {
                STRING, INTEGER, DOUBLE, GEOMETRY, BOOLEAN;
        }

        protected enum AggregateTypes
        {
                MAX, MIN, AVG, SUM, COUNT;
        }

        protected abstract String getGeometryString(ArrayList<Point> points);

        public String getX(Point point)
        {
                return IOHelper.FORMATTER.format(point.getX());
        }

        public String getY(Point point)
        {
                return IOHelper.FORMATTER.format(point.getY());
        }

        public String fillOutputTemplate(ServiceRequest serviceRequest,
                        ArrayList<HashMap<String, Parameter>> output,
                        ResourceHandler handler, Log log)
        {
                StringTemplate template = new StringTemplate(serviceRequest
                                .getTemplate().getBody());

                ArrayList<HashMap<String, String>> out = new ArrayList<HashMap<String, String>>();
                Iterator<HashMap<String, Parameter>> it = output.iterator();

                while (it.hasNext())
                {
                        ++count;
                        HashMap<String, Parameter> paraMap = it.next();
                        HashMap<String, String> stringMap = new HashMap<String, String>();
                        Iterator<Parameter> params = paraMap.values().iterator();
                        while (params.hasNext())
                        {
                                Parameter p = params.next();
                                String value = p.getValue();
                                String name = p.getName();

                                // Geometry string needs to be handled in a special way
                                // if
                                // (p.getType().toLowerCase().equals(ResourceHandler.GEOMETRY))
                                switch (DataTypes.valueOf(p.getType().toUpperCase()))
                                {
                                case GEOMETRY:

                                        srid_in = serviceRequest.getResource().getParameters().get(
                                                        "srid").getValue();
                                        srid_out = srid_in;

                                        ArrayList<Point> points = handler.parseGeometry(value);
                                        try
                                        {
                                                // Check if we need to re-project points
                                                if (serviceRequest.getParameters().containsKey(
                                                                "srid_out"))
                                                {
                                                        srid_out = serviceRequest.getParameters().get("srid_out")
                                                                        .getValue();
                                                }

                                                ListIterator<Point> pi = points.listIterator();
                                                while (pi.hasNext())
                                                {
                                                        Point point = pi.next();

                                                        // calculating max value for all geometry parameters
                                                        if (max.keySet().contains(name + "_x")
                                                                        && max.keySet().contains(name + "_y"))
                                                        {
                                                                if (max.get(name + "_x").doubleValue() < point
                                                                                .getX())
                                                                {
                                                                        max.put(name + "_x", new Double(point
                                                                                        .getX()));
                                                                }
                                                                if (max.get(name + "_y").doubleValue() < point
                                                                                .getY())
                                                                {
                                                                        max.put(name + "_y", new Double(point
                                                                                        .getY()));
                                                                }
                                                        }
                                                        else
                                                        {
                                                                max.put(name + "_x", new Double(point.getX()));
                                                                max.put(name + "_y", new Double(point.getY()));
                                                        }

                                                        // calculating min value for all geometry parameters
                                                        if (min.keySet().contains(name + "_x")
                                                                        && min.keySet().contains(name + "_y"))
                                                        {
                                                                if (min.get(name + "_x").doubleValue() > point
                                                                                .getX())
                                                                {
                                                                        min.put(name + "_x", new Double(point
                                                                                        .getX()));
                                                                }
                                                                if (min.get(name + "_y").doubleValue() > point
                                                                                .getY())
                                                                {
                                                                        min.put(name + "_y", new Double(point
                                                                                        .getY()));
                                                                }
                                                        }
                                                        else
                                                        {
                                                                min.put(name + "_x", new Double(point.getX()));
                                                                min.put(name + "_y", new Double(point.getY()));
                                                        }

                                                        if (srid_in != srid_out)
                                                        {

                                                                String x = IOHelper.FORMATTER.format(point
                                                                                .getX());
                                                                String y = IOHelper.FORMATTER.format(point
                                                                                .getY());
                                                                String[] transformed = handler.transformPoint(
                                                                                x, y, srid_in, srid_out);
                                                                point.setX(Double.parseDouble(transformed[0]));
                                                                point.setY(Double.parseDouble(transformed[1]));
                                                        }
                                                }
                                        }
                                        catch (NullPointerException e)
                                        {
                                                // Can't find srid_in or srid_out
                                                // Do nothing
                                        }
                                        catch (MismatchedDimensionException e)
                                        {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }
                                        catch (NoSuchAuthorityCodeException e)
                                        {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }
                                        catch (FactoryException e)
                                        {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }
                                        catch (ParseException e)
                                        {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }
                                        catch (TransformException e)
                                        {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }

                                        value = getGeometryString(points);
                                        break;
                                case INTEGER:
                                case DOUBLE:
                                        double doubleValue = Double.parseDouble(value);

                                        // calculating max value for all numeric parameters
                                        if (max.keySet().contains(name))
                                        {
                                                if (max.get(name).doubleValue() < doubleValue)
                                                {
                                                        max.put(name, new Double(doubleValue));
                                                }
                                        }
                                        else
                                        {
                                                max.put(name, new Double(doubleValue));
                                        }

                                        // calculating min value for all numeric parameters
                                        if (min.keySet().contains(name))
                                        {
                                                if (min.get(name).doubleValue() > doubleValue)
                                                {
                                                        min.put(name, new Double(doubleValue));
                                                }
                                        }
                                        else
                                        {
                                                min.put(name, new Double(doubleValue));
                                        }

                                        // calculating sum value for all numeric parameters
                                        if (sum.keySet().contains(name))
                                        {
                                                double prevValue = sum.get(name).doubleValue();
                                                sum.put(name, new Double(prevValue + doubleValue));

                                        }
                                        else
                                        {
                                                sum.put(name, new Double(doubleValue));
                                        }

                                        break;
                                }

                                stringMap.put(p.getName(), value);
                        }
                        out.add(stringMap);
                }

                // calculating avg values for all numeric parameters
                Iterator<Entry<String, Double>> sumIt = sum.entrySet().iterator();
                while (sumIt.hasNext())
                {
                        Entry<String, Double> entry = sumIt.next();
                        double avgValue = sum.get(entry.getKey()).doubleValue() / count;
                        avg.put(entry.getKey(), new Double(avgValue));
                }

                template.setAttribute("parameters", out);

                template.setAttribute("min", min);
                template.setAttribute("max", max);
                template.setAttribute("avg", avg);
                template.setAttribute("sum", sum);
                template.setAttribute("count", count);
                template.setAttribute("srid_out", srid_out);
                /*
                 * template.setAttribute("srid_out", serviceRequest.getParameters().get(
                 * "srid_out").getValue());
                 */
                return template.toString();
        }
}