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