ConfigParser.hpp

// -*- C++ -*-
/*
 *    Copyright (C) 2021 Joshua Boudreau <jboudreau@45drives.com>
 *
 *    This file is part of lib45d.
 *
 *    lib45d is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 3 of the License, or
 *    (at your option) any later version.
 *
 *    lib45d 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 General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with lib45d.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <45d/Quota.hpp>
#include <45d/config/ConfigNode.hpp>
#include <45d/config/Exceptions.hpp>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace ffd_internal {
    template<class T>
    T get(const std::string &key,
          const std::unordered_map<std::string, ffd::ConfigNode> *config_map) {
        ffd::ConfigNode node = config_map->at(key);
        std::stringstream ss(node.value_);
        ss.exceptions(std::ios::failbit | std::ios::badbit);
        T result;
        ss >> result;
        return result;
    }
} // namespace ffd_internal
 
namespace ffd {
    class ConfigParser {
        friend class ConfigSubsectionGuard;
    public:
        ConfigParser(std::string path);
        std::string dump_str(void) const;
        template<class T>
        T get(const std::string &key) const {
            return ffd_internal::get<T>(key, config_map_ptr_);
        }
        template<class T>
        T get(const std::string &key, const T &fallback) const noexcept {
            try {
                return get<T>(key);
            } catch (const std::out_of_range &) {
                // silently return fallback
            } catch (const std::ios_base::failure &) {
                try {
                    report_error("Invalid configuration entry format: " + key + " = "
                             + config_map_.at(key).value_);
                } catch (const std::out_of_range &) {
                    report_error("Invalid configuration entry format for " + key);
                }
            } catch (const ConfigException &e) {
                report_error(e.what());
            } catch (const std::exception &e) {
                report_error("Unexpected std::exception while getting " + key + ": " + e.what());
            } catch (...) {
                report_error("Unexplained exception caught while getting " + key);
            }
            return fallback;
        }
        template<class T>
        T get(const std::string &key, bool *fail_flag) const noexcept {
            try {
                return get<T>(key);
            } catch (const std::ios_base::failure &) {
                try {
                    report_error("Invalid configuration entry format: " + key + " = "
                             + config_map_.at(key).value_);
                } catch (const std::out_of_range &) {
                    report_error("Invalid configuration entry format for " + key);
                }
            } catch (const std::out_of_range &) {
                report_error("Option not in config: " + key);
            } catch (const ConfigException &e) {
                report_error(e.what());
            } catch (const std::exception &e) {
                report_error("Unexpected std::exception while getting " + key + ": " + e.what());
            } catch (...) {
                report_error("Unexplained exception caught while getting " + key);
            }
            *fail_flag = true;
            if (std::is_fundamental<T>::value)
                return 0;
            else
                return T();
        }
        template<class T>
        T get_from(const std::string &section, const std::string &key) {
            if (guarded_)
                throw(ffd::ConfigGuardException(
                    "Cannot call get_from while ConfigSubsectionGuard is in scope"));
            set_subsection(section);
            T result = get<T>(key);
            reset_subsection();
            return result;
        }
        template<class T>
        T get_from(const std::string &section, const std::string &key, const T &fallback) noexcept {
            if (guarded_) {
                std::cerr << "Cannot call get_from while ConfigSubsectionGuard is in scope"
                          << std::endl;
                return fallback;
            }
            try {
                set_subsection(section);
            } catch (const std::out_of_range &) {
                reset_subsection();
                return fallback;
            }
            T result = get<T>(key, fallback);
            reset_subsection();
            return result;
        }
        template<class T>
        T get_from(const std::string &section, const std::string &key, bool *fail_flag) noexcept {
            if (guarded_) {
                std::cerr << "Cannot call get_from while ConfigSubsectionGuard is in scope"
                          << std::endl;
                *fail_flag = true;
                if (std::is_fundamental<T>::value)
                    return 0;
                else
                    return T();
            }
            try {
                set_subsection(section);
            } catch (const std::out_of_range &) {
                std::cerr << "Section not in config: " << section << std::endl;
                *fail_flag = true;
                reset_subsection();
                if (std::is_fundamental<T>::value)
                    return 0;
                else
                    return T();
            }
            T result = get<T>(key, fail_flag);
            reset_subsection();
            return result;
        }
        Quota get_quota(const std::string &key, const Bytes &max) const {
            return Quota(max, get<std::string>(key));
        }
        Quota
        get_quota(const std::string &key, const Bytes &max, const Quota &fallback) const noexcept {
            try {
                return get_quota(key, max);
            } catch (const std::out_of_range &) {
                // silently return fallback
            } catch (const std::ios_base::failure &) {
                try {
                    report_error("Invalid configuration entry format: " + key + " = "
                             + config_map_.at(key).value_);
                } catch (const std::out_of_range &) {
                    report_error("Invalid configuration entry format for " + key);
                }
            } catch (const ConfigException &e) {
                report_error(e.what());
            } catch (const std::exception &e) {
                report_error("Unexpected std::exception while getting " + key + ": " + e.what());
            } catch (...) {
                report_error("Unexplained exception caught while getting " + key);
            }
            return fallback;
        }
        Quota get_quota(const std::string &key, const Bytes &max, bool *fail_flag) const noexcept {
            try {
                return get_quota(key, max);
            } catch (const std::ios_base::failure &) {
                try {
                    report_error("Invalid configuration entry format: " + key + " = "
                             + config_map_.at(key).value_);
                } catch (const std::out_of_range &) {
                    report_error("Invalid configuration entry format for " + key);
                }
            } catch (const std::out_of_range &) {
                report_error("Option not in config: " + key);
            } catch (const ConfigException &e) {
                report_error(e.what());
            } catch (const std::exception &e) {
                report_error("Unexpected std::exception while getting " + key + ": " + e.what());
            } catch (...) {
                report_error("Unexplained exception caught while getting " + key);
            }
            *fail_flag = true;
            return Quota();
        }
        Quota get_quota_from(const std::string &section, const std::string &key, const Bytes &max) {
            if (guarded_)
                throw(ffd::ConfigGuardException(
                    "Cannot call get_from while ConfigSubsectionGuard is in scope"));
            set_subsection(section);
            Quota result = get_quota(key, max);
            reset_subsection();
            return result;
        }
        Quota get_quota_from(const std::string &section,
                             const std::string &key,
                             const Bytes &max,
                             const Quota &fallback) noexcept {
            if (guarded_) {
                std::cerr << "Cannot call get_from while ConfigSubsectionGuard is in scope"
                          << std::endl;
                return fallback;
            }
            try {
                set_subsection(section);
            } catch (const std::out_of_range &) {
                reset_subsection();
                return fallback;
            }
            Quota result = get_quota(key, max, fallback);
            reset_subsection();
            return result;
        }
        Quota get_quota_from(const std::string &section,
                             const std::string &key,
                             const Bytes &max,
                             bool *fail_flag) noexcept {
            if (guarded_) {
                std::cerr << "Cannot call get_from while ConfigSubsectionGuard is in scope"
                          << std::endl;
                *fail_flag = true;
                return Quota();
            }
            try {
                set_subsection(section);
            } catch (const std::out_of_range &) {
                std::cerr << "Section not in config." << std::endl;
                *fail_flag = true;
                reset_subsection();
                return Quota();
            }
            Quota result = get_quota(key, max, fail_flag);
            reset_subsection();
            return result;
        }
    protected:
        std::vector<ConfigNode *> sub_confs_; 
        std::string current_section_;         
    private:
        bool guarded_;
        std::unordered_map<std::string, ConfigNode>
            *config_map_ptr_; 
        std::string path_;    
        std::unordered_map<std::string, ConfigNode>
            config_map_; 
 
        void parse(std::ifstream &file);
        void parse_entry(const std::string &line);
        void parse_heading(const std::string &line);
        void set_subsection(const std::string &section) {
            try {
                config_map_ptr_ = config_map_.at(section).sub_map_;
            } catch (const std::out_of_range &) {
                throw std::out_of_range("No subconfig with name `" + section + "`");
            }
            if (config_map_ptr_ == nullptr)
                throw std::out_of_range("`" + section + "` is not a subsection.");
            current_section_ = section;
        }
        void reset_subsection(void) noexcept {
            config_map_ptr_ = &config_map_;
            current_section_ = "";
        }
        void report_error(const std::string &message) const noexcept {
            if (config_map_ptr_ != &config_map_)
                std::cerr << "[" << current_section_ << "]: ";
            std::cerr << message << std::endl;
        }
    };
} // namespace ffd