config.hh

Go to the documentation of this file.

#pragma once
 
#include <cassert>
#include <map>
#include <set>
 
#include "lix/libutil/json-fwd.hh"
#include "lix/libutil/types.hh"
#include "lix/libutil/experimental-features.hh"
#include "lix/libutil/deprecated-features.hh"
#include "lix/libutil/apply-config-options.hh"
 
namespace nix {

 
class Args;
class AbstractSetting;
 
class AbstractConfig
{
protected:
    StringMap unknownSettings;
 
    AbstractConfig(StringMap initials = {});
 
public:

    virtual bool set(const std::string & name, const std::string & value, const ApplyConfigOptions & options = {}) = 0;
 
    struct SettingInfo
    {
        std::string value;
        std::string description;
    };

    virtual void getSettings(std::map<std::string, SettingInfo> & res, bool overriddenOnly = false) = 0;

    void applyConfig(const std::string & contents, const ApplyConfigOptions & options = {});

    virtual void resetOverridden() = 0;

    virtual JSON toJSON() = 0;

    virtual void convertToArgs(Args & args, const std::string & category) = 0;

    void warnUnknownSettings();

    void reapplyUnknownSettings();
};

class Config : public AbstractConfig
{
    friend class AbstractSetting;
 
public:
 
    struct SettingData
    {
        bool isAlias;
        AbstractSetting * setting;
    };
 
    using Settings = std::map<std::string, SettingData>;
 
private:
 
    Settings _settings;
 
public:
 
    Config(StringMap initials = {});
 
    bool set(const std::string & name, const std::string & value, const ApplyConfigOptions & options = {}) override;
 
    void addSetting(AbstractSetting * setting);
 
    void getSettings(std::map<std::string, SettingInfo> & res, bool overriddenOnly = false) override;
 
    void resetOverridden() override;
 
    JSON toJSON() override;
 
    void convertToArgs(Args & args, const std::string & category) override;
};
 
class AbstractSetting
{
    friend class Config;
 
public:
 
    struct deprecated_t {
        explicit deprecated_t() = default;
    };
 
    const std::string name;
    const std::string description;
    const std::set<std::string> aliases;
 
    int created = 123;
 
    bool overridden = false;
 
    std::optional<ExperimentalFeature> experimentalFeature;
 
protected:
 
    AbstractSetting(
        const std::string & name,
        const std::string & description,
        const std::set<std::string> & aliases,
        std::optional<ExperimentalFeature> experimentalFeature = std::nullopt);
 
    virtual ~AbstractSetting();
 
    virtual void set(const std::string & value, bool append = false, const ApplyConfigOptions & options = {}) = 0;

    virtual bool isAppendable() = 0;
 
    virtual std::string to_string() const = 0;
 
    JSON toJSON();
 
    virtual std::map<std::string, JSON> toJSONObject() const;
 
    virtual void convertToArg(Args & args, const std::string & category);
 
    bool isOverridden() const;
 
};

template<typename T>
class BaseSetting : public AbstractSetting
{
protected:
 
    T value;
    const T defaultValue;
    const bool documentDefault;
    const bool deprecated;

    virtual T parse(const std::string & str, const ApplyConfigOptions & options) const;

    virtual void appendOrSet(T newValue, bool append, const ApplyConfigOptions & options);
 
public:
 
    BaseSetting(const T & def,
        const bool documentDefault,
        const std::string & name,
        const std::string & description,
        const std::set<std::string> & aliases = {},
        std::optional<ExperimentalFeature> experimentalFeature = std::nullopt,
        bool deprecated = false)
        : AbstractSetting(name, description, aliases, experimentalFeature)
        , value(def)
        , defaultValue(def)
        , documentDefault(documentDefault)
        , deprecated(deprecated)
    { }
 
    operator const T &() const { return value; }
    const T & get() const { return value; }
    template<typename U>
    bool operator ==(const U & v2) const { return value == v2; }
    template<typename U>
    bool operator !=(const U & v2) const { return value != v2; }
    template<typename U>
    void setDefault(const U & v) { if (!overridden) value = v; }

    void set(const std::string & str, bool append = false, const ApplyConfigOptions & options = {}) override final;
 
    void override(const T & v);

    struct trait;

    bool isAppendable() override final;
 
    std::string to_string() const override;
 
    void convertToArg(Args & args, const std::string & category) override;
 
    std::map<std::string, JSON> toJSONObject() const override;
};
 
template<typename T>
std::ostream & operator <<(std::ostream & str, const BaseSetting<T> & opt)
{
    return str << static_cast<const T &>(opt);
}
 
template<typename T>
bool operator ==(const T & v1, const BaseSetting<T> & v2) { return v1 == static_cast<const T &>(v2); }
 
template<typename T>
class Setting : public BaseSetting<T>
{
public:
    Setting(Config * options,
        const T & def,
        const std::string & name,
        const std::string & description,
        const std::set<std::string> & aliases = {},
        const bool documentDefault = true,
        std::optional<ExperimentalFeature> experimentalFeature = std::nullopt,
        bool deprecated = false)
        : BaseSetting<T>(def, documentDefault, name, description, aliases, std::move(experimentalFeature), deprecated)
    {
        options->addSetting(this);
    }
};

template<typename T>
class PathsSetting : public BaseSetting<T>
{
public:
    PathsSetting(Config * options,
        const T & def,
        const std::string & name,
        const std::string & description,
        const std::set<std::string> & aliases = {},
        const bool documentDefault = true,
        std::optional<ExperimentalFeature> experimentalFeature = std::nullopt,
        bool deprecated = false)
        : BaseSetting<T>(def, documentDefault, name, description, aliases, std::move(experimentalFeature), deprecated)
    {
        options->addSetting(this);
    }
 
    T parse(const std::string & str, const ApplyConfigOptions & options) const override;
};
 
 
struct GlobalConfig : public AbstractConfig
{
    typedef std::vector<Config*> ConfigRegistrations;
    static ConfigRegistrations * configRegistrations;
 
    bool set(const std::string & name, const std::string & value, const ApplyConfigOptions & options = {}) override;
 
    void getSettings(std::map<std::string, SettingInfo> & res, bool overriddenOnly = false) override;
 
    void resetOverridden() override;
 
    JSON toJSON() override;

    std::string toKeyValue(bool overriddenOnly = false);
 
    void convertToArgs(Args & args, const std::string & category) override;
 
    struct Register
    {
        Register(Config * config);
    };
};
 
extern GlobalConfig globalConfig;
 
 
struct FeatureSettings : Config {
    #include "feature-settings.gen.inc"

    bool isEnabled(const ExperimentalFeature &) const;

    void require(const ExperimentalFeature &) const;

    bool isEnabled(const std::optional<ExperimentalFeature> &) const;

    void require(const std::optional<ExperimentalFeature> &) const;

    bool isEnabled(const DeprecatedFeature &) const;

    void require(const DeprecatedFeature &) const;

    bool isEnabled(const std::optional<DeprecatedFeature> &) const;

    void require(const std::optional<DeprecatedFeature> &) const;
};
 
// FIXME: don't use a global variable.
extern FeatureSettings& featureSettings;
 
// Aliases to `featureSettings` for not having to change the name in the code everywhere
using ExperimentalFeatureSettings = FeatureSettings;
extern FeatureSettings experimentalFeatureSettings;
}