config.hpp

 
#pragma once
 
#include <any>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <stdexcept>
#include <string>
#include <string_view>
#include <unordered_map>
 
#include <rapidsmpf/config_defaults.hpp>
#include <rapidsmpf/error.hpp>
#include <rapidsmpf/utils/string.hpp>
 
namespace rapidsmpf::config {
 
template <typename T>
using OptionFactory = std::function<T(std::string const&)>;
 
class OptionValue {
  public:
    OptionValue() = default;
 
    OptionValue(std::string value_as_string)
        : value_as_string_{std::move(value_as_string)} {}
 
    template <typename T>
    explicit OptionValue(T value)
        requires(!std::is_convertible_v<T, std::string_view>)
        : value_{std::make_any<T>(std::move(value))} {}
 
    [[nodiscard]] std::any const& get_value() const {
        return value_;
    }
 
    [[nodiscard]] std::string const& get_value_as_string() const {
        return value_as_string_;
    }
 
    void set_value(std::any value) {
        RAPIDSMPF_EXPECTS(
            !value_.has_value(), "value already set", std::invalid_argument
        );
        value_ = std::move(value);
    }
 
  private:
    std::any value_{};
    std::string value_as_string_{};
    // TODO: add a collective policy.
};
 
namespace detail {
 
struct SharedOptions {
    mutable std::mutex mutex;  
    std::unordered_map<std::string, OptionValue> options;  
};
}  // namespace detail
 
class Options {
  public:
    Options(std::unordered_map<std::string, OptionValue> options = {});
 
 
    Options(std::unordered_map<std::string, std::string> options_as_strings);
 
    bool insert_if_absent(std::string const& key, std::string_view option_as_string);
 
    std::size_t insert_if_absent(
        std::unordered_map<std::string, std::string> options_as_strings
    );
 
    template <typename T>
    bool insert_if_absent(std::string const& key, T value)
        requires(!std::is_convertible_v<T, std::string_view>)
    {
        std::lock_guard<std::mutex> lock(shared_->mutex);
        auto [_, inserted] = shared_->options.try_emplace(
            to_lower(trim(key)), OptionValue{std::move(value)}
        );
        return inserted;
    }
 
    template <typename T>
    T const& get(std::string const& key, OptionFactory<T> factory) {
        auto& shared = *shared_;
        std::lock_guard<std::mutex> lock(shared.mutex);
        auto& option = shared.options[key];
        if (!option.get_value().has_value()) {
            // If the user did not supply a value and `DEFAULTS` contains one
            // for `key`, pass that default to the factory. Otherwise, pass
            // the empty string to the factory parser.
            std::string const& stored = option.get_value_as_string();
            auto it = DEFAULTS.find(key);
            std::string const& effective =
                (stored.empty() && it != DEFAULTS.end()) ? it->second : stored;
            option.set_value(std::make_any<T>(factory(effective)));
        }
        try {
            return std::any_cast<T const&>(option.get_value());
        } catch (const std::bad_any_cast&) {
            RAPIDSMPF_FAIL(
                "accessing option with incompatible template type", std::invalid_argument
            );
        }
    }
 
    [[nodiscard]] std::unordered_map<std::string, std::string> get_strings() const;
 
 
    [[nodiscard]] std::vector<std::uint8_t> serialize() const;
 
    [[nodiscard]] static Options deserialize(std::vector<std::uint8_t> const& buffer);
 
  private:
    std::shared_ptr<detail::SharedOptions> shared_;
};
 
void get_environment_variables(
    std::unordered_map<std::string, std::string>& output,
    std::string const& key_regex = "RAPIDSMPF_(.*)"
);
 
std::unordered_map<std::string, std::string> get_environment_variables(
    std::string const& key_regex = "RAPIDSMPF_(.*)"
);
 
}  // namespace rapidsmpf::config