FeatureConfiguration.hpp

Go to the documentation of this file.

// <FeatureConfiguration.h> -*- C++ -*-
 
 
#pragma once
 
#include "sparta/simulation/ParameterTree.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/StringUtils.hpp"
#include "sparta/utils/MetaStructs.hpp"
 
#include <iostream>
#include <fstream>
#include <memory>
 
#include <boost/lexical_cast.hpp>
 
namespace sparta {
namespace app {
 
class FeatureConfiguration
{
public:
    void setFeatureValue(const std::string & name, const unsigned int value) {
        feature_values_.create(name)->setValue(
            boost::lexical_cast<std::string>(value));
    }
 
    unsigned int getFeatureValue(const std::string & feature_name) const {
        auto feature = feature_values_.tryGet(feature_name);
        if (feature == nullptr || !feature->hasValue()) {
            return 0;
        }
        return std::stoi(feature->getValue());
    }
 
    bool isFeatureValueSet(const std::string & feature_name) const {
        return (feature_values_.tryGet(feature_name) != nullptr);
    }
 
    class FeatureOptions
    {
    public:
        void setOptionsFromYamlFile(const std::string & yaml_opts_fname)
        {
            std::ifstream fin(yaml_opts_fname);
            if (!fin) {
                std::cout << "  [feature] Warning: No options file named '"
                          << yaml_opts_fname << "' found." << std::endl;
                return;
            }
 
            std::vector<std::vector<std::string>> str_vectors;
            utils::split_lines_around_tokens(fin, str_vectors, ":");
            for (auto & strvec : str_vectors) {
                sparta_assert(strvec.size() == 2);
                std::string & option_name = strvec[0];
                std::string & option_value = strvec[1];
                option_name  = sparta::utils::strip_whitespace(option_name);
                option_value = sparta::utils::strip_whitespace(option_value);
                feature_options_.set(option_name, option_value, false);
            }
        }
 
        template <typename T,
                  typename = typename std::enable_if<
                      std::is_trivial<T>::value, T>::type>
        T getOptionValue(
            const std::string & option_name,
            const T default_value) const
        {
            auto option = feature_options_.tryGet(option_name);
            if (option == nullptr || !option->hasValue()) {
                return default_value;
            }
 
            const std::string & opt_value_str = option->getValue();
            try {
                const double opt_value = boost::lexical_cast<double>(opt_value_str);
                return static_cast<T>(opt_value);
            } catch (const boost::bad_lexical_cast &) {
            }
 
            //We could get here if there was an option yaml file like this:
            //
            //    myFoo: 4.6
            //    myBar: helloWorld
            //
            //And the call site looked like this:
            //
            //    auto opt_value = feature_opts->getOptionValue<double>("myBar", 3.14);
            //
            //The myBar option data type is string, but the call site specified
            //a double template argument.
            return default_value;
        }
 
        template <typename T,
                  typename = typename std::enable_if<
                      std::is_same<T, std::string>::value, T>::type>
        std::string getOptionValue(
            const std::string & option_name,
            const T default_value) const
        {
            auto option = feature_options_.tryGet(option_name);
            if (option == nullptr || !option->hasValue()) {
                return default_value;
            }
            return option->getValue();
        }
 
    private:
        ParameterTree feature_options_;
    };
 
    void setFeatureOptionsFromFile(const std::string & feature_name,
                                   const std::string & yaml_opts_fname)
    {
        auto iter = feature_options_.find(feature_name);
        if (iter == feature_options_.end()) {
            std::unique_ptr<FeatureOptions> opts(new FeatureOptions);
            opts->setOptionsFromYamlFile(yaml_opts_fname);
            feature_options_[feature_name] = std::move(opts);
            return;
        }
        iter->second->setOptionsFromYamlFile(yaml_opts_fname);
    }
 
    const FeatureOptions * getFeatureOptions(const std::string & feature_name) const {
        auto iter = feature_options_.find(feature_name);
        if (iter != feature_options_.end()) {
            return iter->second.get();
        }
        return &null_feature_options_;
    }
 
private:
    ParameterTree feature_values_;
    std::unordered_map<std::string, std::unique_ptr<FeatureOptions>> feature_options_;
    FeatureOptions null_feature_options_;
};
 
} // namespace app
 
template <typename T>
typename std::enable_if<
    std::is_same<T, app::FeatureConfiguration>::value,
bool>::type
IsFeatureValueEqualTo(
    const T & cfg,
    const std::string & feature_name,
    const unsigned int feature_value)
{
    return cfg.getFeatureValue(feature_name) == feature_value;
}
 
template <typename T>
typename std::enable_if<
    MetaStruct::is_any_pointer<T>::value,
bool>::type
IsFeatureValueEqualTo(const T & cfg,
                      const std::string & feature_name,
                      const unsigned int feature_value)
{
    return cfg ? IsFeatureValueEqualTo(*cfg, feature_name, feature_value) :
                 (feature_value == 0);
}
 
template <typename T>
typename std::enable_if<
    std::is_same<T, app::FeatureConfiguration>::value,
bool>::type
IsFeatureValueEnabled(
    const T & cfg,
    const std::string & feature_name)
{
    return cfg.getFeatureValue(feature_name) > 0;
}
 
template <typename T>
typename std::enable_if<
    MetaStruct::is_any_pointer<T>::value,
bool>::type
IsFeatureValueEnabled(
    const T & cfg,
    const std::string & feature_name)
{
    return cfg ? IsFeatureValueEnabled(*cfg, feature_name) : false;
}
 
template <typename T>
typename std::enable_if<
    std::is_same<T, app::FeatureConfiguration>::value,
const app::FeatureConfiguration::FeatureOptions*>::type
GetFeatureOptions(const T & cfg,
                  const std::string & feature_name)
{
    return cfg.getFeatureOptions(feature_name);
}
 
template <typename T>
typename std::enable_if<
    MetaStruct::is_any_pointer<T>::value,
const app::FeatureConfiguration::FeatureOptions*>::type
GetFeatureOptions(
    const T & cfg,
    const std::string & feature_name)
{
    return cfg ? GetFeatureOptions(*cfg, feature_name) : nullptr;
}
 
} // namespace sparta