commandline.h

Go to the documentation of this file.

#ifndef COMMANDLINE_H
#define COMMANDLINE_H

#include <cassert>
#include <iostream>
#include <string>
#include <map>
#include <sstream>
#include <algorithm>
#include <cctype>
#include <vector>
#include <set>
using namespace std;

#include <typedefs.h>

class commandline
{
  commandline() { assert(false); }

  map<string,string> mp;   
public:

  vector<string> args;

  //
  //  Input Reading Functions

  explicit commandline(int argc, char** argv);
  explicit commandline(istream & is);
  explicit commandline(stringc & arg);

  void read(stringc & arg);

  void read(istream & is);
  void readfile(stringc var);

  //  Binding

  template< typename T >
  boolc mapvar(T& var, stringc & key);

  template< typename T >
  boolc mapvar(T& var, stringc & key, T const & init);

  template< typename T >
  boolc mapcallback
  ( 
    T & x, 
    void ( T::*p )(),
    stringc & token
  );

  //  Miscellaneous 

  multiset<string> tokens;
  boolc hastoken(stringc & token) const
    { return (tokens.find(token)!=tokens.end()); }

  vector<string> bindvar;

  ostream & enablehelp(ostream & os=cout) const;

};



// ---------------------------------------------------------
// Implementation 

//  Note: I had difficulty with map<string,string>
//    as my compiler just did not produce workable code
//    with iterating over mp within the commandline class.
//    This was weird. The same code however did work in map_var.


template< typename T >
class map_var
{
  T var;
  map<string,string>& tbl;
  bool found;
public:

  map_var(T var_, map<string,string>& tbl_, stringc & key) 
    : var(var_), tbl(tbl_)
  {
    map<string,string>::iterator pos = tbl.find(key);
    found = (pos!=tbl.end());
    if (found)
    {
      stringstream ss(tbl[key]);
      ss >> var;
    }
  }

  boolc foundGet() const { return found; }
  T operator() () { return var; }
};


template<>
class map_var<string&>
{
  string& var;
  map<string,string>& tbl;
  bool found;
public:

  map_var(string& var_, map<string,string>& tbl_, stringc & key)
    : var(var_), tbl(tbl_)
  {
    map<string,string>::iterator pos = tbl.find(key);
    found = (pos!=tbl.end());
    if (found)
    {
      var = tbl[key];
    }
  }
  
  boolc foundGet() const { return found; }
  string& operator() () { return var; }
};


template<>
class map_var<bool&>
{
  bool& var;
  map<string,string>& tbl;
  bool found;
public:

  map_var(bool& var_, map<string,string>& tbl_, stringc & key)
    : var(var_), tbl(tbl_)
  {
    map<string,string>::iterator pos = tbl.find(key);
    found = (pos!=tbl.end());
    if (found)
    {
      string s = tbl[key];
      transform (s.begin(), s.end(), s.begin(), ::tolower );
      if ((s=="false") || (s=="0"))
        var = false;
      if ((s=="true") || (s=="1"))
        var = true;
    }
  }
  
  boolc foundGet() const { return found; }
  bool& operator() () { return var; }
};

template< typename T >
boolc commandline::mapvar(T& var, stringc & key)
{
  bindvar.push_back(key);
  map_var<T&> t(var,mp,key); 
  return t.foundGet();
}

template< typename T >
boolc commandline::mapvar
(
  T& var, 
  stringc & key, 
  T const & init
)
{
  bindvar.push_back(key);
  map_var<T&> t(var,mp,key); 
  boolc res = t.foundGet();
  if (res==false)
    var = init;

  return res;
}

template< typename T >
boolc commandline::mapcallback
( 
  T & x, 
  void ( T::*p )(),
  stringc & token
)
{
  bool found = (tokens.find(token)!=tokens.end());
  if (found)
    (x.*p)();

  return found;
}


#endif