//try the new and faster method with the expat parser

#if 0

int QgsWFSProvider::getExtentFromGML3(QgsRect* extent, const QDomElement& wfsCollectionElement) const

{

QDomNodeList boundedByList = wfsCollectionElement.elementsByTagNameNS(GML_NAMESPACE, "boundedBy");

if(boundedByList.length() < 1)

{

return 1;

}

QDomElement boundedByElement = boundedByList.at(0).toElement();

QDomNode childNode = boundedByElement.firstChild();

if(childNode.isNull())

{

return 2;

}

//support <gml:Box>, <gml:coordinates> and <gml:Envelope>,<gml::lowerCorner>,<gml::upperCorner>. What

//about <gml:Envelope>, <gml:pos>?

QString bboxName = childNode.localName();

if(bboxName == "Envelope")

{

QDomElement envelopeElement = childNode.toElement();

QDomNodeList posList = envelopeElement.elementsByTagNameNS(GML_NAMESPACE, "pos");

if(posList.size() < 2)

{

return 3;

}

QDomElement llPosElement = posList.at(0).toElement();

QStringList llStringList = llPosElement.text().split(" ", QString::SkipEmptyParts);

QDomElement urPosElement = posList.at(1).toElement();

QStringList urStringList = urPosElement.text().split(" ", QString::SkipEmptyParts);

if(llStringList.size() < 2 || urStringList.size() < 2)

{

return 4;

}

bool conversionSuccess;

double xLeft = llStringList.at(0).toDouble(&conversionSuccess);

if(!conversionSuccess){return 5;}

double yLow = llStringList.at(1).toDouble(&conversionSuccess);

if(!conversionSuccess){return 5;}

double xRight = urStringList.at(0).toDouble(&conversionSuccess);

if(!conversionSuccess){return 5;}

double yUp = urStringList.at(1).toDouble(&conversionSuccess);

if(!conversionSuccess){return 5;}

extent->setXmin(xLeft);

extent->setYmin(yLow);

extent->setXmax(xRight);

extent->setYmax(yUp);

}

else if(bboxName == "Box")

{

QDomElement boxElement = childNode.toElement();

QDomNodeList coordinatesList = boxElement.elementsByTagNameNS(GML_NAMESPACE, "coordinates");

if(coordinatesList.length() < 1)

{

return 11;

}

QStringList coordinatesStringList = coordinatesList.at(0).toElement().text().split(" ", QString::SkipEmptyParts);

if(coordinatesStringList.size() < 2)

{

return 12;

}

QStringList lowCoordinateList = coordinatesStringList.at(0).split(",", QString::SkipEmptyParts);

if(lowCoordinateList.size() < 2)

{

return 13;

}

bool conversionSuccess;

double xLow = lowCoordinateList.at(0).toDouble(&conversionSuccess);

if(conversionSuccess)

{

extent->setXmin(xLow);

}

else

{

return 14;

}

double yLow = lowCoordinateList.at(1).toDouble(&conversionSuccess);

if(conversionSuccess)

{

extent->setYmin(yLow);

}

else

{

return 15;

}

QStringList upCoordinateList = coordinatesStringList.at(1).split(",", QString::SkipEmptyParts);

if(upCoordinateList.size() < 2)

{

return 16;

}

double xUp = upCoordinateList.at(0).toDouble(&conversionSuccess);

if(conversionSuccess)

{

extent->setXmax(xUp);

}

else

{

return 17;

}

double yUp = upCoordinateList.at(1).toDouble(&conversionSuccess);

if(conversionSuccess)

{

extent->setYmax(yUp);

}

else

{

return 18;

}

}

return 0;

}

int QgsWFSProvider::getFeaturesFromGML3(const QDomElement& wfsCollectionElement, const QString& geometryAttribute, std::vector<QgsFeature*>& features) const

{

QDomNodeList featureTypeNodeList = wfsCollectionElement.elementsByTagNameNS(GML_NAMESPACE, "featureMember");

QDomElement currentFeatureMemberElem;

QDomElement layerNameElem;

QDomNode currentAttributeChild;

QDomElement currentAttributeElement;

int counter = 0;

QgsFeature* f = 0;

unsigned char* wkb = 0;

int wkbSize = 0;

QGis::WKBTYPE currentType;

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

{

f = new QgsFeature(counter);

currentFeatureMemberElem = featureTypeNodeList.at(i).toElement();

//the first child element is always <namespace:layer>

layerNameElem = currentFeatureMemberElem.firstChild().toElement();

//the children are the attributes

currentAttributeChild = layerNameElem.firstChild();

while(!currentAttributeChild.isNull())

{

currentAttributeElement = currentAttributeChild.toElement();

if(currentAttributeElement.localName() != "boundedBy")

{

if((currentAttributeElement.localName()) != geometryAttribute) //a normal attribute

{

f->addAttribute(currentAttributeElement.localName(), currentAttributeElement.text(), false);

}

else //a geometry attribute

{

getWkbFromGML3(currentAttributeElement, &wkb, &wkbSize, &currentType);

mWKBType = currentType; //a more sophisticated method is necessary

f->setGeometryAndOwnership(wkb, wkbSize);

}

}

currentAttributeChild = currentAttributeChild.nextSibling();

}

if(wkb && wkbSize > 0)

{

features.push_back(f);

}

++counter;

}

return 1;

}

int QgsWFSProvider::getWkbFromGML3(const QDomNode& geometryElement, unsigned char** wkb, int* wkbSize, QGis::WKBTYPE* type) const

{

QDomNode geometryChild = geometryElement.firstChild();

if(geometryChild.isNull())

{

return 1;

}

QDomElement geometryTypeElement = geometryChild.toElement();

QString geomType = geometryTypeElement.localName();

if(geomType == "Point")

{

return getWkbFromGML3Point(geometryTypeElement, wkb, wkbSize, type);

}

else if(geomType == "Polygon")

{

return getWkbFromGML3Polygon(geometryTypeElement, wkb, wkbSize, type);

}

else if(geomType == "LineString")

{

return getWkbFromGML3LineString(geometryTypeElement, wkb, wkbSize, type);

}

else if(geomType == "MultiCurve")

{

return getWkbFromGML3MultiCurve(geometryTypeElement, wkb, wkbSize, type);

}

else if(geomType == "MultiSurface")

{

return getWkbFromGML3MultiSurface(geometryTypeElement, wkb, wkbSize, type);

}

else //unknown type

{

*wkb = 0;

*wkbSize = 0;

}

return 0;

}

int QgsWFSProvider::getWkbFromGML3Point(const QDomElement& geometryElement, unsigned char** wkb, int* wkbSize, QGis::WKBTYPE* type) const

{

QDomNodeList posList = geometryElement.elementsByTagNameNS(GML_NAMESPACE, "pos");

if(posList.size() < 1)

{

return 1;

}

QDomElement posElement = posList.at(0).toElement();

std::list<QgsPoint> pointCoordinate;

if(readCoordinatesFromPosList(pointCoordinate, posElement) != 0)

{

return 2;

}

if(pointCoordinate.size() < 1)

{

return 3;

}

std::list<QgsPoint>::const_iterator point_it = pointCoordinate.begin();

char e = QgsApplication::endian();

double x = point_it->x();

double y = point_it->y();

int size = 1 + sizeof(int) + 2 * sizeof(double);

*wkb = new unsigned char[size];

*wkbSize = size;

*type = QGis::WKBPoint;

int wkbPosition = 0; //current offset from wkb beginning (in bytes)

memcpy(&(*wkb)[wkbPosition], &e, 1);

wkbPosition += 1;

memcpy(&(*wkb)[wkbPosition], type, sizeof(int));

wkbPosition += sizeof(int);

memcpy(&(*wkb)[wkbPosition], &x, sizeof(double));

wkbPosition += sizeof(double);

memcpy(&(*wkb)[wkbPosition], &y, sizeof(double));

return 0;

}

int QgsWFSProvider::getWkbFromGML3LineString(const QDomElement& geometryElement, unsigned char** wkb, int* wkbSize, QGis::WKBTYPE* type) const

{

QDomNodeList posList = geometryElement.elementsByTagNameNS(GML_NAMESPACE, "posList");

if(posList.size() < 1)

{

return 1;

}

QDomElement posListElement = posList.at(0).toElement();

std::list<QgsPoint> lineCoordinates;

if(readCoordinatesFromPosList(lineCoordinates, posListElement) != 0)

{

return 2;

}

char e = QgsApplication::endian();

int size = 1 + 2 * sizeof(int) + lineCoordinates.size() * 2* sizeof(double);

*wkb = new unsigned char[size];

*wkbSize = size;

*type = QGis::WKBLineString;

int wkbPosition = 0; //current offset from wkb beginning (in bytes)

double x, y;

int nPoints = lineCoordinates.size();

//fill the contents into *wkb

memcpy(&(*wkb)[wkbPosition], &e, 1);

wkbPosition += 1;

memcpy(&(*wkb)[wkbPosition], type, sizeof(int));

wkbPosition += sizeof(int);

memcpy(&(*wkb)[wkbPosition], &nPoints, sizeof(int));

wkbPosition += sizeof(int);

std::list<QgsPoint>::const_iterator iter;

for(iter = lineCoordinates.begin(); iter != lineCoordinates.end(); ++iter)

{

x = iter->x();

y = iter->y();

memcpy(&(*wkb)[wkbPosition], &x, sizeof(double));

wkbPosition += sizeof(double);

memcpy(&(*wkb)[wkbPosition], &y, sizeof(double));

wkbPosition += sizeof(double);

}

return 0;

}

int QgsWFSProvider::getWkbFromGML3Polygon(const QDomElement& geometryElement, unsigned char** wkb, int* wkbSize, QGis::WKBTYPE* type) const

{

QDomNodeList exteriorList = geometryElement.elementsByTagNameNS(GML_NAMESPACE, "exterior");

if(exteriorList.size() < 1) //exterior ring is necessary

{

return 1;

}

//then take the <gml:interior> elements into account

QDomNodeList interiorList = geometryElement.elementsByTagNameNS(GML_NAMESPACE, "interior");

//read all the coordinates (as QgsPoint) into memory. Each linear ring has an entry in the vector

std::vector<std::list<QgsPoint> > ringCoordinates;

//exterior ring

QDomElement posListElement = exteriorList.at(0).firstChild().firstChild().toElement();

std::list<QgsPoint> exteriorPointList;

if(readCoordinatesFromPosList(exteriorPointList, posListElement) != 0)

{

return 2;

}

ringCoordinates.push_back(exteriorPointList);

//interior rings

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

{

posListElement = interiorList.at(i).firstChild().firstChild().toElement();

std::list<QgsPoint> interiorPointList;

if(readCoordinatesFromPosList(interiorPointList, posListElement) != 0)

{

return 3;

}

ringCoordinates.push_back(interiorPointList);

}

//calculate number of bytes to allocate

int nrings = 1 + interiorList.size();

int npoints = 0;//total number of points

for(std::vector<std::list<QgsPoint> >::const_iterator it = ringCoordinates.begin(); it != ringCoordinates.end(); ++it)

{

npoints += it->size();

}

int size = 1 + 2 * sizeof(int) + nrings * sizeof(int) + 2 * npoints * sizeof(double);

*wkb = new unsigned char[size];

*wkbSize = size;

*type = QGis::WKBPolygon;

char e = QgsApplication::endian();

int wkbPosition = 0; //current offset from wkb beginning (in bytes)

int nPointsInRing = 0;

double x, y;

//fill the contents into *wkb

memcpy(&(*wkb)[wkbPosition], &e, 1);

wkbPosition += 1;

memcpy(&(*wkb)[wkbPosition], type, sizeof(int));

wkbPosition += sizeof(int);

memcpy(&(*wkb)[wkbPosition], &nrings, sizeof(int));

wkbPosition += sizeof(int);

for(std::vector<std::list<QgsPoint> >::const_iterator it = ringCoordinates.begin(); it != ringCoordinates.end(); ++it)

{

nPointsInRing = it->size();

memcpy(&(*wkb)[wkbPosition], &nPointsInRing, sizeof(int));

wkbPosition += sizeof(int);

//iterate through the string list converting the strings to x-/y- doubles

std::list<QgsPoint>::const_iterator iter;

for(iter = it->begin(); iter != it->end(); ++iter)

{

x = iter->x();

y = iter->y();

//qWarning("currentCoordinate: " + QString::number(x) + " // " + QString::number(y));

memcpy(&(*wkb)[wkbPosition], &x, sizeof(double));

wkbPosition += sizeof(double);

memcpy(&(*wkb)[wkbPosition], &y, sizeof(double));

wkbPosition += sizeof(double);

}

}

return 0;

}

int QgsWFSProvider::getWkbFromGML3MultiSurface(const QDomElement& geometryElement, unsigned char** wkb, int* wkbSize, QGis::WKBTYPE* type) const

{

//get <surfaceMembers> tag

QDomNodeList surfaceMembersList = geometryElement.elementsByTagNameNS(GML_NAMESPACE, "surfaceMembers");

if(surfaceMembersList.size() < 1)

{

return 1;

}

QDomElement surfaceMembersElement = surfaceMembersList.at(0).toElement();

QDomNodeList polygonNodeList = surfaceMembersElement.elementsByTagNameNS(GML_NAMESPACE, "Polygon");

//first list: different polygons, second list: different rings, third list: different points

std::list<std::list<std::list<QgsPoint> > > multiPolygonPoints;

QDomNodeList exteriorNodeList;

QDomElement currentExteriorElement;

QDomNodeList interiorNodeList;

QDomElement currentInteriorElement;

QDomNodeList linearRingNodeList;

QDomElement linearRingElement;

QDomNodeList posListNodeList;

QDomElement posListElement;

QDomElement currentPolygonElement;

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

{

currentPolygonElement = polygonNodeList.at(i).toElement();

std::list<std::list<QgsPoint> > currentPolygonList;

//find exterior ring

exteriorNodeList = currentPolygonElement.elementsByTagNameNS(GML_NAMESPACE, "exterior");

for(int i = 0; i < exteriorNodeList.size(); ++i) //normally only one

{

currentExteriorElement = exteriorNodeList.at(i).toElement();

linearRingNodeList = currentExteriorElement.elementsByTagNameNS(GML_NAMESPACE, "LinearRing");

if(linearRingNodeList.size() < 1)

{

continue;

}

linearRingElement = linearRingNodeList.at(i).toElement();

posListNodeList = linearRingElement.elementsByTagNameNS(GML_NAMESPACE, "posList");

if(posListNodeList.size() < 1)

{

continue;

}

posListElement = posListNodeList.at(i).toElement();

std::list<QgsPoint> ringCoordinates;

if(readCoordinatesFromPosList(ringCoordinates, posListElement) != 0)

{

continue;

}

currentPolygonList.push_back(ringCoordinates);

}

//find interior rings

interiorNodeList = currentPolygonElement.elementsByTagNameNS(GML_NAMESPACE, "interior");

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

{

currentInteriorElement = interiorNodeList.at(i).toElement();

linearRingNodeList = currentInteriorElement.elementsByTagNameNS(GML_NAMESPACE, "LinearRing");

if(linearRingNodeList.size() < 1)

{

continue;

}

linearRingElement = linearRingNodeList.at(i).toElement();

posListNodeList = linearRingElement.elementsByTagNameNS(GML_NAMESPACE, "posList");

if(posListNodeList.size() < 1)

{

continue;

}

posListElement = posListNodeList.at(i).toElement();

std::list<QgsPoint> ringCoordinates;

if(readCoordinatesFromPosList(ringCoordinates, posListElement) != 0)

{

continue;

}

currentPolygonList.push_back(ringCoordinates);

}

multiPolygonPoints.push_back(currentPolygonList);

}

int size = 1 + 2 * sizeof(int);

//calculate the wkb size

for(std::list<std::list<std::list<QgsPoint> > >::const_iterator it = multiPolygonPoints.begin(); it != multiPolygonPoints.end(); ++it)

{

size += 1 + 2 * sizeof(int);

for(std::list<std::list<QgsPoint> >::const_iterator iter = it->begin(); iter != it->end(); ++iter)

{

size += sizeof(int) + 2 * iter->size() * sizeof(double);

}

}

*wkb = new unsigned char[size];

*wkbSize = size;

*type = QGis::WKBMultiPolygon;

int polygonType = QGis::WKBPolygon;

char e = QgsApplication::endian();

int wkbPosition = 0; //current offset from wkb beginning (in bytes)

double x, y;

int nPolygons = multiPolygonPoints.size();

int nRings;

int nPointsInRing;

//fill the contents into *wkb

memcpy(&(*wkb)[wkbPosition], &e, 1);

wkbPosition += 1;

memcpy(&(*wkb)[wkbPosition], type, sizeof(int));

wkbPosition += sizeof(int);

memcpy(&(*wkb)[wkbPosition], &nPolygons, sizeof(int));

wkbPosition += sizeof(int);

for(std::list<std::list<std::list<QgsPoint> > >::const_iterator it = multiPolygonPoints.begin(); it != multiPolygonPoints.end(); ++it)

{

memcpy(&(*wkb)[wkbPosition], &e, 1);

wkbPosition += 1;

memcpy(&(*wkb)[wkbPosition], &polygonType, sizeof(int));

wkbPosition += sizeof(int);

nRings = it->size();

memcpy(&(*wkb)[wkbPosition], &nRings, sizeof(int));

wkbPosition += sizeof(int);

for(std::list<std::list<QgsPoint> >::const_iterator iter = it->begin(); iter != it->end(); ++iter)

{

nPointsInRing = iter->size();

memcpy(&(*wkb)[wkbPosition], &nPointsInRing, sizeof(int));

wkbPosition += sizeof(int);

for(std::list<QgsPoint>::const_iterator iterator = iter->begin(); iterator != iter->end(); ++iterator)

{

x = iterator->x();

y = iterator->y();

memcpy(&(*wkb)[wkbPosition], &x, sizeof(double));

wkbPosition += sizeof(double);

memcpy(&(*wkb)[wkbPosition], &y, sizeof(double));

wkbPosition += sizeof(double);

}

}

}

return 0;

}

int QgsWFSProvider::getWkbFromGML3MultiCurve(const QDomElement& geometryElement, unsigned char** wkb, int* wkbSize, QGis::WKBTYPE* type) const

{

QDomNodeList curveMembersList = geometryElement.elementsByTagNameNS(GML_NAMESPACE, "curveMembers");

if(curveMembersList.size() < 1)

{

return 1;

}

QDomElement curveMembersElement = curveMembersList.at(0).toElement();

//analyze the <LineString> tags

QDomNodeList LineStringNodeList = geometryElement.elementsByTagNameNS(GML_NAMESPACE, "LineString");

//the first list contains the lines, the second one the coordinates for each line

std::list<std::list<QgsPoint> > lineCoordinates;

QDomElement currentLineStringElement;

QDomNodeList currentPosList;

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

{

currentLineStringElement = LineStringNodeList.at(i).toElement();

//posList element

currentPosList = currentLineStringElement.elementsByTagNameNS(GML_NAMESPACE, "posList");

if(currentPosList.size() < 1)

{

return 2;

}

std::list<QgsPoint> currentPointList;

if(readCoordinatesFromPosList(currentPointList, currentPosList.at(0).toElement()) != 0)

{

return 3;

}

lineCoordinates.push_back(currentPointList);

}

//calculate the required wkb size

int size = (lineCoordinates.size() + 1) * (1 + 2 * sizeof(int));

for(std::list<std::list<QgsPoint> >::const_iterator it = lineCoordinates.begin(); it != lineCoordinates.end(); ++it)

{

size += it->size() * 2 * sizeof(double);

}

*wkb = new unsigned char[size];

*wkbSize = size;

*type = QGis::WKBMultiLineString;

//fill the wkb content

char e = QgsApplication::endian();

int wkbPosition = 0; //current offset from wkb beginning (in bytes)

int nLines = lineCoordinates.size();

int nPoints; //number of points in a line

double x, y;

memcpy(&(*wkb)[wkbPosition], &e, 1);

wkbPosition += 1;

memcpy(&(*wkb)[wkbPosition], type, sizeof(int));

wkbPosition += sizeof(int);

memcpy(&(*wkb)[wkbPosition], &nLines, sizeof(int));

wkbPosition += sizeof(int);

for(std::list<std::list<QgsPoint> >::const_iterator it = lineCoordinates.begin(); it != lineCoordinates.end(); ++it)

{

memcpy(&(*wkb)[wkbPosition], &e, 1);

wkbPosition += 1;

memcpy(&(*wkb)[wkbPosition], type, sizeof(int));

wkbPosition += sizeof(int);

nPoints = it->size();

memcpy(&(*wkb)[wkbPosition], &nPoints, sizeof(int));

wkbPosition += sizeof(int);

for(std::list<QgsPoint>::const_iterator iter = it->begin(); iter != it->end(); ++iter)

{

x = iter->x();

//qWarning("x is: " + QString::number(x));

y = iter->y();

//qWarning("y is: " + QString::number(y));

memcpy(&(*wkb)[wkbPosition], &x, sizeof(double));

wkbPosition += sizeof(double);

memcpy(&(*wkb)[wkbPosition], &y, sizeof(double));

wkbPosition += sizeof(double);

}

}

return 0;

}

int QgsWFSProvider::readCoordinatesFromPosList(std::list<QgsPoint>& coords, const QDomElement elem) const

{

//srsDimension

int srsDimension;

int srsDiff; //difference betwen srsDimension and 2

QString srsDimensionString = elem.attributeNS(GML_NAMESPACE, "srsDimension");

if(srsDimensionString.isEmpty())

{

srsDimension = 2;

}

else

{

bool conversionSuccess;

srsDimension = srsDimensionString.toInt(&conversionSuccess);

if(!conversionSuccess)

{

srsDimension = 2;

}

}

if(srsDimension < 2)

{

return 1;

}

srsDiff = srsDimension - 2;

coords.clear();

QStringList coordinateStringList = elem.text().split(" ", QString::SkipEmptyParts);

QStringList::const_iterator iter;

bool conversionSuccess;

double currentX;

double currentY;

for(iter = coordinateStringList.constBegin(); iter != coordinateStringList.constEnd(); ++iter)

{

currentX = iter->toDouble(&conversionSuccess);

if(!conversionSuccess)

{

coords.clear();

return 1;

}

++iter;

if(iter == coordinateStringList.constEnd()) //odd number of doubles

{

coords.clear();

return 2;

}

currentY = iter->toDouble(&conversionSuccess);

if(!conversionSuccess)

{

coords.clear();

return 1;

}

for(int i = 0; i < srsDiff; ++i) //for higher dimensional entries

{

++iter;

}

coords.push_back(QgsPoint(currentX, currentY));

//qWarning("adding coordinates " + QString::number(currentX) + " // " + QString::number(currentY) + " to coordinates list");

}

return 0;

}

int QgsWFSProvider::setSRSFromGML3(const QDomElement& wfsCollectionElement)

{

QgsDebugMsg("entering QgsWFSProvider::setSRSFromGML");

//search <gml:boundedBy>

QDomNodeList boundedByList = wfsCollectionElement.elementsByTagNameNS(GML_NAMESPACE, "boundedBy");

if(boundedByList.size() < 1)

{

QgsDebugMsg("Error, could not find boundedBy element");

return 1;

}

//search <gml:Envelope>

QDomElement boundedByElem = boundedByList.at(0).toElement();

QDomNodeList envelopeList = boundedByElem.elementsByTagNameNS(GML_NAMESPACE, "Envelope");

if(envelopeList.size() < 1)

{

QgsDebugMsg("Error, could not find Envelope element");

return 2;

}

QDomElement envelopeElem = envelopeList.at(0).toElement();

//getAttribute 'srsName'

QString srsName = envelopeElem.attribute("srsName");

if(srsName.isEmpty())

{

QgsDebugMsg("Error, srsName is empty");

return 3;

}

QgsDebugMsg("srsName is: " +srsName);

mSourceSRS = new QgsSpatialRefSys();

if(!mSourceSRS->createFromOgcWmsCrs(srsName))

{

QgsDebugMsg("Error, creation of QgsSpatialRefSys failed");

delete mSourceSRS;

mSourceSRS = 0;

return 4;

}

return 0;

}

#endif //0 //methods for reading GML3

//GML3 specific methods. Not needed at the moment as most servers support GML2

#if 0

/**Evaluates the <gml:boundedBy> element

@return 0 in case of success*/

int getExtentFromGML3(QgsRect* extent, const QDomElement& wfsCollectionElement) const;

/**Turns GML into QGIS features