Utility: TextAccess

Abstraction for file or text access.

review id = 16

fortune cookie message = Good news from someone dear is coming soon.

src/lib/CMakeLists.txt

@@ -111,7 +111,10 @@ add_files(
 	utility/messaging/MessageListenerBase.h
 	utility/messaging/MessageQueue.cpp
 	utility/messaging/MessageQueue.h
-
+	
+	utility/text/TextAccess.cpp
+	utility/text/TextAccess.h
+	
 	utility/ConfigManager.cpp
 	utility/ConfigManager.h
 	utility/FileSystem.cpp

src/lib/utility/ConfigManager.cpp

@@ -1,8 +1,10 @@
 #include "utility/ConfigManager.h"
 
-std::shared_ptr<ConfigManager> ConfigManager::createAndLoad(const std::string& filePath)
+#include "utility/text/TextAccess.h"
+
+std::shared_ptr<ConfigManager> ConfigManager::createAndLoad(const std::shared_ptr<TextAccess> textAccess)
 {
-	std::shared_ptr<ConfigManager> configManager = std::shared_ptr<ConfigManager>(new ConfigManager(filePath));
+	std::shared_ptr<ConfigManager> configManager = std::shared_ptr<ConfigManager>(new ConfigManager(textAccess));
 	configManager->load();
 	return configManager;
 }
@@ -88,10 +90,11 @@ void ConfigManager::setValue(const std::string& key, const bool value)
 
 void ConfigManager::load()
 {
-	// LOG ("Loading config from file: " + m_filePath)
+	std::string text = m_textAccess->getText();
 
-	TiXmlDocument doc(m_filePath.c_str());
-	if (doc.LoadFile())
+	TiXmlDocument doc;
+	const char* pTest = doc.Parse(text.c_str(), 0, TIXML_ENCODING_UTF8);
+	if (pTest != NULL)
 	{
 		TiXmlHandle docHandle(&doc);
 		TiXmlNode *rootNode = docHandle.FirstChild("config").ToNode();
@@ -111,8 +114,8 @@ void ConfigManager::save()
 	// LOG ("Saving config to file: " + m_filePath)
 }
 
-ConfigManager::ConfigManager(const std::string& filePath)
-	: m_filePath(filePath)
+ConfigManager::ConfigManager(const std::shared_ptr<TextAccess> textAccess)
+	: m_textAccess(textAccess)
 {
 }
 

src/lib/utility/ConfigManager.h

@@ -8,11 +8,12 @@
 
 #include "tinyxml/tinyxml.h"
 
+class TextAccess;
 
 class ConfigManager
 {
 public:
-	static std::shared_ptr<ConfigManager> createAndLoad(const std::string& filePath);
+	static std::shared_ptr<ConfigManager> createAndLoad(const std::shared_ptr<TextAccess> textAccess);
 
 	bool getValue(const std::string& key, std::string& value) const;
 	bool getValue(const std::string& key, int& value) const;
@@ -28,13 +29,13 @@ public:
 	void save();
 
 private:
-	ConfigManager(const std::string& filePath);
+	ConfigManager(const std::shared_ptr<TextAccess> textAccess);
 	ConfigManager(const ConfigManager&);
 	ConfigManager operator=(const ConfigManager&);
 
 	void parseSubtree(TiXmlNode* parentElement, const std::string& currentPath);
 
-	const std::string m_filePath;
+	const std::shared_ptr<TextAccess> m_textAccess;
 	std::map<std::string, std::string> m_values;
 };
 

src/lib/utility/text/TextAccess.cpp

@@ -0,0 +1,193 @@
+#include "TextAccess.h"
+
+#include <fstream>
+#include <sstream>
+
+#include "utility/logging/logging.h"
+
+std::shared_ptr<TextAccess> TextAccess::createFromFile(const std::string& filePath)
+{
+	std::shared_ptr<TextAccess> result(new TextAccess());
+
+	result->m_filePath = filePath;
+	result->m_lines = readFile(filePath);
+
+	return result;
+}
+
+std::shared_ptr<TextAccess> TextAccess::createFromString(const std::string& text)
+{
+	std::shared_ptr<TextAccess> result(new TextAccess());
+
+	result->m_lines = splitStringByLines(text);
+
+	return result;
+}
+
+TextAccess::~TextAccess()
+{
+}
+
+unsigned int TextAccess::getLineCount() const
+{
+	return m_lines.size();
+}
+
+std::string TextAccess::getFilePath() const
+{
+	return m_filePath;
+}
+
+std::string TextAccess::getLine(const unsigned int lineNumber) const
+{
+	if(lineNumber < 1)
+	{
+		std::stringstream message;
+		message << "Line numbers start with one, is " << lineNumber;
+		LOG_WARNING(message.str());
+
+		return "";
+	}
+
+	if (checkIndexInRange(lineNumber-1) == false)
+	{
+		return "";
+	}
+
+	return m_lines[lineNumber-1]; // -1 to correct for use as index
+}
+
+std::vector<std::string> TextAccess::getLines(const unsigned int firstLineNumber, const unsigned int lastLineNumber)
+{
+	if(firstLineNumber < 1)
+	{
+		std::stringstream message;
+		message << "Line numbers start with one, is " << firstLineNumber;
+		LOG_WARNING(message.str());
+
+		return std::vector<std::string>();
+	}
+
+	if(lastLineNumber < 1)
+	{
+		std::stringstream message;
+		message << "Line numbers start with one, is " << lastLineNumber;
+		LOG_WARNING(message.str());
+
+		return std::vector<std::string>();
+	}
+
+	if (checkIndexIntervalInRange(firstLineNumber-1, lastLineNumber-1) == false)
+	{
+		return std::vector<std::string>();
+	}
+
+	std::vector<std::string>::iterator first = m_lines.begin() + firstLineNumber-1; // -1 to correct for use as index
+	std::vector<std::string>::iterator last = m_lines.begin() + lastLineNumber; // no correction needed because 'last' needs to point one behind the last included element
+	return std::vector<std::string>(first, last);
+}
+
+std::vector<std::string> TextAccess::getAllLines() const
+{
+	return m_lines;
+}
+
+std::string TextAccess::getText() const
+{
+	std::string result = "";
+
+	for(unsigned int i = 0; i < m_lines.size(); i++)
+	{
+		result += m_lines[i];
+	}
+
+	return result;
+}
+
+std::vector<std::string> TextAccess::readFile(const std::string& filePath)
+{
+	std::vector<std::string> result;
+
+	std::ifstream srcFile;
+	srcFile.open(filePath);
+
+	while (!srcFile.eof())
+	{
+		std::string line;
+		std::getline(srcFile, line);
+		result.push_back(line + "\n");
+	}
+	srcFile.close();
+
+	return result;
+}
+
+std::vector<std::string> TextAccess::splitStringByLines(const std::string& text)
+{
+	std::vector<std::string> result;
+	int prevIndex = 0;
+	int index = text.find("\n");
+
+	while (index != std::string::npos)
+	{
+		result.push_back(text.substr(prevIndex, index - prevIndex) + "\n");
+
+		prevIndex = index+1;
+		index = text.find("\n", prevIndex);
+	}
+
+	if (prevIndex < text.length()-1)
+	{
+		result.push_back(text.substr(prevIndex));
+	}
+
+	return result;
+}
+
+TextAccess::TextAccess()
+	: m_filePath("")
+{
+}
+
+bool TextAccess::checkIndexInRange(const unsigned int index) const
+{
+	if (index >= m_lines.size())
+	{
+		std::stringstream message;
+		message << "Tried to access index " << index;
+		message << ". Maximum index is " << m_lines.size() - 1;
+		LOG_WARNING(message.str());
+
+		return false;
+	}
+
+	return true;
+}
+
+bool TextAccess::checkIndexIntervalInRange(
+	const unsigned int firstIndex,
+	const unsigned int lastIndex
+) const
+{
+	if (checkIndexInRange(firstIndex) == false)
+	{
+		return false;
+	}
+
+	if (checkIndexInRange(lastIndex) == false)
+	{
+		return false;
+	}
+
+	if (firstIndex > lastIndex)
+	{
+		std::stringstream message;
+		message << "Index 'firstLine' has to be lower or equal index 'lastLine'";
+		message << ", is " << firstIndex << " > " << lastIndex;
+		LOG_WARNING(message.str());
+
+		return false;
+	}
+
+	return true;
+}

src/lib/utility/text/TextAccess.h

@@ -0,0 +1,47 @@
+#ifndef TEXT_ACCESS_H
+#define TEXT_ACCESS_H
+
+#include <memory>
+#include <string>
+#include <vector>
+
+class TextAccess
+{
+public:
+	static std::shared_ptr<TextAccess> createFromFile(const std::string& filePath);
+	static std::shared_ptr<TextAccess> createFromString(const std::string& text);
+
+	virtual ~TextAccess();
+
+	unsigned int getLineCount() const;
+
+	std::string getFilePath() const;
+
+	/**
+	 * @param lineNumber: starts with 1
+	 */
+	std::string getLine(const unsigned int lineNumber) const;
+	/**
+	 * @param firstLineNumber: starts with 1
+	 * @param lastLineNumber: starts with 1
+	 */
+	std::vector<std::string> getLines(const unsigned int firstLineNumber, const unsigned int lastLineNumber);
+	std::vector<std::string> getAllLines() const;
+	std::string getText() const;
+
+private:
+	static std::vector<std::string> readFile(const std::string& filePath);
+	static std::vector<std::string> splitStringByLines(const std::string& text);
+
+	TextAccess();
+	TextAccess(const TextAccess&);
+	TextAccess operator=(const TextAccess&);
+
+	bool checkIndexInRange(const unsigned int index) const;
+	bool checkIndexIntervalInRange(const unsigned int firstIndex, const unsigned int lastIndex) const;
+
+	std::string m_filePath;
+	std::vector<std::string> m_lines;
+};
+
+#endif // TEXT_ACCESS_H