arglib.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2012 by Edson Borin                                     *
 *   edson@ic.unicamp.br                                                   *
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 *   This program 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.             *
 ***************************************************************************/

#ifndef ARGLIB_H
#define ARGLIB_H

#include <string>
#include <sstream>
#include <iostream>
#include <vector>

#include "pzreal.h" // PRETTY_FUNCTION for WIN32 Macro definition

using namespace std;

namespace clarg 
{

  int parse_arguments(int argc, char *argv[]);

  int dump_arguments_to_file(ostream& os);

  int parse_arguments_from_file(istream& is);

  void arguments_descriptions(ostream& os, string prefix, string suffix);

  void values(ostream& os, bool defined_only=true);

  class args_container;

  class arg_base
  {
  public:

    arg_base(const char* name, const char* desc);

    const string& get_name() const { return arg_name; }

    const string& get_desc() const { return arg_desc; }

    /* Return true if the argument was set, false otherwise. */
    bool was_set() const { return arg_set; }

    void mark_set(bool m) { arg_set = m; }

  protected:

    virtual int parse_parameters (int argc, char* argv []) = 0;

    virtual void write_parameters (ostream& os, bool def=false) const = 0;

    bool   arg_set;
    string arg_name;
    string arg_desc;

    friend class args_container;
  };

  template<class T>
    class argT : public arg_base
  {
  public:

  argT(const char* arg, const char* desc) :
    arg_base (arg, desc) {}

    /* Returns the argument value. */ 
    const T& get_value() const { return value; }

    /* Sets the argument value. */ 
    void set_value(const T& v) const { value = v; }

  protected:

    /* Argument value */
    T value;
    /* Default argument value */
    T def_value;
  };

  class argString : public argT<string>
  {
  public:
  argString(const char* arg, const char* desc, string v) :
    argT<string>(arg,desc)
  {
    def_value = v;
    value = def_value;
  }
  protected:
    int parse_parameters (int argc, char* argv [])
    {
      if (argc <= 0) return -1;
      value = string(argv[0]);
      return 1;
    }
    void write_parameters (ostream& os, bool def) const
    {
      if (def)
                os << def_value;
      else
                os << value;
    }

  };

  class argInt : public argT<int>
  {
  public:
  argInt(const char* arg, const char* desc, int v = 0) :
      argT<int>(arg,desc)
    {
      def_value = v;
      value = def_value;
    }
  protected:
    int parse_parameters (int argc, char* argv [])
    {
      if (argc <= 0) return -1;
      try {
                std::stringstream(argv[0]) >> value;
      }
      catch (const exception& ) {return -1;}
      return 1;
    }
    void write_parameters (ostream& os, bool def) const
    {
      if (def)
                os << def_value;
      else
                os << value;
    }
  };

  class argDouble : public argT<double>
  {
  public:
  argDouble(const char* arg, const char* desc, double v = 0.0) :
      argT<double>(arg,desc)
    {
      def_value = v;
      value = def_value;
    }
  protected:
    int parse_parameters (int argc, char* argv [])
    {
      if (argc <= 0) return -1;
      try {
                std::stringstream(argv[0]) >> value;
      }
      catch (const exception& ) {return -1;}
      return 1;
    }
    void write_parameters (ostream& os, bool def) const
    {
      if (def)
                os << def_value;
      else
                os << value;
    }
  };

  class argBool : public argT<bool>
  {
  public:
    argBool(const char* arg, const char* desc, bool v = false) :
      argT<bool>(arg,desc)
    {
      def_value = v;
      value = def_value;
    }
  protected:
    int parse_parameters (int argc, char* argv [])
    { value = true; return 0; }
    void write_parameters (ostream& os, bool def) const
    {}
  };

}

#endif