OptionArg.h

#ifndef _theplu_yat_utility_option_arg_
#define _theplu_yat_utility_option_arg_

// $Id: OptionArg.h 3114 2013-11-10 23:51:47Z peter $

/*
  Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009, 2010, 2013 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;
  template<typename T>
  class OptionArg : public Option
  {
  public:
    OptionArg(CommandLine& cmd, std::string name, std::string desc,
              bool required=false)
      : Option(cmd, name, desc), required_(required) {}

    void print_arg(std::string arg) { print_arg_ = arg; }

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

    void value(T v) { value_ = v; }

  protected:
    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