cmnCommandLineOptions.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */
 
/*
  Author(s):  Anton Deguet
  Created on: 2012-08-27
 
  (C) Copyright 2012-2023 Johns Hopkins University (JHU), All Rights Reserved.
 
--- begin cisst license - do not edit ---
 
This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.
 
--- end cisst license ---
*/
 
#pragma once
 
#ifndef _cmnCommandLineOptions_h
#define _cmnCommandLineOptions_h
 
#include <cisstCommon/cmnPortability.h>
#include <cisstCommon/cmnGenericObject.h>
#include <cisstCommon/cmnTokenizer.h>
 
#include <string>
#include <list>
#include <sstream>
#include <iostream>
 
// Always the last cisst include
#include <cisstCommon/cmnExport.h>
 
 
 
// utility to convert const char * to a C type
template <typename _elementType>
bool cmnCommandLineOptionsConvert(const char * value, _elementType & element) {
    std::stringstream localStream;
    localStream << value;
    bool error = false;
    try {
        localStream >> element;
    } catch (...) {
        error = true;
    }
    if (!error) {
        return true;
    }
    return false;
}
 
 
// template specialization to make sure spaces in strings (\ ) don't
// act as separators using >>
template <>
inline bool cmnCommandLineOptionsConvert<std::string>(const char * value, std::string & element) {
    element = value;
    return true;
}
 

 
#undef OPTIONAL   // work-around for Windows
 
class CISST_EXPORT cmnCommandLineOptions: public cmnGenericObject
{
    CMN_DECLARE_SERVICES(CMN_NO_DYNAMIC_CREATION, CMN_LOG_ALLOW_DEFAULT);
 
 public:
    typedef enum {REQUIRED_OPTION, OPTIONAL_OPTION, SQUASH_REQUIRED_OPTION} RequiredType;
 
 protected:
    class OptionBase {
        friend class cmnCommandLineOptions;
    protected:
#if (CISST_COMPILER == CISST_DOTNET2003)
        // Workaround for Visual Studio.NET 2003
    public:
#endif
        OptionBase(const std::string & shortOption, const std::string & longOption,
                   const std::string & description, RequiredType required);
        virtual ~OptionBase() {};
        virtual bool SetValue(const char * value) = 0;
        virtual std::string PrintValues(void) const = 0;
        std::string Short;
        std::string Long;
        std::string Description;
        RequiredType Required;
        bool Set;
    };
 
    class CISST_EXPORT OptionNoValue: public OptionBase {
        friend class cmnCommandLineOptions;
    protected:
        OptionNoValue(const std::string & shortOption, const std::string & longOption,
                      const std::string & description, RequiredType required = OPTIONAL_OPTION);
        virtual ~OptionNoValue() {};
        bool SetValue(const char * value);
        std::string PrintValues(void) const {
            return std::string();
        }
    };
 
    class CISST_EXPORT OptionOneValueBase: public OptionBase {
        friend class cmnCommandLineOptions;
    protected:
#if (CISST_COMPILER == CISST_DOTNET2003)
        // Workaround for Visual Studio.NET 2003
    public:
#endif
        OptionOneValueBase(const std::string & shortOption, const std::string & longOption,
                           const std::string & description, RequiredType required);
        virtual ~OptionOneValueBase() {};
    };
    template <typename _elementType>
    class OptionOneValue: public OptionOneValueBase {
        friend class cmnCommandLineOptions;
    protected:
        OptionOneValue(const std::string & shortOption, const std::string & longOption,
                       const std::string & description, RequiredType required,
                       _elementType * value):
            OptionOneValueBase(shortOption, longOption, description, required),
            Value(value)
        {
        }
        bool SetValue(const char * value) {
            bool result = cmnCommandLineOptionsConvert(value, *(this->Value));
            if (result) {
                this->Set = true;
            }
            return result;
        }
        std::string PrintValues(void) const {
            std::stringstream stream;
            stream << *Value;
            return stream.str();
        }
        _elementType * Value;
    };
 
    class CISST_EXPORT OptionMultipleValuesBase: public OptionBase {
        friend class cmnCommandLineOptions;
    protected:
#if (CISST_COMPILER == CISST_DOTNET2003)
        // Workaround for Visual Studio.NET 2003
    public:
#endif
        OptionMultipleValuesBase(const std::string & shortOption, const std::string & longOption,
                                 const std::string & description, RequiredType required);
        virtual ~OptionMultipleValuesBase() {};
    };
    template <typename _elementType>
    class OptionMultipleValues: public OptionMultipleValuesBase {
        friend class cmnCommandLineOptions;
    protected:
        OptionMultipleValues(const std::string & shortOption, const std::string & longOption,
                       const std::string & description, RequiredType required,
                       std::list<_elementType> * value):
            OptionMultipleValuesBase(shortOption, longOption, description, required),
            Value(value)
        {
        }
        bool SetValue(const char * value) {
            _elementType temp;
            bool result = cmnCommandLineOptionsConvert(value, temp);
            if (result) {
                Value->push_back(temp);
                this->Set = true;
            }
            return result;
        }
        std::string PrintValues(void) const {
            typedef typename std::list<_elementType> ListType;
            typedef typename ListType::const_iterator const_iterator;
            const const_iterator end = Value->end();
            const_iterator iter;
            std::stringstream stream;
            for (iter = Value->begin(); iter != end; ++iter) {
                if (iter != Value->begin()) {
                    stream << ", ";
                }
                stream << *iter;
            }
            return stream.str();
        }
        std::list<_elementType> * Value;
    };
 
 public:
    cmnCommandLineOptions(void);
 
    ~cmnCommandLineOptions();
 
    bool AddOptionNoValue(const std::string & shortOption, const std::string & longOption,
                          const std::string & description, RequiredType required = OPTIONAL_OPTION);
 
    template <typename _elementType>
    bool AddOptionOneValue(const std::string & shortOption, const std::string & longOption,
                           const std::string & description, RequiredType required, _elementType * value) {
        std::string cleanedShort, cleanedLong;
        if (!this->ValidOptions(shortOption, longOption, cleanedShort, cleanedLong)) {
            return false;
        }
        typedef OptionOneValue<_elementType> OptionType;
        OptionType * option = new OptionOneValue<_elementType>(cleanedShort, cleanedLong, description,
                                                               required, value);
        this->Options.push_back(option);
        return true;
    }
 
    template <typename _elementType>
    bool AddOptionMultipleValues(const std::string & shortOption, const std::string & longOption,
                                 const std::string & description, RequiredType required, std::list<_elementType> * value) {
        std::string cleanedShort, cleanedLong;
        if (!this->ValidOptions(shortOption, longOption, cleanedShort, cleanedLong)) {
            return false;
        }
        typedef OptionMultipleValues<_elementType> OptionType;
        OptionType * option = new OptionMultipleValues<_elementType>(cleanedShort, cleanedLong, description,
                                                                     required, value);
        this->Options.push_back(option);
        return true;
    }

    bool Parse(int argc, const char * argv[], std::string & errorMessage);

    bool Parse(int argc, char * argv[], std::string & errorMessage);
    bool Parse(const std::vector<std::string> & arguments, std::string & errorMessage);

    bool Parse(int argc, char * argv[], std::ostream & outputStream);
    bool Parse(const std::vector<std::string> & arguments, std::ostream & outputStream);

    void PrintUsage(std::ostream & outputStream);

    bool IsSet(const std::string & option);
 
 
    /* Print out the list of options parsed successfully. This can be
      used after Parse. */
    void PrintParsedArguments(std::string & parsedArguments) const;
 
 protected:
    std::string ProgramName;
    typedef std::list<OptionBase *> OptionsType;
    OptionsType Options;
    OptionBase * GetShortNoDash(const std::string & shortOption);
    OptionBase * GetLongNoDashDash(const std::string & longOption);
    bool ValidOptions(const std::string & shortOption, const std::string & longOption,
                      std::string & cleanedShort, std::string & cleanedLong);
    OptionBase * Get(const std::string & option);
};
 
 
// Add services instantiation
CMN_DECLARE_SERVICES_INSTANTIATION(cmnCommandLineOptions)
 
 
#endif // _cmnCommandLineOptions_h