CommandLine.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2009 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Util/genutil/CommandLine.h
 
#ifndef __CommandLine_h
#define __CommandLine_h
 
#include "Reference.h"
#include "Functor.h"
#include "tostring.h"
 
#include <string>
#include <vector>
 
#include <getopt.h>

template<typename T>
struct arg_traits { typedef T unref; };
 
template<typename T>
struct arg_traits<const T&> { typedef T unref; };
 
namespace CommandLine {
 
  typedef std::pair<std::string,std::string> Help;

  class Item : public Reference::Able
  {
  public:
 
    virtual ~Item () { }

    virtual bool matches (int code) const = 0;

    virtual void handle (const std::string& arg) = 0;

    virtual void set_handled (bool) { /* do nothing by default */ }

    virtual Help get_help () const = 0;
  };
 
  class Menu;
  class Alias;

  class Argument : public Item
  {
 
  protected:

    std::string short_name;

    std::string long_name;

    std::string type;

    std::string help;

    std::string long_help;

    int has_arg;

    int val;

    bool* handled;
 
    friend class Menu;
    friend class Alias;
 
  public:
 
    Argument () { val = 0; has_arg = no_argument; handled = 0; }
 
    void set_short_name (char c) { 
      if (c=='\0') short_name = "";
      else short_name = std::string(1,c); 
    }
    void set_long_name (const std::string& s) { long_name = s; }
    void set_type (const std::string& s) { type = s; }
    void set_help (const std::string& s) { help = s; }
    void set_long_help (const std::string& s) { long_help = s; }
    void set_has_arg (int h) { has_arg = h; }
 
    void set_handled (bool f) { if (handled) *handled = f; }
    void set_notification (bool& f) { handled = &f; };

    bool matches (int c) const { return val == c; }
 
    Help get_help () const;
  
  };
 

  class Alias : public Argument
  {
 
  protected:
 
    Reference::To<Argument> argument;
    void set_argument (Argument*);
 
  public:
 
    Alias (Argument* a, char short_alias)
    { set_argument (a); short_name = short_alias;}
 
    Alias (Argument* a, const std::string& long_alias)
    { set_argument (a); long_name = long_alias; }
 
    void set_handled (bool f) { argument->set_handled (f); }
    void handle (const std::string& arg) { argument->handle (arg); }
    Help get_help () const;
  };

  template<typename T>
  class Value : public Argument
  {
  protected:

    T& value;
 
  public:

    Value (T& _value)
      : value (_value) { has_arg = required_argument; }

    void handle (const std::string& arg) { value = fromstring<T>(arg); }
  };

  template<typename T>
  class Value< std::vector<T> > : public Argument
  {
  protected:

    std::vector<T>& values;
 
  public:

    Value (std::vector<T>& _values)
      : values (_values) { has_arg = required_argument; }

    void handle (const std::string& arg) 
    {
      values.push_back( fromstring<T>(arg) );
    }
 
  };

  template<>
  class Value<bool> : public Argument
  {
  protected:

    bool& value;
 
  public:

    Value (bool& _value) : value (_value) { }

    void handle (const std::string&) { value = !value; }
  };

  template<class C, typename M, typename P>
  class Attribute : public Argument
  {
  protected:

    C* instance;

    M method;

    P parse;
 
  public:

    Attribute (C* _instance, M _method, P _parse)
      : instance (_instance), method (_method), parse (_parse)
    { has_arg = required_argument; }

    void handle (const std::string& arg)
    { (instance->*method) (parse(arg)); }
  };

  class Parser : public Argument
  {
  protected:

    Functor < void( const std::string& ) > action;
 
  public:

    Parser (Functor < void( const std::string& ) >& _action)
    { action = _action;  has_arg = required_argument; }

    void handle (const std::string& arg)
    {
      // std::cerr << "Parser::handle arg='" << arg << "'" << std::endl;
      action(arg);
    }
  };
  
  class Action : public Argument
  {
  protected:

    Functor < void() > action;
 
  public:

    template<class C, typename M>
    Action (C* instance, M method)
    { action = Functor< void() > (instance, method); }

    void handle (const std::string&) { action(); }
  };

  template<class T>
  class UnaryAction : public Argument
  {
  protected:

    Functor < void(T) > action;

    T argument;
 
  public:

    template<class C, typename M>
    UnaryAction (C* instance, M method, T arg)
    { action = Functor< void(T) > (instance, method); argument=arg; }

    void handle (const std::string&) { action(argument); }
  };
  
  class Heading : public Item
  {
 
  public:

    Heading (const std::string& _text) { text = _text; }

    bool matches (int) const { return false; }

    void handle (const std::string&) { }

    Help get_help () const { return Help(text,""); }
 
  protected:
 
    std::string text;
  };
 

  class Menu : public Reference::Able
  {
  public:

    Menu ();
 
    virtual ~Menu ();

    virtual void set_help_header (const std::string& s)
    { help_header=s; add_help (); }

    std::string get_help_header () const
    { return help_header; }

    virtual void set_help_footer (const std::string& s) { help_footer=s; }

    std::string get_help_footer () const { return help_footer; }

    virtual void add_help ();

    virtual void set_version (const std::string& s)
    { version_info = s; add_version (); }

    virtual void add_version ();

    virtual void parse (int argc, char* const *argv);

    virtual int process_error (int code, char* const *argv);

    virtual void add (Item*);

    virtual void remove (Item*);

    template<typename T>
    Argument* add (T& value, char name, const char* type = 0)
    {
      return add_value (value, name, &Argument::set_short_name, type);
    }

    template<typename T>
    Argument* add (T& value, const std::string& name, const char* type = 0)
    { 
      return add_value (value, name, &Argument::set_long_name, type);
    }

    Argument* add (Functor< void(const std::string&) > action,
                   char name, const char* type = 0)
    {
      return add_parser (action, name, &Argument::set_short_name, type);
    }

    Argument* add (Functor< void(const std::string&) > action,
                   const std::string& name, const char* type = 0)
    { 
      return add_parser (action, name, &Argument::set_long_name, type);
    }
    
    template<class C, class B, typename T>
    Argument* add (C* ptr, void (B::*method)(T), char name, 
                   const char* type = 0)
    {
      return add_attribute (ptr, method,
                            &fromstring< typename arg_traits<T>::unref >,
                            name, &Argument::set_short_name, type);
    }

    template<class C, class B, typename T>
    Argument* add (C* ptr, void (B::*method)(T), const std::string& name, 
                   const char* type = 0)
    {
      return add_attribute (ptr, method,
                            &fromstring< typename arg_traits<T>::unref >,
                            name, &Argument::set_long_name, type);
    }

    template<class C, typename M, typename P>
    Argument* add (C* ptr, M method, P parse, char name, const char* type)
    {
      return add_attribute (ptr, method, parse,
                            name, &Argument::set_short_name, type);
    }

    template<class C, typename M, typename P>
    Argument* add (C* ptr, M method, P parse, const std::string& name, 
                   const char* type)
    {
      return add_attribute (ptr, method, parse,
                            name, &Argument::set_long_name, type);
    }

    template<class C, class B>
    Argument* add (C* ptr, void (B::*method)(), char name)
    {
      return add_action (ptr, method, name, &Argument::set_short_name);
    }

    template<class C, class B>
    Argument* add (C* ptr, void (B::*method)(), const std::string& name)
    {
      return add_action (ptr, method, name, &Argument::set_long_name);
    }

    template<class C, class B, class T>
    Argument* add (C* ptr, void (B::*method)(T), char name, T arg)
    {
      return add_action (ptr, method, name, &Argument::set_short_name, arg);
    }

    template<class C, class B, class T>
    Argument* add (C* ptr, void (B::*method)(T), const std::string& name, T arg)
    {
      return add_action (ptr, method, name, &Argument::set_long_name, arg);
    }

    Argument* find (const std::string& name);

    void add (const std::string&);

    void help (const std::string&);

    void version ();
 
  protected:
 
    std::vector< Reference::To<Item> > item;
 
    std::string version_info;
    Argument* version_item;
 
    std::string help_header;
    std::string help_footer;
    Argument* help_item;

    template<typename T, typename N, typename S>
    Argument* add_value (T& value, N name, S set, const char* type)
    { 
      Argument* argument = new Value<T> (value);
      (argument->*set) (name);
      if (type)
        argument->set_type (type);
      item.push_back (argument);
      return argument;
    }
 
    template<class C, typename M, typename P, typename N, typename S>
    Argument* add_attribute (C* ptr, M method, P parse, N name, S set,
                             const char* type)
    {
      Argument* argument = new Attribute<C,M,P> (ptr, method, parse);
      (argument->*set) (name);
      if (type)
        argument->set_type (type);
      item.push_back (argument);
      return argument;
    }
 
    template<typename N, typename S>
    Argument* add_parser (Functor< void(const std::string&) >& action,
                          N name, S set, const char* type)
    {
      // std::cerr << "Menu::add_parser type='" << type << "'" << std::endl;
 
      Argument* argument = new Parser (action);
      (argument->*set) (name);
      if (type)
        argument->set_type (type);
      item.push_back (argument);
      return argument;
    }
    
    template<class C, typename M, typename N, typename S>
    Argument* add_action (C* ptr, M method, N name, S set)
    {
      Argument* argument = new Action (ptr, method);
 
      (argument->*set) (name);
      item.push_back (argument);
      return argument;
    }
 
    template<class C, typename M, typename N, typename S, typename T>
    Argument* add_action (C* ptr, M method, N name, S set, T arg)
    {
      Argument* argument = new UnaryAction<T> (ptr, method, arg);
 
      (argument->*set) (name);
      item.push_back (argument);
      return argument;
    }
 
  };
 
 
}
 
#endif