Extracted submodule

src/osmimember.cpp

@@ -0,0 +1,66 @@
+#include <osmimember.hpp>
+
+#include <osmobject.hpp>
+#include <tinyxml2.h>
+
+namespace xml = tinyxml2;
+
+namespace osmp
+{
+	IMember::IMember(const xml::XMLElement* element, Object* parent, IMember::Type type) :
+		type(type), parent(parent)
+	{
+		// Get Attribute
+		id = GetSafeAttributeUint64(element, "id");
+		user = GetSafeAttributeString(element, "user");
+		uid = GetSafeAttributeUint64(element, "uid");
+		visible = GetSafeAttributeBool(element, "visible");
+		version = GetSafeAttributeString(element, "version");
+		changeset = GetSafeAttributeUint64(element, "changeset");
+		timestamp = GetSafeAttributeString(element, "timestamp");
+
+		const xml::XMLElement* tag_element = element->FirstChildElement("tag");
+		while (tag_element != nullptr)
+		{
+			tags.push_back({
+				GetSafeAttributeString(tag_element, "k"),
+				GetSafeAttributeString(tag_element, "v"),
+				});
+
+			tag_element = tag_element->NextSiblingElement("tag");
+		}
+	}
+
+	IMember::Type IMember::GetType() const
+	{
+		return type;
+	}
+
+	const std::vector<Tag>& IMember::GetTags() const
+	{
+		return tags;
+	}
+
+	size_t IMember::GetTagsSize() const
+	{
+		return tags.size();
+	}
+
+	const Tag& IMember::GetTag(size_t index) const
+	{
+		return tags[index];
+	}
+
+	std::string IMember::GetTag(const std::string& key) const
+	{
+		for (const Tag& tag : tags)
+		{
+			if (tag.k == key)
+			{
+				return tag.v;
+			}
+		}
+
+		return "";
+	}
+}

src/osmnode.cpp

@@ -0,0 +1,30 @@
+#include <osmnode.hpp>
+
+#include <tinyxml2.h>
+
+namespace xml = tinyxml2;
+
+namespace osmp
+{
+	INode::INode(const tinyxml2::XMLElement* node_elem, Object* parent) :
+		IMember(node_elem, parent, IMember::Type::NODE)
+	{
+		// Get Attribute
+		lat =		GetSafeAttributeFloat(node_elem, "lat");
+		lon =		GetSafeAttributeFloat(node_elem, "lon");
+	}
+
+
+	namespace {
+		struct ConcreteNode : public INode {
+			ConcreteNode(const tinyxml2::XMLElement* node_elem, Object* parent) :
+				INode(node_elem, parent)
+			{}
+		};
+	}
+
+	Node CreateNode(const tinyxml2::XMLElement* node_elem, Object* parent)
+	{
+		return std::make_shared<ConcreteNode>(node_elem, parent);
+	}
+}

src/osmobject.cpp

@@ -0,0 +1,142 @@
+#include <osmobject.hpp>
+
+#include <iostream>
+#include <vector>
+
+#include <tinyxml2.h>
+
+#include <osmnode.hpp>
+#include <osmway.hpp>
+#include <osmrelation.hpp>
+
+namespace xml = tinyxml2;
+
+namespace osmp
+{
+	Object::Object(const std::string& file) :
+		bounds({ 0.0f, 0.0f, 0.0f, 0.0f })
+	{
+		xml::XMLDocument doc;
+		xml::XMLError result = doc.LoadFile(file.c_str());
+		if (result != xml::XML_SUCCESS)
+		{
+			std::cerr << "Error: " << result << std::endl;
+			return;
+		}
+	
+		xml::XMLElement* root = doc.FirstChildElement();
+
+		// Get bounds
+		xml::XMLElement* bounds_elem = root->FirstChildElement("bounds");
+		bounds = {
+			GetSafeAttributeFloat(bounds_elem, "minlat"),
+			GetSafeAttributeFloat(bounds_elem, "minlon"),
+			GetSafeAttributeFloat(bounds_elem, "maxlat"),
+			GetSafeAttributeFloat(bounds_elem, "maxlon")
+		};
+
+		// Get nodes
+		xml::XMLElement* node_elem = root->FirstChildElement("node");
+		while (node_elem != nullptr)
+		{
+			Node new_node = CreateNode(node_elem, this);
+			nodes.insert(std::make_pair(new_node->id, new_node));
+
+			node_elem = node_elem->NextSiblingElement("node");
+		}
+
+		// Get ways
+		xml::XMLElement* way_elem = root->FirstChildElement("way");
+		while (way_elem != nullptr)
+		{
+			Way new_way = CreateWay(way_elem, this);
+			ways.insert(std::make_pair(new_way->id, new_way));
+
+			way_elem = way_elem->NextSiblingElement("way");
+		}
+
+		// Get relations
+		xml::XMLElement* relation_elem = root->FirstChildElement("relation");
+		while (relation_elem != nullptr)
+		{
+			Relation new_way = CreateRelation(relation_elem, this);
+			relations.insert(std::make_pair(new_way->id, new_way));
+
+			relation_elem = relation_elem->NextSiblingElement("relation");
+		}
+	}
+
+	Object::~Object()
+	{
+
+	}
+
+	Nodes Object::GetNodes() const
+	{
+		Nodes vecNodes;
+		for (std::map<uint64_t, Node>::const_iterator it = nodes.begin(); it != nodes.end(); it++)
+			vecNodes.push_back(it->second);
+
+		return vecNodes;
+	}
+
+	size_t Object::GetNodesSize() const
+	{
+		return nodes.size();
+	}
+
+	Node Object::GetNode(uint64_t id) const
+	{
+		std::map<uint64_t, Node>::const_iterator node = nodes.find(id);
+		if (node != nodes.end())
+			return node->second;
+
+		return nullptr;
+	}
+
+	Ways Object::GetWays() const
+	{
+		Ways vecWays;
+		for (std::map<uint64_t, Way>::const_iterator it = ways.begin(); it != ways.end(); it++)
+			vecWays.push_back(it->second);
+
+		return vecWays;
+	}
+
+	size_t Object::GetWaysSize() const
+	{
+		return ways.size();
+	}
+
+	Way Object::GetWay(uint64_t id) const
+	{
+		std::map<uint64_t, Way>::const_iterator way = ways.find(id);
+		if (way != ways.end())
+			return way->second;
+
+		return nullptr;
+	}
+
+	Relations Object::GetRelations() const
+	{
+		Relations vecRelations;
+		for (std::map<uint64_t, Relation>::const_iterator it = relations.begin(); it != relations.end(); it++)
+			vecRelations.push_back(it->second);
+
+		return vecRelations;
+	}
+
+	size_t Object::GetRelationsSize() const
+	{
+		return relations.size();
+	}
+
+	Relation Object::GetRelation(uint64_t id) const
+	{
+		std::map<uint64_t, Relation>::const_iterator relation = relations.find(id);
+		if (relation != relations.end())
+			return relation->second;
+
+		return nullptr;
+	}
+}

src/osmrelation.cpp

@@ -0,0 +1,88 @@
+#include "..\include\osmrelation.hpp"
+#include <osmrelation.hpp>
+
+#include <memory>
+
+#include <tinyxml2.h>
+#include <osmobject.hpp>
+#include <osmnode.hpp>
+#include <osmway.hpp>
+
+namespace xml = tinyxml2;
+
+namespace osmp
+{
+	IRelation::IRelation(const xml::XMLElement* xml, Object* parent) :
+		IMember(xml, parent, IMember::Type::RELATION), hasNullMembers(false)
+	{
+		const xml::XMLElement* member_element = xml->FirstChildElement("member");
+		while (member_element != nullptr)
+		{
+			std::string memberType = GetSafeAttributeString(member_element, "type");
+			uint64_t ref = GetSafeAttributeUint64(member_element, "ref");
+			std::string role = GetSafeAttributeString(member_element, "role");
+
+			if (memberType == "node") {
+				Node node = parent->GetNode(ref);
+				nodes.push_back({ node, role });
+			}
+			else if (memberType == "way") {
+				Way way = parent->GetWay(ref);
+				if (way == nullptr) {
+					hasNullMembers = true;
+				}
+				ways.push_back({ way, role });
+			}
+
+			member_element = member_element->NextSiblingElement("member");
+		}
+	}
+
+	namespace {
+		struct ConcreteRelation : public IRelation {
+			ConcreteRelation(const tinyxml2::XMLElement* way_elem, Object* parent) :
+				IRelation(way_elem, parent)
+			{}
+		};
+	}
+
+	Relation CreateRelation(const tinyxml2::XMLElement* xml, Object* parent)
+	{
+		return std::make_shared<ConcreteRelation>(xml, parent);
+	}
+
+	std::string IRelation::GetRelationType() const
+	{
+		return GetTag("type");
+	}
+
+	const MemberNodes& IRelation::GetNodes() const
+	{
+		return nodes;
+	}
+
+	size_t IRelation::GetNodesSize() const
+	{
+		return nodes.size();
+	}
+
+	const MemberNode& IRelation::GetNode(size_t index) const
+	{
+		return nodes[index];
+	}
+
+	const MemberWays& IRelation::GetWays() const
+	{
+		return ways;
+	}
+
+	size_t IRelation::GetWaysSize() const
+	{
+		return ways.size();
+	}
+
+	const MemberWay& IRelation::GetWay(size_t index) const
+	{
+		return ways[index];
+	}
+}

src/osmway.cpp

@@ -0,0 +1,65 @@
+#include <osmway.hpp>
+
+#include <string>
+
+#include <tinyxml2.h>
+#include <osmobject.hpp>
+#include <osmtag.hpp>
+
+namespace xml = tinyxml2;
+
+namespace osmp
+{
+	IWay::IWay(const tinyxml2::XMLElement* way_elem, Object* parent) :
+		IMember(way_elem, parent, IMember::Type::WAY)
+	{
+		area = GetSafeAttributeBool(way_elem, "area");
+		closed = false;
+
+		const xml::XMLElement* nd_elem = way_elem->FirstChildElement("nd");
+		while (nd_elem != nullptr)
+		{
+			nodes.push_back(
+				parent->GetNode(GetSafeAttributeUint64(nd_elem, "ref"))
+			);
+
+			nd_elem = nd_elem->NextSiblingElement("nd");
+		}
+		
+		if (nodes.front() == nodes.back())
+		{
+			closed = true;
+
+			if (!area && GetTag("barrier") == "" && GetTag("highway") == "")	// this code sucks, it can be done better
+				area = true;
+		}
+	}
+
+	namespace {
+		struct ConcreteWay : public IWay {
+			ConcreteWay(const tinyxml2::XMLElement* way_elem, Object* parent) :
+				IWay(way_elem, parent)
+			{}
+		};
+	}
+
+	Way CreateWay(const tinyxml2::XMLElement* way_elem, Object* parent)
+	{
+		return std::make_shared<ConcreteWay>(way_elem, parent);
+	}
+
+	const Nodes& IWay::GetNodes() const
+	{
+		return nodes;
+	}
+
+	size_t IWay::GetNodesSize() const
+	{
+		return nodes.size();
+	}
+
+	Node IWay::GetNode(size_t index) const
+	{
+		return nodes[index];
+	}
+}

src/util.cpp

@@ -0,0 +1,49 @@
+#include <util.hpp>
+
+#include <iostream>
+#include <tinyxml2.h>
+
+namespace xml = tinyxml2;
+
+namespace osmp
+{
+#define FAILED(err) (err != xml::XML_SUCCESS)
+
+	std::string GetSafeAttributeString(const tinyxml2::XMLElement* elem, const std::string& name)
+	{
+		const char* buffer;
+
+		xml::XMLError result = elem->QueryStringAttribute(name.c_str(), &buffer);
+		if (FAILED(result))
+			return "";
+
+		std::string returnStr(buffer);
+		return returnStr;
+	}
+
+	double GetSafeAttributeFloat(const tinyxml2::XMLElement* elem, const std::string& name)
+	{
+		double returnVal = 0.0f;
+
+		xml::XMLError result = elem->QueryDoubleAttribute(name.c_str(), &returnVal);
+
+		return returnVal;
+	}
+
+	uint64_t GetSafeAttributeUint64(const tinyxml2::XMLElement* elem, const std::string& name)
+	{
+		uint64_t returnVal = 0;
+
+		xml::XMLError result = elem->QueryUnsigned64Attribute(name.c_str(), &returnVal);
+		return returnVal;
+	}
+
+	bool GetSafeAttributeBool(const tinyxml2::XMLElement* elem, const std::string& name)
+	{
+		bool returnVal = false;
+
+		xml::XMLError result = elem->QueryBoolAttribute(name.c_str(), &returnVal);
+
+		return returnVal;
+	}
+}