option.hpp

Go to the documentation of this file.

/* Option++ -- read command-line program options
 * Copyright (C) 2017-2020 Greg Kikola.
 *
 * This file is part of Option++.
 *
 * Option++ is free software: you can redistribute it and/or modify
 * it under the terms of the Boost Software License version 1.0.
 *
 * Option++ is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * Boost Software License for more details.
 *
 * You should have received a copy of the Boost Software License
 * along with Option++.  If not, see
 * <https://www.boost.org/LICENSE_1_0.txt>.
 */
/* Written by Greg Kikola <[email protected]>. */
 
#ifndef OPTIONPP_OPTION_HPP
#define OPTIONPP_OPTION_HPP
 
#include <string>
 
namespace optionpp {
 
  class option {
  public:
 
    enum arg_type { string_arg, //< Indicates a string argument.
                    int_arg, //< Indicates an integer argument.
                    uint_arg, //< Indicates an unsigned int argument.
                    double_arg //< Indicates a floating-point argument.
    };
 
    option() noexcept {}
    option(char short_name) : m_short_name{short_name} {}
    option(const std::string& long_name,
           char short_name = '\0',
           const std::string& description = "",
           const std::string& arg_name = "",
           bool arg_required = false);
 
    option& name(const std::string& long_name, char short_name = '\0') {
      m_long_name = long_name;
      m_short_name = short_name;
      return *this;
    }
 
    std::string name() const noexcept {
      if (!m_long_name.empty())
        return m_long_name;
      else if (m_short_name != '\0')
        return std::string{m_short_name};
      else
        return "";
    }
 
    option& long_name(const std::string& name) {
      m_long_name = name;
      return *this;
    }
    const std::string& long_name() const noexcept { return m_long_name; }
 
    option& short_name(char name) noexcept {
      m_short_name = name;
      return *this;
    }
    char short_name() const noexcept { return m_short_name; }
 
    option& argument(const std::string& name,
                     bool required = true);
    const std::string& argument_name() const noexcept { return m_arg_name; }
    bool is_argument_required() const noexcept { return m_arg_required; }
    arg_type argument_type() const noexcept { return m_arg_type; }
 
    option& bind_bool(bool* var) noexcept;
    option& bind_string(std::string* var) noexcept;
    option& bind_int(int* var) noexcept;
    option& bind_uint(unsigned int* var) noexcept;
    option& bind_double(double* var) noexcept;
    bool has_bound_argument_variable() const noexcept { return m_bound_variable; }
    void write_bool(bool value) const noexcept;
    void write_string(const std::string& value) const;
    void write_int(int value) const;
    void write_uint(unsigned int value) const;
    void write_double(double value) const;
 
    option& description(const std::string& desc) {
      m_desc = desc;
      return *this;
    }
    const std::string& description() const noexcept { return m_desc; }
 
  private:
    std::string m_long_name; //< The long name.
    char m_short_name{'\0'}; //< The short name.
    std::string m_desc; //< Description of option (for help text).
 
    std::string m_arg_name; //< The name of the argument (for help text).
    bool m_arg_required{false}; //< True if argument is mandatory, false if optional.
    arg_type m_arg_type{string_arg}; //< Type of argument that is expected.
    bool* m_is_option_set = nullptr; //< Pointer to value to hold whether the option was set.
    void* m_bound_variable = nullptr; //< Pointer to hold argument value.
  };
 
} // End namespace
 
#endif