CommandLineBoost.h

// WARNING: Changes to this file must be contributed back to Sawyer or else they will
//          be clobbered by the next update from Sawyer.  The Sawyer repository is at
//          https://github.com/matzke1/sawyer.
 
 
 
 
#ifndef Sawyer_CommandLine_Boost_H
#define Sawyer_CommandLine_Boost_H
 
#include <Sawyer/CommandLine.h>
#include <Sawyer/Sawyer.h>
 
namespace Sawyer {
namespace CommandLine {
 
namespace Boost {
 
template<class T>
struct value {};
 
struct options_description {
    Sawyer::CommandLine::SwitchGroup sg;
 
    options_description() {}
 
    explicit options_description(const std::string &title): sg(title) {}
 
    options_description& operator()(const std::string &switchName, const value<std::string>&, const std::string &doc);
    options_description& operator()(const std::string &switchName, const value<int>&, const std::string &doc);
    options_description& operator()(const std::string &switchName, const value<long int>&, const std::string &doc);
    options_description& operator()(const std::string &switchName, const value<std::vector<int> >&, const std::string &doc);
    options_description& operator()(const std::string &switchName, const value< std::vector<std::string> >&,
                                    const std::string &doc);
    options_description& operator()(const std::string &switchName, const std::string &doc);
    options_description& add_options() {
        return *this;
    }
 
    options_description& add(const options_description &other);
 
    void print() const;
};
 
std::ostream& operator<<(std::ostream &out, const options_description &x);
 
struct command_line_parser {
    int argc;                                           
    char **argv;                                        
    Sawyer::CommandLine::Parser parser;                 
    command_line_parser(int argc, char *argv[]): argc(argc), argv(argv) {
        parser.errorStream(Sawyer::Message::mlog[Sawyer::Message::FATAL]); // use error messages instead of exceptions
    }
 
    command_line_parser& options(const options_description&);
    command_line_parser& options(const Sawyer::CommandLine::SwitchGroup&);
    command_line_parser& allow_unregistered() { return *this; }
 
    Sawyer::CommandLine::ParserResult run() {
        return parser.parse(argc, argv).apply();
    }
};
 
struct parsed_values {                                  // not a boost::program_options type
    Sawyer::CommandLine::ParsedValues pv;               
    parsed_values() {}
 
    explicit parsed_values(const Sawyer::CommandLine::ParsedValues &pv): pv(pv) {}
 
    template<class T>
    T as() {
        return as_helper(T());
    }
 
private:
    template<class T>
    T as_helper(const T&) {
        ASSERT_forbid(pv.empty());
        return pv.back().as<T>();
    }
 
    template<class T>
    std::vector<T> as_helper(const std::vector<T>&) {
        std::vector<T> retval;
        BOOST_FOREACH (const Sawyer::CommandLine::ParsedValue &v, pv) {
            Sawyer::CommandLine::ListParser::ValueList elmts = v.as<Sawyer::CommandLine::ListParser::ValueList>();
            BOOST_FOREACH (const Sawyer::CommandLine::ParsedValue &elmt, elmts)
                retval.push_back(elmt.as<T>());
        }
        return retval;
    }
};
 
struct variables_map {
    Sawyer::CommandLine::ParserResult pr;               
    size_t count(const std::string &swName) const;
 
    parsed_values operator[](const std::string &swName) const;
};
 
void store(const Sawyer::CommandLine::ParserResult &results, variables_map &output);
 
void notify(variables_map&);
 
} // namespace
 
} // namespace
} // namespace
 
#endif