A more advanced ini parser

So once upon a time ChrisMAN posted his dumb AS ini parser. It worked for what it did, but godamn it was Angelscript and so not usable by everybody. So carnalis made his little ini/cfg parser in C++ based off ChrisMAN’s, which did the same thing but in C++ instead of Angeslcript. Following the tradition, I’ve decided to expand on this to a full Urho3D Resource based off their initial work.

Some quick features:

  • Works just as any other Urho3D Resource
  • Option to toggle case sensitivity
  • Supports ‘//’ and ‘#’ comments, ‘;’ comments were left out due to being used by some resources
  • Supports ‘=’ and ‘:’ to indicate value pairs
  • ‘Smart Save’ option - Replaces only the values, preserving the rest of the file such as comments and whitespacing
  • ‘Dumb Save’ option (default) - Writes out brand new file

An example of reading some values from a file:

auto configFile = cache->GetResource<blu::ConfigFile>("settings.cfg");

auto width = configFile->GetInt("engine", "WindowWidth", 1024);
auto height = configFile->GetInt("engine", "WindowHeight", 768);

You can set values:

configFile->Set("engine", "WindowWidth", "800");
configFile->Set("engine", "Windowheight", "600");
configFile->Set("engine", "test", "something dark side");

Then save it back out:

// Saves to application directory
Urho3D::File file(context_, "settings.cfg", Urho3D::FILE_WRITE);
configFile->Save(file, true);
file.Close();

This will be later included in a lib of useful-stuff-to-have, but I am release it independently for now.

License:

The MIT License (MIT)

Copyright (c) 2015 Thebluefish

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

ConfigFile.cpp:

#include "ConfigFile.h"

#include <Urho3D/Core/Context.h>
#include <Urho3D/Core/Variant.h>
#include <Urho3D/IO/File.h>
#include <Urho3D/Container/Str.h>
#include <Urho3D/Container/Vector.h>
#include <Urho3D/Container/HashSet.h>
#include <Urho3D/IO/MemoryBuffer.h>
#include <Urho3D/IO/Log.h>

namespace blu
{
	ConfigFile::ConfigFile(Urho3D::Context* context, bool caseSensitive)
		: Urho3D::Resource(context)
		, _caseSensitive(caseSensitive)
	{

	}

	ConfigFile::~ConfigFile()
	{

	}

	void ConfigFile::RegisterObject(Urho3D::Context* context)
	{
		context->RegisterFactory<ConfigFile>();
	}

	bool ConfigFile::BeginLoad(Urho3D::Deserializer& source)
	{
		unsigned dataSize = source.GetSize();
		if (!dataSize && !source.GetName().Empty())
		{
			LOGERROR("Zero sized data in " + source.GetName());
			return false;
		}

        ConfigSection* configSection = new ConfigSection();
        _configMap.Push(*configSection);
		while (!source.IsEof())
		{
			// Reads the next line
			auto line = source.ReadLine();

			// Parse headers
			if (line.StartsWith("[") && line.EndsWith("]"))
			{
				//Urho3D::String sectionName = line.Substring(1, line.Length() - 2);
				//currentMap = &_configMap[sectionName];

                _configMap.Push(ConfigSection());
                configSection = &_configMap.Back();
				
			}

            configSection->Push(line);
		}

		return true;
	}

	bool ConfigFile::Save(Urho3D::Serializer& dest) const
	{
		dest.WriteLine("################");
		dest.WriteLine("# AUTO-GENERATED");
		dest.WriteLine("################");

		// Iterate over all sections, printing out the header followed by the properties
		for (auto itr = _configMap.Begin(); itr != _configMap.End(); itr++)
		{
			if (itr->Begin() == itr->End())
				continue;

			// Don't print section if there's nothing to print
			bool hasHeader = false;
			for (auto section_itr = itr->Begin(); section_itr != itr->End(); section_itr++)
			{
				if (ParseComments(*section_itr) != Urho3D::String::EMPTY)
				{
					hasHeader = true;
					dest.WriteLine("");
					break;
				}
			}

			auto section_itr = itr->Begin();

			// Doesn't print header if it's empty
			if (hasHeader)
			{
				dest.WriteLine("[" + ParseHeader(*section_itr) + "]");
				dest.WriteLine("");
			}

			for (; section_itr != itr->End(); section_itr++)
			{
				auto line = ParseComments(*section_itr);

				Urho3D::String property;
				Urho3D::String value;

				ParseProperty(line, property, value);

				if (property != Urho3D::String::EMPTY && value != Urho3D::String::EMPTY)
					dest.WriteLine(property + "=" + value);
			}
		}

		return true;
	}

	bool ConfigFile::Save(Urho3D::Serializer& dest, bool smartSave) const
	{
		if (!smartSave)
			return Save(dest);

		// Iterate over all sections, printing out the header followed by the properties
		for (auto itr = _configMap.Begin(); itr != _configMap.End(); itr++)
		{
			if (itr->Begin() == itr->End())
				continue;

			for (auto section_itr = itr->Begin(); section_itr != itr->End(); section_itr++)
			{
				auto line = *section_itr;

				dest.WriteLine(line);
			}
		}

		return true;
	}

	bool ConfigFile::FromString(const Urho3D::String& source)
	{
		if (source.Empty())
			return false;

		Urho3D::MemoryBuffer buffer(source.CString(), source.Length());
		return Load(buffer);
	}

	bool ConfigFile::Has(const Urho3D::String& section, const Urho3D::String& parameter)
	{
		return GetString(section, parameter) != Urho3D::String::EMPTY;
	}

	const Urho3D::String ConfigFile::GetString(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::String& defaultValue)
	{
		// Find the correct section
		ConfigSection* configSection = 0;
		for (auto itr = _configMap.Begin(); itr != _configMap.End(); itr++)
		{
			if (itr->Begin() == itr->End())
				continue;

			auto header = *(itr->Begin());
			header = ParseHeader(header);

            if (_caseSensitive)
            {
                if (section == header)
                {
                    configSection = &(*itr);
                }
            }
            else
            {
                if (section.ToLower() == header.ToLower())
                {
                    configSection = &(*itr);
                }
            }
		}

		// Section doesn't exist
		if (!configSection)
			return defaultValue;

		for (auto itr = configSection->Begin(); itr != configSection->End(); itr++)
		{
			Urho3D::String property;
			Urho3D::String value;
			ParseProperty(*itr, property, value);

			if (property == Urho3D::String::EMPTY || value == Urho3D::String::EMPTY)
                continue;

            if (_caseSensitive)
            {
                if (parameter == property)
                    return value;
            }
            else
            {
                if (parameter.ToLower() == property.ToLower())
                    return value;
            }
		}

		return defaultValue;
	}

	const int ConfigFile::GetInt(const Urho3D::String& section, const Urho3D::String& parameter, const int defaultValue)
	{
		auto property = GetString(section, parameter);

		if (property == Urho3D::String::EMPTY)
			return defaultValue;

		return Urho3D::ToInt(property);
	}

	const bool ConfigFile::GetBool(const Urho3D::String& section, const Urho3D::String& parameter, const bool defaultValue)
	{
		auto property = GetString(section, parameter);

		if (property == Urho3D::String::EMPTY)
			return defaultValue;

		return Urho3D::ToBool(property);
	}

	const float ConfigFile::GetFloat(const Urho3D::String& section, const Urho3D::String& parameter, const float defaultValue)
	{
		auto property = GetString(section, parameter);

		if (property == Urho3D::String::EMPTY)
			return defaultValue;

		return Urho3D::ToFloat(property);
	}

	const Urho3D::Vector2 ConfigFile::GetVector2(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Vector2& defaultValue)
	{
		auto property = GetString(section, parameter);

		if (property == Urho3D::String::EMPTY)
			return defaultValue;

		return Urho3D::ToVector2(property);
	}

	const Urho3D::Vector3 ConfigFile::GetVector3(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Vector3& defaultValue)
	{
		auto property = GetString(section, parameter);

		if (property == Urho3D::String::EMPTY)
			return defaultValue;

		return Urho3D::ToVector3(property);
	}

	const Urho3D::Vector4 ConfigFile::GetVector4(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Vector4& defaultValue)
	{
		auto property = GetString(section, parameter);

		if (property == Urho3D::String::EMPTY)
			return defaultValue;

		return Urho3D::ToVector4(property);
	}

	const Urho3D::Quaternion ConfigFile::GetQuaternion(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Quaternion& defaultValue)
	{
		auto property = GetString(section, parameter);

		if (property == Urho3D::String::EMPTY)
			return defaultValue;

		return Urho3D::ToQuaternion(property);
	}

	const Urho3D::Color ConfigFile::GetColor(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Color& defaultValue)
	{
		auto property = GetString(section, parameter);

		if (property == Urho3D::String::EMPTY)
			return defaultValue;

		return Urho3D::ToColor(property);
	}

	const Urho3D::IntRect ConfigFile::GetIntRect(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::IntRect& defaultValue)
	{
		auto property = GetString(section, parameter);

		if (property == Urho3D::String::EMPTY)
			return defaultValue;

		return Urho3D::ToIntRect(property);
	}

	const Urho3D::IntVector2 ConfigFile::GetIntVector2(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::IntVector2& defaultValue)
	{
		auto property = GetString(section, parameter);

		if (property == Urho3D::String::EMPTY)
			return defaultValue;

		return Urho3D::ToIntVector2(property);
	}

	const Urho3D::Matrix3 ConfigFile::GetMatrix3(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Matrix3& defaultValue)
	{
		auto property = GetString(section, parameter);

		if (property == Urho3D::String::EMPTY)
			return defaultValue;

		return Urho3D::ToMatrix3(property);
	}

	const Urho3D::Matrix3x4 ConfigFile::GetMatrix3x4(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Matrix3x4& defaultValue)
	{
		auto property = GetString(section, parameter);

		if (property == Urho3D::String::EMPTY)
			return defaultValue;

		return Urho3D::ToMatrix3x4(property);
	}

	const Urho3D::Matrix4 ConfigFile::GetMatrix4(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Matrix4& defaultValue)
	{
		auto property = GetString(section, parameter);

		if (property == Urho3D::String::EMPTY)
			return defaultValue;

		return Urho3D::ToMatrix4(property);
	}

	void ConfigFile::Set(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::String& value)
	{
        // Find the correct section
        ConfigSection* configSection = 0;
        for (auto itr = _configMap.Begin(); itr != _configMap.End(); itr++)
        {
            if (itr->Begin() == itr->End())
                continue;

            auto header = *(itr->Begin());
            header = ParseHeader(header);

            if (_caseSensitive)
            {
                if (section == header)
                {
                    configSection = &(*itr);
                }
            }
            else
            {
                if (section.ToLower() == header.ToLower())
                {
                    configSection = &(*itr);
                }
            }
        }

        // Section doesn't exist
        if (!configSection)
        {
            // Create section
            _configMap.Push(ConfigSection());
            configSection = &_configMap.Back();
        }

        Urho3D::String* line = 0;
        unsigned separatorPos = 0;
        for (auto itr = configSection->Begin(); itr != configSection->End(); itr++)
        {
            // Find property seperator
            separatorPos = itr->Find("=");
            if (separatorPos == Urho3D::String::NPOS)
            {
                separatorPos = itr->Find(":");
            }

            // Not a property
            if (separatorPos == Urho3D::String::NPOS)
                continue;

            Urho3D::String workingLine = ParseComments(*itr);

            auto oldParameter = workingLine.Substring(0, separatorPos).Trimmed();
            auto oldValue = workingLine.Substring(separatorPos + 1).Trimmed();
            
            // Not the correct parameter
            if (_caseSensitive ? (oldParameter == parameter) : (oldParameter.ToLower() == parameter.ToLower()))
            {
                // Replace the value

                itr->Replace(itr->Find(oldValue, separatorPos), oldValue.Length(), value);
                return;
            }
        }

        // Parameter doesn't exist yet
        // We need to find a good place to insert the parameter
        // Avoiding lines which are entirely comments or whitespacing
        int index = configSection->Size() - 1;
        for (int i = index; i >= 0; i--)
        {
            if (ParseComments((*configSection)[i]) != Urho3D::String::EMPTY)
            {
                index = i + 1;
                break;
            }
        }
        configSection->Insert(index, parameter + "=" + value);
	}

	// Returns header without bracket
	Urho3D::String ConfigFile::ParseHeader(Urho3D::String line) const
	{
		// Only parse comments outside of headers
		unsigned commentPos = 0;

		while (commentPos != Urho3D::String::NPOS)
		{
			// Find next comment
			auto lastCommentPos = commentPos;
			auto commaPos = line.Find("//", commentPos);
			auto hashPos = line.Find("#", commentPos);
			commentPos = (commaPos < hashPos) ? commaPos : hashPos;

			// Header is behind a comment
			if (line.Find("[", lastCommentPos) > commentPos)
			{
				// Stop parsing this line
				break;
			}

			// Header is before the comment
			if (line.Find("[") < commentPos)
			{
				int startPos = line.Find("[") + 1;
				int l1 = line.Find("]");
				int length = l1 - startPos;
				line = line.Substring(startPos, length);
				break;
			}
		}

		line = line.Trimmed();

		return line;
	}

	//  property or Empty if no property
	void ConfigFile::ParseProperty(Urho3D::String line, Urho3D::String& property, Urho3D::String& value) const
	{
        line = ParseComments(line);

        // Find property seperator
        auto separatorPos = line.Find("=");
        if (separatorPos == Urho3D::String::NPOS)
        {
            separatorPos = line.Find(":");
        }

        // Not a property
        if (separatorPos == Urho3D::String::NPOS)
        {
            property = Urho3D::String::EMPTY;
            value = Urho3D::String::EMPTY;
            return;
        }

        property = line.Substring(0, separatorPos).Trimmed();
        value = line.Substring(separatorPos + 1).Trimmed();
	}

	// strips comments and whitespaces
	Urho3D::String ConfigFile::ParseComments(Urho3D::String line) const
	{
		// Comments are normalized
		line.Replace("//", "#");

		// Ignore comments
		unsigned commentPos = line.Find("#");
		if (commentPos != Urho3D::String::NPOS)
		{
			line = line.Substring(0, commentPos);
		}

		return line;
	}
}

ConfigFile.h:

#pragma once

#include <Urho3D/Urho3D.h>
#include <Urho3D/Resource/Resource.h>
#include <Urho3D/Core/Variant.h>
#include <Urho3D/Core/StringUtils.h>

namespace Urho3D
{
	class File;
	class Variant;
}

namespace blu
{
	typedef Urho3D::Vector<Urho3D::String> ConfigSection;
	typedef Urho3D::Vector<ConfigSection> ConfigMap;

	class ConfigFile : public Urho3D::Resource
	{
	public:
		ConfigFile(Urho3D::Context* context, bool caseSensitive = false);
		~ConfigFile();

		static void RegisterObject(Urho3D::Context* context);

		void SetCaseSensitive(bool caseSensitive) { _caseSensitive = caseSensitive; }

		/// Load resource from stream. May be called from a worker thread. Return true if successful.
		virtual bool BeginLoad(Urho3D::Deserializer& source);
		/// Save resource
		virtual bool Save(Urho3D::Serializer& dest) const;
		/// Smart Save resource, replacing only the values, keeping whitespacing and comments
		virtual bool Save(Urho3D::Serializer& dest, bool smartSave) const;

		/// Deserialize from a string. Return true if successful.
		bool FromString(const Urho3D::String& source);

		const ConfigMap* GetMap() { return &_configMap; }

		bool Has(const Urho3D::String& section, const Urho3D::String& parameter);

		const Urho3D::String GetString(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::String& defaultValue = Urho3D::String::EMPTY);
		const int GetInt(const Urho3D::String& section, const Urho3D::String& parameter, const int defaultValue = 0);
		const bool GetBool(const Urho3D::String& section, const Urho3D::String& parameter, const bool defaultValue = false);
		const float GetFloat(const Urho3D::String& section, const Urho3D::String& parameter, const float defaultValue = 0.f);
		const Urho3D::Vector2 GetVector2(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Vector2& defaultValue = Urho3D::Vector2::ZERO);
		const Urho3D::Vector3 GetVector3(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Vector3& defaultValue = Urho3D::Vector3::ZERO);
		const Urho3D::Vector4 GetVector4(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Vector4& defaultValue = Urho3D::Vector4::ZERO);
		const Urho3D::Quaternion GetQuaternion(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Quaternion& defaultValue = Urho3D::Quaternion::IDENTITY);
		const Urho3D::Color GetColor(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Color& defaultValue = Urho3D::Color::WHITE);
		const Urho3D::IntRect GetIntRect(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::IntRect& defaultValue = Urho3D::IntRect::ZERO);
		const Urho3D::IntVector2 GetIntVector2(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::IntVector2& defaultValue = Urho3D::IntVector2::ZERO);
		const Urho3D::Matrix3 GetMatrix3(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Matrix3& defaultValue = Urho3D::Matrix3::IDENTITY);
		const Urho3D::Matrix3x4 GetMatrix3x4(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Matrix3x4& defaultValue = Urho3D::Matrix3x4::IDENTITY);
		const Urho3D::Matrix4 GetMatrix4(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::Matrix4& defaultValue = Urho3D::Matrix4::IDENTITY);
		
		void Set(const Urho3D::String& section, const Urho3D::String& parameter, const Urho3D::String& value);

	protected:

		// Returns header without bracket
		Urho3D::String ParseHeader(Urho3D::String line) const;
		//  property or Empty if no property
		void ParseProperty(Urho3D::String line, Urho3D::String& property, Urho3D::String& value) const;
		// strips comments and whitespaces
		Urho3D::String ParseComments(Urho3D::String line) const;

	protected:

		bool _caseSensitive;
		ConfigMap _configMap;
	};
}
3 Likes