configuration.cpp

/*---------------------------------------------------------------------------*\
*
*  bitpit
*
*  Copyright (C) 2015-2021 OPTIMAD engineering Srl
*
*  -------------------------------------------------------------------------
*  License
*  This file is part of bitpit.
*
*  bitpit is free software: you can redistribute it and/or modify it
*  under the terms of the GNU Lesser General Public License v3 (LGPL)
*  as published by the Free Software Foundation.
*
*  bitpit is distributed in the hope that it will be useful, but WITHOUT
*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
*  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
*  License for more details.
*
*  You should have received a copy of the GNU Lesser General Public License
*  along with bitpit. If not, see <http://www.gnu.org/licenses/>.
*
\*---------------------------------------------------------------------------*/
 
 
#include "configuration.hpp"
#include "configuration_tree.hpp"
 
#include <stringUtils.hpp>
 
#include <sstream>
 
namespace bitpit {
 
/*
    Undefined version.
*/
const int ConfigParser::VERSION_UNDEFINED = -1;
 
 
ConfigParser::ConfigParser(const std::string &rootName)
    : Config(false)
{
    reset(rootName);
}
 
ConfigParser::ConfigParser(const std::string &rootName, bool multiSections)
    : Config(multiSections)
{
    reset(rootName);
}
 
ConfigParser::ConfigParser(const std::string &rootName, int version)
    : Config(false)
{
    reset(rootName, version);
}
 
ConfigParser::ConfigParser(const std::string &rootName, int version, bool multiSections)
    : Config(multiSections)
{
    reset(rootName, version);
}
 
void ConfigParser::reset(const std::string &rootName)
{
    m_rootName     = rootName;
    m_checkVersion = false;
    m_version      = VERSION_UNDEFINED;
 
    clear();
}
 
void ConfigParser::reset(const std::string &rootName, int version)
{
    m_rootName     = rootName;
    m_checkVersion = true;
    m_version      = version;
 
    clear();
}
 
void ConfigParser::reset(const std::string &rootName, int version, bool multiSections)
{
    m_rootName         = rootName;
    m_checkVersion = true;
    m_version      = version;
 
    m_multiSections = multiSections;
 
    clear();
}
 
void ConfigParser::read(const std::string &filename, bool append)
{
    // Processing not-append requests
    if (!append) {
        clear();
    }
 
    // Read the configuration
    std::string extension = "";
    std::size_t dotPosition = filename.find_last_of(".");
    if (dotPosition != std::string::npos) {
        extension = filename.substr(dotPosition + 1);
        extension = utils::string::trim(extension);
    }
 
    config::SourceFormat fileFormat;
    if (extension == "xml" || extension == "XML") {
        fileFormat = config::SOURCE_FORMAT_XML;
    } else if (extension == "json" || extension == "JSON") {
        fileFormat = config::SOURCE_FORMAT_JSON;
    } else {
        throw std::runtime_error("ConfigParser::read - Unsupported file format");
    }
 
    bool checkFileVersion = false;
    if (fileFormat == config::SOURCE_FORMAT_XML) {
        checkFileVersion = m_checkVersion;
    }
 
    config::tree::readConfiguration(filename, fileFormat, m_rootName, checkFileVersion, m_version, this);
}
 
void ConfigParser::read(config::SourceFormat format, const std::string &content, bool append)
{
    // Processing not-append requests
    if (!append) {
        clear();
    }
 
    // Read the configuration
    bool checkFileVersion = false;
    if (format == config::SOURCE_FORMAT_XML) {
        checkFileVersion = m_checkVersion;
    }
 
    std::stringstream contentStream(content, std::ios_base::in | std::ios_base::out | std::ios_base::binary);
 
    config::tree::readConfiguration(contentStream, format, m_rootName, checkFileVersion, m_version, this);
}
 
void ConfigParser::write(const std::string &filename) const
{
    // Write the configuration
    std::string extension = "";
    std::size_t dotPosition = filename.find_last_of(".");
    if (dotPosition != std::string::npos) {
        extension = filename.substr(dotPosition + 1);
        extension = utils::string::trim(extension);
    }
 
    config::SourceFormat fileFormat;
    if (extension == "xml" || extension == "XML") {
        fileFormat = config::SOURCE_FORMAT_XML;
    } else if (extension == "json" || extension == "JSON") {
        fileFormat = config::SOURCE_FORMAT_JSON;
    } else {
        throw std::runtime_error("ConfigParser::read - Unsupported file format");
    }
 
    config::tree::writeConfiguration(filename, fileFormat, m_rootName, m_version, this);
}
 
void ConfigParser::write(config::SourceFormat format, std::string *content) const
{
    std::stringstream contentStream;
    config::tree::writeConfiguration(contentStream, format, m_rootName, m_version, this);
 
    *content = contentStream.str();
}
 
/*
    Initialize the global instance of the configuration file parser.
*/
std::unique_ptr<GlobalConfigParser> GlobalConfigParser::m_parser = nullptr;
 
/*
    Initialize the default name of the root element.
*/
const std::string GlobalConfigParser::DEFAULT_ROOT_NAME = "bitpit";
 
/*
    Initialize the default version of the configuration file.
*/
const int GlobalConfigParser::DEFAULT_VERSION = 1;
 
GlobalConfigParser::GlobalConfigParser()
    : ConfigParser(DEFAULT_ROOT_NAME, DEFAULT_VERSION)
{
}
 
GlobalConfigParser::GlobalConfigParser(const std::string &rootName, int version)
    : ConfigParser(rootName, version)
{
}
 
GlobalConfigParser::GlobalConfigParser(const std::string &rootName, bool multiSections)
    : ConfigParser(rootName, DEFAULT_VERSION, multiSections)
{
}
 
GlobalConfigParser::GlobalConfigParser(const std::string &rootName, int version, bool multiSections)
    : ConfigParser(rootName, version, multiSections)
{
}
 
GlobalConfigParser & GlobalConfigParser::parser()
{
    if (!m_parser) {
        m_parser = std::unique_ptr<GlobalConfigParser>(new GlobalConfigParser());
    }
 
    return *m_parser;
}
 
// Routines for interacting with the global configuration file parser
namespace config {
 
    GlobalConfigParser &root = GlobalConfigParser::parser();
 
    void reset(const std::string &rootName)
    {
        root.reset(rootName);
    }
 
    void reset(const std::string &rootName, int version)
    {
        root.reset(rootName, version);
    }
 
    void reset(const std::string &rootName, int version, bool multiSections)
    {
        root.reset(rootName, version, multiSections);
    }
 
    void read(const std::string &filename, bool append)
    {
        root.read(filename, append);
    }
 
    void read(config::SourceFormat format, const std::string &content, bool append)
    {
        root.read(format, content, append);
    }
 
    void write(const std::string &filename)
    {
        root.write(filename);
    }
 
    void write(config::SourceFormat format, std::string *content)
    {
        root.write(format, content);
    }
 
}
 
}