options.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_UTILITIES_OPTIONS_H
#define ARCHON_UTILITIES_OPTIONS_H

#include <string>
#include <vector>

#include <archon/util/exception.H>
#include <archon/util/term.H>
#include <archon/util/logger.H>

namespace Archon
{
  namespace Utilities
  {
    using namespace std;

    struct Options
    {
      struct DefinitionException: virtual Exception
      {
        DefinitionException(string l, string m): Exception(l, m) {}
      };

      struct FileAccessException: virtual Exception
      {
        FileAccessException(string l, string m): Exception(l, m) {}
      };

      Options(bool treatNegativeNumbersAsOptions = false,
              Logger *logger = Logger::get());
      ~Options();

      enum WantArg
      {
        wantArg_never,    // Do not accept an option-argument.
        wantArg_optional, // Use option-argument if present.
        wantArg_always    // Require option-argument.
      };

      template<typename T> struct Parser
      {
        static T parse(const char *) throw(ParseException);
        static string format(T);
      };

      template<typename T> struct Unrestricted
      {
        void check(const T &) const throw(ParseException) {}
      };

      template<typename T> struct Range
      {
        T from, to;
        Range(T from, T to): from(from), to(to) {}
        void check(const T &v) const throw(ParseException)
        {
          if(v < from || v >= to)
            ARCHON_THROW1(ParseException, "Out of range");
        }
      };

      template<typename T> static Range<T> range(T from, T to)
      {
        return Range<T>(from, to);
      }

      template<typename T, typename D>
      void addConfig(string shortName, string longName,
                     T &var, T val, string description,
                     WantArg wantArg, D domainChecker)
        throw(DefinitionException)
      {
        verify(shortName, longName);
        defs.push_back(new DefVar<T, D>(false, shortName, longName, var, val,
                                        wantArg, domainChecker, description));
      }

      template<typename T>
      void addConfig(string shortName, string longName,
                     T &var, T val, string description,
                     WantArg wantArg = wantArg_never)
        throw(DefinitionException)
      {
        verify(shortName, longName);
        defs.push_back(new DefVar<T, Unrestricted<T> >
                       (false, shortName, longName, var, val,
                        wantArg, Unrestricted<T>(), description));
      }

      template<typename T, typename D>
      void addSwitch(string shortName, string longName,
                     T &var, T val, string description,
                     WantArg wantArg, D domainChecker)
        throw(DefinitionException)
      {
        verify(shortName, longName);
        defs.push_back(new DefVar<T, D>(true, shortName, longName, var, val,
                                        wantArg, domainChecker, description));
      }

      template<typename T>
      void addSwitch(string shortName, string longName,
                     T &var, T val, string description,
                     WantArg wantArg = wantArg_never)
        throw(DefinitionException)
      {
        verify(shortName, longName);
        defs.push_back(new DefVar<T, Unrestricted<T> >
                       (true, shortName, longName, var, val,
                        wantArg, Unrestricted<T>(), description));
      }

      struct IntByInt
      {
        int x, y;

        bool operator==(const IntByInt &o) const { return x == o.x && y == o.y; }
      };

      bool processCommandLine(int &argc, const char *argv[],
                              bool switchesOnly = false);

      bool processConfigFile(string path)
        throw(FileAccessException);

      void saveConfigFile(string path)
        throw(FileAccessException);

      string list(unsigned width = Term::getWidth());

    private:
      struct Def
      {
        bool switchOnly;
        string shortName;  // eg. --version
        string longName;   // eg. -v
        string description;
        WantArg wantArg;

        Def(bool switchOnly, string shortName, string longName,
            string description, WantArg wantArg):
          switchOnly(switchOnly), shortName(shortName), longName(longName),
          description(description), wantArg(wantArg) {}

        virtual ~Def() {}

        virtual void execute(Options *o, const char *arg) const
          throw(ParseException) = 0;
      };

      struct DefVarBase: public Def
      {
        DefVarBase(bool switchOnly, string shortName, string longName,
                   string description, WantArg wantArg):
          Def(switchOnly, shortName, longName, description, wantArg) {}
        virtual ~DefVarBase() {}
        virtual string getValue() const = 0;
        virtual bool isDefaultSet() const = 0;
      };

      template<typename T, typename D>
      struct DefVar: public DefVarBase
      {
        T &var;
        T val;
        D domainChecker;

        DefVar(bool switchOnly, string shortName, string longName,
               T &var, T val, WantArg wantArg, D d, string description):
          DefVarBase(switchOnly, shortName, longName, description, wantArg),
          var(var), val(val), domainChecker(d) {}

        virtual ~DefVar() {}

        void execute(Options *o, const char *arg) const throw(ParseException)
        {
          if(!arg)
          {
            var = val;
            return;
          }

          T v = Parser<T>::parse(arg);
          domainChecker.check(v);
          var = v;
        }

        virtual string getValue() const
        {
          return Parser<T>::format(var);
        }

        virtual bool isDefaultSet() const
        {
          return var == val;
        }
      };

      enum ArgType
      {
        argType_normal,
        argType_shortOption,
        argType_longOption
      };

      ArgType examineArg(string);

    private:
      bool treatNegativeNumbersAsOptions;
      Logger *logger;
      vector<const Def *> defs;

      void verify(string shortName, string longName)
        throw(DefinitionException);
    };
  }
}

#endif // ARCHON_UTILITIES_OPTIONS_H

---