CommandLineOptions.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/Enum.hxx"
#include "Arp/System/Commons/Exceptions/Exceptions.h"
#include "boost/program_options.hpp"
#include <iostream>
 
namespace Arp { namespace System { namespace Commons { namespace Configuration
{
 
using namespace boost::program_options;
 
class CommandLineOptions
{
public: // typedefs
 
public: // construction/destruction
    CommandLineOptions(void);
    CommandLineOptions(const CommandLineOptions& arg) = delete;
    CommandLineOptions& operator=(const CommandLineOptions& arg) = delete;
    ~CommandLineOptions(void) = default;
 
public: // operators
 
public: // static operations
 
public: // setter/getter operations
 
public: // operations
    void    AddOption(const String& name, const String& help);
    template<class T>
    void    AddOption(const String& name, const String& help);
    template<class T>
    void    AddOption(const String& name, const T& defaultValue, const String& help);
    template<class T>
    void    AddOptionEnum(const String& name, const String& help);
    template<class T>
    void    AddOptionEnum(const String& name, const Enum<T>& defaultValue, const String& help);
    void    ParseArgs(int argc, const char* const argv[]);
    void    PrintDescription(std::ostream& os = std::cout);
    bool    ExistsOption(const String& optionName) const;
 
    template<class T>
    T       GetOptionValue(const String& optionName) const;
    template<class T>
    bool    TryGetOptionValue(const String& optionName, T& result) const;
    template<class T>
    Enum<T> GetOptionValueEnum(const char* optionName);
    template<class T>
    bool TryGetOptionValueEnum(const char* optionName, Enum<T>& value);
 
protected: // operations
 
private: // static methods
 
private: // methods
 
private: // fields
    options_description desc;
    variables_map       optionMap;
 
public: // static fields
    static const String helpOptionName;
 
private: // static fields
    static const String helpOptionDescription;
};
 
// inline methods of class CommandLineOptions
inline CommandLineOptions::CommandLineOptions()
    : desc("Allowed options")
{
    desc.add_options()
    (helpOptionName, helpOptionDescription);
}
 
inline void CommandLineOptions::AddOption(const String& name, const String& help)
{
    desc.add_options()
    (name, help);
}
 
template<class T>
inline void CommandLineOptions::AddOption(const String& name, const String& help)
{
    desc.add_options()
    (name, value<T>(), help);
}
 
template<class T>
inline void CommandLineOptions::AddOption(const String& name, const T& defaultValue, const String& help)
{
    desc.add_options()
    (name, value<T>()->default_value(defaultValue), help);
}
 
template<class T>
inline void CommandLineOptions::AddOptionEnum(const String& name, const String& help)
{
    desc.add_options()
    (name, value<String>(), help);
}
 
template<class T>
inline void CommandLineOptions::AddOptionEnum(const String& name, const Enum<T>& defaultValue, const String& help)
{
    desc.add_options()
    (name, value<String>()->default_value(defaultValue.ToString()), help);
}
 
inline void CommandLineOptions::ParseArgs(int argc, const char* const argv[])
{
    store(parse_command_line(argc, argv, this->desc), optionMap);
    notify(optionMap);
}
 
inline void CommandLineOptions::PrintDescription(std::ostream& os)
{
    os << desc << std::endl;
}
 
inline bool CommandLineOptions::ExistsOption(const String& optionName) const
{
    bool found = false;
    if (optionMap.count(optionName))
    {
        found = true;
    }
    return found;
}
 
template<class T>
inline T CommandLineOptions::GetOptionValue(const String& optionName) const
{
    T result;
    if(!this->TryGetOptionValue(optionName, result))
    {
        throw KeyNotFoundException::Create(optionName);
    }
    return result;
}
 
template<class T>
inline bool CommandLineOptions::TryGetOptionValue(const String& optionName, T& result) const
{
    bool found = false;
    if(optionMap.count(optionName) > 0)
    {
        result = optionMap[optionName].as<T>();
        found = true;
    }
    return found;
}
 
template<class T>
Enum<T> CommandLineOptions::GetOptionValueEnum(const char* optionName)
{
    Enum<T> returnValue;
 
    if (TryGetOptionValueEnum(optionName, returnValue))
    {
        return returnValue;
    }
    else
    {
        throw Exception("GetOptionValueEnum failed for mandatory option: {0}", optionName);
    }
 
}
 
template<class T>
bool CommandLineOptions::TryGetOptionValueEnum(const char* optionName, Enum<T>& value)
{
    String returnValue;
    if (!this->TryGetOptionValue<String>(optionName, returnValue))
    {
        return false;
    }
    // else
    value = Enum<T>::Parse(returnValue);
    return true;
}
 
}}}} // end of namespace Arp::System::Commons