#ifndef GETOPT_H

#define GETOPT_H

#include <ctype.h>

#include <stdio.h>

#include <string>

namespace Util {

    extern int optind ;

    extern int opterr ;

    extern int optopt ;

    extern int optpos ;

    extern const char* optarg;

    int getopt(int argc, char * const argv[], const char *optstring);

    // *********************************************************************

    // class definitions

    /*!

      @brief Parse the command line options of a program.

      A wrapper around the POSIX %getopt(3) function.  Parses the command line

      options and passes each option to virtual option().  A derived class

      implements this method to handle options as needed.  Similarly,

      remaining non-option parameters are passed to the virtual nonoption()

      method.

     */

    class Getopt {

    public:

        //! Default constructor.

        Getopt();

        //! Destructor.

        virtual ~Getopt();

        /*!

          @brief Parse command line arguments.

          Parses the command line arguments. Calls option() with the

          character value of the option and its argument (if any) for each

          recognized option and with ':' or '?' for unrecognized options.

          See the manual pages for %getopt(3) for details.  In addition,

          nonoption() is invoked for each remaining non-option parameter on

          the command line.

          @param argc Argument count as passed to main() on  program invocation.

          @param argv Argument array as passed to main() on  program invocation.

          @param optstring String containing the legitimate option characters.

          @return Number of errors (the sum of the return values from option()

                  and nonoption()).

         */

        int getopt(int argc, char* const argv[], const std::string& optstring);

        /*!

          @brief Callback used by getopt() to pass on each option and its

                 argument (if any).

          Implement this method in a derived class to handle the options as

          needed. See the manual pages for %getopt(3) for further details, in

          particular, the semantics of optarg and optopt.

          @param opt Value of the option character as returned by %getopt(3).

          @param optarg The corresponding option argument.

          @param optopt The actual option character in case of an unrecognized

                 option or a missing option argument (opt is '?' or ':').

          @return 0 if successful, 1 in case of an error.

         */

        virtual int option(int opt, const std::string& optarg, int optopt) = 0;

        /*!

          @brief Callback used by getopt() to pass on each non-option parameter

                 found on the command line.

          Implement this method in a derived class to handle the non-option

          parameters as needed. The default implementation ignores all non-option

          parameters.

          @param argv The non-option parameter from the command line.

          @return 0 if successful, 1 in case of an error.

         */

        virtual int nonoption(const std::string& argv);

        //! Program name (argv[0])

        const std::string& progname() const { return progname_; }

        //! Total number of errors returned by calls to option()

        int errcnt() const { return errcnt_; }

    private:

        std::string progname_;

        int errcnt_;

    };

}; // namespace Util

#endif