Options.H

Go to the documentation of this file.

#ifndef Options_H
#define Options_H

/** @file Options.H
    Command line options.

    $Id: Options.H 5817 2007-09-12 23:59:14Z sorsten $
    $Source$
*/

// This is an ORTS file (c) Michael Buro, licensed under the GPL

#include "Global.H"

//===================================================================

/** Base class for command line option. */
class Opt {

public:

  std::string remark;
  bool param;
  
  /** Parse option value from string.
      @return true on error
  */
  virtual bool from_string(const std::string &s) = 0;
  virtual std::string to_string() const = 0;
  virtual std::string get_type_name() const = 0;

  Opt() : param(true) {}
  virtual ~Opt() {}
};

//===================================================================

/** Command line option. */
template <class T> class OptT : public Opt
{
public:
  
  T value;

  OptT(T v) { value = v; }

  std::string to_string() const;
  bool from_string(const std::string &s);
  std::string get_type_name() const;
  
  static std::string type_name;
};

//===================================================================

/** Command line option parser. */
class Options {

public:

  typedef std::map<std::string, Opt*> OMap;
  typedef OMap::iterator OMapIt;
  typedef OMap::const_iterator OMapCIt;  

protected:

  static Vector<std::string> heading_name;
  static Vector<OMap> options;
  static OMap s_omap;

  OMap *omap;

  template <class T> struct Type {
    static std::string name;
  };
  
public:

  /** Add an option that takes a parameter. */

  template <class T>
  void put(const char *skey, T v, const char *remark=0)
  {
    std::string key(skey);
    OMapIt oit = s_omap.find(key);

    if (oit == s_omap.end()) {

      if (!remark) {
        errstr << "remark missing: " << skey << std::endl;
        ERR("");
      }
      
      // new entry
      OptT<T> *o = new OptT<T>(v);
      o->remark = std::string(remark);
      s_omap[key] = o;
      (*omap)[key] = o;
      return;
    }

    // entry found, check type

    OptT<T> *o = dynamic_cast<OptT<T>*>(oit->second);

    if (!o) {
      errstr << "different type for option " << skey << " - " << remark << std::endl;      
      abort(); exit(20);
    }

    // when redefining skey, type and value have to match
    
    if (remark && o->value != v) {
      OptT<T> temp(v);
      errstr << "different value for option " << skey << ": was " << o->to_string() << ", now: " << temp.to_string() << std::endl;
      abort(); exit(20);
    }

    o->value = v; // overwrite
  }

  //-------------------------------------------------------------------

  /** Add a flag - does not take any parameters. */

  void put(const char *skey, const char *remark=0)
  {
    std::string key(skey);
    OMapIt oit = s_omap.find(key);

    if (oit == s_omap.end()) {

      if (!remark) {
        errstr << "remark missing: " << skey << std::endl;
        ERR("");
      }
      
      // new entry
      OptT<bool> *o = new OptT<bool>(false);
      o->remark = std::string(remark);
      s_omap[key] = o;
      (*omap)[key] = o;
      o->param = false;
      return;
    }

    // entry found, check type

    OptT<bool> *o = dynamic_cast<OptT<bool>*>(oit->second);

    if (!o) {
      errstr << "different type for option " << skey << " - " << remark << std::endl;      
      ERR("");
    }

    // when redefining skey, type and value have to match
    
    if (remark && o->value != false) {
      errstr << "different value for option " << skey << ": was " << o->value << ", now: " << false << std::endl;
      ERR("");
    }

    o->value = false; // overwrite    
  }

  //-------------------------------------------------------------------

  /** Get value of option.
      @param key          Name of the option to extract.
      @param v            Location to store the retrieved value.
      @param bReportErr
      If true, then function reports errors (ERR iff illegal).
      If false, the function returns true on errors.
      This is useful in cases where we would like to fail silently or
      report/handle the error in the calling code.
  */
  template <class T>
  static bool get(const std::string &key, T &v, bool bReportErr = true)
  {
    OMapCIt oit = s_omap.find(key);

    if (oit == s_omap.end()) {
      // not found
      if (bReportErr) {
        errstr << "option not found: " << key << std::endl;
        ERR("");
      }
      return true;
    }      
    
    OptT<T> *o = dynamic_cast<OptT<T>*>(oit->second);
    if (!o) {
      // illegal type
      if (bReportErr) {
        errstr << "illegal value type for option " << key << ": expected "
               << oit->second->get_type_name() << ", got " << Type<T>::name << std::endl;
        ERR("");
      }
      return true;
    }

    v = o->value;
    return false;
  }

  //-------------------------------------------------------------------

  template <class T>
  static bool set(const std::string &key, T v, bool bReportErr = true)
  {
    OMapCIt oit = s_omap.find(key);

    if (oit == s_omap.end()) {
      // not found
      if (bReportErr) {
        errstr << "option not found: " << key << std::endl;
        ERR("");
      }
      return true;
    }      
    
    OptT<T> *o = dynamic_cast<OptT<T>*>(oit->second);
    if (!o) {
      // illegal type
      if (bReportErr) {
        errstr << "illegal value type for option " << key << ": expected "
               << oit->second->get_type_name() << ", got " << Type<T>::name << std::endl;
        ERR("");
      }
      return true;
    }

    o->value = v;
    return false;
  }

  // write options to stream
  static void write(std::ostream &os);
  
  // clears all options
  static void reset();
  
  // @return false iff OK
  static bool process(sint4 argc, char **argv, std::ostream &oserr, const char *remark=0);
  // return non-options in rest (useful for mandatory parameters)
  static bool process2(sint4 argc, char **argv, std::ostream &oserr, Vector<std::string> &rest);
  static bool process(const std::string& args , std::ostream &oserr, const char *remark);

  Options(std::string heading="");
  virtual ~Options();

private:

  // prevent copying and assigning (not implemented yet)
  Options(const Options &) {}
  //  Options &operator=(const Options &) {}
};

//===================================================================

REGISTER_TYPEOF(20, Options::OMap::iterator);
REGISTER_TYPEOF(21, Options::OMap::const_iterator);
REGISTER_TYPEOF(22, Vector<Options::OMap>::iterator);
REGISTER_TYPEOF(23, Vector<Options::OMap>::const_iterator);

#endif