wfs-server-1_7.patch

Michael Douchin, 2012-03-01 08:43 AM

+      }
+    }
     QString QgsGeometry::exportToGeoJSON()
+    {
       QgsDebugMsg( "entered." );
       // TODO: implement with GEOS
       if ( mDirtyWkb )
+      {
         exportGeosToWkb();
+      }
       if ( !mGeometry )
+      {
         QgsDebugMsg( "WKB geometry not available!" );
         return QString::null;
+      }
       QGis::WkbType wkbType;
       bool hasZValue = false;
       double *x, *y;
       QString mWkt; // TODO: rename
       // Will this really work when mGeometry[0] == 0 ???? I (gavin) think not.
       //wkbType = (mGeometry[0] == 1) ? mGeometry[1] : mGeometry[4];
       memcpy( &wkbType, &( mGeometry[1] ), sizeof( int ) );
       switch ( wkbType )
+      {
         case QGis::WKBPoint25D:
         case QGis::WKBPoint:
+        {
           mWkt += "{ \"type\": \"Point\", \"coordinates\": [";
           x = ( double * )( mGeometry + 5 );
           mWkt += QString::number( *x, 'f', 6 );
           mWkt += ", ";
           y = ( double * )( mGeometry + 5 + sizeof( double ) );
           mWkt += QString::number( *y, 'f', 6 );
           mWkt += "] }";
           return mWkt;
+        }
         case QGis::WKBLineString25D:
           hasZValue = true;
         case QGis::WKBLineString:
+        {
           QgsDebugMsg( "LINESTRING found" );
           unsigned char *ptr;
           int *nPoints;
           int idx;
           mWkt += "{ \"type\": \"LineString\", \"coordinates\": [ ";
           // get number of points in the line
           ptr = mGeometry + 5;
           nPoints = ( int * ) ptr;
           ptr = mGeometry + 1 + 2 * sizeof( int );
           for ( idx = 0; idx < *nPoints; ++idx )
+          {
             if ( idx != 0 )
+            {
               mWkt += ", ";
+            }
             mWkt += "[";
             x = ( double * ) ptr;
             mWkt += QString::number( *x, 'f', 6 );
             mWkt += ", ";
             ptr += sizeof( double );
             y = ( double * ) ptr;
             mWkt += QString::number( *y, 'f', 6 );
             ptr += sizeof( double );
             if ( hasZValue )
+            {
               ptr += sizeof( double );
+            }
             mWkt += "]";
+          }
           mWkt += " ] }";
           return mWkt;
+        }
         case QGis::WKBPolygon25D:
           hasZValue = true;
         case QGis::WKBPolygon:
+        {
           QgsDebugMsg( "POLYGON found" );
           unsigned char *ptr;
           int idx, jdx;
           int *numRings, *nPoints;
           mWkt += "{ \"type\": \"Polygon\", \"coordinates\": [ ";
           // get number of rings in the polygon
           numRings = ( int * )( mGeometry + 1 + sizeof( int ) );
           if ( !( *numRings ) )  // sanity check for zero rings in polygon
+          {
             return QString();
+          }
           int *ringStart; // index of first point for each ring
           int *ringNumPoints; // number of points in each ring
           ringStart = new int[*numRings];
           ringNumPoints = new int[*numRings];
           ptr = mGeometry + 1 + 2 * sizeof( int ); // set pointer to the first ring
           for ( idx = 0; idx < *numRings; idx++ )
+          {
             if ( idx != 0 )
+            {
               mWkt += ", ";
+            }
             mWkt += "[ ";
             // get number of points in the ring
             nPoints = ( int * ) ptr;
             ringNumPoints[idx] = *nPoints;
             ptr += 4;
             for ( jdx = 0; jdx < *nPoints; jdx++ )
+            {
               if ( jdx != 0 )
+              {
                 mWkt += ", ";
+              }
               mWkt += "[";
               x = ( double * ) ptr;
               mWkt += QString::number( *x, 'f', 6 );
               mWkt += ", ";
               ptr += sizeof( double );
               y = ( double * ) ptr;
               mWkt += QString::number( *y, 'f', 6 );
               ptr += sizeof( double );
               if ( hasZValue )
+              {
                 ptr += sizeof( double );
+              }
               mWkt += "]";
+            }
             mWkt += " ]";
+          }
           mWkt += " ] }";
           delete [] ringStart;
           delete [] ringNumPoints;
           return mWkt;
+        }
         case QGis::WKBMultiPoint25D:
           hasZValue = true;
         case QGis::WKBMultiPoint:
+        {
           unsigned char *ptr;
           int idx;
           int *nPoints;
           mWkt += "{ \"type\": \"MultiPoint\", \"coordinates\": [ ";
           nPoints = ( int* )( mGeometry + 5 );
           ptr = mGeometry + 5 + sizeof( int );
           for ( idx = 0; idx < *nPoints; ++idx )
+          {
             ptr += ( 1 + sizeof( int ) );
             if ( idx != 0 )
+            {
               mWkt += ", ";
+            }
             mWkt += "[";
             x = ( double * )( ptr );
             mWkt += QString::number( *x, 'f', 6 );
             mWkt += ", ";
             ptr += sizeof( double );
             y = ( double * )( ptr );
             mWkt += QString::number( *y, 'f', 6 );
             ptr += sizeof( double );
             if ( hasZValue )
+            {
               ptr += sizeof( double );
+            }
             mWkt += "]";
+          }
           mWkt += " ] }";
           return mWkt;
+        }
         case QGis::WKBMultiLineString25D:
           hasZValue = true;
         case QGis::WKBMultiLineString:
+        {
           QgsDebugMsg( "MULTILINESTRING found" );
           unsigned char *ptr;
           int idx, jdx, numLineStrings;
           int *nPoints;
           mWkt += "{ \"type\": \"MultiLineString\", \"coordinates\": [ ";
           numLineStrings = ( int )( mGeometry[5] );
           ptr = mGeometry + 9;
           for ( jdx = 0; jdx < numLineStrings; jdx++ )
+          {
             if ( jdx != 0 )
+            {
               mWkt += ", ";
+            }
             mWkt += "[ ";
             ptr += 5; // skip type since we know its 2
             nPoints = ( int * ) ptr;
             ptr += sizeof( int );
             for ( idx = 0; idx < *nPoints; idx++ )
+            {
               if ( idx != 0 )
+              {
                 mWkt += ", ";
+              }
               mWkt += "[";
               x = ( double * ) ptr;
               mWkt += QString::number( *x, 'f', 6 );
               ptr += sizeof( double );
               mWkt += ", ";
               y = ( double * ) ptr;
               mWkt += QString::number( *y, 'f', 6 );
               ptr += sizeof( double );
               if ( hasZValue )
+              {
                 ptr += sizeof( double );
+              }
               mWkt += "]";
+            }
             mWkt += " ]";
+          }
           mWkt += " ] }";
           return mWkt;
+        }
         case QGis::WKBMultiPolygon25D:
           hasZValue = true;
         case QGis::WKBMultiPolygon:
+        {
           QgsDebugMsg( "MULTIPOLYGON found" );
           unsigned char *ptr;
           int idx, jdx, kdx;
           int *numPolygons, *numRings, *nPoints;
           mWkt += "{ \"type\": \"MultiPolygon\", \"coordinates\": [ ";
           ptr = mGeometry + 5;
           numPolygons = ( int * ) ptr;
           ptr = mGeometry + 9;
           for ( kdx = 0; kdx < *numPolygons; kdx++ )
+          {
             if ( kdx != 0 )
+            {
               mWkt += ", ";
+            }
             mWkt += "[ ";
             ptr += 5;
             numRings = ( int * ) ptr;
             ptr += 4;
             for ( idx = 0; idx < *numRings; idx++ )
+            {
               if ( idx != 0 )
+              {
                 mWkt += ", ";
+              }
               mWkt += "[ ";
               nPoints = ( int * ) ptr;
               ptr += 4;
               for ( jdx = 0; jdx < *nPoints; jdx++ )
+              {
                 if ( jdx != 0 )
+                {
                   mWkt += ", ";
+                }
                 mWkt += "[";
                 x = ( double * ) ptr;
                 mWkt += QString::number( *x, 'f', 6 );
                 ptr += sizeof( double );
                 mWkt += ", ";
                 y = ( double * ) ptr;
                 mWkt += QString::number( *y, 'f', 6 );
                 ptr += sizeof( double );
                 if ( hasZValue )
+                {
                   ptr += sizeof( double );
+                }
                 mWkt += "]";
+              }
               mWkt += " ]";
+            }
             mWkt += " ]";
+          }
           mWkt += " ] }";
           return mWkt;
+        }
         default:
           QgsDebugMsg( "error: mGeometry type not recognized" );
           return QString::null;
+      }
+    }
     bool QgsGeometry::exportWkbToGeos()
+    {
       QgsDebugMsgLevel( "entered.", 3 );

          */
         QString exportToWkt();
         /** Exports the geometry to mGeoJSON
             @return true in case of success and false else
          */
         QString exportToGeoJSON();
         /* Accessor functions for getting geometry data */
         /** return contents of the geometry as a point

src/mapserver/CMakeLists.txt
27	27	qgssldparser.cpp
28	28	qgssldrenderer.cpp
29	29	qgswmsserver.cpp
	30	qgswfsserver.cpp
30	31	qgsmapserviceexception.cpp
31	32	qgsmapserverlogger.cpp
32	33	qgsmslayercache.cpp

     #include "qgsmapserviceexception.h"
     #include "qgsprojectparser.h"
     #include "qgssldparser.h"
     #include "qgswfsserver.h"
     #include <QDomDocument>
     #include <QImage>
     #include <QSettings>
-...
+        }
         QgsWMSServer* theServer = 0;
         if ( serviceIt->second == "WFS" )
+        {
           delete theServer;
           QgsWFSServer* theServer = 0;
           try
+          {
             theServer = new QgsWFSServer( parameterMap );
+          }
           catch ( QgsMapServiceException e ) //admin.sld may be invalid
+          {
             theRequestHandler->sendServiceException( e );
             continue;
+          }
           theServer->setAdminConfigParser( adminConfigParser );
           //request type
           std::map<QString, QString>::const_iterator requestIt = parameterMap.find( "REQUEST" );
           if ( requestIt == parameterMap.end() )
+          {
             //do some error handling
             QgsMSDebugMsg( "unable to find 'REQUEST' parameter, exiting..." );
             theRequestHandler->sendServiceException( QgsMapServiceException( "OperationNotSupported", "Please check the value of the REQUEST parameter" ) );
             delete theRequestHandler;
             delete theServer;
             continue;
+          }
           if ( requestIt->second == "GetCapabilities" )
+          {
             QDomDocument capabilitiesDocument;
             try
+            {
               capabilitiesDocument = theServer->getCapabilities();
+            }
             catch ( QgsMapServiceException& ex )
+            {
               theRequestHandler->sendServiceException( ex );
               delete theRequestHandler;
               delete theServer;
               continue;
+            }
             QgsMSDebugMsg( "sending GetCapabilities response" );
             theRequestHandler->sendGetCapabilitiesResponse( capabilitiesDocument );
             delete theRequestHandler;
             delete theServer;
             continue;
+          }
           else if ( requestIt->second == "DescribeFeatureType" )
+          {
             QDomDocument describeDocument;
             try
+            {
               describeDocument = theServer->describeFeatureType();
+            }
             catch ( QgsMapServiceException& ex )
+            {
               theRequestHandler->sendServiceException( ex );
               delete theRequestHandler;
               delete theServer;
               continue;
+            }
             QgsMSDebugMsg( "sending GetCapabilities response" );
             theRequestHandler->sendGetCapabilitiesResponse( describeDocument );
             delete theRequestHandler;
             delete theServer;
             continue;
+          }
           else if ( requestIt->second == "GetFeature" )
+          {
             //output format for GetFeature
             QString outputFormat;
             std::map<QString, QString>::const_iterator p_it = parameterMap.find( "OUTPUTFORMAT" );
             if ( p_it != parameterMap.end() )
+            {
               outputFormat = p_it->second;
+            }
             try
+            {
               if ( theServer->getFeature( *theRequestHandler, outputFormat ) != 0 )
+              {
                 delete theRequestHandler;
                 delete theServer;
                 continue;
               } else {
                 delete theRequestHandler;
                 delete theServer;
                 continue;
+              }
+            }
             catch ( QgsMapServiceException& ex )
+            {
               theRequestHandler->sendServiceException( ex );
               delete theRequestHandler;
               delete theServer;
               continue;
+            }
+          }
           return 0;
+        }
         else
+        {
         try
+        {
           theServer = new QgsWMSServer( parameterMap, theMapRenderer );
-...
           theRequestHandler->sendServiceException( e );
           continue;
+        }
+        }
         theServer->setAdminConfigParser( adminConfigParser );

         /**Adds layer and style specific capabilities elements to the parent node. This includes the individual layers and styles, their description, native CRS, bounding boxes, etc.*/
         virtual void layersAndStylesCapabilities( QDomElement& parentElement, QDomDocument& doc ) const = 0;
         virtual void featureTypeList( QDomElement& parentElement, QDomDocument& doc ) const = 0;
         /**Returns one or possibly several maplayers for a given layer name and style. If there are several layers, the layers should be drawn in inverse list order.
            If no layers/style are found, an empty list is returned*/
         virtual QList<QgsMapLayer*> mapLayerFromStyle( const QString& layerName, const QString& styleName, bool allowCaching = true ) const = 0;

     #include <QImage>
     #include <QStringList>
     #include <QUrl>
     #include <fcgi_stdio.h>
     QgsGetRequestHandler::QgsGetRequestHandler(): QgsHttpRequestHandler()
+    {
-...
+    {
       sendHttpResponse( ba, formatToMimeType( mFormat ) );
+    }
     bool QgsGetRequestHandler::startGetFeatureResponse( QByteArray* ba, const QString& infoFormat ) const
+    {
       if ( !ba )
+      {
         return false;
+      }
       if ( ba->size() < 1 )
+      {
         return false;
+      }
       QString format;
       if (infoFormat == "GeoJSON")
         format = "text/plain";
       else
         format = "text/xml";
       printf( "Content-Type: " );
       printf( format.toLocal8Bit() );
       printf( "\n" );
       printf( "\n" );
       fwrite( ba->data(), ba->size(), 1, FCGI_stdout );
       return true;
+    }
     void QgsGetRequestHandler::sendGetFeatureResponse( QByteArray* ba ) const
+    {
       if ( !ba )
+      {
         return;
+      }
       if ( ba->size() < 1 )
+      {
         return;
+      }
       fwrite( ba->data(), ba->size(), 1, FCGI_stdout );
+    }
     void QgsGetRequestHandler::endGetFeatureResponse( QByteArray* ba ) const
+    {
       if ( !ba )
+      {
         return;
+      }
       fwrite( ba->data(), ba->size(), 1, FCGI_stdout );
+    }

src/mapserver/qgsgetrequesthandler.h
30	30	void sendServiceException( const QgsMapServiceException& ex ) const;
31	31	void sendGetStyleResponse( const QDomDocument& doc ) const;
32	32	void sendGetPrintResponse( QByteArray* ba ) const;
	33	bool startGetFeatureResponse( QByteArray* ba, const QString& infoFormat ) const;
	34	void sendGetFeatureResponse( QByteArray* ba ) const;
	35	void endGetFeatureResponse( QByteArray* ba ) const;
33	36	};

       parentElement.appendChild( layerParentElem );
+    }
     void QgsProjectParser::featureTypeList( QDomElement& parentElement, QDomDocument& doc ) const
+    {
       QList<QDomElement> layerElems = projectLayerElements();
       QStringList nonIdentifiableLayers = identifyDisabledLayers();
       if ( layerElems.size() < 1 )
+      {
         return;
+      }
       QMap<QString, QgsMapLayer *> layerMap;
       QList<QDomElement>::const_iterator layerIt = layerElems.constBegin();
       for ( ; layerIt != layerElems.constEnd(); ++layerIt )
+      {
         QDomElement elem = *layerIt;
         QString type = elem.attribute( "type" );
         if ( type == "vector" )
+        {
           QgsMapLayer *layer = createLayerFromElement( *layerIt );
           if ( layer )
+          {
             QgsMSDebugMsg( QString( "add layer %1 to map" ).arg( layer->id() ) );
             layerMap.insert( layer->id(), layer );
             QDomElement layerElem = doc.createElement( "FeatureType" );
             QDomElement nameElem = doc.createElement( "Name" );
             //We use the layer name even though it might not be unique.
             //Because the id sometimes contains user/pw information and the name is more descriptive
             QDomText nameText = doc.createTextNode( layer->name() );
             nameElem.appendChild( nameText );
             layerElem.appendChild( nameElem );
             QDomElement titleElem = doc.createElement( "Title" );
             QDomText titleText = doc.createTextNode( layer->name() );
             titleElem.appendChild( titleText );
             layerElem.appendChild( titleElem );
             //appendExGeographicBoundingBox( layerElem, doc, layer->extent(), layer->crs() );
             QDomElement srsElem = doc.createElement( "SRS" );
             QDomText srsText = doc.createTextNode( layer->crs().authid() );
             srsElem.appendChild( srsText );
             layerElem.appendChild( srsElem );
             QgsRectangle layerExtent = layer->extent();
             QDomElement bBoxElement = doc.createElement( "LatLongBoundingBox" );
             bBoxElement.setAttribute( "minx", QString::number( layerExtent.xMinimum() ) );
             bBoxElement.setAttribute( "miny", QString::number( layerExtent.yMinimum() ) );
             bBoxElement.setAttribute( "maxx", QString::number( layerExtent.xMaximum() ) );
             bBoxElement.setAttribute( "maxy", QString::number( layerExtent.yMaximum() ) );
             layerElem.appendChild( bBoxElement );
             parentElement.appendChild(layerElem);
+          }
     #if QGSMSDEBUG
           else
+          {
             QString buf;
             QTextStream s( &buf );
             layerIt->save( s, 0 );
             QgsMSDebugMsg( QString( "layer %1 not found" ).arg( buf ) );
+          }
     #endif
+        }
+      }
       return;
+    }
     void QgsProjectParser::addLayers( QDomDocument &doc,
                                       QDomElement &parentElem,
                                       const QDomElement &legendElem,

         /**Adds layer and style specific capabilities elements to the parent node. This includes the individual layers and styles, their description, native CRS, bounding boxes, etc.*/
         virtual void layersAndStylesCapabilities( QDomElement& parentElement, QDomDocument& doc ) const;
         virtual void featureTypeList( QDomElement& parentElement, QDomDocument& doc ) const;
         int numberOfLayers() const;
         /**Returns one or possibly several maplayers for a given layer name and style. If no layers/style are found, an empty list is returned*/

src/mapserver/qgsrequesthandler.h
41	41	virtual void sendServiceException( const QgsMapServiceException& ex ) const = 0;
42	42	virtual void sendGetStyleResponse( const QDomDocument& doc ) const = 0;
43	43	virtual void sendGetPrintResponse( QByteArray* ba ) const = 0;
	44	virtual void sendGetFeatureResponse( QByteArray* ba, const QString& infoFormat ) const = 0;
44	45	QString format() const { return mFormat; }
45	46	protected:
46	47	/*This is set by the parseInput methods of the subclasses (parameter FORMAT, e.g. 'FORMAT=PNG')/

         /**Adds layer and style specific capabilities elements to the parent node. This includes the individual layers and styles, their description, native CRS, bounding boxes, etc.*/
         void layersAndStylesCapabilities( QDomElement& parentElement, QDomDocument& doc ) const;
         void featureTypeList( QDomElement& parentElement, QDomDocument& doc ) const {};
         /**Returns number of layers in configuration*/
         int numberOfLayers() const;

         void sendServiceException( const QgsMapServiceException& ex ) const;
         void sendGetStyleResponse( const QDomDocument& doc ) const;
         void sendGetPrintResponse( QByteArray* ba ) const;
         bool startGetFeatureResponse( QByteArray* ba, const QString& infoFormat ) const { return false; };
         void sendGetFeatureResponse( QByteArray* ba ) const {};
         void endGetFeatureResponse( QByteArray* ba ) const {};
       private:
         /**Parses the xml of a getMap request and fills the parameters into the map. Returns 0 in case of success*/
         int parseGetMapElement( std::map<QString, QString>& parameterMap, const QDomElement& getMapElement ) const;

     #include "qgswfsserver.h"
     #include "qgsconfigparser.h"
     #include "qgsepsgcache.h"
     #include "qgsfield.h"
     #include "qgsgeometry.h"
     #include "qgsmaplayer.h"
     #include "qgsmaplayerregistry.h"
     #include "qgsmaprenderer.h"
     #include "qgsmaptopixel.h"
     #include "qgspallabeling.h"
     #include "qgsproject.h"
     #include "qgsrasterlayer.h"
     #include "qgsscalecalculator.h"
     #include "qgscoordinatereferencesystem.h"
     #include "qgsvectordataprovider.h"
     #include "qgsvectorlayer.h"
     #include "qgsfilter.h"
     #include "qgsmapserverlogger.h"
     #include "qgsmapserviceexception.h"
     #include "qgssldparser.h"
     #include "qgssymbol.h"
     #include "qgssymbolv2.h"
     #include "qgsrenderer.h"
     #include "qgslegendmodel.h"
     #include "qgscomposerlegenditem.h"
     #include "qgslogger.h"
     #include "qgsrequesthandler.h"
     #include <QImage>
     #include <QPainter>
     #include <QStringList>
     #include <QTextStream>
     #include <QDir>
     //for printing
     #include "qgscomposition.h"
     #include <QBuffer>
     #include <QPrinter>
     #include <QSvgGenerator>
     #include <QUrl>
     #include <QPaintEngine>
     QgsWFSServer::QgsWFSServer( std::map<QString, QString> parameters )
         : mParameterMap( parameters )
         , mConfigParser( 0 )
+    {
+    }
     QgsWFSServer::~QgsWFSServer()
+    {
+    }
     QgsWFSServer::QgsWFSServer()
+    {
+    }
     QDomDocument QgsWFSServer::getCapabilities()
+    {
       QgsMSDebugMsg( "Entering." );
       QDomDocument doc;
       //wfs:WFS_Capabilities element
       QDomElement wfsCapabilitiesElement = doc.createElement( "WFS_Capabilities"/*wms:WFS_Capabilities*/ );
       wfsCapabilitiesElement.setAttribute( "xmlns", "http://www.opengis.net/wfs" );
       wfsCapabilitiesElement.setAttribute( "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance" );
       wfsCapabilitiesElement.setAttribute( "xsi:schemaLocation", "http://www.opengis.net/wfs http://schemas.opengis.net/wfs/1.0.0/wfs.xsd" );
       wfsCapabilitiesElement.setAttribute( "xmlns:ogc", "http://www.opengis.net/ogc" );
       wfsCapabilitiesElement.setAttribute( "xmlns:gml", "http://www.opengis.net/gml" );
       wfsCapabilitiesElement.setAttribute( "xmlns:ows", "http://www.opengis.net/ows" );
       wfsCapabilitiesElement.setAttribute( "xmlns:xlink", "http://www.w3.org/1999/xlink" );
       wfsCapabilitiesElement.setAttribute( "version", "1.0.0" );
       wfsCapabilitiesElement.setAttribute( "updateSequence", "0" );
       doc.appendChild( wfsCapabilitiesElement );
       if ( mConfigParser )
+      {
         mConfigParser->serviceCapabilities( wfsCapabilitiesElement, doc );
+      }
       //wfs:Capability element
       QDomElement capabilityElement = doc.createElement( "Capability"/*wfs:Capability*/ );
       wfsCapabilitiesElement.appendChild( capabilityElement );
       //wfs:Request element
       QDomElement requestElement = doc.createElement( "Request"/*wfs:Request*/ );
       capabilityElement.appendChild( requestElement );
       //wfs:GetCapabilities
       QDomElement getCapabilitiesElement = doc.createElement( "GetCapabilities"/*wfs:GetCapabilities*/ );
       requestElement.appendChild( getCapabilitiesElement );
       QDomElement capabilitiesFormatElement = doc.createElement( "Format" );/*wfs:Format*/
       getCapabilitiesElement.appendChild( capabilitiesFormatElement );
       QDomText capabilitiesFormatText = doc.createTextNode( "text/xml" );
       capabilitiesFormatElement.appendChild( capabilitiesFormatText );
       QDomElement dcpTypeElement = doc.createElement( "DCPType"/*wfs:DCPType*/ );
       getCapabilitiesElement.appendChild( dcpTypeElement );
       QDomElement httpElement = doc.createElement( "HTTP"/*wfs:HTTP*/ );
       dcpTypeElement.appendChild( httpElement );
       //Prepare url
       //Some client requests already have http://<SERVER_NAME> in the REQUEST_URI variable
       QString hrefString;
       QString requestUrl = getenv( "REQUEST_URI" );
       QUrl mapUrl( requestUrl );
       mapUrl.setHost( QString( getenv( "SERVER_NAME" ) ) );
       mapUrl.removeQueryItem( "REQUEST" );
       mapUrl.removeQueryItem( "VERSION" );
       mapUrl.removeQueryItem( "SERVICE" );
       hrefString = mapUrl.toString();
       //only Get supported for the moment
       QDomElement getElement = doc.createElement( "Get"/*wfs:Get*/ );
       httpElement.appendChild( getElement );
       QDomElement olResourceElement = doc.createElement( "OnlineResource"/*wfs:OnlineResource*/ );
       olResourceElement.setAttribute( "xlink:type", "simple" );
       requestUrl.truncate( requestUrl.indexOf( "?" ) + 1 );
       olResourceElement.setAttribute( "xlink:href", hrefString );
       getElement.appendChild( olResourceElement );
       //wfs:DescribeFeatureType
       QDomElement describeFeatureTypeElement = doc.createElement( "DescribeFeatureType"/*wfs:DescribeFeatureType*/ );
       requestElement.appendChild( describeFeatureTypeElement );
       QDomElement schemaDescriptionLanguageElement = doc.createElement( "SchemaDescriptionLanguage"/*wfs:SchemaDescriptionLanguage*/ );
       describeFeatureTypeElement.appendChild( schemaDescriptionLanguageElement );
       QDomElement xmlSchemaElement = doc.createElement( "XMLSCHEMA"/*wfs:XMLSCHEMA*/ );
       schemaDescriptionLanguageElement.appendChild( xmlSchemaElement );
       QDomElement describeFeatureTypeDhcTypeElement = dcpTypeElement.cloneNode().toElement();//this is the same as for 'GetCapabilities'
       describeFeatureTypeElement.appendChild( describeFeatureTypeDhcTypeElement );
       //wfs:GetFeature
       QDomElement getFeatureElement = doc.createElement( "GetFeature"/*wfs:GetFeature*/ );
       requestElement.appendChild( getFeatureElement );
       QDomElement getFeatureFormatElement = doc.createElement( "ResultFormat" );/*wfs:ResultFormat*/
       getFeatureElement.appendChild( getFeatureFormatElement );
       QDomElement gmlFormatElement = doc.createElement( "GML2" );/*wfs:GML2*/
       getFeatureFormatElement.appendChild( gmlFormatElement );
       QDomElement geojsonFormatElement = doc.createElement( "GeoJSON" );/*wfs:GeoJSON*/
       getFeatureFormatElement.appendChild( geojsonFormatElement );
       QDomElement getFeatureDhcTypeElement = dcpTypeElement.cloneNode().toElement();//this is the same as for 'GetCapabilities'
       getFeatureElement.appendChild( getFeatureDhcTypeElement );
       //wfs:FeatureTypeList element
       QDomElement featureTypeListElement = doc.createElement( "FeatureTypeList"/*wfs:FeatureTypeList*/ );
       capabilityElement.appendChild( featureTypeListElement );
       //wfs:Operations element
       QDomElement operationsElement = doc.createElement( "Operations"/*wfs:Operations*/ );
       featureTypeListElement.appendChild( operationsElement );
       //wfs:Query element
       QDomElement queryElement = doc.createElement( "Query"/*wfs:Query*/ );
       operationsElement.appendChild( queryElement );
       /*
        * Adding layer liste in featureTypeListElement
        */
       if ( mConfigParser )
+      {
         mConfigParser->featureTypeList( featureTypeListElement, doc );
+      }
       /*
        * Adding ogc:Filter_Capabilities in capabilityElement
        */
       //ogc:Filter_Capabilities element
       QDomElement filterCapabilitiesElement = doc.createElement( "ogc:Filter_Capabilities"/*ogc:Filter_Capabilities*/ );
       capabilityElement.appendChild( filterCapabilitiesElement );
       QDomElement spatialCapabilitiesElement = doc.createElement( "ogc:Spatial_Capabilities"/*ogc:Spatial_Capabilities*/ );
       filterCapabilitiesElement.appendChild( spatialCapabilitiesElement );
       QDomElement spatialOperatorsElement = doc.createElement( "ogc:Spatial_Operators"/*ogc:Spatial_Operators*/ );
       spatialCapabilitiesElement.appendChild( spatialOperatorsElement );
       QDomElement ogcBboxElement = doc.createElement( "ogc:BBOX"/*ogc:BBOX*/ );
       spatialOperatorsElement.appendChild( ogcBboxElement );
       QDomElement scalarCapabilitiesElement = doc.createElement( "ogc:Scalar_Capabilities"/*ogc:Scalar_Capabilities*/ );
       filterCapabilitiesElement.appendChild( scalarCapabilitiesElement );
       QDomElement comparisonOperatorsElement = doc.createElement( "ogc:Comparison_Operators"/*ogc:Comparison_Operators*/ );
       scalarCapabilitiesElement.appendChild( comparisonOperatorsElement );
       QDomElement simpleComparisonsElement = doc.createElement( "ogc:Simple_Comparisons"/*ogc:Simple_Comparisons*/ );
       comparisonOperatorsElement.appendChild( simpleComparisonsElement );
       return doc;
+    }
     QDomDocument QgsWFSServer::describeFeatureType()
+    {
       QgsMSDebugMsg( "Entering." );
       QDomDocument doc;
       //xsd:schema
       QDomElement schemaElement = doc.createElement( "schema"/*xsd:schema*/ );
       schemaElement.setAttribute( "xmlns", "http://www.w3.org/2001/XMLSchema" );
       schemaElement.setAttribute( "xmlns:xsd", "http://www.w3.org/2001/XMLSchema" );
       schemaElement.setAttribute( "xmlns:ogc", "http://www.opengis.net/ogc" );
       schemaElement.setAttribute( "xmlns:gml", "http://www.opengis.net/gml" );
       schemaElement.setAttribute( "xmlns:qgs", "http://www.qgis.org/gml" );
       schemaElement.setAttribute( "targetNamespace", "http://www.qgis.org/gml" );
       doc.appendChild( schemaElement );
       //xsd:import
       QDomElement importElement = doc.createElement( "import"/*xsd:import*/ );
       importElement.setAttribute( "namespace", "http://www.opengis.net/gml" );
       importElement.setAttribute( "schemaLocation", "http://schemas.opengis.net/gml/2.1.2/feature.xsd" );
       schemaElement.appendChild( importElement );
       //read TYPENAME
       QString typeName;
       std::map<QString, QString>::const_iterator type_name_it = mParameterMap.find( "TYPENAME" );
       if ( type_name_it != mParameterMap.end() )
+      {
         typeName = type_name_it->second;
+      }
       else
+      {
         return doc;
+      }
       QStringList nonIdentifiableLayers = mConfigParser->identifyDisabledLayers();
       QMap< QString, QMap< int, QString > > aliasInfo = mConfigParser->layerAliasInfo();
       QMap< QString, QSet<QString> > hiddenAttributes = mConfigParser->hiddenAttributes();
       QList<QgsMapLayer*> layerList;
       QgsMapLayer* currentLayer = 0;
       layerList = mConfigParser->mapLayerFromStyle( typeName, "" );
       currentLayer = layerList.at( 0 );
       QgsVectorLayer* layer = dynamic_cast<QgsVectorLayer*>( currentLayer );
       if ( layer )
+      {
         //is there alias info for this vector layer?
         QMap< int, QString > layerAliasInfo;
         QMap< QString, QMap< int, QString > >::const_iterator aliasIt = aliasInfo.find( currentLayer->id() );
         if ( aliasIt != aliasInfo.constEnd() )
+        {
           layerAliasInfo = aliasIt.value();
+        }
         //hidden attributes for this layer
         QSet<QString> layerHiddenAttributes;
         QMap< QString, QSet<QString> >::const_iterator hiddenIt = hiddenAttributes.find( currentLayer->id() );
         if ( hiddenIt != hiddenAttributes.constEnd() )
+        {
           layerHiddenAttributes = hiddenIt.value();
+        }
         //do a select with searchRect and go through all the features
         QgsVectorDataProvider* provider = layer->dataProvider();
         if ( !provider )
+        {
           return doc;
+        }
         typeName = typeName.replace( QString(" "), QString("_") );
         //xsd:element
         QDomElement elementElem = doc.createElement( "element"/*xsd:element*/ );
         elementElem.setAttribute( "name", typeName );
         elementElem.setAttribute( "type", "qgs:" + typeName + "Type" );
         elementElem.setAttribute( "substitutionGroup", "gml:_Feature" );
         schemaElement.appendChild( elementElem );
         //xsd:complexType
         QDomElement complexTypeElem = doc.createElement( "complexType"/*xsd:complexType*/ );
         complexTypeElem.setAttribute( "name", typeName + "Type" );
         schemaElement.appendChild( complexTypeElem );
         //xsd:complexType
         QDomElement complexContentElem = doc.createElement( "complexContent"/*xsd:complexContent*/ );
         complexTypeElem.appendChild( complexContentElem );
         //xsd:extension
         QDomElement extensionElem = doc.createElement( "extension"/*xsd:extension*/ );
         extensionElem.setAttribute( "base", "gml:AbstractFeatureType" );
         complexContentElem.appendChild( extensionElem );
         //xsd:sequence
         QDomElement sequenceElem = doc.createElement( "sequence"/*xsd:sequence*/ );
         extensionElem.appendChild( sequenceElem );
         //xsd:element
         QDomElement geomElem = doc.createElement( "element"/*xsd:element*/ );
         geomElem.setAttribute( "name", "geometry" );
         geomElem.setAttribute( "type", "gml:GeometryPropertyType" );
         geomElem.setAttribute( "minOccurs", "0" );
         geomElem.setAttribute( "maxOccurs", "1" );
         sequenceElem.appendChild( geomElem );
         const QgsFieldMap& fields = provider->fields();
         for ( QgsFieldMap::const_iterator it = fields.begin(); it != fields.end(); ++it )
+        {
           QString attributeName = it.value().name();
           //skip attribute if it has edit type 'hidden'
           if ( layerHiddenAttributes.contains( attributeName ) )
+          {
             continue;
+          }
           //check if the attribute name should be replaced with an alias
           QMap<int, QString>::const_iterator aliasIt = layerAliasInfo.find( it.key() );
           if ( aliasIt != layerAliasInfo.constEnd() )
+          {
             attributeName = aliasIt.value();
+          }
           //xsd:element
           QDomElement geomElem = doc.createElement( "element"/*xsd:element*/ );
           geomElem.setAttribute( "name", attributeName );
           if ( it.value().type() == 2 )
             geomElem.setAttribute( "type", "integer" );
           else if ( it.value().type() == 6 )
             geomElem.setAttribute( "type", "double" );
           else
             geomElem.setAttribute( "type", "string" );
           sequenceElem.appendChild( geomElem );
+        }
+      }
       return doc;
+    }
     int QgsWFSServer::getFeature( QgsRequestHandler& request, const QString& format )
+    {
       QByteArray result;
       QgsMSDebugMsg( "Info format is:" + infoFormat );
       //read TYPENAME
       QString typeName;
       std::map<QString, QString>::const_iterator type_name_it = mParameterMap.find( "TYPENAME" );
       if ( type_name_it != mParameterMap.end() )
+      {
         typeName = type_name_it->second;
+      }
       else
+      {
         return 1;
+      }
       QStringList nonIdentifiableLayers = mConfigParser->identifyDisabledLayers();
       QMap< QString, QMap< int, QString > > aliasInfo = mConfigParser->layerAliasInfo();
       QMap< QString, QSet<QString> > hiddenAttributes = mConfigParser->hiddenAttributes();
       QList<QgsMapLayer*> layerList;
       QgsMapLayer* currentLayer = 0;
       layerList = mConfigParser->mapLayerFromStyle( typeName, "" );
       currentLayer = layerList.at( 0 );
       QgsVectorLayer* layer = dynamic_cast<QgsVectorLayer*>( currentLayer );
       if ( layer )
+      {
         //is there alias info for this vector layer?
         QMap< int, QString > layerAliasInfo;
         QMap< QString, QMap< int, QString > >::const_iterator aliasIt = aliasInfo.find( currentLayer->id() );
         if ( aliasIt != aliasInfo.constEnd() )
+        {
           layerAliasInfo = aliasIt.value();
+        }
         //hidden attributes for this layer
         QSet<QString> layerHiddenAttributes;
         QMap< QString, QSet<QString> >::const_iterator hiddenIt = hiddenAttributes.find( currentLayer->id() );
         if ( hiddenIt != hiddenAttributes.constEnd() )
+        {
           layerHiddenAttributes = hiddenIt.value();
+        }
         //do a select with searchRect and go through all the features
         QgsVectorDataProvider* provider = layer->dataProvider();
         if ( !provider )
+        {
           return 2;
+        }
         QgsFeature feature;
         QgsAttributeMap featureAttributes;
         const QgsFieldMap& fields = provider->fields();
         //map extent
         QgsRectangle searchRect = layer->extent();
         //read FEATUREDID
         bool fidOk = false;
         QString fid;
         std::map<QString, QString>::const_iterator fidIt = mParameterMap.find( "FEATUREID" );
         if ( fidIt != mParameterMap.end() ) {
           fidOk = true;
           fid = fidIt->second;
+        }
         //read FILTER
         bool filterOk = false;
         QDomDocument filter;
         std::map<QString, QString>::const_iterator filterIt = mParameterMap.find( "FILTER" );
         if ( filterIt != mParameterMap.end() ) {
           try {
           QString errorMsg;
           if ( !filter.setContent( filterIt->second, true, &errorMsg ) )
+          {
             QgsMSDebugMsg( "soap request parse error" );
             QgsMSDebugMsg( "error message: " + errorMsg );
             QgsMSDebugMsg( "the xml string was:" );
             QgsMSDebugMsg( filterIt->second );
+          }
           else
+          {
             filterOk = true;
+          }
           } catch(QgsMapServiceException& e ) {
             filterOk = false;
+          }
+        }
         //read BBOX
         bool conversionSuccess;
         double minx, miny, maxx, maxy;
         bool bboxOk = false;
         std::map<QString, QString>::const_iterator bbIt = mParameterMap.find( "BBOX" );
         if ( bbIt == mParameterMap.end() )
+        {
           minx = 0; miny = 0; maxx = 0; maxy = 0;
+        }
         else
+        {
           bboxOk = true;
           QString bbString = bbIt->second;
           minx = bbString.section( ",", 0, 0 ).toDouble( &conversionSuccess );
           if ( !conversionSuccess ) {bboxOk = false;}
           miny = bbString.section( ",", 1, 1 ).toDouble( &conversionSuccess );
           if ( !conversionSuccess ) {bboxOk = false;}
           maxx = bbString.section( ",", 2, 2 ).toDouble( &conversionSuccess );
           if ( !conversionSuccess ) {bboxOk = false;}
           maxy = bbString.section( ",", 3, 3 ).toDouble( &conversionSuccess );
           if ( !conversionSuccess ) {bboxOk = false;}
+        }
         //read MAXFEATURES
         long maxFeat = layer->featureCount();
         long featureCounter = 0;
         std::map<QString, QString>::const_iterator mfIt = mParameterMap.find( "MAXFEATURES" );
         if ( mfIt != mParameterMap.end() )
+        {
            QString mfString = mfIt->second;;
            bool mfOk;
            maxFeat = mfString.toLong(&mfOk, 10);
            if ( !mfOk ) { maxFeat = layer->featureCount(); }
+        }
         QList<QgsFeature> featureList;
         if ( fidOk )
+        {
           provider->featureAtId(  fid.toInt(), feature, true, provider->attributeIndexes() );
           featureList.append(feature);
+        }
         else if ( filterOk )
+        {
           provider->select( provider->attributeIndexes(), searchRect, true, true );
           try {
             QgsFilter* mFilter = QgsFilter::createFilterFromXml( filter.firstChild().toElement().firstChild().toElement(), layer );
             while ( provider->nextFeature( feature ) && featureCounter < maxFeat)
+            {
               if ( mFilter )
+              {
                 if ( mFilter->evaluate( feature ) )
+                {
                   featureList.append(feature);
                   ++featureCounter;
+                }
+              }
               else
+              {
                 featureList.append(feature);
                 ++featureCounter;
+              }
+            }
             delete mFilter;
           } catch(QgsMapServiceException& e ) {
             while ( provider->nextFeature( feature )  && featureCounter < maxFeat)
+            {
               featureList.append(feature);
               ++featureCounter;
+            }
+          }
+        }
         else
+        {
           if ( bboxOk )
             searchRect.set( minx, miny, maxx, maxy );
           provider->select( provider->attributeIndexes(), searchRect, true, true );
           while ( provider->nextFeature( feature )  && featureCounter < maxFeat )
+          {
             featureList.append(feature);
             ++featureCounter;
+          }
+        }
         QList<QgsFeature>::const_iterator featureIt = featureList.constBegin();
         QString fcString;
         if ( format == "GeoJSON" )
+        {
           featureCounter = 0;
           fcString = "{\"type\": \"FeatureCollection\",\n";
           fcString += " \"features\": [\n";
           result = fcString.toUtf8();
           request.startGetFeatureResponse(&result, format);
           fcString = "";
           for ( ; featureIt != featureList.constEnd(); ++featureIt )
+          {
             feature = *featureIt;
             if (featureCounter == 0)
               fcString += "  {\"type\": \"Feature\",\n";
             else
               fcString += " ,{\"type\": \"Feature\",\n";
             fcString += "   \"id\": ";
             fcString +=  QString::number( feature.id() );
             fcString += ",\n";
             QgsGeometry* geom = feature.geometry();
             if ( geom )
+            {
               fcString += "  \"geometry\": ";
               fcString += geom->exportToGeoJSON();
               fcString += ",\n";
+            }
             fcString += "   \"properties\": {\n";
             //read all attribute values from the feature
             featureAttributes = feature.attributeMap();
             int attributeCounter = 0;
             for ( QgsAttributeMap::const_iterator it = featureAttributes.begin(); it != featureAttributes.end(); ++it )
+            {
               QString attributeName = fields[it.key()].name();
               //skip attribute if it has edit type 'hidden'
               if ( layerHiddenAttributes.contains( attributeName ) )
+              {
                 continue;
+              }
               //check if the attribute name should be replaced with an alias
               QMap<int, QString>::const_iterator aliasIt = layerAliasInfo.find( it.key() );
               if ( aliasIt != layerAliasInfo.constEnd() )
+              {
                 attributeName = aliasIt.value();
+              }
               if (attributeCounter == 0)
                 fcString += "    \"";
               else
                 fcString += "   ,\"";
               fcString += attributeName;
               fcString += "\": ";
               if (it->type() == 6 || it->type() == 2)
+              {
                 fcString +=  it->toString();
+              }
               else
+              {
                 fcString += "\"";
                 fcString +=  it->toString().replace( QString( "\"" ), QString( "\\\"" ) );
                 fcString += "\"";
+              }
               fcString += "\n";
               ++attributeCounter;
+            }
             fcString += "   }\n";
             fcString += "  }";
             fcString += "\n";
             result = fcString.toUtf8();
             request.sendGetFeatureResponse( &result );
             fcString = "";
             ++featureCounter;
+          }
           fcString = "";
           fcString += " ]\n";
           fcString += "}";
           result = fcString.toUtf8();
           request.endGetFeatureResponse( &result );
           fcString = "";
+        }
         else
+        {
           QDomDocument gmlDoc;
           //wfs:FeatureCollection
           fcString = "<wfs:FeatureCollection";
           fcString += " xmlns=\"http://www.opengis.net/wfs\"";
           fcString += " xmlns:wfs=\"http://www.opengis.net/wfs\"";
           fcString += " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"";
           fcString += " xsi:schemaLocation=\"http://www.opengis.net/wfs http://schemas.opengis.net/wfs/1.0.0/wfs.xsd\"";
           fcString += " xmlns:ogc=\"http://www.opengis.net/ogc\"";
           fcString += " xmlns:gml=\"http://www.opengis.net/gml\"";
           fcString += " xmlns:ows=\"http://www.opengis.net/ows\"";
           fcString += " xmlns:xlink=\"http://www.w3.org/1999/xlink\"";
           fcString += " xmlns:qgs=\"http://www.qgis.org/gml\"";
           fcString += ">";
           result = fcString.toUtf8();
           request.startGetFeatureResponse(&result, format);
           fcString = "";
           for ( ; featureIt != featureList.constEnd(); ++featureIt )
+          {
             feature = *featureIt;
             //gml:FeatureMember
             QDomElement featureElement = gmlDoc.createElement( "gml:featureMember"/*wfs:FeatureMember*/ );
             gmlDoc.appendChild(featureElement);
             //qgs:%TYPENAME%
             QDomElement typeNameElement = gmlDoc.createElement( "qgs:"+typeName.replace( QString(" "), QString("_") )/*qgs:%TYPENAME%*/ );
             typeNameElement.setAttribute( "fid", QString::number( feature.id() ) );
             featureElement.appendChild(typeNameElement);
             //add geometry column (as gml)
             QDomElement geomElem = gmlDoc.createElement( "qgs:geometry" );
             QDomElement gmlElem = createGeometryElem( feature.geometry(), gmlDoc );
             if ( !gmlElem.isNull() )
+            {
               QgsCoordinateReferenceSystem layerCrs = layer->crs();
               if ( layerCrs.isValid() )
+              {
                 gmlElem.setAttribute( "srsName", layerCrs.authid() );
+              }
               geomElem.appendChild( gmlElem );
               typeNameElement.appendChild( geomElem );
+            }
             //read all attribute values from the feature
             featureAttributes = feature.attributeMap();
             for ( QgsAttributeMap::const_iterator it = featureAttributes.begin(); it != featureAttributes.end(); ++it )
+            {
               QString attributeName = fields[it.key()].name();
               //skip attribute if it has edit type 'hidden'
               if ( layerHiddenAttributes.contains( attributeName ) )
+              {
                 continue;
+              }
               //check if the attribute name should be replaced with an alias
               QMap<int, QString>::const_iterator aliasIt = layerAliasInfo.find( it.key() );
               if ( aliasIt != layerAliasInfo.constEnd() )
+              {
                 attributeName = aliasIt.value();
+              }
               QDomElement fieldElem = gmlDoc.createElement( "qgs:"+attributeName );
               QDomText fieldText = gmlDoc.createTextNode( it->toString() );
               fieldElem.appendChild( fieldText );
               typeNameElement.appendChild( fieldElem );
+            }
             result = gmlDoc.toByteArray();
             request.sendGetFeatureResponse( &result );
             gmlDoc.removeChild(featureElement);
+          }
           fcString = "</wfs:FeatureCollection>";
           result = fcString.toUtf8();
           request.endGetFeatureResponse( &result );
           fcString = "";
+        }
+      }
       else
+      {
         return 2;
+      }
       return 0;
+    }
     QDomElement QgsWFSServer::createGeometryElem( QgsGeometry* geom, QDomDocument& doc ) /*const*/
+    {
       if ( !geom )
+      {
         return QDomElement();
+      }
       QDomElement geomElement;
       QString geomTypeName;
       QGis::WkbType wkbType = geom->wkbType();
       switch ( wkbType )
+      {
         case QGis::WKBPoint:
         case QGis::WKBPoint25D:
           geomElement = createPointElem( geom, doc );
           break;
         case QGis::WKBMultiPoint:
         case QGis::WKBMultiPoint25D:
           geomElement = createMultiPointElem( geom, doc );
           break;
         case QGis::WKBLineString:
         case QGis::WKBLineString25D:
           geomElement = createLineStringElem( geom, doc );
           break;
         case QGis::WKBMultiLineString:
         case QGis::WKBMultiLineString25D:
           geomElement = createMultiLineStringElem( geom, doc );
           break;
         case QGis::WKBPolygon:
         case QGis::WKBPolygon25D:
           geomElement = createPolygonElem( geom, doc );
           break;
         case QGis::WKBMultiPolygon:
         case QGis::WKBMultiPolygon25D:
           geomElement = createMultiPolygonElem( geom, doc );
           break;
         default:
           return QDomElement();
+      }
       return geomElement;
+    }
     QDomElement QgsWFSServer::createLineStringElem( QgsGeometry* geom, QDomDocument& doc ) const
+    {
       if ( !geom )
+      {
         return QDomElement();
+      }
       QDomElement lineStringElem = doc.createElement( "gml:LineString" );
       QDomElement coordElem = createCoordinateElem( geom->asPolyline(), doc );
       lineStringElem.appendChild( coordElem );
       return lineStringElem;
+    }
     QDomElement QgsWFSServer::createMultiLineStringElem( QgsGeometry* geom, QDomDocument& doc ) const
+    {
       if ( !geom )
+      {
         return QDomElement();
+      }
       QDomElement multiLineStringElem = doc.createElement( "gml:MultiLineString" );
       QgsMultiPolyline multiline = geom->asMultiPolyline();
       QgsMultiPolyline::const_iterator multiLineIt = multiline.constBegin();
       for ( ; multiLineIt != multiline.constEnd(); ++multiLineIt )
+      {
         QgsGeometry* lineGeom = QgsGeometry::fromPolyline( *multiLineIt );
         if ( lineGeom )
+        {
           QDomElement lineStringMemberElem = doc.createElement( "gml:lineStringMember" );
           QDomElement lineElem = createLineStringElem( lineGeom, doc );
           lineStringMemberElem.appendChild( lineElem );
           multiLineStringElem.appendChild( lineStringMemberElem );
+        }
         delete lineGeom;
+      }
       return multiLineStringElem;
+    }
     QDomElement QgsWFSServer::createPointElem( QgsGeometry* geom, QDomDocument& doc ) const
+    {
       if ( !geom )
+      {
         return QDomElement();
+      }
       QDomElement pointElem = doc.createElement( "gml:Point" );
       QgsPoint p = geom->asPoint();
       QVector<QgsPoint> v;
       v.append( p );
       QDomElement coordElem = createCoordinateElem( v, doc );
       pointElem.appendChild( coordElem );
       return pointElem;
+    }
     QDomElement QgsWFSServer::createMultiPointElem( QgsGeometry* geom, QDomDocument& doc ) const
+    {
       if ( !geom )
+      {
         return QDomElement();
+      }
       QDomElement multiPointElem = doc.createElement( "gml:MultiPoint" );
       QgsMultiPoint multiPoint = geom->asMultiPoint();
       QgsMultiPoint::const_iterator multiPointIt = multiPoint.constBegin();
       for ( ; multiPointIt != multiPoint.constEnd(); ++multiPointIt )
+      {
         QgsGeometry* pointGeom = QgsGeometry::fromPoint( *multiPointIt );
         if ( pointGeom )
+        {

... This diff was truncated because it exceeds the maximum size that can be displayed.

QGIS » QGIS Application

wfs-server-1_7.patch