source: trunk/yat/utility/CommandLine.cc @ 687

// $Id: CommandLine.cc 687 2006-10-16 23:51:10Z jari $

/*
  Copyright (C) 2006 Peter Johansson

  This file is part of the yat library, http://lev.thep.lu.se/trac/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of the
  License, or (at your option) any later version.

  The yat library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#include "CommandLine.h"

#include "Option.h"
#include "utility.h"

#include <algorithm>
#include <functional>
#include <fstream>
#include <iostream>
#include <sstream>


namespace theplu {
namespace yat {
namespace utility {

  CommandLine::CommandLine(void)
    : max_argument_(0), min_argument_(0)
  {
  }


  CommandLine::~CommandLine(void)
  {
    // Cleaning up
    for (std::list<Option*>::iterator i=options_.begin();i!=options_.end();++i)
      delete *(i);
  }


  Option* CommandLine::add(char short_name,
                           const std::string& long_name,
                           Option::argument_type arg,
                           const std::string& describtion)
  {
    using namespace std;
    if (short_name=='\0' && long_name.empty()){
      cerr << "warning: cannot add parameter with no name" << endl;
      return NULL;
    }
    Option* o = new Option(short_name, long_name, arg, describtion);

    if (!long_name.empty()){
      key2option::iterator i = param_.lower_bound(long_name);
      if (i!=param_.end() && i->first == string(1,short_name)){
        cerr << "warning: " << long_name << " already defined.\n";
        delete o;
        return NULL;
      }
      else
        param_.insert(i, make_pair(long_name, o));
    }
    if (short_name!='\0'){
      key2option::iterator i = param_.lower_bound(string(1,short_name));
      if (i!=param_.end() && i->first == string(1,short_name)){
        cerr << "warning: " << short_name << " already defined.\n";
        delete o;
        return NULL;
      }
      else
        param_.insert(i, make_pair(string(1,short_name), o));
    }
    options_.push_back(o);
    return o;
  }


  void CommandLine::add_parameter(const std::string& name,
                                  Option::argument_type arg,
                                  const std::string& description)
  {
    if (name.size()==1)
      add(name[0], "", arg, description);
    else
      add('\0', name, arg, description);
  }
  

  void CommandLine::add_parameter(char name,
                                  Option::argument_type arg,
                                  const std::string& description)
  {
    add(name, "", arg, description);
  }
  

  void CommandLine::parse(int argc,const char* argv[])
  {
    using namespace std;
    stringstream ss(argv[0]);
    // keeping string after last /
    while (getline(ss,app_name_,'/')) {}

    for (int k=1; k<argc; ++k) {
      string key(argv[k]);
      string value = string();
      // argument
      if (key.size()<2 || key[0]!='-'){
        arguments_.push_back(key);        
        continue;
      }
      // short name '-o'
      if (key[1]!='-'){
        if (k<argc-1)
          value = argv[k+1];
        for (size_t i = 1; i<key.size(); ++i)
          if (update(key.substr(i,1),value))//update used one argv as argument
            ++k; 
      }
      // long name '--option'
      else{
        key.erase(0,2);
        // find first '='
        size_t i = key.find('=');
        if (i!=std::string::npos){
          std::string q = key.substr(0,1);
          value = key.substr(i+1,key.size()-i+1); // everything after first '='
          key = key.substr(0,i); // everything before first '='
        }
        if (value.empty() && k<argc-1)
          value = argv[++k];
        update(key,value);
      }
    }
  }
  

  bool CommandLine::update(const std::string& key, 
                           const std::string& value)
  {
    key2option::iterator i = param_.find(key);
    // Can't find key
    if (i == param_.end()){
      std::cerr << app_name_ << ": invalid option -- " 
                << key << std::endl;
      print_try_help();
      exit(-1);
    }
    if (i->second==help_option_){
      usage();
      exit(0);
    }

    i->second->present()=true;

    if (i->second->arg_type()==Option::no_arg)
      return false;

    // value is required
    if (value.empty() || value[0]=='-'){
      std::cerr << app_name_ << ": option "; 
      if (i->first.size()>1)
        std::cerr << "`--" << i->first << "' "
                  << "requires an argument\n";
      else 
        std::cerr << "requires an argument -- " << i->first << "\n";
      print_try_help();
      exit(-1);
    }
    // wrong type of value
    if ( (i->second->arg_type()==Option::double_arg&&!is_double(value))||
         (i->second->arg_type()==Option::int_arg&&!is_int(value)) ){
      std::cerr << app_name_ << ": invalid value `" << value << "'" 
                << std::endl;
      exit(-1);
    }
    i->second->value()=value;
    return true;
  }


  void CommandLine::print_try_help(void) const
  {
    if (help_option_){
      std::cerr << "Type '" << app_name_ ;
      if (!help_option_->long_name().empty()) 
        std::cerr << " --" << help_option_->long_name(); 
      else
        std::cerr << " -" << help_option_->name(); 
      std::cerr << "' for more information.\n";
    }
  }


  void CommandLine::set_help(char shortname,
                             const std::string& longname,
                             const std::string& descr) 
  {
    help_option_ = add(shortname, longname, Option::no_arg, descr);
  }



  std::string CommandLine::split(std::string& str, char del) const
  {
    size_t i = str.find(del);
    if (i==std::string::npos)
      return std::string();
    std::string my_str(str);
    str = str.substr(0,i);
    return my_str.substr(i+1,str.size()-i-1);
  }


  void CommandLine::usage(void) const
  {
    using std::cerr;
    cerr << "Usage: " << app_name_; 
    if (!param_.empty()){
      //cerr << " [OPTION]...\n";
      cerr << "\n\n";
      cerr << "Mandatory arguments to long options are mandatory for " 
           << "short options too.\n";
      std::for_each(options_.begin(), options_.end(), 
                    std::mem_fun(&Option::print));

    }
    cerr << std::endl;

  }


  bool CommandLine::present(const std::string& key) const
  {
    key2option::const_iterator i = param_.find(key);
    if (i==param_.end())
      return false;
    return i->second->present();
      
  }


  std::string CommandLine::value(const std::string& key) const
  {
    key2option::const_iterator i = param_.find(key);
    if (i==param_.end()){
      std::cerr << "error: illegal key: value(\"" << key << "\"): \n";
      exit(-1);
    }
    
    return i->second->value();
  }


  double CommandLine::value_double(const std::string& key) const
  {
    key2option::const_iterator i = param_.find(key);
    if (i->second->arg_type()!=Option::double_arg)
      std::cerr << "error: option " << key << " does not take double argument"
                << std::endl;
    std::string str = value(key);
    double value;
    std::stringstream ss(str);
    ss>>value;
    return value;
  }


  int CommandLine::value_int(const std::string& key) const
  {
    std::string str = value(key);
    key2option::const_iterator i = param_.find(key);
    if (i->second->arg_type()!=Option::int_arg)
      std::cerr << "error: option " << key << " does not take int argument"
                << std::endl;
    int value;
    std::stringstream ss(str);
    ss>>value;
    return value;
  }

}}} // of namespace utility, yat, and theplu