optionParser.h

Go to the documentation of this file.

#ifndef _DLRUTILITIES_OPTIONPARSER_H_
#define _DLRUTILITIES_OPTIONPARSER_H_

#include <map>
#include <string>
#include <vector>
#include <dlrUtilities/optionDescription.h>
#include <dlrUtilities/stringManipulation.h>

namespace dlr {

  namespace utilities {

    
    class OptionParser {
    public:

      OptionParser(bool allowExtraArguments = true,
                   bool allowStackedShortOptions = true,
                   bool allowOptionishArguments = false);


      explicit
      OptionParser(int exitCode,
                   bool handleMinusMinusHelp = true,
                   bool printUsage = true,
                   bool allowExtraArguments = true,
                   bool allowStackedShortOptions = true,
                   bool allowOptionishArguments = false);


      ~OptionParser();


      void
      addOption(const std::string& name,
                const std::string& shortVersion,
                const std::string& longVersion,
                const std::string& docString,
                bool allowPartialMatch = true);

      
      void
      addOptionWithValue(const std::string& name,
                         const std::string& shortVersion,
                         const std::string& longVersion,
                         const std::string& defaultValue,
                         const std::string& docString,
                         bool requireArgument = true,
                         bool allowPartialMatch = true,
                         bool allowOptionishValue = false);
      

      void
      addPositionalArgument(const std::string& name,
                            const std::string& docString,
                            bool isRequired = false,
                            const std::string& defaultValue = "");


      template<class Type>
      Type
      convertValue(const std::string& name);


      template<class Type>
      Type
      convertValue(const std::string& name, int valueIndex);


      size_t
      getCount(const std::string& name) const;


      std::vector<std::string>
      getExtraPositionalArguments();


      std::string
      getOptionsDescription();


      std::string
      getUsage();


      std::string
      getValue(const std::string& name);


      std::string
      getValue(const std::string& name, int valueIndex);


      template<class Type>
      Type
      getValue(const std::string& name, type_tag<Type>);

    
      template<class Type>
      Type
      getValue(const std::string& name, int valueIndex, type_tag<Type>);


      void
      parseCommandLine(int argc, const char* argv[]);
    

      void
      parseCommandLine(int argc, char* argv[]);
    

    private:

      // Private enum for specifying how to handle illegal commandlines.
      enum ErrorBehavior {ExitOnError, ThrowOnError, UsageAndExitOnError};


      // Private member functions
      bool
      findOptionDescription(const std::string& argument,
                            OptionDescription& optionDescription,
                            size_t& typedLength,
                            bool& isShortMatch);

      
      void
      recordPositionalArgument(const std::string& argument);
      

      // Private data members.
      bool m_allowExtraArguments;
      bool m_allowOptionishArguments;
      bool m_allowStackedShortOptions;
      ErrorBehavior m_errorBehavior;
      int m_exitCode;
      std::vector<std::string> m_extraArgumentValues;
      bool m_handleHelp;
      size_t m_numberOfPosArgRequired;
      size_t m_numberOfPosArgParsed;
      std::map<std::string, size_t> m_optionCounts;
      std::map<std::string, OptionDescription> m_optionDescriptions;
      std::map< std::string, std::vector<std::string> > m_optionValues;
      std::vector<std::string> m_positionalArgumentNames;
      std::vector<std::string> m_positionalArgumentDefaultValues;
      std::vector<std::string> m_positionalArgumentDocs;
      std::string m_programName;

    }; // class OptionParser

  } // namespace utilities

} // namespace dlr

/* ========= Definitions of inline and template functions below. ========== */

namespace dlr {

  namespace utilities {

    
    template<class Type>
    Type
    OptionParser::
    convertValue(const std::string& name)
    {
      try {
        return convertString<Type>(this->getValue(name));
      } catch(ConversionException&) {
        std::ostringstream message;
        message << "Error when parsing option " << name << ": "
                << "can't convert \"" << this->getValue(name)
                << "\" to appropriate type.";
        DLR_THROW(ConversionException, "OptionParser::convertValue()",
                  message.str().c_str());
      }
    }
    
    
    template<class Type>
    Type
    OptionParser::
    convertValue(const std::string& name, int valueIndex)
    {
      try {
        return convertString<Type>(this->getValue(name, valueIndex));
      } catch(ConversionException&) {
        std::ostringstream message;
        message << "Error when parsing option " << name << ": "
                << "can't convert \"" << this->getValue(name, valueIndex)
                << "\" to appropriate type.";
        DLR_THROW(ConversionException, "OptionParser::convertValue()",
                  message.str().c_str());
      }
    }
    
    
    template<class Type>
    Type
    OptionParser::
    getValue(const std::string& name, type_tag<Type>)
    {
      return this->convertValue<Type>(name);
    }
    
    
    template<class Type>
    Type
    OptionParser::
    getValue(const std::string& name, int valueIndex, type_tag<Type>)
    {
      return this->convertValue<Type>(name, valueIndex);
    }
    
    
  } // namespace utilities

} // namespace dlr

#endif // #ifndef _DLRUTILITES_OPTIONPARSER_H_