config.h

Go to the documentation of this file.

/* ***********************************************************************
//
//   Copyright (C) 2025 -- The 4D-STAR Collaboration
//   File Author: Emily Boudreaux
//   Last Modified: March 26, 2025
//
//   4DSSE is free software; you can use it and/or modify
//   it under the terms and restrictions the GNU General Library Public
//   License version 3 (GPLv3) as published by the Free Software Foundation.
//
//   4DSSE 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 Library General Public License for more details.
//
//   You should have received a copy of the GNU Library General Public License
//   along with this software; if not, write to the Free Software
//   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// *********************************************************************** */
#pragma once
 
#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <map>
#include <algorithm>
#include <stdexcept>
 
// Required for YAML parsing
#include "yaml-cpp/yaml.h"
 
// -- Forward Def of Resource manager to let it act as a friend of Config --
namespace serif::resource { class ResourceManager; }
 
class configTestPrivateAccessor; // Forward declaration for test utility
 
namespace serif::config {

   class Config {
   private:
      Config();

      ~Config();
 
      YAML::Node yamlRoot; 
      std::string configFilePath; 
      bool debug = false; 
      bool loaded = false; 
 
      std::map<std::string, YAML::Node> configMap; 
      std::vector<std::string> unknownKeys; 

      template <typename T>
      T getFromCache(const std::string &key, T defaultValue) {
         if (configMap.find(key) != configMap.end()) {
            try {
               return configMap[key].as<T>();
            } catch (const YAML::Exception& e) {
               return defaultValue;
            }
         }
         return defaultValue;
      }
 

      bool isKeyInCache(const std::string &key);

      void addToCache(const std::string &key, const YAML::Node &node);

      void registerUnknownKey(const std::string &key);
 
      bool m_loaded = false;
 
      // Only friends can access get without a default value
      template <typename T>
      T get(const std::string &key) {
         if (!m_loaded) {
            throw std::runtime_error("Error! Config file not loaded");
         }
         if (has(key)) {
            return getFromCache<T>(key, T());
         } else {
            throw std::runtime_error("Error! Key not found in config file");
         }
      }
 
   public:
      static Config& getInstance();
 
      Config (const Config&) = delete;
      Config& operator= (const Config&) = delete;
      Config (Config&&) = delete;
      Config& operator= (Config&&) = delete;
 
      void setDebug(bool debug) { this->debug = debug; }

      bool loadConfig(const std::string& configFilePath);

      std::string getInputTable() const;

      template <typename T>
      T get(const std::string &key, T defaultValue) {
         if (!m_loaded) {
            // ONLY THROW ERROR IF HARSH OR WARN CONFIGURATION
#if defined(CONFIG_HARSH)
         throw std::runtime_error("Error! Config file not loaded. To disable this error, recompile with CONFIG_HARSH=0");
#elif defined(CONFIG_WARN)
         std::cerr << "Warning! Config file not loaded. This instance of 4DSSE was compiled with CONFIG_WARN so the code will continue using only default values" << std::endl;
#endif
         }
         // --- Check if the key has already been checked for existence
         if (std::find(unknownKeys.begin(), unknownKeys.end(), key) != unknownKeys.end()) {
            return defaultValue; // If the key has already been added to the unknown cache do not traverse the YAML tree or hit the cache
         }
 
         // --- Check if the key is already in the cache (avoid traversing YAML nodes)
         if (isKeyInCache(key)) {
            return getFromCache<T>(key, defaultValue);
         }
         // --- If the key is not in the cache, check the YAML file
         else {
            YAML::Node node = YAML::Clone(yamlRoot);
            std::istringstream keyStream(key);
            std::string subKey;
            while (std::getline(keyStream, subKey, ':')) {
               if (!node[subKey]) {
                  // Key does not exist
                  registerUnknownKey(key);
                  return defaultValue;
               }
               node = node[subKey]; // go deeper
            }
 
            try {
               // Key exists and is of the requested type
               addToCache(key, node);
               return node.as<T>();
            } catch (const YAML::Exception& e) {
               // Key is not of the requested type
               registerUnknownKey(key);
               return defaultValue; // return default value if the key does not exist
            }
         }
      }

      bool has(const std::string &key);

      std::vector<std::string> keys() const;

      friend std::ostream& operator<<(std::ostream& os, const Config& config) {
         if (!config.m_loaded) {
            os << "Config file not loaded" << std::endl;
            return os;
         }
         if (!config.debug) {
            os << "Config file: " << config.configFilePath << std::endl;
         } else{
            // Print entire YAML file from root
            os << "Config file: " << config.configFilePath << std::endl;
            os << config.yamlRoot << std::endl;
         }
         return os;
      }
 
      // Setup gTest class as a friend
      friend class ::configTestPrivateAccessor; // Friend declaration for global test accessor
      // -- Resource Manager is a friend of config so it can create a seperate instance
      friend class serif::resource::ResourceManager; // Adjusted friend declaration
   };
 
}