wms/client/1.1.1/XMLParser.cpp

Go to the documentation of this file.

/*  Copyright (C) 2017 National Institute For Space Research (INPE) - Brazil.

    This file is part of the TerraLib - a Framework for building GIS enabled applications.

    TerraLib is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License,
    or (at your option) any later version.

    TerraLib is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with TerraLib. See COPYING. If not, write to
    TerraLib Team at <terralib-team@terralib.org>.
 */


#include "XMLParser.h"

#include <iostream>

//BOOST
#include <boost/algorithm/string.hpp>

#include "../../../../../common/StringUtils.h"
#include "../../../../core/Utils.h"
#include "../../../../core/Exception.h"

te::ws::ogc::wms::version_1_1_1::XMLParser::XMLParser()
{
  m_version = "1.1.1";
}

te::ws::ogc::wms::version_1_1_1::XMLParser::~XMLParser() = default;

te::ws::ogc::wms::WMSCapabilities  te::ws::ogc::wms::version_1_1_1::XMLParser::parseCapabilities(const std::string &xmlPath)
{

  // Read XML file
  std::unique_ptr<te::xml::Reader> reader(te::xml::ReaderFactory::make("XERCES"));
  reader->setValidationScheme(false);
  reader->setDoSchema(false);
  reader->setIgnoreWhiteSpaces(true);
  reader->setCacheGrammarFromParse(false);
  reader->setUseCachedGrammarInParse(false);

  reader->read(xmlPath);

  // Validate the XML file
  if(!reader->next())
  {
    throw te::ws::core::Exception() << te::ErrorDescription(TE_TR("Could not read the WMS 1.1.1 GetCapabilities response XML file!"));
  }

  if(!boost::iequals(reader->getElementLocalName(), "WMT_MS_Capabilities"))
  {
    throw te::ws::core::WrongVersionException() << te::ErrorDescription(TE_TR("Could not find a WMS 1.1.1 GetCapabilities response in the received XML!"));
  }

  WMSCapabilities capabilities;

  while (reader->next())
  {
    if(boost::iequals(reader->getElementLocalName(), "Capability"))
    {
      capabilities.m_capability = this->parseCapability(reader);
    }
  }

  return capabilities;
}

te::ws::ogc::wms::Layer te::ws::ogc::wms::version_1_1_1::XMLParser::parseLayers(const std::unique_ptr<te::xml::Reader> &reader)
{
  Layer layer;

  if (reader->hasAttrs())
  {
    for (size_t i = 0; i < reader->getNumberOfAttrs(); i++)
    {
      if(boost::iequals(reader->getAttrLocalName(i), "queryable"))
        layer.m_queryable = (reader->getAttrAsInt32("queryable") != 0) ? true : false;
      else if (boost::iequals(reader->getAttrLocalName(i), "cascaded"))
        layer.m_cascaded = (reader->getAttrAsInt32("cascaded") != 0) ? true : false;
      else if (boost::iequals(reader->getAttrLocalName(i), "opaque"))
        layer.m_opaque = (reader->getAttrAsInt32("opaque") != 0) ? true : false;
      else if (boost::iequals(reader->getAttrLocalName(i), "noSubsets"))
        layer.m_noSubsets = (reader->getAttrAsInt32("noSubsets") != 0) ? true : false;
      else if (boost::iequals(reader->getAttrLocalName(i), "fixedWidth"))
        layer.m_fixedWidth = (reader->getAttrAsInt32("fixedWidth") != 0) ? true : false;
      else if (boost::iequals(reader->getAttrLocalName(i), "fixedHeight"))
        layer.m_fixedHeight = (reader->getAttrAsInt32("fixedHeight") != 0) ? true : false;
    }
  }

  std::vector<std::string> srsList;

  while (reader->next() && !(reader->getNodeType() == te::xml::END_ELEMENT && boost::iequals(reader->getElementLocalName(), "Layer")))
  {
    if(reader->getNodeType() == te::xml::VALUE && boost::iequals(reader->getElementLocalName(), "Name"))
    {
      layer.m_name = reader->getElementValue();
    }
    else if(reader->getNodeType() == te::xml::VALUE && boost::iequals(reader->getElementLocalName(), "Title"))
    {
      layer.m_title = reader->getElementValue();
    }
    else if(reader->getNodeType() == te::xml::VALUE && boost::iequals(reader->getElementLocalName(), "Abstract"))
    {
      layer.m_abstract = reader->getElementValue();
    }
    else if(reader->getNodeType() == te::xml::VALUE && boost::iequals(reader->getElementLocalName(), "SRS"))
    {
      srsList.push_back(reader->getElementValue());
    }
    else if(reader->getNodeType() == te::xml::START_ELEMENT && boost::iequals(reader->getElementLocalName(), "KeywordList"))
    {
      std::vector<std::string> keywordList;

      while (reader->next() && !(reader->getNodeType() == te::xml::END_ELEMENT && boost::iequals(reader->getElementLocalName(), "KeywordList")))
      {
        if(reader->getNodeType() == te::xml::VALUE && boost::iequals(reader->getElementLocalName(), "Keyword"))
        {
          keywordList.push_back(reader->getElementValue());
        }
      }

      layer.m_keywordList = keywordList;
    }
    else if (reader->getNodeType() == te::xml::START_ELEMENT && boost::iequals(reader->getElementLocalName(), "LatLonBoundingBox"))
    {
      layer.m_geoBoundingBox = this->parseGeographicBoundingBox(reader);
    }
    else if (reader->getNodeType() == te::xml::START_ELEMENT && boost::iequals(reader->getElementLocalName(), "BoundingBox") && reader->hasAttrs())
    {
      layer.m_boundingBoxes.push_back(this->parseBoundingBox(reader));
    }
    else if (boost::iequals(reader->getElementLocalName(), "Dimension") && reader->hasAttrs())
    {
      layer.m_dimensions.push_back(this->parseDimension(reader));
    }
    else if (reader->getNodeType() == te::xml::START_ELEMENT && boost::iequals(reader->getElementLocalName(), "Style"))
    {
      layer.m_styles.push_back(this->parseStyle(reader));
    }
    else if (reader->getNodeType() == te::xml::START_ELEMENT && boost::iequals(reader->getElementLocalName(), "ScaleHint") && reader->hasAttrs())
    {
      for (unsigned int i = 0; i < reader->getNumberOfAttrs(); i++)
      {
        if(boost::iequals(reader->getAttrLocalName(i), "min"))
          layer.m_minScaleDenominator = reader->getAttrAsDouble("min");
        else if (boost::iequals(reader->getAttrLocalName(i), "max"))
          layer.m_maxScaleDenominator = reader->getAttrAsDouble("max");
      }
    }
    else if (reader->getNodeType() == te::xml::START_ELEMENT && boost::iequals(reader->getElementLocalName(), "Layer"))
    {
      Layer subLayer = this->parseLayers(reader);
      layer.m_layers.push_back(subLayer);
    }
  }

  layer.m_crs = srsList;

  return layer;
}

te::ws::ogc::wms::GeographicBoundingBox te::ws::ogc::wms::version_1_1_1::XMLParser::parseGeographicBoundingBox(const std::unique_ptr<te::xml::Reader> &reader)
{

  te::ws::ogc::wms::GeographicBoundingBox latLonBoundingBox;

  latLonBoundingBox.m_westBoundLongitude = reader->getAttrAsDouble("minx");
  latLonBoundingBox.m_eastBoundLongitude = reader->getAttrAsDouble("maxx");
  latLonBoundingBox.m_southBoundLatitude = reader->getAttrAsDouble("miny");
  latLonBoundingBox.m_northBoundLatitude = reader->getAttrAsDouble("maxy");

  return latLonBoundingBox;
}

te::ws::ogc::wms::Dimension te::ws::ogc::wms::version_1_1_1::XMLParser::parseDimension(const std::unique_ptr<te::xml::Reader> &reader)
{

  te::ws::ogc::wms::Dimension dimension;

  for (unsigned int i = 0; i < reader->getNumberOfAttrs(); i++)
  {
    if(boost::iequals(reader->getAttrLocalName(i), "name"))
      dimension.m_name = reader->getAttr("name");
    else if (boost::iequals(reader->getAttrLocalName(i), "units"))
      dimension.m_units = reader->getAttr("units");
    else if (boost::iequals(reader->getAttrLocalName(i), "unitSymbol"))
      dimension.m_unitSymbol = reader->getAttr("unitSymbol");
  }

  reader->next();
  reader->next();

  if (boost::iequals(reader->getElementLocalName(), "Extent"))
  {
    for (unsigned int i = 0; i < reader->getNumberOfAttrs(); i++)
    {
      if (boost::iequals(reader->getAttrLocalName(i), "default"))
            dimension.m_default = reader->getAttr("default");
      else if (boost::iequals(reader->getAttrLocalName(i), "nearestValue"))
        dimension.m_nearestValue = (reader->getAttrAsInt32("nearestValue") != 0) ? true : false;
    }

    while (reader->next() && !(reader->getNodeType() == te::xml::END_ELEMENT && boost::iequals(reader->getElementLocalName(), "Extent")))
    {
      if(reader->getNodeType() == te::xml::VALUE)
      {
        std::string allowedValuesStr = reader->getElementValue();

        std::vector<std::string> allowedValues = te::common::SplitString(allowedValuesStr, ',');

        dimension.m_allowedValues = allowedValues;
      }
    }
  }

  return dimension;
}

te::ws::ogc::wms::BoundingBox te::ws::ogc::wms::version_1_1_1::XMLParser::parseBoundingBox(const std::unique_ptr<te::xml::Reader> &reader)
{
  BoundingBox box;

  box.m_crs = reader->getAttr("SRS");

  box.m_minX = reader->getAttrAsDouble("minx");
  box.m_minY = reader->getAttrAsDouble("miny");
  box.m_maxX = reader->getAttrAsDouble("maxx");
  box.m_maxY = reader->getAttrAsDouble("maxy");

  return box;
}