b2cmdline.H

Go to the documentation of this file.

//------------------------------------------------------------------------
// b2cmdline.H --
//
//     Command-line parsing classes for ./src/processor/main.C
//
// written by Mathias Doreille
//
// Copyright (c) 2004-2012,2016,2017
//     SMR Engineering & Development SA
//     2502 Bienne, Switzerland
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//------------------------------------------------------------------------
 
#ifndef __B2CMDLINE_H__
#define __B2CMDLINE_H__
 
#include <cctype>
#include <complex>
#include <iostream>
#include <iterator>
#include <map>
#include <sstream>
#include <string>
#include <vector>
 
#include "b2csda.H"
#include "b2dictionary.H"
#include "b2exception.H"
#include "b2logging.H"
#include "b2ppconfig.h"
#include "b2rtable.H"
 
namespace b2000 { namespace cmdline {
 
class CmdLine;
 
class CmdOptBase {
public:
    CmdOptBase(
          std::string name_, std::string short_desc_, std::string long_desc_,
          bool multiple_ = false)
        : name(name_),
          short_desc(short_desc_),
          long_desc(long_desc_),
          is_set_(false),
          multiple(multiple_) {}
 
    virtual ~CmdOptBase() {}
 
    bool is_set() { return is_set_; }
 
protected:
    friend class CmdLine;
    virtual void parse_arg(const std::string& arg) = 0;
    std::string get_short_desc() const;
    std::string name;
    std::string short_desc;
    std::string long_desc;
    bool is_set_;
    bool multiple;
};
 
template <typename T = std::string>
class CmdOpt : public CmdOptBase {
public:
    CmdOpt(std::string name_, std::string short_desc_, std::string long_desc_, T default_ = T())
        : CmdOptBase(name_, short_desc_, long_desc_), value(default_) {}
    operator T&() { return value; }
 
private:
    void parse_arg(const std::string& arg) override {
        std::istringstream i(arg);
        i >> value;
        if (!i) {
            Exception() << "Cannot convert the command-line argument " << arg
                        << " to the specific type of the option -" << name << "." << THROW;
        }
        std::string s;
        i >> s;
        if (s.size()) {
            Exception() << "Cannot convert the command-line argument " << arg
                        << " to the specific type of the option -" << name << "." << THROW;
        }
        is_set_ = true;
    }
 
    T value;
};
 
template <typename T = std::string>
class CmdOptList : public std::vector<T>, public CmdOptBase {
public:
    CmdOptList(std::string name_, std::string short_desc_, std::string long_desc_)
        : CmdOptBase(name_, short_desc_, long_desc_, true) {}
 
private:
    void parse_arg(const std::string& arg) override {
        T value;
        std::istringstream i(arg);
        i >> value;
        if (!i) {
            Exception() << "Cannot convert the command-line argument " << arg
                        << " to the specific type of the option -" << name << "." << THROW;
        }
        std::string s;
        i >> s;
        if (s.size()) {
            Exception() << "Cannot convert the command-line argument " << arg
                        << " to the specific type of the option -" << name << "." << THROW;
        }
        std::vector<T>::push_back(value);
        is_set_ = true;
    }
};
 
class CmdOptRTable : public CmdOptBase, public RTable {
public:
    CmdOptRTable(std::string name_, std::string short_desc_, std::string long_desc_)
        : CmdOptBase(name_, (short_desc_ == "" ? "key=value" : short_desc_), long_desc_, true) {}
 
private:
    void parse_arg(const std::string& arg) override {
        int pos_equal = arg.find('=');
        if (pos_equal == -1) {
            Exception() << "Cannot convert the command-line argument " << arg
                        << " to the specific type of the option -" << name << "."
                        << "The = character is missing." << THROW;
        }
        std::string key = arg.substr(0, pos_equal);
        std::string val = arg.substr(pos_equal + 1);
 
        {
            std::istringstream iss(val);
            int v;
            iss >> v;
            if (iss && iss.eof()) {
                set(key, v);
                is_set_ = true;
                return;
            }
        }
        {
            std::istringstream iss(val);
            float v;
            iss >> v;
            if (iss && iss.eof()) {
                set(key, v);
                is_set_ = true;
                return;
            }
        }
        set(key, val);
        is_set_ = true;
    }
};
 
class CmdOptDictionary : public CmdOptBase, public Dictionary {
public:
    CmdOptDictionary(std::string name_, std::string short_desc_, std::string long_desc_)
        : CmdOptBase(name_, (short_desc_ == "" ? "key=value" : short_desc_), long_desc_, true),
          logger(logging::get_logger(std::string("command_line.") + name_)) {}
 
    bool has_key(const std::string& key) const override {
        logger << logging::debug << "Try to use the key " << key << " of the command line option -"
               << name << "." << logging::LOGFLUSH;
        return list_key.find(key) != list_key.end();
    }
 
    bool get_bool(const std::string& key) const override {
        list_key_t::const_iterator i = list_key.find(key);
        if (i == list_key.end()) { KeyError() << THROW; }
        const_cast<bool&>(i->second.second) = true;
        logger << logging::debug << "Using the key " << key << " of the command-line option -"
               << name << " has boolean." << logging::LOGFLUSH;
        const std::string& s = i->second.first;
        if (s == "1" || s == "yes" || s == "YES" || s == "true" || s == "TRUE") {
            return true;
        } else if (s == "0" || s == "no" || s == "NO" || s == "false" || s == "FALSE") {
            return false;
        }
        Exception() << "Cannot convert the string " << i->second.first << " of key " << key
                    << " to a value of type bool." << THROW;
        return false;
    }
 
    int get_int(const std::string& key) const override {
        list_key_t::const_iterator i = list_key.find(key);
        if (i == list_key.end()) { KeyError() << THROW; }
        const_cast<bool&>(i->second.second) = true;
        std::istringstream o(i->second.first);
        std::istream_iterator<int> oo(o);
        std::vector<int> v(oo, std::istream_iterator<int>());
        if (v.size() != 1 || !o.eof()) {
            Exception() << "Cannot convert the string " << i->second.first << " of key " << key
                        << " to an integer value." << THROW;
        }
        logger << logging::debug << "Using the key " << key << " of the command line option -"
               << name << " has integer." << logging::LOGFLUSH;
        return v[0];
    }
 
    double get_double(const std::string& key) const override {
        list_key_t::const_iterator i = list_key.find(key);
        if (i == list_key.end()) { KeyError() << THROW; }
        const_cast<bool&>(i->second.second) = true;
        std::istringstream o(i->second.first);
        std::istream_iterator<double> oo(o);
        std::vector<double> v(oo, std::istream_iterator<double>());
        if (v.size() != 1 || !o.eof()) {
            Exception() << "Cannot convert the string " << i->second.first << " of key " << key
                        << " to a floating point value." << THROW;
        }
        logger << logging::debug << "Using the key " << key << " of the command line option -"
               << name << " has floating point value." << logging::LOGFLUSH;
        return v[0];
    }
 
    b2000::csda<double> get_csda_double(const std::string& key) const override {
        list_key_t::const_iterator i = list_key.find(key);
        if (i == list_key.end()) { KeyError() << THROW; }
        const_cast<bool&>(i->second.second) = true;
        std::istringstream o(i->second.first);
        std::istream_iterator<b2000::csda<double> > oo(o);
        std::vector<b2000::csda<double> > v(oo, std::istream_iterator<b2000::csda<double> >());
        if (v.size() != 1 || !o.eof()) {
            Exception() << "Cannot convert the string " << i->second.first << " of key " << key
                        << " to a csda value." << THROW;
        }
        logger << logging::debug << "Using the key " << key << " of the command line option -"
               << name << " has csda value." << logging::LOGFLUSH;
        return v[0];
    }
 
    std::complex<double> get_complex_double(const std::string& key) const override {
        list_key_t::const_iterator i = list_key.find(key);
        if (i == list_key.end()) { KeyError() << THROW; }
        const_cast<bool&>(i->second.second) = true;
        std::istringstream o(i->second.first);
        std::istream_iterator<std::complex<double> > oo(o);
        std::vector<std::complex<double> > v(oo, std::istream_iterator<std::complex<double> >());
        if (v.size() != 1 || !o.eof()) {
            Exception() << "Cannot convert the string " << i->second.first << " of key " << key
                        << " to a complex value." << THROW;
        }
        logger << logging::debug << "Using the key " << key << " of the command line option -"
               << name << " has complex value." << logging::LOGFLUSH;
        return v[0];
    }
 
    std::string get_string(const std::string& key) const override {
        list_key_t::const_iterator i = list_key.find(key);
        if (i == list_key.end()) { KeyError() << THROW; }
        const_cast<bool&>(i->second.second) = true;
        logger << logging::debug << "Using the key " << key << " of the command line option -"
               << name << " has string." << logging::LOGFLUSH;
        return i->second.first;
    }
 
    void get(const std::string& key, std::vector<int>& v) const override {
        list_key_t::const_iterator i = list_key.find(key);
        if (i == list_key.end()) { KeyError() << THROW; }
        const_cast<bool&>(i->second.second) = true;
        std::istringstream o(i->second.first);
        std::istream_iterator<int> oo(o);
        std::vector<int> vv(oo, std::istream_iterator<int>());
        if (!o.eof()) {
            Exception() << "Cannot convert the string " << i->second.first << " of key " << key
                        << " to an array of integers." << THROW;
        }
        logger << logging::debug << "Using the key " << key << " of the command line option -"
               << name << " has array of integers." << logging::LOGFLUSH;
        vv.swap(v);
    }
 
    void get(const std::string& key, std::vector<double>& v) const override {
        list_key_t::const_iterator i = list_key.find(key);
        if (i == list_key.end()) { KeyError() << THROW; }
        const_cast<bool&>(i->second.second) = true;
        std::istringstream o(i->second.first);
        std::istream_iterator<double> oo(o);
        std::vector<double> vv(oo, std::istream_iterator<double>());
        if (!o.eof()) {
            Exception() << "Cannot convert the string " << i->second.first << " of key " << key
                        << " to an array of floating point values." << THROW;
        }
        logger << logging::debug << "Using the key " << key << " of the command line option -"
               << name << " has array of double." << logging::LOGFLUSH;
        vv.swap(v);
    }
 
    void get(const std::string& key, std::vector<b2000::csda<double> >& v) const override {
        list_key_t::const_iterator i = list_key.find(key);
        if (i == list_key.end()) { KeyError() << THROW; }
        const_cast<bool&>(i->second.second) = true;
        std::istringstream o(i->second.first);
        std::istream_iterator<b2000::csda<double> > oo(o);
        std::vector<b2000::csda<double> > vv(oo, std::istream_iterator<b2000::csda<double> >());
        if (!o.eof()) {
            Exception() << "Cannot convert the string " << i->second.first << " of key " << key
                        << " to an array of csda values." << THROW;
        }
        logger << logging::debug << "Using the key " << key << " of the command line option -"
               << name << " has array of csda values." << logging::LOGFLUSH;
        vv.swap(v);
    }
 
    void get(const std::string& key, std::vector<std::complex<double> >& v) const override {
        list_key_t::const_iterator i = list_key.find(key);
        if (i == list_key.end()) { KeyError() << THROW; }
        const_cast<bool&>(i->second.second) = true;
        std::istringstream o(i->second.first);
        std::istream_iterator<std::complex<double> > oo(o);
        std::vector<std::complex<double> > vv(oo, std::istream_iterator<std::complex<double> >());
        if (!o.eof()) {
            Exception() << "Cannot convert the string " << i->second.first << " of key " << key
                        << " to an array of complex values." << THROW;
        }
        logger << logging::debug << "Using the key " << key << " of the command line option -"
               << name << " has array of complex doubles." << logging::LOGFLUSH;
        vv.swap(v);
    }
 
    void warn_on_non_used_key() const override {
        std::string res;
        for (list_key_t::const_iterator i = list_key.begin(); i != list_key.end(); ++i) {
            if (!i->second.second) {
                if (!res.empty()) { res += ", "; }
                res += i->first;
            }
        }
        if (!res.empty()) {
            logger << logging::warning << "Key '" << res
                   << "' of command line option ignored, because unknown" << logging::LOGFLUSH;
        }
    }
 
    std::string has_string() const override {
        std::string res = "{";
        for (list_key_t::const_iterator i = list_key.begin(); i != list_key.end(); ++i) {
            res += '"';
            res += i->first;
            res += "\": ";
            res += i->second.first;
            res += ", ";
        }
        res += '}';
        return res;
    }
 
private:
    void parse_arg(const std::string& arg) override {
        int pos_equal = arg.find('=');
        if (pos_equal == -1) {
            Exception() << "Cannot convert the command-line argument " << arg
                        << " to the specific type of the option -" << name << "."
                        << "The = character is missing." << THROW;
        }
        std::string key = arg.substr(0, pos_equal);
        std::string val = arg.substr(pos_equal + 1);
 
        // The command-line argument may be given in lower-case.
        for (std::string::iterator i = key.begin(); i != key.end(); ++i) {
            (*i) = std::toupper(*i);
        }
        for (std::string::iterator i = val.begin(); i != val.end(); ++i) {
            (*i) = std::toupper(*i);
        }
 
        if (has_key(key)) {
            Exception() << "The key " << key
                        << " of the command-line "
                           "argument "
                        << arg << " of the option -" << name << " already exists." << THROW;
        }
        list_key[key] = std::pair<std::string, bool>(val, false);
        is_set_ = true;
    }
 
    typedef std::map<std::string, std::pair<std::string, bool> > list_key_t;
    list_key_t list_key;
    logging::Logger& logger;
};
 
class CmdArgBase {
public:
    CmdArgBase(std::string short_desc_, std::string long_desc_)
        : short_desc(short_desc_), long_desc(long_desc_) {}
    virtual ~CmdArgBase() {}
 
protected:
    friend class CmdLine;
    virtual void parse_arg(const std::string& arg) = 0;
    std::string short_desc;
    std::string long_desc;
};
 
template <typename T = std::string>
class CmdArg : public CmdArgBase {
public:
    CmdArg(std::string short_desc_, std::string long_desc_) : CmdArgBase(short_desc_, long_desc_) {}
 
    operator T&() { return value; }
 
private:
    T value;
    void parse_arg(const std::string& arg) override {
        std::istringstream i(arg);
        i >> value;
        if (!i) {
            Exception() << "Cannot convert the command-line argument " << arg
                        << " to the specific type of  the argument " << short_desc << "." << THROW;
        }
        std::string s;
        i >> s;
        if (s.size()) {
            Exception() << "Cannot convert the command-line argument " << arg
                        << " to the specific type of the argument " << short_desc << "." << THROW;
        }
    }
};
 
class CmdArgListBase {
public:
    CmdArgListBase(std::string short_desc_, std::string long_desc_)
        : short_desc(short_desc_), long_desc(long_desc_) {}
    virtual ~CmdArgListBase() {}
 
protected:
    friend class CmdLine;
    virtual void parse_arg(const std::string& arg) = 0;
    std::string short_desc;
    std::string long_desc;
};
 
template <typename T = std::string>
class CmdArgList : public std::vector<T>, public CmdArgListBase {
public:
    CmdArgList(std::string short_desc_, std::string long_desc_)
        : CmdArgListBase(short_desc_, long_desc_) {}
 
private:
    void parse_arg(const std::string& arg) override {
        T value;
        std::istringstream i(arg);
        i >> value;
        if (!i) {
            Exception() << "Cannot convert the command-line argument " << arg
                        << " to the specific type of the argument " << short_desc << "." << THROW;
        }
        std::string s;
        i >> s;
        if (s.size()) {
            Exception() << "Cannot convert the command-line argument " << arg
                        << " to the specific type of the argument " << short_desc << "." << THROW;
        }
        std::vector<T>::push_back(value);
    }
};
 
template <>
inline void CmdOpt<std::string>::parse_arg(const std::string& arg) {
    value = arg;
    is_set_ = true;
}
 
template <>
inline void CmdOptList<std::string>::parse_arg(const std::string& arg) {
    std::vector<std::string>::push_back(arg);
    is_set_ = true;
}
 
template <>
inline void CmdArg<std::string>::parse_arg(const std::string& arg) {
    value = arg;
}
 
template <>
inline void CmdArgList<std::string>::parse_arg(const std::string& arg) {
    std::vector<std::string>::push_back(arg);
}
 
template <>
inline void CmdOpt<bool>::parse_arg(const std::string& arg) {
    value = true;
    is_set_ = true;
}
 
template <>
inline void CmdOptList<bool>::parse_arg(const std::string& arg) {
    std::vector<bool>::push_back(true);
    is_set_ = true;
}
 
template <>
inline void CmdArg<bool>::parse_arg(const std::string& arg) {
    value = true;
}
 
template <>
inline void CmdArgList<bool>::parse_arg(const std::string& arg) {
    std::vector<bool>::push_back(true);
}
 
class CmdLine {
public:
    CmdLine(int argc_, char* argv_[])
        : argc(argc_), argv(argv_), opt_parsed(false), arg_list(nullptr) {}
 
    CmdLine& operator<<(CmdOptBase& opt) {
        opts.push_back(&opt);
        if (!name_opts.insert(name_opts_t::value_type(opt.name, &opt)).second) {
            Exception() << "The command-line option -" << opt.name << " is already defined."
                        << THROW;
        }
        return *this;
    }
 
    CmdLine& operator<<(CmdArgBase& opt) {
        args.push_back(&opt);
        return *this;
    }
 
    CmdLine& operator<<(CmdArgListBase& opt) {
        if (arg_list != nullptr) {
            Exception() << "Only one CmdArgList can by inserted in a CmdLine." << THROW;
        }
        arg_list = &opt;
        return *this;
    }
 
    void parse(bool only_opt = false);
 
    void print_short_desc(std::ostream& out) const;
 
    void print_long_desc(std::ostream& out) const;
 
    std::string get_command_name() const;
 
    std::string get_command_line() const;
 
private:
    static void format_print(std::ostream& out, const std::string& a, const std::string& b);
    int argc;
    char** argv;
    bool opt_parsed;
    std::vector<CmdOptBase*> opts;
    typedef std::map<std::string, CmdOptBase*> name_opts_t;
    name_opts_t name_opts;
    std::vector<CmdArgBase*> args;
    CmdArgListBase* arg_list;
};
 
}}  // namespace b2000::cmdline
 
#endif /* __B2CMDLINE_H__ */