sven/plains
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

new file: lib/mini-yaml/yaml.hpp

Browse Source 
modified:   src/core/CMakeLists.txt
	modified:   src/core/ConfigManager.cpp
This commit is contained in:
Sven Luethi committed 2024-06-11 21:50:21 +02:00
1 parent 1a059baa3b
commit c064b4409c
3 files changed
+658
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

lib/mini-yaml/yaml.hpp
+656
View File
@@ -0,0 +1,656 @@
/*
* MIT License
*
* Copyright(c) 2018 Jimmie Bergmann
*
* 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.
*
*/
/*
YAML documentation:
http://yaml.org/spec/1.0/index.html
https://www.codeproject.com/Articles/28720/YAML-Parser-in-C
*/
#pragma once
#include <exception>
#include <string>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <map>
/**
* @breif Namespace wrapping mini-yaml classes.
*
*/
namespace Yaml
{
/**
* @breif Forward declarations.
*
*/
class Node;
/**
* @breif Helper classes and functions
*
*/
namespace impl
{
/**
* @breif Helper functionality, converting string to any data type.
* Strings are left untouched.
*
*/
template<typename T>
struct StringConverter
{
static T Get(const std::string & data)
{
T type;
std::stringstream ss(data);
ss >> type;
return type;
}
static T Get(const std::string & data, const T & defaultValue)
{
T type;
std::stringstream ss(data);
ss >> type;
if(ss.fail())
{
return defaultValue;
}
return type;
}
};
template<>
struct StringConverter<std::string>
{
static std::string Get(const std::string & data)
{
return data;
}
static std::string Get(const std::string & data, const std::string & defaultValue)
{
if(data.size() == 0)
{
return defaultValue;
}
return data;
}
};
template<>
struct StringConverter<bool>
{
static bool Get(const std::string & data)
{
std::string tmpData = data;
std::transform(tmpData.begin(), tmpData.end(), tmpData.begin(), ::tolower);
if(tmpData == "true" || tmpData == "yes" || tmpData == "1")
{
return true;
}
return false;
}
static bool Get(const std::string & data, const bool & defaultValue)
{
if(data.size() == 0)
{
return defaultValue;
}
return Get(data);
}
};
}
/**
* @breif Exception class.
*
*/
class Exception : public std::runtime_error
{
public:
/**
* @breif Enumeration of exception types.
*
*/
enum eType
{
InternalError, ///< Internal error.
ParsingError, ///< Invalid parsing data.
OperationError ///< User operation error.
};
/**
* @breif Constructor.
*
* @param message Exception message.
* @param type Type of exception.
*
*/
Exception(const std::string & message, const eType type);
/**
* @breif Get type of exception.
*
*/
eType Type() const;
/**
* @breif Get message of exception.
*
*/
const char * Message() const;
private:
eType m_Type; ///< Type of exception.
};
/**
* @breif Internal exception class.
*
* @see Exception
*
*/
class InternalException : public Exception
{
public:
/**
* @breif Constructor.
*
* @param message Exception message.
*
*/
InternalException(const std::string & message);
};
/**
* @breif Parsing exception class.
*
* @see Exception
*
*/
class ParsingException : public Exception
{
public:
/**
* @breif Constructor.
*
* @param message Exception message.
*
*/
ParsingException(const std::string & message);
};
/**
* @breif Operation exception class.
*
* @see Exception
*
*/
class OperationException : public Exception
{
public:
/**
* @breif Constructor.
*
* @param message Exception message.
*
*/
OperationException(const std::string & message);
};
/**
* @breif Iterator class.
*
*/
class Iterator
{
public:
friend class Node;
/**
* @breif Default constructor.
*
*/
Iterator();
/**
* @breif Copy constructor.
*
*/
Iterator(const Iterator & it);
/**
* @breif Assignment operator.
*
*/
Iterator & operator = (const Iterator & it);
/**
* @breif Destructor.
*
*/
~Iterator();
/**
* @breif Get node of iterator.
* First pair item is the key of map value, empty if type is sequence.
*
*/
std::pair<const std::string &, Node &> operator *();
/**
* @breif Post-increment operator.
*
*/
Iterator & operator ++ (int);
/**
* @breif Post-decrement operator.
*
*/
Iterator & operator -- (int);
/**
* @breif Check if iterator is equal to other iterator.
*
*/
bool operator == (const Iterator & it);
/**
* @breif Check if iterator is not equal to other iterator.
*
*/
bool operator != (const Iterator & it);
private:
enum eType
{
None,
SequenceType,
MapType
};
eType m_Type; ///< Type of iterator.
void * m_pImp; ///< Implementation of iterator class.
};
/**
* @breif Constant iterator class.
*
*/
class ConstIterator
{
public:
friend class Node;
/**
* @breif Default constructor.
*
*/
ConstIterator();
/**
* @breif Copy constructor.
*
*/
ConstIterator(const ConstIterator & it);
/**
* @breif Assignment operator.
*
*/
ConstIterator & operator = (const ConstIterator & it);
/**
* @breif Destructor.
*
*/
~ConstIterator();
/**
* @breif Get node of iterator.
* First pair item is the key of map value, empty if type is sequence.
*
*/
std::pair<const std::string &, const Node &> operator *();
/**
* @breif Post-increment operator.
*
*/
ConstIterator & operator ++ (int);
/**
* @breif Post-decrement operator.
*
*/
ConstIterator & operator -- (int);
/**
* @breif Check if iterator is equal to other iterator.
*
*/
bool operator == (const ConstIterator & it);
/**
* @breif Check if iterator is not equal to other iterator.
*
*/
bool operator != (const ConstIterator & it);
private:
enum eType
{
None,
SequenceType,
MapType
};
eType m_Type; ///< Type of iterator.
void * m_pImp; ///< Implementation of constant iterator class.
};
/**
* @breif Node class.
*
*/
class Node
{
public:
friend class Iterator;
/**
* @breif Enumeration of node types.
*
*/
enum eType
{
None,
SequenceType,
MapType,
ScalarType
};
/**
* @breif Default constructor.
*
*/
Node();
/**
* @breif Copy constructor.
*
*/
Node(const Node & node);
/**
* @breif Assignment constructors.
* Converts node to scalar type if needed.
*
*/
Node(const std::string & value);
Node(const char * value);
/**
* @breif Destructor.
*
*/
~Node();
/**
* @breif Functions for checking type of node.
*
*/
eType Type() const;
bool IsNone() const;
bool IsSequence() const;
bool IsMap() const;
bool IsScalar() const;
/**
* @breif Completely clear node.
*
*/
void Clear();
/**
* @breif Get node as given template type.
*
*/
template<typename T>
T As() const
{
return impl::StringConverter<T>::Get(AsString());
}
/**
* @breif Get node as given template type.
*
*/
template<typename T>
T As(const T & defaultValue) const
{
return impl::StringConverter<T>::Get(AsString(), defaultValue);
}
/**
* @breif Get size of node.
* Nodes of type None or Scalar will return 0.
*
*/
size_t Size() const;
// Sequence operators
/**
* @breif Insert sequence item at given index.
* Converts node to sequence type if needed.
* Adding new item to end of sequence if index is larger than sequence size.
*
*/
Node & Insert(const size_t index);
/**
* @breif Add new sequence index to back.
* Converts node to sequence type if needed.
*
*/
Node & PushFront();
/**
* @breif Add new sequence index to front.
* Converts node to sequence type if needed.
*
*/
Node & PushBack();
/**
* @breif Get sequence/map item.
* Converts node to sequence/map type if needed.
*
* @param index Sequence index. Returns None type Node if index is unknown.
* @param key Map key. Creates a new node if key is unknown.
*
*/
Node & operator [] (const size_t index);
Node & operator [] (const std::string & key);
/**
* @breif Erase item.
* No action if node is not a sequence or map.
*
*/
void Erase(const size_t index);
void Erase(const std::string & key);
/**
* @breif Assignment operators.
*
*/
Node & operator = (const Node & node);
Node & operator = (const std::string & value);
Node & operator = (const char * value);
/**
* @breif Get start iterator.
*
*/
Iterator Begin();
ConstIterator Begin() const;
/**
* @breif Get end iterator.
*
*/
Iterator End();
ConstIterator End() const;
private:
/**
* @breif Get as string. If type is scalar, else empty.
*
*/
const std::string & AsString() const;
void * m_pImp; ///< Implementation of node class.
};
/**
* @breif Parsing functions.
* Population given root node with deserialized data.
*
* @param root Root node to populate.
* @param filename Path of input file.
* @param stream Input stream.
* @param string String of input data.
* @param buffer Char array of input data.
* @param size Buffer size.
*
* @throw InternalException An internal error occurred.
* @throw ParsingException Invalid input YAML data.
* @throw OperationException If filename or buffer pointer is invalid.
*
*/
void Parse(Node & root, const char * filename);
void Parse(Node & root, std::iostream & stream);
void Parse(Node & root, const std::string & string);
void Parse(Node & root, const char * buffer, const size_t size);
/**
* @breif Serialization configuration structure,
* describing output behavior.
*
*/
struct SerializeConfig
{
/**
* @breif Constructor.
*
* @param spaceIndentation Number of spaces per indentation.
* @param scalarMaxLength Maximum length of scalars. Serialized as folder scalars if exceeded.
* Ignored if equal to 0.
* @param sequenceMapNewline Put maps on a new line if parent node is a sequence.
* @param mapScalarNewline Put scalars on a new line if parent node is a map.
*
*/
SerializeConfig(const size_t spaceIndentation = 2,
const size_t scalarMaxLength = 64,
const bool sequenceMapNewline = false,
const bool mapScalarNewline = false);
size_t SpaceIndentation; ///< Number of spaces per indentation.
size_t ScalarMaxLength; ///< Maximum length of scalars. Serialized as folder scalars if exceeded.
bool SequenceMapNewline; ///< Put maps on a new line if parent node is a sequence.
bool MapScalarNewline; ///< Put scalars on a new line if parent node is a map.
};
/**
* @breif Serialization functions.
*
* @param root Root node to serialize.
* @param filename Path of output file.
* @param stream Output stream.
* @param string String of output data.
* @param config Serialization configurations.
*
* @throw InternalException An internal error occurred.
* @throw OperationException If filename or buffer pointer is invalid.
* If config is invalid.
*
*/
void Serialize(const Node & root, const char * filename, const SerializeConfig & config = {2, 64, false, false});
void Serialize(const Node & root, std::iostream & stream, const SerializeConfig & config = {2, 64, false, false});
void Serialize(const Node & root, std::string & string, const SerializeConfig & config = {2, 64, false, false});
}
src/core/CMakeLists.txt
+1
View File
@@ -3,3 +3,4 @@ add_library(Core OBJECT EventBus.cpp ConfigManager.cpp Logger.cpp Exception.cpp)
target_include_directories(Core PUBLIC include)
target_link_libraries(Core PRIVATE MiniYAML)
src/core/ConfigManager.cpp
+1
View File
@@ -1,6 +1,7 @@
#include "ConfigManager.hpp"
#include <stdio.h>
#include <unistd.h>
#include "yaml.hpp"
namespace Plains {
namespace Core {