Refactored osmp

lib/osmparser/include/osmimember.hpp

@@ -24,7 +24,7 @@ namespace osmp
 
 		[[nodiscard]] IMember::Type GetType() const;
 
-		[[nodiscard]] const std::vector<Tag>& GetTags() const;
+		[[nodiscard]] const TagList& GetTags() const;
 		[[nodiscard]] size_t GetTagsSize() const;
 		[[nodiscard]] const Tag& GetTag(size_t index) const;
 		[[nodiscard]] std::string GetTag(const std::string& key) const;
@@ -36,8 +36,7 @@ namespace osmp
 		IMember::Type type;
 		Object* parent;
 
-		std::vector<Tag> tags;
-		// std::map<std::string, std::string> tags;
+		TagList tags;
 		
 	public:
 		uint64_t id;

lib/osmparser/include/osmnode.hpp

@@ -1,7 +1,7 @@
 #pragma once
 #include <vector>
 
-#include "util.hpp"
+#include <util.hpp>
 #include <osmimember.hpp>
 #include <osmtag.hpp>
 
@@ -9,10 +9,17 @@ namespace osmp
 {
 	class Object;
 
-	class Node : public IMember
+	class INode : public IMember
 	{
 	public:
-		Node(const tinyxml2::XMLElement* xml, Object* parent);
+		INode(const INode& other) = delete;
+		INode(const INode&& other) = delete;
+		virtual ~INode() {}
+
+		friend Node CreateNode(const tinyxml2::XMLElement* element, Object* parent);
+
+	protected:
+		INode(const tinyxml2::XMLElement* xml, Object* parent);
 
 	public:
 		double lat, lon;

lib/osmparser/include/osmobject.hpp

@@ -8,27 +8,23 @@
 
 namespace osmp
 {
-	class Node;
-	class Way;
-	class Relation;
-
 	class Object
 	{
 	public:
 		explicit Object(const std::string& file);
 		~Object();
 
-		[[nodiscard]] std::vector<std::shared_ptr<Node>> GetNodes() const;
+		[[nodiscard]] Nodes GetNodes() const;
 		[[nodiscard]] size_t GetNodesSize() const;
-		[[nodiscard]] std::shared_ptr<Node> GetNode(uint64_t id) const;
+		[[nodiscard]] Node GetNode(uint64_t id) const;
 
-		[[nodiscard]] std::vector<std::shared_ptr<Way>> GetWays() const;
+		[[nodiscard]] Ways GetWays() const;
 		[[nodiscard]] size_t GetWaysSize() const;
-		[[nodiscard]] std::shared_ptr<Way> GetWay(uint64_t id) const;
+		[[nodiscard]] Way GetWay(uint64_t id) const;
 
-		[[nodiscard]] std::vector<std::shared_ptr<Relation>> GetRelations() const;
+		[[nodiscard]] Relations GetRelations() const;
 		[[nodiscard]] size_t GetRelationsSize() const;
-		[[nodiscard]] std::shared_ptr<Relation> GetRelation(uint64_t id) const;
+		[[nodiscard]] Relation GetRelation(uint64_t id) const;
 
 	public:
 		const std::string version;
@@ -37,8 +33,8 @@ namespace osmp
 		Bounds bounds;
 		
 	private:
-		std::map<uint64_t, std::shared_ptr<Node>> nodes;
-		std::map<uint64_t, std::shared_ptr<Way>> ways;
-		std::map<uint64_t, std::shared_ptr<Relation>> relations;
+		std::map<uint64_t, Node> nodes;
+		std::map<uint64_t, Way> ways;
+		std::map<uint64_t, Relation> relations;
 	};
 }

lib/osmparser/include/osmrelation.hpp

@@ -9,35 +9,50 @@
 namespace osmp
 {
 	class Object;
+	class IMember;
 
-	class Relation : public IMember
+	typedef struct sMemberNode {
+		Node node;
+		std::string role;
+	} MemberNode;
+
+	typedef struct sMemberWay {
+		Way way;
+		std::string role;
+	} MemberWay;
+
+	typedef std::vector<MemberNode> MemberNodes;
+	typedef std::vector<MemberWay> MemberWays;
+
+	class IRelation : public IMember
 	{
 	public:
-		typedef struct sMember {
-			std::shared_ptr<IMember> member;
-			std::string role;
-		} Member;
+		IRelation(const IRelation& other) = delete;
+		IRelation(const IRelation&& other) = delete;
+		virtual ~IRelation() {}
 
-	public:
-		Relation(const tinyxml2::XMLElement* xml, Object* parent);
+		friend Relation CreateRelation(const tinyxml2::XMLElement* xml, Object* parent);
 
-		[[nodiscard]] std::string GetRelationType();
+		[[nodiscard]] std::string GetRelationType() const;
 
-		[[nodiscard]] const std::vector<Member>& GetNodes() const;
+		[[nodiscard]] const MemberNodes& GetNodes() const;
 		[[nodiscard]] size_t GetNodesSize() const;
-		[[nodiscard]] const Member& GetNode(size_t index) const;
+		[[nodiscard]] const MemberNode& GetNode(size_t index) const;
 
-		[[nodiscard]] const std::vector<Member>& GetWays() const;
+		[[nodiscard]] const MemberWays& GetWays() const;
 		[[nodiscard]] size_t GetWaysSize() const;
-		[[nodiscard]] const Member& GetWay(size_t index) const;
+		[[nodiscard]] const MemberWay& GetWay(size_t index) const;
 
 		[[nodiscard]] bool HasNullMembers() const { return hasNullMembers; }
 
+	protected:
+		IRelation(const tinyxml2::XMLElement* xml, Object* parent);
+
 	private:
 		std::string relationType;
 		bool hasNullMembers;
 
-		std::vector<Member> nodes;
-		std::vector<Member> ways;
+		MemberNodes nodes;
+		MemberWays ways;
 	};
 }

lib/osmparser/include/osmtag.hpp

@@ -33,4 +33,6 @@ namespace osmp
 		std::string k;	// TODO: Should/could be an enum
 		std::string v;
 	} Tag;
+
+	typedef std::vector<Tag> TagList;
 }

lib/osmparser/include/osmway.hpp

@@ -9,21 +9,27 @@
 namespace osmp
 {
 	class Object;
-	class Node;
 
-	class Way : public IMember
+	class IWay : public IMember
 	{
 	public:
-		Way(const tinyxml2::XMLElement* way_elem, Object* parent);
+		IWay(const IWay& other) = delete;
+		IWay(const IWay&& other) = delete;
+		virtual ~IWay() {}
 
-		[[nodiscard]] const std::vector<std::shared_ptr<Node>>& GetNodes() const;
+		friend Way CreateWay(const tinyxml2::XMLElement* way_elem, Object* parent);
+
+		[[nodiscard]] const Nodes& GetNodes() const;
 		[[nodiscard]] size_t GetNodesSize() const;
-		[[nodiscard]] const std::shared_ptr<Node>& GetNode(size_t index) const;
+		[[nodiscard]] Node GetNode(size_t index) const;
+
+	protected:
+		IWay(const tinyxml2::XMLElement* way_elem, Object* parent);
 
 	public:
 		bool area, closed;	// Closed := Startpoint = endpoint, Area := Closed AND certain conditions are not met
 
 	private:
-		std::vector<std::shared_ptr<Node>> nodes;
+		Nodes nodes;
 	};
 }

lib/osmparser/include/util.hpp

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <string>
+#include <vector>
+#include <memory>
 
 namespace tinyxml2
 {
@@ -9,6 +11,18 @@ namespace tinyxml2
 
 namespace osmp
 {
+	class INode;
+	class IWay;
+	class IRelation;
+
+	typedef std::shared_ptr<INode>		Node;
+	typedef std::shared_ptr<IWay>		Way;
+	typedef std::shared_ptr<IRelation>	Relation;
+
+	typedef std::vector<Node>			Nodes;
+	typedef std::vector<Way>			Ways;
+	typedef std::vector<Relation>		Relations;
+
 	typedef struct sBounds 
 	{
 		double minlat, minlon, maxlat, maxlon;

lib/osmparser/src/osmnode.cpp

@@ -6,11 +6,25 @@ namespace xml = tinyxml2;
 
 namespace osmp
 {
-	Node::Node(const tinyxml2::XMLElement* node_elem, Object* parent) :
+	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);
+	}
 }

lib/osmparser/src/osmobject.cpp

@@ -39,7 +39,7 @@ namespace osmp
 		xml::XMLElement* node_elem = root->FirstChildElement("node");
 		while (node_elem != nullptr)
 		{
-			std::shared_ptr<Node> new_node = std::make_shared<Node>(node_elem, this);
+			Node new_node = CreateNode(node_elem, this);
 			nodes.insert(std::make_pair(new_node->id, new_node));
 
 			node_elem = node_elem->NextSiblingElement("node");
@@ -49,7 +49,7 @@ namespace osmp
 		xml::XMLElement* way_elem = root->FirstChildElement("way");
 		while (way_elem != nullptr)
 		{
-			std::shared_ptr<Way> new_way = std::make_shared<Way>(way_elem, this);
+			Way new_way = CreateWay(way_elem, this);
 			ways.insert(std::make_pair(new_way->id, new_way));
 
 			way_elem = way_elem->NextSiblingElement("way");
@@ -59,7 +59,7 @@ namespace osmp
 		xml::XMLElement* relation_elem = root->FirstChildElement("relation");
 		while (relation_elem != nullptr)
 		{
-			std::shared_ptr<Relation> new_way = std::make_shared<Relation>(relation_elem, this);
+			Relation new_way = CreateRelation(relation_elem, this);
 			relations.insert(std::make_pair(new_way->id, new_way));
 
 			relation_elem = relation_elem->NextSiblingElement("relation");
@@ -71,10 +71,10 @@ namespace osmp
 
 	}
 
-	std::vector<std::shared_ptr<Node>> Object::GetNodes() const
+	Nodes Object::GetNodes() const
 	{
-		std::vector<std::shared_ptr<Node>> vecNodes;
-		for (std::map<uint64_t, std::shared_ptr<Node>>::const_iterator it = nodes.begin(); it != nodes.end(); it++)
+		Nodes vecNodes;
+		for (std::map<uint64_t, Node>::const_iterator it = nodes.begin(); it != nodes.end(); it++)
 			vecNodes.push_back(it->second);
 
 		return vecNodes;
@@ -85,19 +85,19 @@ namespace osmp
 		return nodes.size();
 	}
 
-	std::shared_ptr<Node> Object::GetNode(uint64_t id) const
+	Node Object::GetNode(uint64_t id) const
 	{
-		std::map<uint64_t, std::shared_ptr<Node>>::const_iterator node = nodes.find(id);
+		std::map<uint64_t, Node>::const_iterator node = nodes.find(id);
 		if (node != nodes.end())
 			return node->second;
 
 		return nullptr;
 	}
 
-	std::vector<std::shared_ptr<Way>> Object::GetWays() const
+	Ways Object::GetWays() const
 	{
-		std::vector<std::shared_ptr<Way>> vecWays;
-		for (std::map<uint64_t, std::shared_ptr<Way>>::const_iterator it = ways.begin(); it != ways.end(); it++)
+		Ways vecWays;
+		for (std::map<uint64_t, Way>::const_iterator it = ways.begin(); it != ways.end(); it++)
 			vecWays.push_back(it->second);
 
 		return vecWays;
@@ -108,19 +108,19 @@ namespace osmp
 		return ways.size();
 	}
 
-	std::shared_ptr<Way> Object::GetWay(uint64_t id) const
+	Way Object::GetWay(uint64_t id) const
 	{
-		std::map<uint64_t, std::shared_ptr<Way>>::const_iterator way = ways.find(id);
+		std::map<uint64_t, Way>::const_iterator way = ways.find(id);
 		if (way != ways.end())
 			return way->second;
 
 		return nullptr;
 	}
 
-	std::vector<std::shared_ptr<Relation>> Object::GetRelations() const
+	Relations Object::GetRelations() const
 	{
-		std::vector<std::shared_ptr<Relation>> vecRelations;
-		for (std::map<uint64_t, std::shared_ptr<Relation>>::const_iterator it = relations.begin(); it != relations.end(); it++)
+		Relations vecRelations;
+		for (std::map<uint64_t, Relation>::const_iterator it = relations.begin(); it != relations.end(); it++)
 			vecRelations.push_back(it->second);
 
 		return vecRelations;
@@ -131,9 +131,9 @@ namespace osmp
 		return relations.size();
 	}
 
-	std::shared_ptr<Relation> Object::GetRelation(uint64_t id) const
+	Relation Object::GetRelation(uint64_t id) const
 	{
-		std::map<uint64_t, std::shared_ptr<Relation>>::const_iterator relation = relations.find(id);
+		std::map<uint64_t, Relation>::const_iterator relation = relations.find(id);
 		if (relation != relations.end())
 			return relation->second;
 

lib/osmparser/src/osmrelation.cpp

@@ -1,3 +1,4 @@
+#include "..\include\osmrelation.hpp"
 #include <osmrelation.hpp>
 
 #include <memory>
@@ -11,7 +12,7 @@ namespace xml = tinyxml2;
 
 namespace osmp
 {
-	Relation::Relation(const xml::XMLElement* xml, Object* parent) :
+	IRelation::IRelation(const xml::XMLElement* xml, Object* parent) :
 		IMember(xml, parent, IMember::Type::RELATION), hasNullMembers(false)
 	{
 		const xml::XMLElement* member_element = xml->FirstChildElement("member");
@@ -21,54 +22,66 @@ namespace osmp
 			uint64_t ref = GetSafeAttributeUint64(member_element, "ref");
 			std::string role = GetSafeAttributeString(member_element, "role");
 
-			std::shared_ptr<IMember> member = nullptr;
 			if (memberType == "node") {
-				member = parent->GetNode(ref);
-				nodes.push_back({ member, role });
+				Node node = parent->GetNode(ref);
+				nodes.push_back({ node, role });
 			}
 			else if (memberType == "way") {
-				member = parent->GetWay(ref);
-				if (member == nullptr) {
+				Way way = parent->GetWay(ref);
+				if (way == nullptr) {
 					hasNullMembers = true;
 				}
-				ways.push_back({ member, role });
+				ways.push_back({ way, role });
 			}
 
 			member_element = member_element->NextSiblingElement("member");
 		}
 	}
 
-	std::string Relation::GetRelationType()
+	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 std::vector<Relation::Member>& Relation::GetNodes() const
+	const MemberNodes& IRelation::GetNodes() const
 	{
 		return nodes;
 	}
 
-	size_t Relation::GetNodesSize() const
+	size_t IRelation::GetNodesSize() const
 	{
 		return nodes.size();
 	}
 
-	const Relation::Member& Relation::GetNode(size_t index) const
+	const MemberNode& IRelation::GetNode(size_t index) const
 	{
 		return nodes[index];
 	}
 
-	const std::vector<Relation::Member>& Relation::GetWays() const
+	const MemberWays& IRelation::GetWays() const
 	{
 		return ways;
 	}
 
-	size_t Relation::GetWaysSize() const
+	size_t IRelation::GetWaysSize() const
 	{
 		return ways.size();
 	}
 
-	const Relation::Member& Relation::GetWay(size_t index) const
+	const MemberWay& IRelation::GetWay(size_t index) const
 	{
 		return ways[index];
 	}

lib/osmparser/src/osmway.cpp

@@ -10,7 +10,7 @@ namespace xml = tinyxml2;
 
 namespace osmp
 {
-	Way::Way(const tinyxml2::XMLElement* way_elem, Object* parent) :
+	IWay::IWay(const tinyxml2::XMLElement* way_elem, Object* parent) :
 		IMember(way_elem, parent, IMember::Type::WAY)
 	{
 		area = GetSafeAttributeBool(way_elem, "area");
@@ -35,17 +35,30 @@ namespace osmp
 		}
 	}
 
-	const std::vector<std::shared_ptr<Node>>& Way::GetNodes() const
+	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 Way::GetNodesSize() const
+	size_t IWay::GetNodesSize() const
 	{
 		return nodes.size();
 	}
 
-	const std::shared_ptr<Node>& Way::GetNode(size_t index) const
+	Node IWay::GetNode(size_t index) const
 	{
 		return nodes[index];
 	}