Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

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

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

 *

 */

/*

 * AUTHORS (In addition to CIT):

 * 2010 Prodevelop S.L. main development

 * http://www.prodevelop.es

 */

package org.gvsig.remoteclient.arcims;

import java.awt.geom.Rectangle2D;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.io.UnsupportedEncodingException;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.ArrayList;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import java.util.StringTokenizer;

import java.util.Vector;

import org.exolab.castor.xml.dtd.parser.ParseException;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.aggregate.impl.MultiPoint2D;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.primitive.GeneralPathX;

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.remoteclient.arcims.exceptions.ArcImsException;

import org.gvsig.remoteclient.arcims.utils.ArcImsDownloadUtils;

import org.gvsig.remoteclient.arcims.utils.ArcImsFeature;

import org.gvsig.remoteclient.arcims.utils.FieldInformation;

import org.gvsig.remoteclient.arcims.utils.GetFeaturesTags;

import org.gvsig.remoteclient.arcims.utils.ServiceInfoTags;

import org.gvsig.remoteclient.arcims.utils.ServiceInformation;

import org.gvsig.remoteclient.arcims.utils.ServiceInformationLayerFeatures;

import org.gvsig.remoteclient.utils.BoundaryBox;

import org.kxml2.io.KXmlParser;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.xmlpull.v1.XmlPullParserException;

/**

 * @author jsanz

 * 

 */

public class ArcImsProtFeatureHandler extends ArcImsProtocolHandler {

        private static boolean hasMore;

        private static int featCount;

        private static Logger logger = LoggerFactory

                        .getLogger(ArcImsProtFeatureHandler.class.getName());

        /**

         * Method to retrieve an ArrayList of features from an ArcIMS FeatureService

         * 

         * @param status

         * @return ArrayList of IFeatures with geometries and Id's to attribute

         *         table

         * @throws ArcImsException

         */

        public List<List<ArcImsFeature>> getMap(ArcImsVectStatus status)

                        throws ArcImsException {

                logger.info("Start getMap");

                List<List<ArcImsFeature>> array = new ArrayList<List<ArcImsFeature>>();

                try {

                        /*

                         * Build the request

                         */

                        URL url = new URL(buildCapabilitiesRequest(status));

                        hasMore = true;

                        featCount = 1;

                        while (hasMore) {

                                /*

                                 * Build the proper ArcXML

                                 */

                                String request = ArcXMLFeatures.getFeatureLayerRequest(status,

                                                featCount);

                                if (status.verbose) {

                                        System.err.println(request);

                                }

                                /*

                                 * Request the reader

                                 */

                                logger.info("Start features downloading");

                                File f = ArcImsDownloadUtils.doRequestPost(url, request,

                                                "getFeatures.xml");

                                logger.info("End features downloading");

                                /*

                                 * Parse response and add geometries to the general Array

                                 */

                                String layerId = (String) status.getLayersIdsSelected().get(0);

                                // Deal with UTF-8

                                Reader reader = null;

                                FileInputStream fis = new FileInputStream(f);

                                InputStreamReader isr = new InputStreamReader(fis, "UTF-8");

                                BufferedReader br = new BufferedReader(isr);

                                reader = br;

                                logger.debug("Start features with attributes parsing");

                                List<ArcImsFeature> feats = this.getFeatures(reader, status

                                                .getServiceInfo(), layerId, status.getSubfields(), 1);

                                array.add(feats);

                                logger.debug("End features with attributes parsing");

                        }

                        hasMore = true;

                        featCount = 1;

                } catch (MalformedURLException e) {

                        logger.error(e.getMessage(), e);

                        throw new ArcImsException("arcims_server_error");

                } catch (FileNotFoundException e) {

                        logger.error(e.getMessage(), e);

                        throw new ArcImsException("arcims_server_error");

                } catch (UnsupportedEncodingException e) {

                        logger.error(e.getMessage(), e);

                }

                logger.debug("End getMap");

                return array;

        }

        /**

         * Parse the XML data retrieved from ArcIMS GET_FEATURES request to get a

         * set of Features if withGeometries is true or an ArrayList of Value[] if

         * this boolean is false

         * 

         * @param Reader

         *            Stream to parse

         * @param si

         *            ServiceInformation with metadata

         * @param layerId

         *            Layer retrieved

         * @param subfields

         *            Subfields retrieved

         * @param withGeometries

         *            Will geometries be parsed?: 0=no 1=yes 2=evelopes

         * @return ArrayList of IFeatures or Value[]

         * @throws ArcImsException

         */

        private List<ArcImsFeature> getFeatures(Reader lector,

                        ServiceInformation si, String layerId, String[] subfields,

                        int withGeometries) throws ArcImsException {

                // fill features map

                FieldInformation fi = null;

                ServiceInformationLayerFeatures sil = (ServiceInformationLayerFeatures) si

                                .getLayerById(layerId);

                /*

                 * Prepare a Value array to store every FEATURE tag information

                 */

                Vector<FieldInformation> fieldsInfo = sil.getFieldsInfo();

                // If flag == true, throw an Exception (no layerId found)

                if (fieldsInfo == null) {

                        throw new ArcImsException("arcims_no_features");

                }

                // We will store names and types in a hashmap

                List<FieldInformation> fieldsInfoA = new ArrayList<FieldInformation>();

                /*

                 * If subfields[0] is equal to #ALL we add the entire vector into the

                 * Hasmap

                 */

                if (subfields[0].equals("#ALL#")) {

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

                                fi = fieldsInfo.get(i);

                                fieldsInfoA.add(fi);

                        }

                } else {

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

                                fi = null;

                                fi = sil.getFieldInformation(subfields[i]);

                                if (fi != null) {

                                        fieldsInfoA.add(fi);

                                }

                        }

                }

                /*

                 * Get the separators

                 */

                String delCoords = si.getSeparators().getCs();

                String delTuple = si.getSeparators().getTs();

                char delDec = si.getSeparators().getDs();

                /*

                 * ArrayList with features

                 */

                List<ArcImsFeature> features = new ArrayList<ArcImsFeature>();

                /*

                 * Start parsing

                 */

                int tag;

                KXmlParser kxmlParser = new KXmlParser();

                Geometry geom = null;

                //Object[] values = new Object[fieldsInfoA.size()];

                // Value[] values = new Value[fieldsInfoA.size()];

                int[] position = new int[fieldsInfoA.size()];

                // Initialize position array

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

                        position[i] = -1;

                // long timeFeat = 0;

                // long timeGeom = 0;

                // long timeTemp = 0;

                try {

                        kxmlParser.setInput(lector);

                        kxmlParser.nextTag();

                        if (kxmlParser.getEventType() != KXmlParser.END_DOCUMENT) {

                                kxmlParser.require(KXmlParser.START_TAG, null,

                                                ServiceInfoTags.tARCXML);

                                tag = kxmlParser.nextTag();

                                while (tag != KXmlParser.END_DOCUMENT) {

                                        ArcImsFeature afeat = new ArcImsFeature();

                                        switch (tag) {

                                        case KXmlParser.START_TAG:

                                                if (kxmlParser.getName().compareTo(

                                                                GetFeaturesTags.FEATURE) == 0) {

                                                        /*

                                                         * parse FEATURES' tag

                                                         */

                                                        // FIRST ENVELOPE TAG (We hope that ENVELOPE will

                                                        // ALLWAYS be returned at first...)

                                                        if (withGeometries == 2) {

                                                                // timeTemp = System.currentTimeMillis();

                                                                geom = parseEnvelopeFromFeatureTag(kxmlParser,

                                                                                delDec);

                                                                afeat.putGeometry(geom);

                                                        }

                                                        // SECOND FIELDS TAG

                                                        // timeTemp = System.currentTimeMillis();

                                                        afeat = parseValuesFromFeatureTag(kxmlParser, // the

                                                                        // kxml

                                                                        // parser

                                                                        fieldsInfoA, // Hashmap with names and

                                                                        // FieldInformation objects)

                                                                        delDec, // the separators

                                                                        position, // the relative positions of

                                                        // returned values

                                                                        afeat

                                                        );

                                                        // timeFeat += System.currentTimeMillis() -

                                                        // timeTemp;

                                                        // If geometries are neede we add to the ArrayList

                                                        // the Ifeature

                                                        if (withGeometries == 1) {

                                                                // THIRD GEOMETRIES

                                                                // timeTemp = System.currentTimeMillis();

                                                                geom = parseGeomFromFeatureTag(kxmlParser, // the

                                                                                // kxml

                                                                                // parser

                                                                                delTuple, delCoords, delDec // the

                                                                // separators

                                                                );

                                                                afeat.putGeometry(geom);

                                                                // timeGeom += System.currentTimeMillis() -

                                                                // timeTemp;

                                                        }

                                                        // // If some geometry is created, we add a IFeature

                                                        // // into features ArrayList

                                                        // if (withGeometries > 0) {

                                                        // features.add(new ArcImsFeature(geom, values));

                                                        // }

                                                        // // Else we only need the Value[] array

                                                        // else {

                                                        // features.add(new ArcImsFeature(values));

                                                        // }

                                                } else if (kxmlParser.getName().compareTo(

                                                                GetFeaturesTags.FEATURECOUNT) == 0) {

                                                        String value = new String();

                                                        // Get the feature count

                                                        value = kxmlParser.getAttributeValue("",

                                                                        GetFeaturesTags.COUNT);

                                                        Integer intFeatCount = new Integer(value);

                                                        featCount += intFeatCount.intValue();

                                                        // Get the hasmore boolean

                                                        value = kxmlParser.getAttributeValue("",

                                                                        GetFeaturesTags.HASMORE);

                                                        Boolean boHasMore = new Boolean(value);

                                                        hasMore = boHasMore.booleanValue();

                                                } else if (kxmlParser.getName().compareTo(

                                                                ServiceInfoTags.tERROR) == 0) {

                                                        logger.error("Error parsing GET_FEATURES:\r\n"

                                                                        + kxmlParser.nextText());

                                                        throw new ArcImsException("arcims_server_error");

                                                }

                                                break;

                                        case KXmlParser.END_TAG:

                                                break;

                                        case KXmlParser.TEXT:

                                                break;

                                        }

                                        if(afeat != null){

                                                features.add(afeat);

                                        }

                                        tag = kxmlParser.next();

                                }

                                kxmlParser.require(KXmlParser.END_DOCUMENT, null, null);

                        }

                }

                catch (XmlPullParserException parser_ex) {

                        logger.error(parser_ex.getMessage(), parser_ex);

                        throw new ArcImsException("arcims_no_features");

                } catch (IOException ioe) {

                        logger.error(ioe.getMessage(), ioe);

                        throw new ArcImsException("arcims_no_features");

                } catch (CreateGeometryException e) {

                        logger.error(e.getMessage(), e);

                        throw new ArcImsException("arcims_no_features");

                }

                return features;

        }

        /**

         * Returns an IGeometry with a line between corners of an ENVELOPE

         * 

         * @param parser

         * @param delDec

         * @return

         * @throws XmlPullParserException

         * @throws IOException

         */

        private Geometry parseEnvelopeFromFeatureTag(KXmlParser parser, char delDec)

                        throws XmlPullParserException, IOException {

                int currentTag;

                boolean end = false;

                BoundaryBox bb = null;

                // parser.require(KXmlParser.START_TAG,null,GetFeaturesTags.FIELDS);

                currentTag = parser.next();

                while (!end) {

                        switch (currentTag) {

                        case KXmlParser.START_TAG:

                                if (parser.getName().equals(ServiceInfoTags.tENVELOPE)) {

                                        bb = super.parseEnvelope(parser, delDec);

                                        end = true;

                                }

                                break;

                        case KXmlParser.END_TAG:

                                if (parser.getName().equals(GetFeaturesTags.FIELDS)) {

                                        end = true;

                                }

                                break;

                        case KXmlParser.TEXT:

                                break;

                        }

                        if (!end) {

                                currentTag = parser.next();

                        }

                }

                // If BoundaryBox object has been created, we can convert it into a

                // IGeometry (polyline).

                if (bb != null) {

                        GeneralPathX polyline = new GeneralPathX(GeneralPathX.WIND_EVEN_ODD);

                        polyline.moveTo(bb.getXmin(), bb.getYmin());

                        polyline.lineTo(bb.getXmax(), bb.getYmax());

                        GeometryManager geomManager = GeometryLocator.getGeometryManager();

                        Geometry curve = null;

                        try {

                                curve = geomManager.createCurve(polyline,

                                                Geometry.SUBTYPES.GEOM2D);

                        } catch (CreateGeometryException e) {

                                logger.error("Error creating curve", e);

                                return null;

                        }

                        return curve;

                } else {

                        return null;

                }

        }

        /**

         * @param kxmlParser

         * @param fieldsInfoH

         * @param delDec

         * @param position

         * @return

         * @throws IOException

         * @throws XmlPullParserException

         * @throws IOException

         * @throws XmlPullParserException

         * @throws ArcImsException

         * @throws ArcImsException

         * @throws ParseException

         */

        private ArcImsFeature parseValuesFromFeatureTag(KXmlParser parser,

                        List<FieldInformation> fieldsInfoA, char delDec, int[] position, ArcImsFeature afeat )

                        throws XmlPullParserException, IOException, ArcImsException {

                int currentTag;

                boolean end = false;

                int f = 0;

                String att;

                String text;

                int type;

                //Object[] values = new Object[fieldsInfoA.size()];

                currentTag = parser.next();

                while (!end) {

                        switch (currentTag) {

                        case KXmlParser.START_TAG:

                                if (parser.getName().equals(GetFeaturesTags.FIELD)) {

                                        att = parser.getAttributeValue("", GetFeaturesTags.NAME);

                                        text = parser.getAttributeValue("", GetFeaturesTags.VALUE);

                                        /*

                                         * As NAME is known, we need to get the position of that

                                         * attribute into the ArrayList of fieldInformation objects

                                         */

                                        if (position[f] == -1) {

                                                position[f] = getPosition(fieldsInfoA.iterator(), att);                                                

                                        }

                                        if (position[f] == -1) {

                                                logger.error("Attribute not found at Metadata");

                                                throw new ArcImsException(

                                                                "Attribute not found at Metadata");

                                        }

                                        // This way we can create a NullValue

                                        if (text.equals("")) {

                                                text = null;

                                        }

                                        /*

                                         * At this point we know wat FieldInfo of the ArrayList we

                                         * have to retrieve

                                         */

                                        type = ((FieldInformation) fieldsInfoA.get(position[f]))

                                                        .getType();

                                        // Add the Value into the correct position

                                        if (text == null) {

                                                String fieldName = fieldsInfoA.get(position[f]).getName();

                                                afeat.put(fieldName,null);                                                

                                        } else {

                                                String fieldName = fieldsInfoA.get(position[f]).getName();

                                                switch (type) {

                                                case FieldInformation.BOOLEAN:

                                                        afeat.put(fieldName,new Boolean(text));

                                                        f++;

                                                        break;

                                                case FieldInformation.SHAPE:

                                                case FieldInformation.STRING:

                                                        afeat.put(fieldName, new String(text));

                                                        f++;

                                                        break;

                                                case FieldInformation.DATE:

                                                        afeat.put(fieldName, new Date(Long.parseLong(text)));

                                                        f++;

                                                        break;

                                                case FieldInformation.FLOAT:

                                                        String textfloat = text.replace(delDec, '.');

                                                        afeat.put(fieldName, new Float(textfloat));

                                                        f++;

                                                        break;

                                                case FieldInformation.DOUBLE:

                                                        String textdouble = text.replace(delDec, '.');

                                                        afeat.put(fieldName, new Double(textdouble));

                                                        f++;

                                                        break;

                                                case FieldInformation.SMALLINT:

                                                        afeat.put(fieldName, new Short(text));

                                                        f++;

                                                        break;

                                                case FieldInformation.BIGINT:

                                                        afeat.put(fieldName, new Long(text));

                                                        f++;

                                                        break;

                                                case FieldInformation.ID:

                                                        afeat.put(fieldName, new String(text));

                                                        afeat.setFieldPK(fieldName);

                                                        f++;

                                                        break;

                                                case FieldInformation.INTEGER:

                                                        afeat.put(fieldName, new Integer(text));

                                                        f++;

                                                        break;

                                                default:

                                                        afeat.put(fieldName, new String(text));

                                                        f++;

                                                }

                                        }

                                }

                                break;

                        case KXmlParser.END_TAG:

                                if (parser.getName().equals(GetFeaturesTags.FIELDS)) {

                                        end = true;

                                }

                                break;

                        case KXmlParser.TEXT:

                                break;

                        }

                        if (!end) {

                                currentTag = parser.next();

                        }

                }

                return afeat;

        }

        /**

         * Method to get the position of an attribute into the subfields array

         * 

         * @param fieldsInfoA

         * @param att

         * @return

         */

        private int getPosition(Iterator it, String att) {

                int res = 0;

                FieldInformation fi;

                while (it.hasNext()) {

                        fi = (FieldInformation) it.next();

                        if (fi.getName().equals(att)) {

                                return res;

                        }

                        res++;

                }

                // If no integer has returned at this point we return a -1

                return -1;

        }

        /**

         * Parses the Feature Tag to get a IFeature

         * 

         * @param KxmlParser

         *            with the FEATURE tag

         * @param Value

         *            array with the correct subtypes to store FIELDS data

         * @param String

         *            array with the correct fields names to retrieve

         * @param String

         *            with the tuple separator

         * @param String

         *            with the coordinates separator

         * @param Char

         *            with the decimal separator

         * @return @see com.hardcode.gdbms.engine.values.Value.IFeature

         * @throws IOException

         * @throws XmlPullParserException

         * @throws IOException

         * @throws XmlPullParserException

         * @throws CreateGeometryException

         * @throws ArcImsException

         * @throws CreateGeometryException

         * @throws ArcImsException

         */

        private Geometry parseGeomFromFeatureTag(KXmlParser parser,

                        String delTuple, String delCoords, char delDec)

                        throws XmlPullParserException, IOException,

                        CreateGeometryException, ArcImsException {

                GeometryManager geomManager = GeometryLocator.getGeometryManager();

                int currentTag;

                boolean end = false;

                Geometry geom = null;

                currentTag = parser.next();

                while (!end) {

                        String featType = parser.getName();

                        switch (currentTag) {

                        case KXmlParser.START_TAG:

                                // //////////////////////////

                                // geometry type MULTIPOINT

                                // //////////////////////////

                                if (featType.equals(GetFeaturesTags.MULTIPOINT)) {

                                        // Go to COORDS tag

                                        parser.nextTag();

                                        if (parser.getName().equals(GetFeaturesTags.COORDS)) {

                                                // Create a tokenizer with the tuples

                                                String strPoints = parser.nextText();

                                                // Get the points from COORDS string

                                                List<Point> points = parseCoords(strPoints, delTuple,

                                                                delCoords, delDec);

                                                geom = geomManager.create(Geometry.TYPES.MULTIPOINT,

                                                                Geometry.SUBTYPES.GEOM2D);

                                                MultiPoint2D mpoint = (MultiPoint2D) geom;

                                                for (Point point : points) {

                                                        mpoint.addPoint(point);

                                                }

                                        } else {

                                                logger.error("Error parsing MULTIPOINT tag");

                                                throw new ArcImsException("arcims_features_error");

                                        }

                                }

                                // ////////////////////////////////////////////

                                // POLYLINE or POLYGON

                                // ////////////////////////////////////////////

                                else if (featType.equals(GetFeaturesTags.POLYLINE)

                                                || featType.equals(GetFeaturesTags.POLYGON)) {

                                        // Parse while parser doesn't found </FEATURES> tag

                                        // The GeneralPath to store the different paths

                                        GeneralPathX polyline = new GeneralPathX(

                                                        GeneralPathX.WIND_EVEN_ODD);

                                        boolean endpol = false;

                                        while (!endpol) {

                                                switch (currentTag) {

                                                case KXmlParser.START_TAG:

                                                        if (parser.getName().equals(GetFeaturesTags.COORDS)) {

                                                                // Create a tokenizer with the tuples

                                                                String strPoints = parser.nextText();

                                                                // Get the points (Point2D) from COORDS string

                                                                List<Point> points = parseCoords(strPoints,

                                                                                delTuple, delCoords, delDec);

                                                                Iterator<Point> it = points.iterator();

                                                                Point point;

                                                                // First we MOVE to the first point of the path

                                                                point = (Point) it.next();

                                                                polyline.moveTo(point.getX(), point.getY());

                                                                // And now we can LINE to the rest of the points

                                                                // of the path

                                                                while (it.hasNext()) {

                                                                        point = (Point) it.next();

                                                                        polyline.lineTo(point.getX(), point.getY());

                                                                }

                                                        }

                                                        break;

                                                case KXmlParser.END_TAG:

                                                        if (parser.getName().equals(featType)) {

                                                                endpol = true;

                                                        }

                                                        break;

                                                case KXmlParser.TEXT:

                                                        break;

                                                }

                                                if (!endpol) {

                                                        currentTag = parser.next();

                                                }

                                        }

                                        if (featType.equals(GetFeaturesTags.POLYLINE)) {

                                                geom = geomManager.createMultiCurve(polyline,

                                                                Geometry.SUBTYPES.GEOM2D);

                                        } else if (featType.equals(GetFeaturesTags.POLYGON)) {

                                                geom = geomManager.createMultiSurface(polyline,

                                                                Geometry.SUBTYPES.GEOM2D);

                                        }

                                }

                                break;

                        case KXmlParser.END_TAG:

                                if (parser.getName().compareTo(GetFeaturesTags.FEATURE) == 0) {

                                        end = true;

                                }

                                break;

                        case KXmlParser.TEXT:

                                break;

                        }

                        if (!end) {

                                currentTag = parser.next();

                        }

                }

                return geom;

        }

        /**

         * Private method that parses a COORDS tag to return an ArrayList of

         * Point2D.Double objects

         * 

         * @param strCoords

         * @param delTuple

         * @param delCoords

         * @param delDec

         * @return

         * @throws CreateGeometryException

         */

        private List<Point> parseCoords(String strCoords, String delTuple,

                        String delCoords, char delDec) throws CreateGeometryException {

                GeometryManager geomManager = GeometryLocator.getGeometryManager();

                List<Point> points = new ArrayList<Point>();

                String tupla = new String();

                String[] tuplaPart;

                Double x;

                Double y;

                /*

                 * Replaces Decimal Separator to convert coords to suitable doubles.

                 * 

                 * Maybe it will have a better performance if we insert this replace

                 * into the while

                 */

                if (delDec != '.') {

                        strCoords = strCoords.replace(delDec, '.');

                }

                // Creates a tokenizer to run over the string

                StringTokenizer tuplas = new StringTokenizer(strCoords, delTuple, false);

                // Get ArrayLists collections with X's and Y's

                while (tuplas.hasMoreTokens()) {

                        // tupla = tuplas.nextToken().replace(delDec,'.');

                        tupla = tuplas.nextToken();

                        tuplaPart = tupla.split(delCoords);

                        x = new Double(tuplaPart[0]);

                        y = new Double(tuplaPart[1]);

                        Point pto = geomManager.createPoint(x.doubleValue(), y

                                        .doubleValue(), Geometry.SUBTYPES.GEOM2D);

                        points.add(pto);

                }

                // Return an array of Point objects

                return points;

        }

        /**

         * @param status

         * @return

         * @throws ArcImsException

         */

        public Rectangle2D getLayerExtent(ArcImsVectStatus status)

                        throws ArcImsException {

                Rectangle2D envelope = null;

                String layerId = (String) status.getLayersIdsSelected().get(0);

                // logger.info("Getting Vectorial Layer Extent (" + status.getl)

                ServiceInformation si = status.getServiceInfo();

                String ini_srs = ServiceInfoTags.vINI_SRS;

                String srsView = status.getSrs().substring(ini_srs.length()).trim();

                String srsServ = si.getFeaturecoordsys();

                boolean srsAssumed = si.isSrsAssumed();

                if (srsAssumed || (srsView.equals(srsServ))) {

                        BoundaryBox bb = si.getLayerById(layerId).getEnvelope();

                        /*

                         * At the end, we convert the BoundaryBox to a Rectangle2D

                         */

                        envelope = new Rectangle2D.Double();

                        envelope.setFrameFromDiagonal(bb.getXmin(), bb.getYmin(), bb

                                        .getXmax(), bb.getYmax());

                        return envelope;

                }

                /*

                 * If SRS of View and Service are different, we do a custom request to

                 * retrieve the global envelope of the layer

                 */

                try {

                        /*

                         * Build the request

                         */

                        URL url;

                        url = new URL(buildCapabilitiesRequest(status));

                        /*

                         * Build the proper ArcXML

                         */

                        String request = ArcXMLFeatures.getLayerExtentRequest(status);

                        if (status.verbose) {

                                System.err.println(request);

                        }

                        /*

                         * Request the envelope

                         */

                        File response;

                        response = ArcImsDownloadUtils.doRequestPost(url, request,

                                        "getLayerExtent.xml");

                        /*

                         * Parse response and return a Rectangle2D

                         */

                        char ds = si.getSeparators().getDs();

                        envelope = parseEnvelopeTag(new FileReader(response), ds);

                } catch (MalformedURLException e) {

                        logger.error(e.getMessage(), e);

                        throw new ArcImsException("arcims_server_error");

                } catch (FileNotFoundException e) {

                        logger.error(e.getMessage(), e);

                        throw new ArcImsException("arcims_server_error");

                }

                return envelope;

        }

        /**

         * Retrieves an ArrayList of Value arrays. The query can be filtered by a

         * WHERE clause or an envelope. Only subfields passed will be retrieved

         * 

         * @param status

         * @param subfields

         * @param where

         * @param envelope

         * @return

         * @throws ArcImsException

         */

        public List<List<ArcImsFeature>> getAttributes(ArcImsVectStatus status,

                        String[] subfields, String where, Rectangle2D envelope)

                        throws ArcImsException {

                logger.info("Start getAttributes");

                List<List<ArcImsFeature>> features = new ArrayList<List<ArcImsFeature>>();

                // Clone the status and set temporal subfields and where clause

                ArcImsVectStatus statusCloned = status;

                String[] subTemp = status.getSubfields();

                String whereTemp = status.getWhere();

                Rectangle2D rectTemp = status.getEnvelopeRect();

                statusCloned.setSubfields(subfields);

                statusCloned.setWhere(where);

                statusCloned.setEnvelope(envelope);

                try {

                        /*

                         * Build the request

                         */

                        URL url;

                        url = new URL(buildCapabilitiesRequest(statusCloned));

                        hasMore = true;

                        featCount = 0;

                        while (hasMore) {

                                /*

                                 * Build the proper ArcXML

                                 */

                                String request = ArcXMLFeatures.getAttributesRequest(

                                                statusCloned, featCount);

                                if (status.verbose) {

                                        System.err.println(request);

                                }

                                // The attributes come from ArcIMS in ASCII/cp1252 encoding

                                boolean withUTF = false;

                                // Don't download the file, pass the data directly from the

                                // connection

                                boolean withFile = false;

                                /*

                                 * Get an InputStream from File or directly from the connection

                                 */

                                InputStream is = null;

                                if (withFile) {

                                        File f = ArcImsDownloadUtils.doRequestPost(url, request,

                                                        "getAttributes.xml");

                                        try {

                                                is = new FileInputStream(f);

                                        } catch (FileNotFoundException e) {

                                                logger.error(e.getMessage(), e);

                                        }

                                } else {

                                        is = ArcImsDownloadUtils.getRemoteIS(url, request);

                                }

                                InputStreamReader isr = null;

                                if (withUTF) {

                                        // Deal with UTF-8

                                        try {

                                                isr = new InputStreamReader(is, "UTF-8");

                                        } catch (UnsupportedEncodingException e) {

                                                logger.error(e.getMessage(), e);

                                        }

                                } else {

                                        // No deal with UTF-8

                                        isr = new InputStreamReader(is);

                                }

                                /*

                                 * Finally, we can create a BufferedReader from the

                                 * InputStreamReader

                                 */

                                BufferedReader br = new BufferedReader(isr);

                                /*

                                 * Parse response and return a Rectangle2D

                                 */

                                String layerId = (String) statusCloned.getLayersIdsSelected().get(0);

                                logger.debug("Start attributes downloading and parsing ("

                                                + featCount + ") ids retrieved");

                                features.add(getFeatures(br, statusCloned.getServiceInfo(),

                                                layerId, statusCloned.getSubfields(), 0));

                                logger.debug("End attributes downloading and parsing");

                        }

                        hasMore = true;

                        featCount = 0;

                } catch (MalformedURLException e) {

                        logger.error(e.getMessage(), e);

                        throw new ArcImsException("arcims_server_error");

                } catch (ArcImsException e) {

                        logger.error(e.getMessage(), e);

                        throw new ArcImsException("arcims_server_error");

                } finally {

                        status.setSubfields(subTemp);

                        status.setWhere(whereTemp);

                        status.setEnvelope(rectTemp);

                }

                logger.debug("End attributes retrieving");

                return features;

        }

        /**

         * Retrieves an ArrayList of I by some IDs. The geometry returned is the

         * envelope of the feature requested. The query can be filtered by a WHERE

         * clause or an envelope. Only subfields passed will be retrieved

         * 

         * @param status

         * @param subfields

         * @param where

         * @param envelope

         * @return

         * @throws ArcImsException

         */

        public List<List<ArcImsFeature>> getAttributesWithEnvelope(

                        ArcImsVectStatus status, String[] subfields, String where,

                        Rectangle2D envelope) throws ArcImsException {

                logger.info("Start getAttributesWihtEnvelope");

                List<List<ArcImsFeature>> features = new ArrayList<List<ArcImsFeature>>();

                // Clone the status and set temporal subfields and where clause

                ArcImsVectStatus statusCloned = status;

                String[] subTemp = status.getSubfields();

                String whereTemp = status.getWhere();

                Rectangle2D rectTemp = status.getEnvelopeRect();

                statusCloned.setSubfields(subfields);

                statusCloned.setWhere(where);

                statusCloned.setEnvelope(envelope);

                try {

                        /*

                         * Build the request

                         */

                        URL url;

                        url = new URL(buildCapabilitiesRequest(statusCloned));

                        hasMore = true;

                        featCount = 0;

                        while (hasMore) {

                                /*

                                 * Build the proper ArcXML

                                 */

                                String request = ArcXMLFeatures.getAttributesRequest(

                                                statusCloned, featCount);

                                if (status.verbose) {

                                        System.err.println(request);

                                }

                                // The attributes come from ArcIMS in ASCII/cp1252 encoding

                                boolean withUTF = false;

                                // Don't download the file, pass the data directly from the

                                // connection

                                boolean withFile = false;

                                /*

                                 * Get an InputStream from File or directly from the connection

                                 */

                                InputStream is = null;

                                if (withFile) {

                                        File f = ArcImsDownloadUtils.doRequestPost(url, request,

                                                        "getAttributes.xml");

                                        try {

                                                is = new FileInputStream(f);

                                        } catch (FileNotFoundException e) {

                                                logger.error(e.getMessage(), e);

                                        }

                                } else {

                                        is = ArcImsDownloadUtils.getRemoteIS(url, request);

                                }

                                InputStreamReader isr = null;

                                if (withUTF) {

                                        // Deal with UTF-8

                                        try {

                                                isr = new InputStreamReader(is, "UTF-8");

                                        } catch (UnsupportedEncodingException e) {

                                                logger.error(e.getMessage(), e);

                                        }

                                } else {

                                        // No deal with UTF-8

                                        isr = new InputStreamReader(is);

                                }

                                /*

                                 * Finally, we can create a BufferedReader from the

                                 * InputStreamReader

                                 */

                                BufferedReader br = new BufferedReader(isr);

                                /*

                                 * Parse response and return a Rectangle2D

                                 */

                                String layerId = (String) statusCloned.getLayersIdsSelected().get(0);

                                logger.debug("Start attributes downloading and parsing ("

                                                + featCount + ") ids retrieved");

                                features.add(getFeatures(br, statusCloned.getServiceInfo(),

                                                layerId, statusCloned.getSubfields(), 2)); // Here we

                                // request

                                // envelopes instead

                                // of geometries

                                logger.debug("End attributes downloading and parsing");

                        }

                        hasMore = true;

                        featCount = 0;

                } catch (MalformedURLException e) {

                        logger.error(e.getMessage(), e);

                        throw new ArcImsException("arcims_server_error");

                } catch (ArcImsException e) {

                        logger.error(e.getMessage(), e);

                        throw new ArcImsException("arcims_server_error");

                } finally {

                        status.setSubfields(subTemp);

                        status.setWhere(whereTemp);

                        status.setEnvelope(rectTemp);

                }

                logger.debug("End attributes retrieving");

                return features;

        }

        /*

         * (non-Javadoc)

         * 

         * @see

         * org.gvsig.remoteClient.arcims.ArcImsProtocolHandler#getElementInfo(org

         * .gvsig.remoteClient.arcims.ArcImsStatus, int, int, int)

         */

        public String getElementInfo(ArcImsStatus status, int x, int y,

                        int featureCount) throws ArcImsException {

                throw new ClassCastException(

                                "Invalid request, this method is only valid for Image Services");

        }

}