configuration_config.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 <stdexcept>
 
#include "configuration_config.hpp"
 
namespace bitpit {
 
Config::Config(bool multiSections)
    : m_multiSections(multiSections),
      m_options(std::unique_ptr<Options>(new Options())),
      m_sections(std::unique_ptr<Sections>(new Sections()))
{
}
 
Config::Config(const Config &other)
    : m_multiSections(other.m_multiSections),
      m_options(std::unique_ptr<Options>(new Options(*(other.m_options)))),
      m_sections(std::unique_ptr<Sections>(new Sections()))
{
    for (const auto &entry : *(other.m_sections)) {
        std::unique_ptr<Config> config = std::unique_ptr<Config>(new Config(*(entry.second)));
        m_sections->insert(std::make_pair(entry.first, std::move(config)));
    }
}
 
Config & Config::operator=(Config other)
{
    this->swap(other);
 
    return *this;
}
 
void Config::swap(Config &other)
{
    std::swap(m_multiSections, other.m_multiSections);
    std::swap(m_options, other.m_options);
    std::swap(m_sections, other.m_sections);
}
 
 
bool Config::isMultiSectionsEnabled() const
{
    return m_multiSections;
}
 
int Config::getOptionCount() const
{
    return m_options->size();
}
 
Config::Options & Config::getOptions()
{
    return const_cast<Options &>(static_cast<const Config &>(*this).getOptions());
}
 
const Config::Options & Config::getOptions() const
{
    return *m_options;
}
 
bool Config::hasOption(const std::string &key) const
{
    return (m_options->count(key) > 0);
}
 
const std::string & Config::get(const std::string &key) const
{
    return m_options->at(key);
}
 
std::string Config::get(const std::string &key, const std::string &fallback) const
{
    if (hasOption(key)) {
        return get(key);
    } else {
        return fallback;
    }
}
 
void Config::set(const std::string &key, const std::string &value)
{
    (*m_options)[key] = value;
}
 
bool Config::removeOption(const std::string &key)
{
    return (m_options->erase(key) != 0);
}
 
int Config::getSectionCount() const
{
    return m_sections->size();
}
 
int Config::getSectionCount(const std::string &key) const
{
    return m_sections->count(key);
}
 
Config::Sections & Config::getSections()
{
    return const_cast<Sections &>(static_cast<const Config &>(*this).getSections());
}
 
const Config::Sections & Config::getSections() const
{
    return *m_sections;
}
 
Config::MultiSection Config::getSections(const std::string &key)
{
    MultiSection sections;
    sections.reserve(getSectionCount(key));
 
    auto range = m_sections->equal_range(key);
    for (auto itr = range.first; itr != range.second; ++itr) {
        sections.push_back(itr->second.get());
    }
 
    return sections;
}
 
Config::ConstMultiSection Config::getSections(const std::string &key) const
{
    ConstMultiSection sections;
    sections.reserve(getSectionCount(key));
 
    auto range = m_sections->equal_range(key);
    for (auto itr = range.first; itr != range.second; ++itr) {
        sections.push_back(const_cast<const Section *>(itr->second.get()));
    }
 
    return sections;
}
 
bool Config::hasSection(const std::string &key) const
{
    return (getSectionCount(key) > 0);
}
 
Config::Section & Config::getSection(const std::string &key)
{
    return const_cast<Section &>(static_cast<const Config &>(*this).getSection(key));
}
 
const Config::Section & Config::getSection(const std::string &key) const
{
    auto sectionItr = m_sections->find(key);
    if (sectionItr == m_sections->end()) {
        throw std::runtime_error("The section named \"" + key + "\" does not esists");
    }
 
    return *(sectionItr->second);
}
 
Config::Section & Config::addSection(const std::string &key)
{
    if (!m_multiSections && hasSection(key)) {
        throw std::runtime_error("A section named \"" + key + "\" already esists");
    }
 
    std::unique_ptr<Section> section = std::unique_ptr<Section>(new Section(m_multiSections));
    auto sectionItr = m_sections->insert(std::make_pair(key, std::move(section)));
 
    return *(sectionItr->second);
}
 
bool Config::removeSection(const std::string &key)
{
    return (m_sections->erase(key) != 0);
}
 
void Config::clear()
{
    m_options->clear();
    m_sections->clear();
}
 
const Config::Section & Config::operator[](const std::string &key) const
{
    return getSection(key);
}
 
Config::Section & Config::operator[](const std::string &key)
{
    return getSection(key);
}
 
void Config::dump(std::ostream &out, int indentLevel) const
{
    const int INDENT_SIZE = 2;
 
    std::string padding(INDENT_SIZE, ' ');
    std::string indent(INDENT_SIZE * indentLevel, ' ');
 
    out << std::endl;
    out << indent << "Options..." << std::endl;
    if (getOptionCount() > 0) {
        for (const auto &entry : getOptions()) {
            out << indent << padding << entry.first << " = " << entry.second << std::endl;
        }
    } else {
        out << indent << padding << "No options." << std::endl;
    }
 
    ++indentLevel;
    for (const auto &entry : getSections()) {
        out << std::endl;
        out << indent << padding << "::: Section " << entry.first << " :::" << std::endl;
        entry.second->dump(out, indentLevel);
    }
}
 
}