MultiDetailOptions.hpp

Go to the documentation of this file.

// <MultiDetailOptions.hpp> -*- C++ -*-
 
 
#pragma once
 
#include <boost/program_options.hpp>
 
#include "sparta/sparta.hpp"
 
namespace po = boost::program_options;
 
namespace sparta {
    namespace app {
 
template <typename ArgT>
class named_value_type : public po::typed_value<ArgT>
{
    unsigned min_;
    unsigned max_;
    std::string my_name_;
 
public:
 
    typedef po::typed_value<ArgT> base_t;
 
    named_value_type(std::string const& name, ArgT* val) :
        po::typed_value<ArgT>(val),
        min_(0),
        max_(1),
        my_name_(name)
    { }
 
    named_value_type(std::string const& name, ArgT* val, unsigned min, unsigned max) :
        po::typed_value<ArgT>(val),
        min_(min),
        max_(max),
        my_name_(name)
    { }
 
    virtual ~named_value_type() {}
 
    virtual std::string name() const override { return my_name_; }
 
    named_value_type* min(unsigned min)
    {
        min_ = min;
        return this;
    }
 
    named_value_type* max(unsigned max)
    {
        max_ = max;
        return this;
    }
 
    named_value_type* multitoken()
    {
        base_t::multitoken();
        return this;
    }
 
    virtual unsigned min_tokens() const override { return min_; }
 
    virtual unsigned max_tokens() const override { return max_; }
 
    virtual void xparse(boost::any& value_store,
                        const std::vector<std::basic_string<char>>& new_tokens) const override;
 
    void xparse_base_(boost::any& value_store,
                      const std::vector<std::basic_string<char>>& new_tokens) const {
        po::typed_value<ArgT>::xparse(value_store, new_tokens);
    }
};
 
template <typename ArgT>
class named_value_parser {
public:
 
    static void parse_(const named_value_type<ArgT>& nvt,
                       boost::any& value_store,
                       const std::vector<std::basic_string<char>>& new_tokens) {
        nvt.xparse_base_(value_store, new_tokens);
    }
};
 
template <class ArgT>
void named_value_type<ArgT>::xparse(boost::any& value_store,
                                     const std::vector<std::basic_string<char>>& new_tokens) const {
    // Invoked the appropriately typed named_value_parser
    //std::cout << "parsing " << my_name_ << " : " << new_tokens << std::endl;
    named_value_parser<ArgT>::parse_(*this, value_store, new_tokens);
}
 
template <>
class named_value_parser<uint64_t> {
public:
    static void parse_(const named_value_type<uint64_t>& nvt,
                       boost::any& value_store,
                       const std::vector<std::basic_string<char>>& new_tokens) {
        (void) nvt;
        size_t end_pos;
        uint64_t val = utils::smartLexicalCast<uint64_t>(new_tokens.at(0), end_pos);
        //std::cout << "      got: " << val << std::endl;
        value_store = val;
    }
};
 
template <>
class named_value_parser<int64_t> {
public:
    static void parse_(const named_value_type<int64_t>& nvt,
                       boost::any& value_store,
                       const std::vector<std::basic_string<char>>& new_tokens) {
        (void) nvt;
        size_t end_pos;
        int64_t val = utils::smartLexicalCast<int64_t>(new_tokens.at(0), end_pos);
        //std::cout << "      got: " << val << std::endl;
        value_store = val;
    }
};
 
template <>
class named_value_parser<uint32_t> {
public:
    static void parse_(const named_value_type<uint32_t>& nvt,
                       boost::any& value_store,
                       const std::vector<std::basic_string<char>>& new_tokens) {
        (void) nvt;
        size_t end_pos;
        uint32_t val = utils::smartLexicalCast<uint32_t>(new_tokens.at(0), end_pos);
        //std::cout << "      got: " << val << std::endl;
        value_store = val;
    }
};
 
template <>
class named_value_parser<int32_t> {
public:
    static void parse_(const named_value_type<int32_t>& nvt,
                       boost::any& value_store,
                       const std::vector<std::basic_string<char>>& new_tokens) {
        (void) nvt;
        size_t end_pos;
        int32_t val = utils::smartLexicalCast<int32_t>(new_tokens.at(0), end_pos);
        //std::cout << "      got: " << val << std::endl;
        value_store = val;
    }
};
 
template <>
class named_value_parser<uint16_t> {
public:
    static void parse_(const named_value_type<uint16_t>& nvt,
                       boost::any& value_store,
                       const std::vector<std::basic_string<char>>& new_tokens) {
        (void) nvt;
        size_t end_pos;
        uint16_t val = utils::smartLexicalCast<uint16_t>(new_tokens.at(0), end_pos);
        //std::cout << "      got: " << val << std::endl;
        value_store = val;
    }
};
 
template <>
class named_value_parser<int16_t> {
public:
    static void parse_(const named_value_type<int16_t>& nvt,
                       boost::any& value_store,
                       const std::vector<std::basic_string<char>>& new_tokens) {
        (void) nvt;
        size_t end_pos;
        int16_t val = utils::smartLexicalCast<int16_t>(new_tokens.at(0), end_pos);
        //std::cout << "      got: " << val << std::endl;
        value_store = val;
    }
};
 
template <>
class named_value_parser<uint8_t> {
public:
    static void parse_(const named_value_type<uint8_t>& nvt,
                       boost::any& value_store,
                       const std::vector<std::basic_string<char>>& new_tokens) {
        (void) nvt;
        size_t end_pos;
        uint8_t val = utils::smartLexicalCast<uint8_t>(new_tokens.at(0), end_pos);
        //std::cout << "      got: " << val << std::endl;
        value_store = val;
    }
};
 
template <>
class named_value_parser<int8_t> {
public:
    static void parse_(const named_value_type<int8_t>& nvt,
                       boost::any& value_store,
                       const std::vector<std::basic_string<char>>& new_tokens) {
        (void) nvt;
        size_t end_pos;
        int8_t val = utils::smartLexicalCast<int8_t>(new_tokens.at(0), end_pos);
        //std::cout << "      got: " << val << std::endl;
        value_store = val;
    }
};
 
 
template <typename ArgT>
inline named_value_type<ArgT>* named_value(std::string const& name, ArgT* val=nullptr) {
    return new named_value_type<ArgT>(name, val);
}
 
template <typename ArgT>
inline named_value_type<ArgT>* named_value(std::string const& name, unsigned min, unsigned max, ArgT* val=nullptr) {
    return new named_value_type<ArgT>(name, val, min, max);
}
 
 
class MultiDetailOptions final
{
public:
 
    typedef uint32_t level_t;
 
    static const level_t VERBOSE = 0;
    static const level_t BRIEF = 1;
 
    class OptAdder {
        MultiDetailOptions& opts_;
 
    public:
        OptAdder(MultiDetailOptions& opts) :
            opts_(opts)
        {;}
 
        template <typename ...Args>
        OptAdder& operator()(const char* name,
                             const char* verbose_desc,
                             const Args& ...args)
        {
            opts_.add_option_with_desc_level_(0, name, verbose_desc, args...);
 
            return *this;
        }
 
        template <typename ...Args>
        OptAdder operator()(const char* name,
                         const boost::program_options::value_semantic* s,
                         const char* verbose_desc,
                         const Args& ...args)
        {
            opts_.add_option_with_desc_level_(0, name, s, verbose_desc, args...);
 
            return *this;
        }
    };
 
    friend class OptAdded;
 
    MultiDetailOptions(const MultiDetailOptions&) = delete;
 
    MultiDetailOptions& operator=(const MultiDetailOptions&) = delete;
 
    MultiDetailOptions() = delete;
 
    MultiDetailOptions(const std::string& name, uint32_t w=80, uint32_t hw=40) :
        opt_adder_(*this),
        name_(name)
    {
        descs_.emplace_back(new po::options_description(name_, w, hw));
        descs_.emplace_back(new po::options_description(name_, w, hw));
 
        sparta_assert(descs_.size() > VERBOSE);
        sparta_assert(descs_.size() > BRIEF);
    }
 
    const po::options_description& getOptionsLevelUpTo(level_t level) const {
        if(level < descs_.size()){
            return *descs_.at(level);
        }else{
            sparta_assert(descs_.size() > 0);
            return *descs_.at(descs_.size() - 1);
        }
    }
 
    const po::options_description& getOptionsLevel(level_t level) const {
        return *descs_.at(level);
    }
 
    const po::options_description& getVerboseOptions() const noexcept {
        return *descs_.at(VERBOSE);
    }
 
    size_t getNumLevels() const {
        return descs_.size();
    }
 
    template <typename ...Args>
    OptAdder& add_options(const char* name,
                         const char* verbose_desc,
                         const Args& ...args)
    {
        add_option_with_desc_level_(0, name, verbose_desc, args...);
 
        return opt_adder_;
    }
 
    template <typename ...Args>
    OptAdder& add_options(const char* name,
                     const boost::program_options::value_semantic* s,
                     const char* verbose_desc,
                     const Args& ...args)
    {
        add_option_with_desc_level_(0, name, s, verbose_desc, args...);
 
        return opt_adder_;
    }
 
    OptAdder& add_options()
    {
        return opt_adder_;
    }
 
private:
 
    void add_option_with_desc_level_(size_t level,
                                     const char* name)
    {
        (void) level;
        (void) name;
    }
 
    template <typename ...Args>
    void add_option_with_desc_level_(size_t level,
                                     const char* name,
                                     const char* desc,
                                     const Args& ...args) {
        while(descs_.size() <= level){
            descs_.emplace_back(new po::options_description(name_));
        }
 
        descs_.at(level)->add_options()
            (name, desc);
 
        // Recursively invoke until terminator overload of this func is reached
        add_option_with_desc_level_(level+1, name, args...);
    }
 
 
    //void add_option_with_desc_level_(size_t level,
    //                                 const char* name,
    //                                 const boost::program_options::value_semantic* s)
    //{
    //    (void) level;
    //    (void) name;
    //    delete s; // Delete unused copy of value_semantic
    //}
 
    template <typename ...Args>
    void add_option_with_desc_level_(size_t level,
                                     const char* name,
                                     const boost::program_options::value_semantic* s,
                                     const char* desc,
                                     const Args& ...args) {
        while(descs_.size() <= level){
            descs_.emplace_back(new po::options_description(name_));
        }
 
        descs_.at(level)->add_options()
            (name, s, desc);
 
        // Recursively invoke until terminator overload of this func is reached
        // Note that this invoked the OTHER signature with NO VALUE SEMANTIC.
        // Boost frees these on destruction, so assigning the same pointer to
        // multiple options will create a double-free segfault.
        // The implication is that parsing must be done at the verbose level and
        // higher levels will have no semantic information (e.g. arguments)
        add_option_with_desc_level_(level+1, name, args...);
    }
 
    OptAdder opt_adder_;
 
    const std::string name_;
 
    std::vector<std::unique_ptr<po::options_description>> descs_;
 
}; // class MultiDetailOptions
 
    } // namespace app
} // namespace sparta