001 //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/branches/2.3_testing/src/org/deegree/ogcwebservices/wfs/operation/GetFeature.java $
002 /*----------------------------------------------------------------------------
003 This file is part of deegree, http://deegree.org/
004 Copyright (C) 2001-2009 by:
005 Department of Geography, University of Bonn
006 and
007 lat/lon GmbH
008
009 This library is free software; you can redistribute it and/or modify it under
010 the terms of the GNU Lesser General Public License as published by the Free
011 Software Foundation; either version 2.1 of the License, or (at your option)
012 any later version.
013 This library is distributed in the hope that it will be useful, but WITHOUT
014 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
015 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
016 details.
017 You should have received a copy of the GNU Lesser General Public License
018 along with this library; if not, write to the Free Software Foundation, Inc.,
019 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020
021 Contact information:
022
023 lat/lon GmbH
024 Aennchenstr. 19, 53177 Bonn
025 Germany
026 http://lat-lon.de/
027
028 Department of Geography, University of Bonn
029 Prof. Dr. Klaus Greve
030 Postfach 1147, 53001 Bonn
031 Germany
032 http://www.geographie.uni-bonn.de/deegree/
033
034 e-mail: info@deegree.org
035 ----------------------------------------------------------------------------*/
036 package org.deegree.ogcwebservices.wfs.operation;
037
038 import java.net.URI;
039 import java.util.ArrayList;
040 import java.util.HashMap;
041 import java.util.List;
042 import java.util.Map;
043
044 import org.deegree.datatypes.QualifiedName;
045 import org.deegree.framework.log.ILogger;
046 import org.deegree.framework.log.LoggerFactory;
047 import org.deegree.framework.util.KVP2Map;
048 import org.deegree.framework.xml.NamespaceContext;
049 import org.deegree.framework.xml.XMLParsingException;
050 import org.deegree.i18n.Messages;
051 import org.deegree.model.filterencoding.FeatureFilter;
052 import org.deegree.model.filterencoding.FeatureId;
053 import org.deegree.model.filterencoding.Filter;
054 import org.deegree.ogcbase.PropertyPath;
055 import org.deegree.ogcbase.PropertyPathFactory;
056 import org.deegree.ogcbase.PropertyPathStep;
057 import org.deegree.ogcbase.SortProperty;
058 import org.deegree.ogcwebservices.InconsistentRequestException;
059 import org.deegree.ogcwebservices.InvalidParameterValueException;
060 import org.deegree.ogcwebservices.MissingParameterValueException;
061 import org.deegree.ogcwebservices.OGCWebServiceException;
062 import org.deegree.ogcwebservices.wfs.WFService;
063 import org.w3c.dom.Element;
064
065 /**
066 * Represents a <code>GetFeature</code> request to a web feature service.
067 * <p>
068 * The GetFeature operation allows the retrieval of features from a web feature service. A GetFeature request is
069 * processed by a WFS and when the value of the outputFormat attribute is set to text/gml; subtype=gml/3.1.1, a GML
070 * instance document, containing the result set, is returned to the client.
071 *
072 * @author <a href="mailto:poth@lat-lon.de">Andreas Poth </a>
073 * @author <a href="mailto:schneider@lat-lon.de">Markus Schneider</a>
074 * @author last edited by: $Author: mschneider $
075 *
076 * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18. Jun 2009) $
077 */
078 public class GetFeature extends AbstractWFSRequest {
079
080 private static final ILogger LOG = LoggerFactory.getLogger( GetFeature.class );
081
082 private static final long serialVersionUID = 8885456550385433051L;
083
084 /** Serialized java object format (deegree specific extension) * */
085 public static final String FORMAT_FEATURECOLLECTION = "FEATURECOLLECTION";
086
087 /**
088 * Known result types.
089 */
090 public static enum RESULT_TYPE {
091
092 /** A full response should be generated. */
093 RESULTS,
094
095 /** Only a count of the number of features should be returned. */
096 HITS
097 }
098
099 protected RESULT_TYPE resultType = RESULT_TYPE.RESULTS;
100
101 protected String outputFormat;
102
103 protected int maxFeatures;
104
105 private int traverseXLinkDepth;
106
107 private int traverseXLinkExpiry;
108
109 protected List<Query> queries;
110
111 // deegree specific extension, default: 1 (start at first feature)
112 protected int startPosition;
113
114 /**
115 * Creates a new <code>GetFeature</code> instance.
116 *
117 * @param version
118 * request version
119 * @param id
120 * id of the request
121 * @param handle
122 * @param resultType
123 * desired result type (results | hits)
124 * @param outputFormat
125 * requested result format
126 * @param maxFeatures
127 * @param startPosition
128 * deegree specific parameter defining where to start considering features
129 * @param traverseXLinkDepth
130 * indicates the depth to which nested property XLink linking element locator attribute (href) XLinks are
131 * traversed and resolved if possible (not implemented yet, use -1 as default)
132 * @param traverseXLinkExpiry
133 * indicates how long a Web Feature Service should wait to receive a response to a nested GetGmlObject
134 * request (not implemented yet, use 0 as default)
135 * @param queries
136 * @param vendorSpecificParam
137 */
138 GetFeature( String version, String id, String handle, RESULT_TYPE resultType, String outputFormat, int maxFeatures,
139 int startPosition, int traverseXLinkDepth, int traverseXLinkExpiry, Query[] queries,
140 Map<String, String> vendorSpecificParam ) {
141 super( version, id, handle, vendorSpecificParam );
142 this.setQueries( queries );
143 this.outputFormat = outputFormat;
144 this.maxFeatures = maxFeatures;
145 this.startPosition = startPosition;
146 this.resultType = resultType;
147 this.traverseXLinkDepth = traverseXLinkDepth;
148 this.traverseXLinkExpiry = traverseXLinkExpiry;
149 }
150
151 /**
152 * Creates an uninitialized {@link GetFeature} instance.
153 */
154 protected GetFeature() {
155 super( null, null, null, null );
156 }
157
158 /**
159 * Creates a new <code>GetFeature</code> instance from the given parameters.
160 *
161 * @param version
162 * request version
163 * @param id
164 * id of the request
165 * @param resultType
166 * desired result type (results | hits)
167 * @param outputFormat
168 * requested result format
169 * @param handle
170 * @param maxFeatures
171 * default = -1 (all features)
172 * @param startPosition
173 * default = 0 (starting at the first feature)
174 * @param traverseXLinkDepth
175 * @param traverseXLinkExpiry
176 * @param queries
177 * a set of Query objects that describes the query to perform
178 * @return new <code>GetFeature</code> request
179 */
180 public static GetFeature create( String version, String id, RESULT_TYPE resultType, String outputFormat,
181 String handle, int maxFeatures, int startPosition, int traverseXLinkDepth,
182 int traverseXLinkExpiry, Query[] queries ) {
183 return new GetFeature( version, id, handle, resultType, outputFormat, maxFeatures, startPosition,
184 traverseXLinkDepth, traverseXLinkExpiry, queries, null );
185 }
186
187 /**
188 * Creates a new <code>GetFeature</code> instance from a document that contains the DOM representation of the
189 * request.
190 *
191 * @param id
192 * of the request
193 * @param root
194 * element that contains the DOM representation of the request
195 * @return new <code>GetFeature</code> request
196 * @throws OGCWebServiceException
197 */
198 public static GetFeature create( String id, Element root )
199 throws OGCWebServiceException {
200 GetFeatureDocument doc = new GetFeatureDocument();
201 doc.setRootElement( root );
202 GetFeature request;
203 try {
204 request = doc.parse( id );
205 } catch ( InvalidParameterValueException e ) {
206 throw e;
207 } catch ( XMLParsingException e ) {
208 // have to wrap it, to set exception code
209 throw new InvalidParameterValueException( e.getMessage(), e );
210 } catch ( Exception e ) {
211 LOG.logError( e.getMessage(), e );
212 throw new OGCWebServiceException( "GetFeature", e.getMessage() );
213 }
214 return request;
215 }
216
217 /**
218 * Creates a new <code>GetFeature</code> instance from the given key-value pair encoded request.
219 *
220 * @param id
221 * request identifier
222 * @param request
223 * @return new <code>GetFeature</code> request
224 * @throws InvalidParameterValueException
225 * @throws InconsistentRequestException
226 * @throws MissingParameterValueException
227 */
228 public static GetFeature create( String id, String request )
229 throws InconsistentRequestException, InvalidParameterValueException,
230 MissingParameterValueException {
231 Map<String, String> map = KVP2Map.toMap( request );
232 map.put( "ID", id );
233 return create( map );
234 }
235
236 /**
237 * Creates a new <code>GetFeature</code> request from the given map.
238 *
239 * @param kvp
240 * key-value pairs, keys have to be uppercase
241 * @return new <code>GetFeature</code> request
242 * @throws InvalidParameterValueException
243 * @throws InconsistentRequestException
244 * @throws MissingParameterValueException
245 */
246 public static GetFeature create( Map<String, String> kvp )
247 throws InconsistentRequestException, InvalidParameterValueException,
248 MissingParameterValueException {
249
250 // SERVICE
251 checkServiceParameter( kvp );
252
253 // ID (deegree specific)
254 String id = kvp.get( "ID" );
255
256 // VERSION
257 String version = checkVersionParameter( kvp );
258
259 boolean is100 = version.equals( "1.0.0" );
260
261 // OUTPUTFORMAT
262 String outputFormat = getParam( "OUTPUTFORMAT", kvp, is100 ? FORMAT_GML2_WFS100 : FORMAT_GML3 );
263
264 // RESULTTYPE
265 RESULT_TYPE resultType = RESULT_TYPE.RESULTS;
266 String resultTypeString = kvp.get( "RESULTTYPE" );
267 if ( "hits".equals( resultTypeString ) ) {
268 resultType = RESULT_TYPE.HITS;
269 }
270
271 // FEATUREVERSION
272 String featureVersion = kvp.get( "FEATUREVERSION" );
273
274 // MAXFEATURES
275 String maxFeaturesString = kvp.get( "MAXFEATURES" );
276 // -1: fetch all features
277 int maxFeatures = -1;
278 if ( maxFeaturesString != null ) {
279 try {
280 maxFeatures = Integer.parseInt( maxFeaturesString );
281 if ( maxFeatures < 1 ) {
282 throw new NumberFormatException();
283 }
284 } catch ( NumberFormatException e ) {
285 LOG.logError( e.getMessage(), e );
286 String msg = Messages.getMessage( "WFS_PARAMETER_INVALID_INT", maxFeaturesString, "MAXFEATURES" );
287 throw new InvalidParameterValueException( msg );
288 }
289 }
290
291 // STARTPOSITION (deegree specific)
292 String startPosString = getParam( "STARTPOSITION", kvp, "1" );
293 int startPosition = 1;
294 try {
295 startPosition = Integer.parseInt( startPosString );
296 if ( startPosition < 1 ) {
297 throw new NumberFormatException();
298 }
299 } catch ( NumberFormatException e ) {
300 LOG.logError( e.getMessage(), e );
301 String msg = Messages.getMessage( "WFS_PARAMETER_INVALID_INT", startPosString, "STARTPOSITION" );
302 throw new InvalidParameterValueException( msg );
303 }
304
305 // SRSNAME
306 String srsName = kvp.get( "SRSNAME" );
307
308 // SORTBY
309 SortProperty[] sortProperties = SortProperty.create( kvp.get( "SORTBY" ),
310 extractNamespaceParameter( kvp ).getNamespaceMap() );
311
312 // TRAVERSEXLINKDEPTH
313 int traverseXLinkDepth = -1;
314
315 // TRAVERSEXLINKEXPIRY
316 int traverseXLinkExpiry = -1;
317
318 Map<QualifiedName, Filter> filterMap = null;
319
320 // TYPENAME
321 QualifiedName[] typeNames = extractTypeNames( kvp );
322 if ( typeNames.length == 0 ) {
323 // check if FEATUREID is present
324 String featureId = kvp.get( "FEATUREID" );
325 if ( featureId != null ) {
326 // no TYPENAME parameter -> request needs to be augmented later (with configuration)
327 return new AugmentableGetFeature( version, id, null, resultType, outputFormat, maxFeatures,
328 startPosition, traverseXLinkDepth, traverseXLinkExpiry, new Query[0],
329 kvp );
330 }
331 String msg = Messages.getMessage( "WFS_TYPENAME+FID_PARAMS_MISSING" );
332 throw new InvalidParameterValueException( msg );
333 }
334
335 // check if FEATUREID is present
336 String featureId = kvp.get( "FEATUREID" );
337 if ( featureId != null ) {
338 String[] featureIds = featureId.split( "," );
339 if ( typeNames.length != 1 && featureIds.length != typeNames.length ) {
340 String msg = Messages.getMessage( "WFS_TYPENAME+FID_COUNT_MISMATCH", typeNames.length,
341 featureIds.length );
342 throw new InvalidParameterValueException( msg );
343 } else if ( typeNames.length == 1 ) {
344 // build one filter
345 ArrayList<FeatureId> fids = new ArrayList<FeatureId>( featureIds.length );
346 for ( String fid : featureIds ) {
347 fids.add( new FeatureId( fid ) );
348 }
349 Filter filter = new FeatureFilter( fids );
350 filterMap = new HashMap<QualifiedName, Filter>();
351 filterMap.put( typeNames[0], filter );
352 } else {
353 throw new InvalidParameterValueException(
354 "Usage of FEATUREID with multiple TYPENAME values is not supported yet." );
355 }
356 }
357
358 // BBOX
359 Filter bboxFilter = extractBBOXFilter( kvp );
360
361 // FILTER (mutually exclusive with FEATUREID or BBOX, prequisite: TYPENAME)
362 if ( filterMap != null || bboxFilter != null ) {
363 if ( kvp.containsKey( "FILTER" ) ) {
364 String msg = Messages.getMessage( "WFS_GET_FEATURE_FEATUREID_BBOX_AND_FILTER" );
365 throw new InvalidParameterValueException( msg );
366 }
367 } else {
368 filterMap = extractFilters( kvp, typeNames );
369 }
370
371 // PROPERTYNAME
372 Map<QualifiedName, PropertyPath[]> propertyNameMap = extractPropNames( kvp, typeNames );
373
374 // build a Query instance for each requested feature type (later also for each featureid...)
375 Query[] queries = new Query[typeNames.length];
376 for ( int i = 0; i < queries.length; i++ ) {
377 QualifiedName ftName = typeNames[i];
378 PropertyPath[] properties = propertyNameMap.get( ftName );
379 Filter filter;
380 if ( filterMap != null ) {
381 filter = filterMap.get( ftName );
382 } else {
383 filter = bboxFilter;
384 }
385 QualifiedName[] ftNames = new QualifiedName[] { ftName };
386 queries[i] = new Query( properties, null, sortProperties, null, featureVersion, ftNames, null, srsName,
387 filter, resultType, maxFeatures, startPosition );
388 }
389
390 // build a GetFeature request that contains all queries
391 GetFeature request = new GetFeature( version, id, null, resultType, outputFormat, maxFeatures, startPosition,
392 traverseXLinkDepth, traverseXLinkExpiry, queries, kvp );
393 return request;
394 }
395
396 /**
397 * Extracts the PROPERTYNAME parameter and assigns them to the requested type names.
398 *
399 * @param kvp
400 * @param typeNames
401 * @return map with the assignments of type names to property names
402 * @throws InvalidParameterValueException
403 */
404 protected static Map<QualifiedName, PropertyPath[]> extractPropNames( Map<String, String> kvp,
405 QualifiedName[] typeNames )
406 throws InvalidParameterValueException {
407 Map<QualifiedName, PropertyPath[]> propMap = new HashMap<QualifiedName, PropertyPath[]>();
408 String propNameString = kvp.get( "PROPERTYNAME" );
409 if ( propNameString != null ) {
410 String[] propNameLists = propNameString.split( "\\)" );
411 if ( propNameLists.length != typeNames.length ) {
412 String msg = Messages.getMessage( "WFS_PROPNAME_PARAM_WRONG_COUNT",
413 Integer.toString( propNameLists.length ),
414 Integer.toString( typeNames.length ) );
415 throw new InvalidParameterValueException( msg );
416 }
417 NamespaceContext nsContext = extractNamespaceParameter( kvp );
418 for ( int i = 0; i < propNameLists.length; i++ ) {
419 String propNameList = propNameLists[i];
420 if ( propNameList.startsWith( "(" ) ) {
421 propNameList = propNameList.substring( 1 );
422 }
423 String[] propNames = propNameList.split( "," );
424 PropertyPath[] paths = new PropertyPath[propNames.length];
425 for ( int j = 0; j < propNames.length; j++ ) {
426 PropertyPath path = transformToPropertyPath( propNames[j], nsContext );
427 paths[j] = ( path );
428 }
429 propMap.put( typeNames[i], paths );
430 }
431 }
432 return propMap;
433 }
434
435 /**
436 * Transforms the given property name to a (qualified) <code>PropertyPath</code> object by using the specified
437 * namespace bindings.
438 *
439 * @param propName
440 * @param nsContext
441 * @return (qualified) <code>PropertyPath</code> object
442 * @throws InvalidParameterValueException
443 */
444 private static PropertyPath transformToPropertyPath( String propName, NamespaceContext nsContext )
445 throws InvalidParameterValueException {
446 String[] steps = propName.split( "/" );
447 List<PropertyPathStep> propertyPathSteps = new ArrayList<PropertyPathStep>( steps.length );
448
449 for ( int i = 0; i < steps.length; i++ ) {
450 PropertyPathStep propertyStep = null;
451 QualifiedName propertyName = null;
452 String step = steps[i];
453 boolean isAttribute = false;
454 boolean isIndexed = false;
455 int selectedIndex = -1;
456
457 // check if step begins with '@' -> must be the final step then
458 if ( step.startsWith( "@" ) ) {
459 if ( i != steps.length - 1 ) {
460 String msg = "PropertyName '" + propName + "' is illegal: the attribute specifier may only "
461 + "be used for the final step.";
462 throw new InvalidParameterValueException( msg );
463 }
464 step = step.substring( 1 );
465 isAttribute = true;
466 }
467
468 // check if the step ends with brackets ([...])
469 if ( step.endsWith( "]" ) ) {
470 if ( isAttribute ) {
471 String msg = "PropertyName '" + propName
472 + "' is illegal: if the attribute specifier ('@') is used, "
473 + "index selection ('[...']) is not possible.";
474 throw new InvalidParameterValueException( msg );
475 }
476 int bracketPos = step.indexOf( '[' );
477 if ( bracketPos < 0 ) {
478 String msg = "PropertyName '" + propName + "' is illegal. No opening brackets found for step '"
479 + step + "'.";
480 throw new InvalidParameterValueException( msg );
481 }
482 try {
483 selectedIndex = Integer.parseInt( step.substring( bracketPos + 1, step.length() - 1 ) );
484 } catch ( NumberFormatException e ) {
485 LOG.logError( e.getMessage(), e );
486 String msg = "PropertyName '" + propName + "' is illegal. Specified index '"
487 + step.substring( bracketPos + 1, step.length() - 1 ) + "' is not a number.";
488 throw new InvalidParameterValueException( msg );
489 }
490 step = step.substring( 0, bracketPos );
491 isIndexed = true;
492 }
493
494 // determine namespace prefix and binding (if any)
495 int colonPos = step.indexOf( ':' );
496 String prefix = "";
497 String localName = step;
498 if ( colonPos > 0 ) {
499 prefix = step.substring( 0, colonPos );
500 localName = step.substring( colonPos + 1 );
501 }
502 URI nsURI = nsContext.getURI( prefix );
503 propertyName = new QualifiedName( prefix, localName, nsURI );
504
505 if ( isAttribute ) {
506 propertyStep = PropertyPathFactory.createAttributePropertyPathStep( propertyName );
507 } else if ( isIndexed ) {
508 propertyStep = PropertyPathFactory.createPropertyPathStep( propertyName, selectedIndex );
509 } else {
510 propertyStep = PropertyPathFactory.createPropertyPathStep( propertyName );
511 }
512 propertyPathSteps.add( propertyStep );
513 }
514 return PropertyPathFactory.createPropertyPath( propertyPathSteps );
515 }
516
517 /**
518 * Returns the output format.
519 * <p>
520 * The outputFormat attribute defines the format to use to generate the result set. Vendor specific formats,
521 * declared in the capabilities document are possible. The WFS-specs implies GML as default output format.
522 *
523 * @return the output format.
524 */
525 public String getOutputFormat() {
526 return this.outputFormat;
527 }
528
529 /**
530 * The query defines which feature type to query, what properties to retrieve and what constraints (spatial and
531 * non-spatial) to apply to those properties.
532 * <p>
533 * only used for xml-coded requests
534 *
535 * @return contained queries
536 */
537 public Query[] getQuery() {
538 return queries.toArray( new Query[queries.size()] );
539 }
540
541 /**
542 * sets the <Query>
543 *
544 * @param query
545 */
546 public void setQueries( Query[] query ) {
547 if ( query != null ) {
548 this.queries = new ArrayList<Query>( query.length );
549 for ( int i = 0; i < query.length; i++ ) {
550 this.queries.add( query[i] );
551 }
552 } else {
553 this.queries = new ArrayList<Query>();
554 }
555 }
556
557 /**
558 * The optional maxFeatures attribute can be used to limit the number of features that a GetFeature request
559 * retrieves. Once the maxFeatures limit is reached, the result set is truncated at that point. If not limit is set
560 * -1 will be returned.
561 *
562 * @return number of feature to fetch, -1 if no limit is set
563 */
564 public int getMaxFeatures() {
565 return maxFeatures;
566 }
567
568 /**
569 * @see #getMaxFeatures()
570 * @param max
571 */
572 public void setMaxFeatures( int max ) {
573 this.maxFeatures = max;
574 for ( int i = 0; i < queries.size(); i++ ) {
575 queries.get( i ).setMaxFeatures( max );
576 }
577 }
578
579 /**
580 * The startPosition parameter identifies the first result set entry to be returned specified the default is the
581 * first record. If not startposition is set 0 will be returned
582 *
583 * @return the first result set entry to be returned
584 */
585 public int getStartPosition() {
586 return startPosition;
587 }
588
589 /**
590 * Returns the desired result type of the GetFeature operation. Possible values are 'results' and 'hits'.
591 *
592 * @return the desired result type
593 */
594 public RESULT_TYPE getResultType() {
595 return this.resultType;
596 }
597
598 /**
599 * The optional traverseXLinkDepth attribute indicates the depth to which nested property XLink linking element
600 * locator attribute (href) XLinks in all properties of the selected feature(s) are traversed and resolved if
601 * possible. A value of "1" indicates that one linking element locator attribute (href) XLink will be traversed and
602 * the referenced element returned if possible, but nested property XLink linking element locator attribute (href)
603 * XLinks in the returned element are not traversed. A value of "*" indicates that all nested property XLink linking
604 * element locator attribute (href) XLinks will be traversed and the referenced elements returned if possible. The
605 * range of valid values for this attribute consists of positive integers plus "*".
606 *
607 * @return the depth to which nested property XLinks are traversed and resolved
608 */
609 public int getTraverseXLinkDepth() {
610 return traverseXLinkDepth;
611 }
612
613 /**
614 * The traverseXLinkExpiry attribute is specified in minutes. It indicates how long a Web Feature Service should
615 * wait to receive a response to a nested GetGmlObject request. If no traverseXLinkExpiry attribute is present for a
616 * GetGmlObject request, the WFS wait time is implementation dependent.
617 *
618 * @return how long to wait to receive a response to a nested GetGmlObject request
619 */
620 public int getTraverseXLinkExpiry() {
621 return traverseXLinkExpiry;
622 }
623
624 /**
625 * Adds missing namespaces in the names of requested feature types.
626 * <p>
627 * If the {@link QualifiedName} of a requested type has a null namespace, the first qualified feature type name of
628 * the given {@link WFService} with the same local name is used instead.
629 * <p>
630 * Note: The method changes this request (the feature type names) and should only be called by the
631 * <code>WFSHandler</code> class.
632 *
633 * @param wfs
634 * {@link WFService} instance that is used for the lookup of proper (qualified) feature type names
635 */
636 public void guessMissingTypeNameNamespaces( WFService wfs ) {
637 for ( Query query : queries ) {
638 query.guessMissingTypeNameNamespace( wfs );
639 }
640 }
641
642 /**
643 * Adds missing namespaces to requested feature type names, property names, filter properties and sort properties.
644 * <p>
645 * Note: The method changes the request and should only be called by the <code>WFSHandler</code> class.
646 *
647 * @param wfs
648 * {@link WFService} instance that is used for the lookup of proper (qualified) feature and property
649 * names
650 */
651 public void guessAllMissingNamespaces( WFService wfs ) {
652 for ( Query query : queries ) {
653 query.guessAllMissingNamespaces( wfs );
654 }
655 }
656
657 @Override
658 public String toString() {
659 String ret = null;
660 ret = "WFSGetFeatureRequest: { \n ";
661 ret += "outputFormat = " + outputFormat + "\n";
662 ret += ( "handle = " + getHandle() + "\n" );
663 ret += ( "query = " + queries + "\n" );
664 ret += "}\n";
665 return ret;
666 }
667 }