source: trunk/yat/OptionArg.h @ 1336

#ifndef _theplu_yat_utility_option_arg_
#define _theplu_yat_utility_option_arg_

// $Id: OptionArg.h 2384 2010-12-22 14:03:36Z peter $

/*
  Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009, 2010 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/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 3 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "Option.h"
#include "CommandLine.h"
#include "Exception.h"
#include "utility.h"

#include <stdexcept>
#include <string>
#include <sstream>

namespace theplu {
namespace yat {
namespace utility {

  class CommandLine;
  /**
     \brief Option with argument

     If the option is present, argument is set during
     parsing. Supported formats are both gnu-style
     "--support-gnu=value", POSIX-like "--support-posix value", as
     well as shorter "-s value". The argument of an parameter is
     retrived by the value() function. The type \c T should be either
     a string or a type supported by function convert().
   */
  template<typename T>
  class OptionArg : public Option
  {
  public:
    /**
       \brief Constructor 
       
       \param cmd Commandline Option is associated with 
       \param name string such as "help" for --help, "h" for -h or
       "h,help" for having both short and long option name
       \param desc string used in help display
       \param required If true option must be found in commandline or
       exception is thrown in validation
    */
    OptionArg(CommandLine& cmd, std::string name, std::string desc,
              bool required=false)
      : Option(cmd, name, desc), required_(required) {}

    /**
       \param arg string to be used in help output such as `=TARGET'
       in `--target=TARGET'. See print3().

       \since New in yat 0.5.
     */
    void print_arg(std::string arg) { print_arg_ = arg; }

    /**
       \return value
    */
    T value(void) const 
    { 
      if (!cmd().parsed()) {
        std::string s("OptionArg::value called before Commandline was parsed");
        throw std::logic_error(s);
      }
      return value_; 
    }

    /**
       \brief set value

       \since new in yat 0.5
    */
    void value(T v) { value_ = v; }

  protected:
    /**
       \return true if Option is required, i.e., if Option is not
       found during parsing an exception will be thrown.
     */
    inline bool required(void) const { return required_; }

  private:
    std::string print_arg_;
    bool required_;
    T value_;

    void do_parse(std::vector<std::string>::iterator& first, 
                  const std::vector<std::string>::iterator& last) 
    {
      if ( first->size()>2 && (*first)[0]=='-' && (*first)[1]!='-'){
        std::stringstream ss;
        ss << "option requires an argument -- " << short_name() << "\n"
           << cmd().try_help();
        throw cmd_error(ss.str());
      }
      if (first+1==last ) {
        if (first->size()>2){
          std::stringstream ss;
          ss << "option `--" << long_name() << "' requires an argument\n"
             << cmd().try_help();
          throw cmd_error(ss.str());
        }
        else {
          std::stringstream ss;
          ss << "option requires an argument -- " << short_name() << "\n"
             << cmd().try_help();
          throw cmd_error(ss.str());
        }
      }       
        
      if ( *(first+1)->begin() == '"' && *((first+1)->end()-1) == '"')
        *(first+1) = (first+1)->substr(1, (first+1)->size()-2); 
      assign(value_, *(++first));
    }

    void assign(std::string& lhs, const std::string& rhs )
    { 
      lhs = rhs;
    }
    
    template<class T1>
    void assign(T1& lhs, const std::string& rhs )
    { 
      try {
        lhs = convert<T1>(rhs);
      }
      catch (runtime_error& e) {
        std::stringstream sstr(rhs);
        sstr << "invalid argument";
        sstr << "`" << rhs << "' for `";
        if (!long_name().empty())
          sstr << "--" << long_name();
        else
          sstr << "-" << short_name();
        sstr << "'";
        throw cmd_error(sstr.str());
      }
    }

    /**
     */
    void do_validate(void) const 
    {
      if (required_ && !present()) {
        std::stringstream ss;
        ss << "mandatory option `";
        if (long_name().size())
          ss << long_name();
        else
          ss << short_name();
        ss << "' not given\n";
        ss << cmd().try_help();
        throw cmd_error(ss.str());
      }
      do_validate2();
    }


    virtual void do_validate2(void) const {}

    virtual std::string print3(void) const 
    { 
      return print_arg_; 
    }

  };

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

#endif