Initial commit.

src/web/xml/XmlAttribute.cpp

@@ -0,0 +1,29 @@
+#include "XmlAttribute.h"
+
+
+XmlAttribute::XmlAttribute(const std::string& name)
+	: mName(name),
+	  mValue()
+{
+
+}
+
+std::shared_ptr<XmlAttribute> XmlAttribute::Create(const std::string& name)
+{
+	return std::make_shared<XmlAttribute>(name);
+}
+
+void XmlAttribute::SetValue(const std::string& value)
+{
+	mValue = value;
+}
+
+std::string XmlAttribute::GetName() const
+{
+	return mName;
+}
+
+std::string XmlAttribute::GetValue() const
+{
+	return mValue;
+}

src/web/xml/XmlAttribute.h

@@ -0,0 +1,25 @@
+#pragma once
+#include <memory>
+#include <vector>
+#include <string>
+
+class XmlAttribute
+{
+
+	std::string mName;
+	std::string mValue;
+
+public:
+
+	XmlAttribute(const std::string& name);
+
+	static std::shared_ptr<XmlAttribute> Create(const std::string& name);
+
+	void SetValue(const std::string& value);
+
+	std::string GetName() const;
+
+	std::string GetValue() const;
+};
+
+using XmlAttributePtr = std::shared_ptr<XmlAttribute>;

src/web/xml/XmlDocument.cpp

@@ -0,0 +1,34 @@
+#include "XmlDocument.h"
+
+
+XmlDocument::XmlDocument()
+	:mProlog(XmlProlog::Create("xml"))
+{
+
+}
+
+std::shared_ptr<XmlDocument> XmlDocument::Create()
+{
+	return std::make_shared<XmlDocument>();
+}
+
+void XmlDocument::SetProlog(XmlPrologPtr prolog)
+{
+	mProlog = prolog;
+}
+
+XmlPrologPtr XmlDocument::GetProlog() const
+{
+	return mProlog;
+}
+
+void XmlDocument::SetRoot(XmlElementPtr root)
+{
+	mRoot = root;
+}
+
+XmlElementPtr XmlDocument::GetRoot() const
+{
+	return mRoot;
+}
+

src/web/xml/XmlDocument.h

@@ -0,0 +1,26 @@
+#pragma once
+#include <memory>
+#include <string>
+#include "XmlElement.h"
+#include "XmlProlog.h"
+
+class XmlDocument
+{
+	XmlPrologPtr mProlog;
+	XmlElementPtr mRoot;
+
+public:
+	XmlDocument();
+
+	static std::shared_ptr<XmlDocument> Create();
+
+	void SetProlog(XmlPrologPtr prolog);
+	XmlPrologPtr GetProlog() const;
+
+	void SetRoot(XmlElementPtr root);
+	XmlElementPtr GetRoot() const;
+
+
+};
+
+using XmlDocumentPtr = std::shared_ptr<XmlDocument>;

src/web/xml/XmlElement.cpp

@@ -0,0 +1,61 @@
+#include "XmlElement.h"
+
+
+XmlElement::XmlElement(const std::string& tagName)
+	: mTagName(tagName),
+	  mChildren()
+{
+
+}
+
+std::shared_ptr<XmlElement> XmlElement::Create(const std::string& tagName)
+{
+	return std::make_shared<XmlElement>(tagName);
+}
+
+void XmlElement::AddChild(std::shared_ptr<XmlElement> child)
+{
+	mChildren.push_back(child);
+}
+
+std::string XmlElement::GetTagName() const
+{
+	return mTagName;
+}
+
+std::string XmlElement::GetText() const
+{
+	return mText;
+}
+
+void XmlElement::SetText(const std::string& text)
+{
+	mText = text;
+}
+
+void XmlElement::AddAttribute(XmlAttributePtr attribute)
+{
+	mAttributes.push_back(attribute);
+}
+
+XmlAttributePtr XmlElement::GetAttribute(const std::string& attributeName) const
+{
+	for(const auto& attribute : mAttributes)
+	{
+		if(attribute->GetName() == attributeName)
+		{
+			return attribute;
+		}
+	}
+	return nullptr;
+}
+
+std::size_t XmlElement::GetNumAttributes() const
+{
+	return mAttributes.size();
+}
+
+std::vector<XmlAttributePtr> XmlElement::GetAttributes()
+{
+	return mAttributes;
+}

src/web/xml/XmlElement.h

@@ -0,0 +1,32 @@
+#pragma once
+#include <memory>
+#include <vector>
+#include <string>
+#include "XmlAttribute.h"
+
+class XmlElement
+{
+protected:
+	std::string mTagName;
+	std::vector<XmlAttributePtr> mAttributes;
+	std::vector<std::shared_ptr<XmlElement> > mChildren;
+	std::string mText;
+
+public:
+	XmlElement(const std::string& tagName);
+	virtual ~XmlElement() = default;
+
+	static std::shared_ptr<XmlElement> Create(const std::string& tagName);
+
+	void AddChild(std::shared_ptr<XmlElement> child);
+	std::string GetTagName() const;
+	std::string GetText() const;
+	void SetText(const std::string& text);
+
+	void AddAttribute(XmlAttributePtr attribute);
+	XmlAttributePtr GetAttribute(const std::string& attribute) const;
+	std::size_t GetNumAttributes() const;
+	std::vector<XmlAttributePtr> GetAttributes();
+};
+
+using XmlElementPtr = std::shared_ptr<XmlElement>;

src/web/xml/XmlParser.cpp

@@ -0,0 +1,380 @@
+#include "XmlParser.h"
+#include "StringUtils.h"
+#include <iostream>
+
+using LS = XmlParser::LineState;
+using DS = XmlParser::DocumentState;
+
+XmlParser::XmlParser()
+	: mDocument(XmlDocument::Create()),
+	  mDocumentState(XmlParser::DocumentState::Await_Prolog),
+	  mLineState(XmlParser::LineState::Await_Tag_Open)
+{
+
+}
+
+void XmlParser::ProcessLine(const std::string& input)
+{
+	for(std::size_t idx; idx<input.size(); idx++)
+	{
+		switch (input[idx])
+		{
+			case StringUtils::LEFT_BRACKET:
+				OnLeftBracket();
+				break;
+			case StringUtils::RIGHT_BRACKET:
+				OnRightBracket();
+				break;
+			case StringUtils::QUESTION_MARK:
+				OnQuestionMark();
+				break;
+			case StringUtils::FORWARD_SLASH:
+				OnForwardSlash();
+				break;
+			case StringUtils::EQUALS:
+				OnEquals();
+				break;
+			case StringUtils::DOUBLE_QUOTE:
+				OnDoubleQuote();
+				break;
+			default:
+				OnChar(input[idx]);
+				break;
+		}
+	}
+}
+
+void XmlParser::OnChar(char c)
+{
+	if(StringUtils::IsAlphaNumeric(c))
+	{
+		OnAlphaNumeric(c);
+	}
+	else if(StringUtils::IsSpace(c))
+	{
+		OnSpace(c);
+	}
+	else
+	{
+		OnNonAlphaNumeric(c);
+	}
+}
+
+void XmlParser::OnAlphaNumeric(char c)
+{
+	switch(mLineState)
+	{
+		case LS::Await_Tag_Open:
+			OnTextStart(c);
+			break;
+		case LS::Await_Tag_Follower:
+		case LS::Await_Tag_Name:
+		{
+			OnTagNameStart(c);
+			break;
+		}
+		case LS::Await_Tag_Name_End:
+		{
+			mWorkingTagName.push_back(c);
+			break;
+		}
+		case LS::Await_Attribute_Name:
+		{
+			OnAttributeNameStart(c);
+			break;
+		}
+		case LS::Await_Attribute_Name_End:
+		{
+			mWorkingAttributeName.push_back(c);
+			break;
+		}
+		case LS::Await_Attribute_Value:
+		{
+			break;
+		}
+		case LS::Await_Attribute_Value_End:
+		{
+			mWorkingAttributeValue.push_back(c);
+			break;
+		}
+		case LS::Await_Text_End:
+		{
+			mWorkingText.push_back(c);
+			break;
+		}
+		default:
+			break;
+	}
+}
+
+void XmlParser::OnNonAlphaNumeric(char c)
+{
+	switch(mLineState)
+	{
+		case LS::Await_Tag_Name_End:
+		{
+			mWorkingTagName.push_back(c);
+			break;
+		}
+		case LS::Await_Attribute_Name_End:
+		{
+			mWorkingAttributeName.push_back(c);
+			break;
+		}
+		case LS::Await_Attribute_Value_End:
+		{
+			mWorkingAttributeValue.push_back(c);
+			break;
+		}
+		case LS::Await_Text_End:
+		{
+			mWorkingText.push_back(c);
+			break;
+		}
+		default:
+			break;
+	}
+}
+
+void XmlParser::OnSpace(char c)
+{
+	switch(mLineState)
+	{
+	case LS::Await_Tag_Name_End:
+		OnTagNameEnd();
+		break;
+	case LS::Await_Attribute_Name_End:
+		OnAttributeNameEnd();
+		break;
+	case LS::Await_Text_End:
+		mWorkingText.push_back(c);
+		break;
+	case LS::Await_Attribute_Value_End:
+		mWorkingAttributeValue.push_back(c);
+		break;
+	default:
+		break;
+	}
+}
+
+void XmlParser::OnLeftBracket()
+{
+	switch(mLineState)
+	{
+	case LS::Await_Tag_Open:
+	{
+		OnTagOpen();
+		break;
+	}
+	case LS::Await_Text_End:
+	{
+		OnTextEnd();
+		OnTagOpen();
+		break;
+	}
+	default:
+		OnNonAlphaNumeric(StringUtils::LEFT_BRACKET);
+		break;
+	}
+}
+
+void XmlParser::OnRightBracket()
+{
+	switch(mLineState)
+	{
+	case LS::Await_Tag_Name_End:
+	case LS::Await_Attribute_Name:
+	case LS::Await_Attribute_Name_End:
+	case LS::Await_Attribute_Value:
+	{
+		OnTagClose();
+		break;
+	}
+	default:
+		OnNonAlphaNumeric(StringUtils::RIGHT_BRACKET);
+		break;
+	}
+}
+
+void XmlParser::OnQuestionMark()
+{
+	if(mLineState == LS::Await_Tag_Follower)
+	{
+		if(mDocumentState == DS::Await_Prolog)
+		{
+			OnStartProlog();
+		}
+	}
+	else if(mDocumentState != DS::Build_Prolog)
+	{
+		OnNonAlphaNumeric(StringUtils::QUESTION_MARK);
+	}
+}
+
+void XmlParser::OnForwardSlash()
+{
+	if(mLineState == LS::Await_Tag_Follower)
+	{
+		if(mDocumentState == DS::Await_Element || mDocumentState == DS::Build_Element)
+		{
+			mDocumentState = DS::Close_Element;
+		}
+	}
+}
+
+void XmlParser::OnEquals()
+{
+	if(mLineState == LS::Await_Attribute_Name_End)
+	{
+		OnAttributeNameEnd();
+	}
+	else
+	{
+		OnNonAlphaNumeric(StringUtils::EQUALS);
+	}
+}
+
+void XmlParser::OnDoubleQuote()
+{
+	if(mLineState == LS::Await_Attribute_Value)
+	{
+		OnAttributeValueStart();
+	}
+	else if(mLineState == LS::Await_Attribute_Value_End)
+	{
+		OnAttributeValueEnd();
+	}
+}
+
+void XmlParser::OnTagOpen()
+{
+	mLineState = LS::Await_Tag_Follower;
+}
+
+void XmlParser::OnTagClose()
+{
+	if(mDocumentState == DS::Build_Prolog)
+	{
+		onFinishProlog();
+	}
+	else if(mDocumentState == DS::Build_Element)
+	{
+		if(mLineState == LS::Await_Tag_Name_End)
+		{
+			OnTagNameEnd();
+		}
+		onElementTagEnd();
+	}
+	else if(mDocumentState == DS::Close_Element)
+	{
+		if(mWorkingElement->GetTagName() == mWorkingTagName)
+		{
+			mDocumentState = DS::Await_Element;
+			mLineState = LS::Await_Tag_Open;
+			if(mParentElement)
+			{
+				mWorkingElement = mParentElement;
+			}
+		}
+	}
+}
+
+void XmlParser::OnTextStart(char c)
+{
+	mWorkingText = c;
+	mLineState = LS::Await_Text_End;
+}
+
+void XmlParser::OnTextEnd()
+{
+	mWorkingElement->SetText(mWorkingText);
+}
+
+void XmlParser::onElementTagEnd()
+{
+	mDocumentState = DS::Await_Element;
+	mLineState = LS::Await_Tag_Open;
+}
+
+void XmlParser::OnTagNameStart(char c)
+{
+	mWorkingTagName = c;
+	mLineState = LS::Await_Tag_Name_End;
+	if(mDocumentState != DS::Build_Prolog && mDocumentState != DS::Close_Element)
+	{
+		mDocumentState = DS::Build_Element;
+	}
+}
+
+void XmlParser::OnTagNameEnd()
+{
+	if(mDocumentState == DS::Build_Prolog)
+	{
+		mWorkingProlog = XmlProlog::Create(mWorkingTagName);
+		mLineState = LS::Await_Attribute_Name;
+	}
+	else if(mDocumentState == DS::Build_Element)
+	{
+		auto new_element = XmlElement::Create(mWorkingTagName);
+		mParentElement = mWorkingElement;
+		mWorkingElement = new_element;
+
+		if(!mDocument->GetRoot())
+		{
+			mDocument->SetRoot(mWorkingElement);
+		}
+		mLineState = LS::Await_Attribute_Name;
+	}
+}
+
+void XmlParser::OnAttributeNameStart(char c)
+{
+	mWorkingAttributeName = c;
+	mLineState = LS::Await_Attribute_Name_End;
+}
+
+void XmlParser::OnAttributeNameEnd()
+{
+	mWorkingAttribute = XmlAttribute::Create(mWorkingAttributeName);
+	if(mDocumentState == DS::Build_Prolog)
+	{
+		mWorkingProlog->AddAttribute(mWorkingAttribute);
+	}
+	else if(mDocumentState == DS::Build_Element)
+	{
+		mWorkingElement->AddAttribute(mWorkingAttribute);
+	}
+	mLineState = LS::Await_Attribute_Value;
+}
+
+void XmlParser::OnAttributeValueStart()
+{
+	mWorkingAttributeValue = "";
+	mLineState = LS::Await_Attribute_Value_End;
+}
+
+void XmlParser::OnAttributeValueEnd()
+{
+	mWorkingAttribute->SetValue(mWorkingAttributeValue);
+	mLineState = LS::Await_Attribute_Name;
+}
+
+void XmlParser::OnStartProlog()
+{
+	mDocumentState = DS::Build_Prolog;
+	mLineState = LS::Await_Tag_Name_End;
+}
+
+void XmlParser::onFinishProlog()
+{
+	mWorkingProlog->Update();
+	mDocument->SetProlog(mWorkingProlog);
+	mWorkingProlog = nullptr;
+	mDocumentState = DS::Await_Element;
+	mLineState = LS::Await_Tag_Open;
+}
+
+XmlDocumentPtr XmlParser::GetDocument() const
+{
+	return mDocument;
+}

src/web/xml/XmlParser.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <string>
+#include "XmlDocument.h"
+
+class XmlParser
+{
+public:
+	enum class DocumentState
+	{
+		Await_Prolog,
+		Build_Prolog,
+		Await_Element,
+		Build_Element,
+		Close_Element
+	};
+
+	enum class LineState
+	{
+		Await_Tag_Open,
+		Await_Tag_Follower,
+		Await_Tag_Name,
+		Await_Tag_Name_End,
+		Await_Attribute_Name,
+		Await_Attribute_Name_End,
+		Await_Attribute_Value,
+		Await_Attribute_Value_End,
+		Await_Text_End
+	};
+
+private:
+
+	DocumentState mDocumentState;
+	LineState mLineState;
+	XmlDocumentPtr mDocument;
+	XmlPrologPtr mWorkingProlog;
+	XmlElementPtr mParentElement;
+	XmlElementPtr mWorkingElement;
+	XmlAttributePtr mWorkingAttribute;
+	std::string mWorkingAttributeName;
+	std::string mWorkingTagName;
+	std::string mWorkingAttributeValue;
+	std::string mWorkingText;
+
+public:
+
+	XmlParser();
+
+	void ProcessLine(const std::string& input);
+
+	XmlDocumentPtr GetDocument() const;
+
+private:
+
+	void OnLeftBracket();
+
+	void OnRightBracket();
+
+	void OnQuestionMark();
+
+	void OnForwardSlash();
+
+	void OnChar(char c);
+
+	void OnSpace(char c);
+
+	void OnAlphaNumeric(char c);
+
+	void OnNonAlphaNumeric(char c);
+
+	void OnEquals();
+
+	void OnDoubleQuote();
+
+	void OnTagOpen();
+
+	void OnTagNameStart(char c);
+
+	void OnTagNameEnd();
+
+	void OnTagClose();
+
+	void OnTextStart(char c);
+
+	void OnTextEnd();
+
+	void OnAttributeNameStart(char c);
+
+	void OnAttributeNameEnd();
+
+	void OnAttributeValueStart();
+
+	void OnAttributeValueEnd();
+
+	void OnPrologId();
+
+	void OnStartProlog();
+
+	void onFinishProlog();
+
+	void onElementTagEnd();
+};

src/web/xml/XmlProlog.cpp

@@ -0,0 +1,54 @@
+#include "XmlProlog.h"
+
+
+XmlProlog::XmlProlog(const std::string& tagName)
+	: XmlElement(tagName),
+	  mVersion(XmlProlog::Version::V1_0),
+	  mEncoding(XmlProlog::Encoding::UTF8)
+{
+
+}
+
+std::shared_ptr<XmlProlog> XmlProlog::Create(const std::string& tagName)
+{
+	return std::make_shared<XmlProlog>(tagName);
+}
+
+XmlProlog::Encoding XmlProlog::GetEncoding() const
+{
+	return mEncoding;
+}
+
+XmlProlog::Version XmlProlog::GetVersion() const
+{
+	return mVersion;
+}
+
+void XmlProlog::SetEncoding(const std::string& encoding)
+{
+	if(encoding == "UTF-8")
+	{
+		mEncoding == XmlProlog::Encoding::UTF8;
+	}
+}
+
+void XmlProlog::SetVersion(const std::string& version)
+{
+	if(version == "1.0")
+	{
+		mVersion == XmlProlog::Version::V1_0;
+	}
+}
+
+void XmlProlog::Update()
+{
+	if(const auto version = GetAttribute("version"))
+	{
+		SetVersion(version->GetValue());
+	}
+
+	if(const auto encoding = GetAttribute("encoding"))
+	{
+		SetEncoding(encoding->GetValue());
+	}
+}

src/web/xml/XmlProlog.h

@@ -0,0 +1,36 @@
+#pragma once
+#include <memory>
+#include <vector>
+#include "XmlElement.h"
+
+class XmlProlog : public XmlElement
+{
+public:
+
+	enum class Version{
+		V1_0
+	};
+
+	enum class Encoding{
+		UTF8
+	};
+
+private:
+
+	Version mVersion;
+	Encoding mEncoding;
+	std::string mTagName;
+
+public:
+	XmlProlog(const std::string& tagName);
+
+	static std::shared_ptr<XmlProlog> Create(const std::string& tagName);
+	void Update();
+	Encoding GetEncoding() const;
+	Version GetVersion() const;
+
+	void SetEncoding(const std::string& encoding);
+	void SetVersion(const std::string& version);
+};
+
+using XmlPrologPtr = std::shared_ptr<XmlProlog>;