bool LineStringElementParser::parseChildElementEndTag(const NodeType::XMLNode& node, const std::string& characters)
{
if (m_model == nullptr) {
throw std::runtime_error("LineStringElementParser::parseChildElementEndTag called before LineStringElementParser::parseElementStartTag");
}
if (node == NodeType::GML_PosListNode
|| node == NodeType::GML_PosNode) {
if (m_model->getDimensions() < 0) {
CITYGML_LOG_ERROR(m_logger, "No srsDimension given for LineString before or as attribute of <" << NodeType::GML_PosListNode << "> child element at " << getDocumentLocation());
} else if (m_model->getDimensions() == 2) {
m_model->setVertices2D(parseVecList<TVec2d>(characters, m_logger, getDocumentLocation()));
} else if (m_model->getDimensions() == 3) {
m_model->setVertices3D(parseVecList<TVec3d>(characters, m_logger, getDocumentLocation()));
} else {
CITYGML_LOG_WARN(m_logger, "Unsupported dimension of LineString positions at " << getDocumentLocation() << ". Only 2 and 3 dimensions are supported.");
}
return true;
}
return GMLObjectElementParser::parseChildElementEndTag(node, characters);
}
bool GMLFeatureCollectionElementParser::parseChildElementEndTag(const NodeType::XMLNode& node, const std::string& characters)
{
if (getFeatureObject() == nullptr) {
throw std::runtime_error("Invalid call to GMLFeatureCollectionElementParser::parseChildElementEndTag");
}
if (node == NodeType::GML_LowerCornerNode) {
if (m_bounds != nullptr) {
m_bounds->setLowerBound(parseValue<TVec3d>(characters, m_logger, getDocumentLocation()));
} else {
CITYGML_LOG_WARN(m_logger, "Definition of " << NodeType::GML_LowerCornerNode << " outside " << NodeType::GML_EnvelopeNode << " at " << getDocumentLocation());
}
return true;
} else if (node == NodeType::GML_UpperCornerNode) {
if (m_bounds != nullptr) {
m_bounds->setUpperBound(parseValue<TVec3d>(characters, m_logger, getDocumentLocation()));
} else {
CITYGML_LOG_WARN(m_logger, "Definition of " << NodeType::GML_UpperCornerNode << " outside " << NodeType::GML_EnvelopeNode << " at " << getDocumentLocation());
}
return true;
} else if (node == NodeType::GML_EnvelopeNode) {
getFeatureObject()->setEnvelope(m_bounds);
return true;
} else if (node == NodeType::GML_BoundedByNode) {
return true;
}
return GMLObjectElementParser::parseChildElementEndTag(node, characters);
}
std::string Attributes::getCityGMLIDAttribute() const
{
std::string id = getAttribute("gml:id", "");
if (id.empty()) {
std::stringstream defaultID;
defaultID << "genID_" << getDocumentLocation().getDocumentFileName() << "_" << getDocumentLocation().getCurrentLine() << "_" << + getDocumentLocation().getCurrentColumn();
id = defaultID.str();
}
return id;
}
void NclDocument::setDocumentLocation(
NclDocument* document, string location) {
string oldLocation;
if (documentBase != NULL) {
oldLocation = getDocumentLocation(document);
documentLocations->erase(oldLocation);
(*documentLocations)[location] = document;
}
}
bool SequenceParser::endElement(const NodeType::XMLNode& node, const std::string&)
{
if (node != m_containerType) {
CITYGML_LOG_ERROR(m_logger, "Sequence parser was bound to container element <" << m_containerType << "> but found unexpected"
" end tag <" << node << "> at " << getDocumentLocation() << ". Ignoring tag...");
return false;
} else {
m_documentParser.removeCurrentElementParser(this);
}
return true;
}
bool NclDocument::removeDocument(NclDocument* document) {
string alias, location;
vector<NclDocument*>::iterator i;
if (documentBase == NULL) {
return false;
}
alias = getDocumentAlias(document);
location = getDocumentLocation(document);
for (i=documentBase->begin(); i!=documentBase->end(); ++i) {
if (*i == document) {
documentBase->erase(i);
documentAliases->erase(alias);
documentLocations->erase(location);
return true;
}
}
return false;
}
bool GMLFeatureCollectionElementParser::parseChildElementStartTag(const NodeType::XMLNode& node, Attributes& attributes)
{
if (getFeatureObject() == nullptr) {
throw std::runtime_error("Invalid call to GMLFeatureCollectionElementParser::parseChildElementStartTag");
}
if (node == NodeType::GML_LowerCornerNode
|| node == NodeType::GML_UpperCornerNode
|| node == NodeType::GML_BoundedByNode) {
return true;
} else if (node == NodeType::GML_EnvelopeNode) {
if (m_sourceSRSOverride) {
return true;
}
if (m_bounds != nullptr) {
CITYGML_LOG_WARN(m_logger, "Duplicate definition of " << NodeType::GML_EnvelopeNode << " at " << getDocumentLocation());
return true;
}
m_bounds = new Envelope(attributes.getAttribute("srsName"));
return true;
}
return GMLObjectElementParser::parseChildElementStartTag(node, attributes);
}
bool LineStringElementParser::parseElementStartTag(const NodeType::XMLNode& node, Attributes& attributes)
{
if (!handlesElement(node)) {
CITYGML_LOG_ERROR(m_logger, "Expected start tag <" << NodeType::GML_LineStringNode << "> or <" << NodeType::GML_PointNode << "> but got <" << node.name() << "> at " << getDocumentLocation());
throw std::runtime_error("Unexpected start tag found.");
}
m_model = m_factory.createLineString(attributes.getCityGMLIDAttribute());
parseDimension(attributes);
return true;
}
std::string Attributes::getXLinkValue()
{
return parseReference(getAttribute("xlink:href", ""), m_logger, getDocumentLocation());
}
bool PolygonElementParser::parseElementStartTag(const NodeType::XMLNode& node, Attributes& attributes)
{
if (!handlesElement(node)) {
CITYGML_LOG_ERROR(m_logger, "Expected start tag of PolygonObject but got <" << node.name() << "> at " << getDocumentLocation());
throw std::runtime_error("Unexpected start tag found.");
}
m_model = m_factory.createPolygon(attributes.getCityGMLIDAttribute());
return true;
}
bool AddressParser::parseElementStartTag(const NodeType::XMLNode& node, Attributes& attributes)
{
if (k_rootElements.count(node) == 0) {
CITYGML_LOG_ERROR(m_logger, "Expected an address start tag but got <" << node << "> at " << getDocumentLocation());
throw std::runtime_error("Unexpected start tag found.");
}
m_address = make_unique<Address>(attributes.getCityGMLIDAttribute());
return true;
}
bool CityGMLElementParser::endElement(const NodeType::XMLNode& node, const std::string& characters)
{
if (!m_boundElement.valid()) {
// This might happen if an container element that usally contains a child element links to an exting object using XLink an thus
// uses a combined start/end element: e.g.: <surfaceMember xlink:href="#..."/>
// For such elements a child parser must only be created if there is no xlink attribute.
CITYGML_LOG_ERROR(m_logger, "CityGMLElementParser::endElement called on unbound " << elementParserName() << " object for element <" << node << "> at " << getDocumentLocation());
throw std::runtime_error("CityGMLElementParser::endElement called on unbound CityGMLElementParser object.");
}
if (m_boundElement == node) {
m_documentParser.removeCurrentElementParser(this);
return parseElementEndTag(node, characters);
} else {
return parseChildElementEndTag(node, characters);
}
}
bool CityGMLElementParser::startElement(const NodeType::XMLNode& node, Attributes& attributes)
{
if (!node.valid()) {
CITYGML_LOG_ERROR(m_logger, "Invalid xml start tag (no name) found at " << getDocumentLocation());
throw std::runtime_error("Error parsing xml document. Invalid start tag.");
}
if (!m_boundElement.valid()) {
m_boundElement = node;
return parseElementStartTag(node, attributes);
} else {
return parseChildElementStartTag(node, attributes);
}
}
bool CityObjectElementParser::parseChildElementStartTag(const NodeType::XMLNode& node, Attributes& attributes)
{
initializeAttributesSet();
if (m_model == nullptr) {
throw std::runtime_error("CityObjectElementParser::parseChildElementStartTag called before CityObjectElementParser::parseElementStartTag");
}
if ( node == NodeType::GEN_StringAttributeNode
|| node == NodeType::GEN_DoubleAttributeNode
|| node == NodeType::GEN_IntAttributeNode
|| node == NodeType::GEN_DateAttributeNode
|| node == NodeType::GEN_UriAttributeNode) {
m_lastAttributeName = attributes.getAttribute("name");
} else if (attributesSet.count(node.typeID()) > 0 || node == NodeType::GEN_ValueNode) {
return true;
} else if (node == NodeType::BLDG_BoundedByNode
|| node == NodeType::BLDG_OuterBuildingInstallationNode
|| node == NodeType::BLDG_InteriorBuildingInstallationNode
|| node == NodeType::BLDG_InteriorFurnitureNode
|| node == NodeType::BLDG_RoomInstallationNode
|| node == NodeType::BLDG_InteriorRoomNode
|| node == NodeType::BLDG_OpeningNode
|| node == NodeType::BLDG_ConsistsOfBuildingPartNode
|| node == NodeType::GRP_GroupMemberNode
|| node == NodeType::GRP_ParentNode
|| node == NodeType::TRANS_TrafficAreaNode
|| node == NodeType::TRANS_AuxiliaryTrafficAreaNode
|| node == NodeType::WTR_BoundedByNode) {
setParserForNextElement(new CityObjectElementParser(m_documentParser, m_factory, m_logger, [this](CityObject* obj) {
m_model->addChildCityObject(obj);
}));
} else if (node == NodeType::APP_AppearanceNode // Compatibility with CityGML 1.0 (in CityGML 2 CityObjects can only contain appearanceMember elements)
|| node == NodeType::APP_AppearanceMemberNode) {
setParserForNextElement(new AppearanceElementParser(m_documentParser, m_factory, m_logger));
} else if (node == NodeType::BLDG_Lod1MultiCurveNode
|| node == NodeType::BLDG_Lod1MultiSurfaceNode
|| node == NodeType::BLDG_Lod1SolidNode
|| node == NodeType::BLDG_Lod1TerrainIntersectionNode
|| node == NodeType::GEN_Lod1TerrainIntersectionNode
|| node == NodeType::FRN_Lod1TerrainIntersectionNode
|| node == NodeType::LUSE_Lod1MultiSurfaceNode
|| node == NodeType::TRANS_Lod1MultiSurfaceNode
|| node == NodeType::WTR_Lod1MultiCurveNode
|| node == NodeType::WTR_Lod1MultiSurfaceNode
|| node == NodeType::WTR_Lod1SolidNode) {
parseGeometryForLODLevel(1);
} else if (node == NodeType::BLDG_Lod2MultiCurveNode
|| node == NodeType::BLDG_Lod2MultiSurfaceNode
|| node == NodeType::BLDG_Lod2SolidNode
|| node == NodeType::BLDG_Lod2TerrainIntersectionNode
|| node == NodeType::GEN_Lod2TerrainIntersectionNode
|| node == NodeType::FRN_Lod2TerrainIntersectionNode
|| node == NodeType::LUSE_Lod2MultiSurfaceNode
|| node == NodeType::TRANS_Lod2MultiSurfaceNode
|| node == NodeType::WTR_Lod2SolidNode
|| node == NodeType::WTR_Lod2SurfaceNode) {
parseGeometryForLODLevel(2);
} else if (node == NodeType::BLDG_Lod3MultiCurveNode
|| node == NodeType::BLDG_Lod3MultiSurfaceNode
|| node == NodeType::BLDG_Lod3SolidNode
|| node == NodeType::BLDG_Lod3TerrainIntersectionNode
|| node == NodeType::GEN_Lod3TerrainIntersectionNode
|| node == NodeType::FRN_Lod3TerrainIntersectionNode
|| node == NodeType::LUSE_Lod3MultiSurfaceNode
|| node == NodeType::TRANS_Lod3MultiSurfaceNode
|| node == NodeType::WTR_Lod3SolidNode
|| node == NodeType::WTR_Lod3SurfaceNode) {
parseGeometryForLODLevel(3);
} else if (node == NodeType::BLDG_Lod4MultiCurveNode
|| node == NodeType::BLDG_Lod4MultiSurfaceNode
|| node == NodeType::BLDG_Lod4SolidNode
|| node == NodeType::BLDG_Lod4TerrainIntersectionNode
|| node == NodeType::GEN_Lod4TerrainIntersectionNode
|| node == NodeType::FRN_Lod4TerrainIntersectionNode
|| node == NodeType::LUSE_Lod4MultiSurfaceNode
|| node == NodeType::TRANS_Lod4MultiSurfaceNode
|| node == NodeType::WTR_Lod4SolidNode
|| node == NodeType::WTR_Lod4SurfaceNode) {
parseGeometryForLODLevel(4);
} else if (node == NodeType::GEN_Lod1GeometryNode
|| node == NodeType::FRN_Lod1GeometryNode
|| node == NodeType::VEG_Lod1GeometryNode) {
parseGeometryPropertyElementForLODLevel(1, attributes.getCityGMLIDAttribute());
} else if (node == NodeType::GEN_Lod2GeometryNode
|| node == NodeType::FRN_Lod2GeometryNode
|| node == NodeType::BLDG_Lod2GeometryNode
|| node == NodeType::VEG_Lod2GeometryNode) {
parseGeometryPropertyElementForLODLevel(2, attributes.getCityGMLIDAttribute());
} else if (node == NodeType::GEN_Lod3GeometryNode
|| node == NodeType::FRN_Lod3GeometryNode
|| node == NodeType::BLDG_Lod3GeometryNode
|| node == NodeType::VEG_Lod3GeometryNode) {
parseGeometryPropertyElementForLODLevel(3, attributes.getCityGMLIDAttribute());
} else if (node == NodeType::GEN_Lod4GeometryNode
|| node == NodeType::FRN_Lod4GeometryNode
|| node == NodeType::BLDG_Lod4GeometryNode
|| node == NodeType::VEG_Lod4GeometryNode) {
parseGeometryPropertyElementForLODLevel(4, attributes.getCityGMLIDAttribute());
} else if (node == NodeType::VEG_Lod1ImplicitRepresentationNode
|| node == NodeType::FRN_Lod1ImplicitRepresentationNode
|| node == NodeType::GEN_Lod1ImplicitRepresentationNode) {
parseImplicitGeometryForLODLevel(1);
} else if (node == NodeType::VEG_Lod2ImplicitRepresentationNode
|| node == NodeType::FRN_Lod2ImplicitRepresentationNode
|| node == NodeType::GEN_Lod2ImplicitRepresentationNode) {
parseImplicitGeometryForLODLevel(2);
} else if (node == NodeType::VEG_Lod3ImplicitRepresentationNode
|| node == NodeType::FRN_Lod3ImplicitRepresentationNode
|| node == NodeType::GEN_Lod3ImplicitRepresentationNode) {
parseImplicitGeometryForLODLevel(3);
} else if (node == NodeType::VEG_Lod4ImplicitRepresentationNode
|| node == NodeType::FRN_Lod4ImplicitRepresentationNode
|| node == NodeType::GEN_Lod4ImplicitRepresentationNode) {
parseImplicitGeometryForLODLevel(4);
} else if (node == NodeType::CORE_GeneralizesToNode
|| node == NodeType::CORE_ExternalReferenceNode
|| node == NodeType::GML_MultiPointNode
|| node == NodeType::GRP_GeometryNode
|| node == NodeType::DEM_ReliefComponentNode
|| node == NodeType::GEN_Lod0GeometryNode
|| node == NodeType::GEN_Lod0ImplicitRepresentationNode
|| node == NodeType::GEN_Lod0TerrainIntersectionNode
|| node == NodeType::TRANS_Lod0NetworkNode
|| node == NodeType::WTR_Lod0MultiCurveNode
|| node == NodeType::WTR_Lod0MultiSurfaceNode) {
CITYGML_LOG_INFO(m_logger, "Skipping CityObject child element <" << node << "> at " << getDocumentLocation() << " (Currently not supported!)");
setParserForNextElement(new SkipElementParser(m_documentParser, m_logger, node));
return true;
} else {
return GMLFeatureCollectionElementParser::parseChildElementStartTag(node, attributes);
}
return true;
}
bool CityObjectElementParser::parseElementStartTag(const NodeType::XMLNode& node, Attributes& attributes)
{
initializeTypeIDTypeMap();
auto it = typeIDTypeMap.find(node.typeID());
if (it == typeIDTypeMap.end()) {
CITYGML_LOG_ERROR(m_logger, "Expected start tag of CityObject but got <" << node.name() << "> at " << getDocumentLocation());
throw std::runtime_error("Unexpected start tag found.");
}
m_model = m_factory.createCityObject(attributes.getCityGMLIDAttribute(), static_cast<CityObject::CityObjectsType>(it->second));
return true;
}
