program-options.hh

/*
 * This file is open source software, licensed to you under the terms
 * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership.  You may not use this file except in compliance with the License.
 *
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
/*
 * Copyright (C) 2017 ScyllaDB
 */
 
#pragma once
 
#include <seastar/core/sstring.hh>
#include <seastar/core/print.hh>
#include <seastar/util/modules.hh>
 
#ifndef SEASTAR_MODULE
#include <fmt/format.h>
 
#include <boost/any.hpp>
#include <boost/intrusive/list.hpp>
 
#include <string>
#include <unordered_map>
#include <vector>
#include <set>
#endif
 
 
namespace seastar {
 
namespace program_options {
 
class string_map final : private std::unordered_map<sstring, sstring> {
private:
    using base = std::unordered_map<sstring, sstring>;
public:
    using base::value_type;
    using base::key_type;
    using base::mapped_type;
 
    using base::base;
    using base::at;
    using base::find;
    using base::count;
    using base::emplace;
    using base::clear;
    using base::operator[];
    using base::begin;
    using base::end;
 
    friend bool operator==(const string_map&, const string_map&);
    friend bool operator!=(const string_map&, const string_map&);
};
 
inline bool operator==(const string_map& lhs, const string_map& rhs) {
    return static_cast<const string_map::base&>(lhs) == static_cast<const string_map::base&>(rhs);
}
 
inline bool operator!=(const string_map& lhs, const string_map& rhs) {
    return !(lhs == rhs);
}
 
sstring get_or_default(const string_map&, const sstring& key, const sstring& def = sstring());
 
std::istream& operator>>(std::istream& is, string_map&);
std::ostream& operator<<(std::ostream& os, const string_map&);
 
 
//
// Required implementation hook for Boost.Program_options.
//
void validate(boost::any& out, const std::vector<std::string>& in, string_map*, int);
 
using list_base_hook = boost::intrusive::list_base_hook<boost::intrusive::link_mode<boost::intrusive::auto_unlink>>;
 
} // namespace program_options
 
SEASTAR_MODULE_EXPORT_BEGIN
enum class log_level;
enum class logger_timestamp_style;
enum class logger_ostream_type;
namespace memory {
    enum class alloc_failure_kind;
}
 
namespace program_options {
 
 
 
class option_group;
 
class options_descriptor {
public:
    virtual bool visit_group_start(const std::string& name, bool used) = 0;
    virtual void visit_group_end() = 0;
 
    virtual bool visit_value_metadata(const std::string& name, const std::string& description, bool used) = 0;
 
    virtual void visit_value() = 0;
    virtual void visit_value(const bool* default_val) = 0;
    virtual void visit_value(const int* default_val) = 0;
    virtual void visit_value(const unsigned* default_val) = 0;
    virtual void visit_value(const float* default_val) = 0;
    virtual void visit_value(const double* default_val) = 0;
    virtual void visit_value(const std::string* default_val) = 0;
    virtual void visit_value(const std::set<unsigned>* default_val) = 0;
    virtual void visit_value(const log_level* default_val) = 0;
    virtual void visit_value(const logger_timestamp_style* default_val) = 0;
    virtual void visit_value(const logger_ostream_type* default_val) = 0;
    virtual void visit_value(const memory::alloc_failure_kind* default_val) = 0;
    virtual void visit_value(const std::unordered_map<sstring, log_level>* default_val) = 0;
 
    virtual void visit_selection_value(const std::vector<std::string>& candidate_names, const std::size_t* default_candidate) = 0;
};
 
class options_mutator {
public:
    virtual bool visit_group_start(const std::string& name, bool used) = 0;
    virtual void visit_group_end() = 0;
 
    virtual bool visit_value_metadata(const std::string& name, bool used) = 0;
 
    virtual bool visit_value() = 0;
    virtual bool visit_value(bool& val) = 0;
    virtual bool visit_value(int& val) = 0;
    virtual bool visit_value(unsigned& val) = 0;
    virtual bool visit_value(float& val) = 0;
    virtual bool visit_value(double& val) = 0;
    virtual bool visit_value(std::string& val) = 0;
    virtual bool visit_value(std::set<unsigned>& val) = 0;
    virtual bool visit_value(log_level& val) = 0;
    virtual bool visit_value(logger_timestamp_style& val) = 0;
    virtual bool visit_value(logger_ostream_type& val) = 0;
    virtual bool visit_value(memory::alloc_failure_kind& val) = 0;
    virtual bool visit_value(std::unordered_map<sstring, log_level>& val) = 0;
 
    virtual bool visit_selection_value(const std::vector<std::string>& candidate_names, std::size_t& selected_candidate) = 0;
};
 
struct unused {};
 
class basic_value;
 
class option_group : public list_base_hook {
    friend class basic_value;
 
public:
    using value_list_type = boost::intrusive::list<
            basic_value,
            boost::intrusive::base_hook<list_base_hook>,
            boost::intrusive::constant_time_size<false>>;
 
    using option_group_list_type = boost::intrusive::list<
            option_group,
            boost::intrusive::base_hook<list_base_hook>,
            boost::intrusive::constant_time_size<false>>;
 
private:
    option_group* _parent;
    bool _used = true;
    std::string _name;
    value_list_type _values;
    option_group_list_type _subgroups;
 
public:
    explicit option_group(option_group* parent, std::string name);
    explicit option_group(option_group* parent, std::string name, unused);
    option_group(option_group&&);
    option_group(const option_group&) = delete;
    virtual ~option_group() = default;
 
    option_group& operator=(option_group&&) = delete;
    option_group& operator=(const option_group&) = delete;
 
    operator bool () const { return !_values.empty(); }
    bool used() const { return _used; }
    const std::string& name() const { return _name; }
    const value_list_type& values() const { return _values; }
    value_list_type& values() { return _values; }
 
    void describe(options_descriptor& descriptor) const;
    void mutate(options_mutator& mutator);
};
 
class basic_value : public list_base_hook {
    friend class option_group;
 
public:
    option_group* _group;
    bool _used = true;
    std::string _name;
    std::string _description;
 
private:
    virtual void do_describe(options_descriptor& descriptor) const = 0;
    virtual void do_mutate(options_mutator& mutator) = 0;
 
public:
    basic_value(option_group& group, bool used, std::string name, std::string description);
    basic_value(basic_value&&);
    basic_value(const basic_value&) = delete;
    virtual ~basic_value() = default;
 
    basic_value& operator=(basic_value&&) = delete;
    basic_value& operator=(const basic_value&) = delete;
 
    bool used() const { return _used; }
    const std::string& name() const { return _name; }
    const std::string& description() const { return _description; }
 
    void describe(options_descriptor& descriptor) const;
    void mutate(options_mutator& mutator);
};
 
template <typename T = std::monostate>
class value : public basic_value {
    std::optional<T> _value;
    bool _defaulted = true;
 
private:
    virtual void do_describe(options_descriptor& descriptor) const override {
        auto* val = _value ? &*_value : nullptr;
        descriptor.visit_value(val);
    }
    virtual void do_mutate(options_mutator& mutator) override {
        T val;
        if (mutator.visit_value(val)) {
            _value = std::move(val);
            _defaulted = false;
        }
    }
    void do_set_value(T value, bool defaulted) {
        _value = std::move(value);
        _defaulted = defaulted;
    }
 
public:
    value(option_group& group, std::string name, std::optional<T> default_value, std::string description)
        : basic_value(group, true, std::move(name), std::move(description))
        , _value(std::move(default_value))
    { }
    value(option_group& group, std::string name, unused)
        : basic_value(group, false, std::move(name), {})
    { }
    value(value&&) = default;
    operator bool () const { return bool(_value); }
    bool defaulted() const { return _defaulted; }
    const T& get_value() const { return _value.value(); }
    T& get_value() { return _value.value(); }
    void set_default_value(T value) { do_set_value(std::move(value), true); }
    void set_value(T value) { do_set_value(std::move(value), false); }
};
 
template <>
class value<std::monostate> : public basic_value {
    std::optional<bool> _set;
 
private:
    virtual void do_describe(options_descriptor& descriptor) const override {
        descriptor.visit_value();
    }
    virtual void do_mutate(options_mutator& mutator) override {
        bool is_set = mutator.visit_value();
        if (_set.has_value()) {
            // override the value only if it is not preset
            if (is_set) {
                _set = true;
            }
        } else {
            _set = is_set;
        }
    }
 
public:
    value(option_group& group, std::string name, std::string description)
        : basic_value(group, true, std::move(name), std::move(description))
    { }
    value(option_group& group, std::string name, unused)
        : basic_value(group, false, std::move(name), {})
    { }
    operator bool () const { return _set ? _set.value() : false; }
    void set_value() { _set = true; }
    void unset_value() { _set = false; }
};
 
template <typename T = std::monostate>
class selection_value : public basic_value {
public:
    using deleter = std::function<void(T*)>;
    using value_handle = std::unique_ptr<T, deleter>;
    struct candidate {
        std::string name;
        value_handle value;
        std::unique_ptr<option_group> opts;
    };
    using candidates = std::vector<candidate>;
 
private:
    static constexpr size_t no_selected_candidate = -1;
 
private:
    candidates _candidates;
    size_t _selected_candidate = no_selected_candidate;
    bool _defaulted = true;
 
private:
    std::vector<std::string> get_candidate_names() const {
        std::vector<std::string> candidate_names;
        candidate_names.reserve(_candidates.size());
        for (const auto& c : _candidates) {
            candidate_names.push_back(c.name);
        }
        return candidate_names;
    }
    virtual void do_describe(options_descriptor& descriptor) const override {
        descriptor.visit_selection_value(get_candidate_names(), _selected_candidate == no_selected_candidate ? nullptr : &_selected_candidate);
        for (auto& c : _candidates) {
            if (c.opts) {
                c.opts->describe(descriptor);
            }
        }
    }
    virtual void do_mutate(options_mutator& mutator) override {
        if (mutator.visit_selection_value(get_candidate_names(), _selected_candidate)) {
            _defaulted = false;
        }
        if (_selected_candidate != no_selected_candidate) {
            auto& c = _candidates.at(_selected_candidate);
            if (c.opts) {
                c.opts->mutate(mutator);
            }
        }
    }
    size_t find_candidate(const std::string& candidate_name) {
        auto it = find_if(_candidates.begin(), _candidates.end(), [&] (const auto& candidate) {
            return candidate.name == candidate_name;
        });
        if (it == _candidates.end()) {
            throw std::invalid_argument(fmt::format("find_candidate(): failed to find candidate {}", candidate_name));
        }
        return it - _candidates.begin();
    }
 
    option_group* do_select_candidate(std::string candidate_name, bool defaulted) {
        _selected_candidate = find_candidate(candidate_name);
        _defaulted = defaulted;
        return _candidates.at(_selected_candidate).opts.get();
    }
 
public:
    selection_value(option_group& group, std::string name, candidates candidates, std::string default_candidate, std::string description)
        : basic_value(group, true, std::move(name), std::move(description))
        , _candidates(std::move(candidates))
        , _selected_candidate(find_candidate(default_candidate))
    { }
    selection_value(option_group& group, std::string name, candidates candidates, std::string description)
        : basic_value(group, true, std::move(name), std::move(description))
        , _candidates(std::move(candidates))
    { }
    selection_value(option_group& group, std::string name, unused)
        : basic_value(group, false, std::move(name), {})
    { }
    operator bool () const { return _selected_candidate != no_selected_candidate; }
    bool defaulted() const { return _defaulted; }
    const std::string& get_selected_candidate_name() const { return _candidates.at(_selected_candidate).name; }
    const option_group* get_selected_candidate_opts() const { return _candidates.at(_selected_candidate).opts.get(); }
    option_group* get_selected_candidate_opts() { return _candidates.at(_selected_candidate).opts.get(); }
    T& get_selected_candidate() const { return *_candidates.at(_selected_candidate).value; }
    option_group* select_candidate(std::string candidate_name) { return do_select_candidate(candidate_name, false); }
    option_group* select_default_candidate(std::string candidate_name) { return do_select_candidate(candidate_name, true); }
};
 
 
}
SEASTAR_MODULE_EXPORT_END
 
}