parser_result.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_PARSER_RESULT_HPP
#define OPTIONPP_PARSER_RESULT_HPP
 
#include <cstddef>
#include <initializer_list>
#include <iterator>
#include <string>
#include <utility>
#include <vector>
#include <optionpp/error.hpp>
#include <optionpp/option.hpp>
 
namespace optionpp {
 
  struct parsed_entry {
    parsed_entry() noexcept {};
 
    explicit parsed_entry(const std::string& original_text,
                          bool is_option = false,
                          const std::string& long_name = "",
                          char short_name = '\0',
                          const std::string& argument = "")
      : original_text{original_text}, is_option{is_option},
        long_name{long_name}, short_name{short_name}, argument{argument} {}
 
    std::string original_text;
 
    std::string original_without_argument;
 
    bool is_option{false};
 
    std::string long_name;
 
    char short_name{'\0'};
 
    std::string argument;
 
    const option* opt_info{nullptr};
  };
 
  class parser_result {
  public:
 
    using value_type = parsed_entry;
    using container_type = std::vector<value_type>;
    using size_type = container_type::size_type;
    using iterator = container_type::iterator;
    using const_iterator = container_type::const_iterator;
    using reverse_iterator = container_type::reverse_iterator;
    using const_reverse_iterator = container_type::const_reverse_iterator;
 
    parser_result() noexcept {}
    parser_result(const std::initializer_list<value_type>& il)
      : m_entries{il} {}
    template <typename InputIt>
    parser_result(InputIt first, InputIt last) : m_entries{first, last} {}
 
    void push_back(const value_type& entry) { m_entries.push_back(entry); }
    void push_back(value_type&& entry) { m_entries.push_back(std::move(entry)); }
 
    void clear() noexcept { m_entries.clear(); }
 
    size_type size() const noexcept { return m_entries.size(); }
    bool empty() const noexcept { return m_entries.empty(); }
 
    iterator begin() noexcept { return m_entries.begin(); }
    const_iterator begin() const noexcept { return cbegin(); }
    iterator end() noexcept { return m_entries.end(); }
    const_iterator end() const noexcept { return cend(); }
 
    const_iterator cbegin() const noexcept { return m_entries.cbegin(); }
    const_iterator cend() const noexcept { return m_entries.cend(); }
 
    reverse_iterator rbegin() noexcept { return m_entries.rbegin(); }
    const_reverse_iterator rbegin() const noexcept { return crbegin(); }
    reverse_iterator rend() noexcept { return m_entries.rend(); }
    const_reverse_iterator rend() const noexcept { return crend(); }
 
    const_reverse_iterator crbegin() const noexcept { return m_entries.crbegin(); }
    const_reverse_iterator crend() const noexcept { return m_entries.crend(); }
 
    value_type& at(size_type index) {
      if (index >= size())
        throw out_of_range("out of bounds parser_result access",
                           "optionpp::parser_result::at");
      return (*this)[index];
    }
    const value_type& at(size_type index) const {
      if (index >= size())
        throw out_of_range("out of bounds parser_result access",
                           "optionpp::parser_result::at");
      return (*this)[index];
    }
 
    value_type& operator[](size_type index) { return m_entries[index]; }
    const value_type& operator[](size_type index) const {
      return m_entries[index];
    }
 
    value_type& back() {
      if (empty())
        throw out_of_range("out of bounds parser_result access",
                           "optionpp::parser_result::back");
      return m_entries.back();
    }
 
    const value_type& back() const {
      if (empty())
        throw out_of_range("out of bounds parser_result access",
                           "optionpp::parser_result::at");
      return m_entries.back();
    }
 
    bool is_option_set(const std::string& long_name) const noexcept;
    bool is_option_set(char short_name) const noexcept;
 
    std::string get_argument(std::string long_name) const noexcept;
    std::string get_argument(char short_name) const noexcept;
 
  private:
    container_type m_entries; //< The internal container of `parsed_entry` instances.
  };
 
} // End namespace
 
#endif