source: trunk/yat/utility/OptionArg.h @ 1487

#ifndef _theplu_yat_utility_option_arg_
#define _theplu_yat_utility_option_arg_

// $Id: OptionArg.h 1487 2008-09-10 08:41:36Z jari $

/*
  Copyright (C) 2007 Jari Häkkinen, Peter Johansson
  Copyright (C) 2008 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 <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
   */
  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) {}

    /**
       \return value
    */
    T value(void) const { return value_; }

  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:
    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, std::string rhs )
    { 
      lhs = rhs;
    }
    
    template<class T1>
    void assign(T1& lhs, std::string rhs )
    { 
      std::stringstream ss(rhs);
      ss >> lhs;
      bool fail = ss.fail();
      std::string str;
      ss >> str;
      if (fail || str.size()) {
        std::stringstream sstr(rhs);
        sstr << ": invalid argument";
        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 {}
  };

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

#endif