root/tools/routingservice/branches/wrs-2.0/src/util/format/JSONParser.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 java.util.Iterator;
import java.util.StringTokenizer;
import java.util.Vector;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONTokener;

import util.Parameter;

public class JSONParser extends FormatParser
{

        @SuppressWarnings("unchecked")
        @Override
        public Vector<Parameter> parseInput(String text)
        {
                Vector<Parameter> params = new Vector<Parameter>();
                JSONTokener tokener = new JSONTokener(text);
                try
                {
                        JSONObject json = new JSONObject(tokener);

                        Iterator<String> keys = json.keys();
                        while (keys.hasNext())
                        {
                                String key = keys.next();
                                switch (DataTypes.valueOf(key.toUpperCase()))
                                {
                                case POINTS:
                                        JSONArray data = json.getJSONArray(key);
                                        for(int i = 0; i < data.length(); ++i)
                                        {
                                                String point = data.getString(i);
                                                StringTokenizer sst = new StringTokenizer(point, " ");
                                                Parameter x = new Parameter();
                                                x.setName("x" + (i+1));
                                                x.setSource("url");
                                                x.setValue(sst.nextToken().trim());
                                                x.setType(DataTypes.DOUBLE.name());

                                                params.add(x);

                                                Parameter y = new Parameter();
                                                y.setName("y" + (i+1));
                                                y.setSource("url");
                                                y.setValue(sst.nextToken().trim());
                                                y.setType(DataTypes.DOUBLE.name());

                                                params.add(y);
                                        }
                                        break;
                                case DISTANCE:
                                        String distance = json.getString(key).trim();
                                        Parameter dist = new Parameter();
                                        dist.setName("distance");
                                        dist.setSource("url");
                                        dist.setValue(distance);
                                        dist.setType(DataTypes.DOUBLE.name());
                                        params.add(dist);
                                        break;
                                case CRS:
                                        String crs = json.getString(key);
                                        StringTokenizer crsst = new StringTokenizer(crs, ",");

                                        Parameter in = new Parameter();
                                        in.setName("srid_in");
                                        in.setSource("url");
                                        in.setValue(crsst.nextToken().trim());
                                        in.setType(DataTypes.INTEGER.name());

                                        params.add(in);
                                        
                                        Parameter out = new Parameter();
                                        out.setName("srid_out");
                                        out.setSource("url");

                                        if (crsst.hasMoreTokens())
                                        {
                                                out.setValue(crsst.nextToken().trim());
                                        }
                                        else
                                        {
                                                out.setValue(in.getValue());
                                        }
                                                                                
                                        out.setType(DataTypes.INTEGER.name());

                                        params.add(out);
                                        
                                        break;
                                case ADDRESS:
                                        String address = json.getString(key).trim();
                                        Parameter addr = new Parameter();
                                        addr.setName("address");
                                        addr.setSource("url");
                                        addr.setValue(address);
                                        addr.setType(DataTypes.STRING.name());
                                        params.add(addr);
                                        break;
                                //TODO add default case here for overridable parameters
                                }
                        }

                }
                catch (JSONException e)
                {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                return params;
        }

}