result_iterator.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_RESULT_ITERATOR_HPP
#define OPTIONPP_RESULT_ITERATOR_HPP
 
#include <optionpp/parser_result.hpp>
 
namespace optionpp {
 
  template <typename T, typename Ptr, typename Ref, bool IsOption>
  class result_iterator : public std::iterator<std::bidirectional_iterator_tag,
                                               T, std::ptrdiff_t,
                                               Ptr, Ref> {
  public:
    result_iterator() noexcept : m_result{nullptr}, m_index{} {}
    result_iterator(T& result)
      : m_result{&result}, m_index{0} {
        if (!result.empty() && result[0].is_option != IsOption)
          ++(*this);
      }
 
    Ref operator*() const;
 
    Ptr operator->() const { return &**this; }
 
    result_iterator& operator++();
 
    result_iterator operator++(int) {
      result_iterator<T, Ptr, Ref, IsOption> copy{*this};
      ++(*this);
      return copy;
    }
 
    result_iterator& operator--();
 
    result_iterator operator--(int) {
      result_iterator<T, Ptr, Ref, IsOption> copy{*this};
      --(*this);
      return copy;
    }
 
    bool operator==(const result_iterator<T, Ptr, Ref, IsOption>& other) const;
 
    inline bool operator!=(const result_iterator<T, Ptr, Ref, IsOption>& other) const {
      return !(*this == other);
    }
 
  private:
    T* m_result; //< `parser_result` being iterated over.
    typename T::size_type m_index; //< Current entry index.
  };
 
  template <typename T,
            typename Ptr, typename Ref, bool IsOption>
  inline result_iterator<T, Ptr, Ref, IsOption>
  begin(result_iterator<T, Ptr, Ref, IsOption> it) noexcept { return it; }
 
  template <typename T,
            typename Ptr, typename Ref, bool IsOption>
  inline result_iterator<T, Ptr, Ref, IsOption>
  end(const result_iterator<T, Ptr, Ref, IsOption>&) noexcept {
    return result_iterator<T, Ptr, Ref, IsOption>{};
  }
 
  using option_iterator = result_iterator<parser_result,
                                          parsed_entry*,
                                          parsed_entry&,
                                          true>;
 
  using option_const_iterator = result_iterator<const parser_result,
                                                const parsed_entry*,
                                                const parsed_entry&,
                                                true>;
 
  using non_option_iterator = result_iterator<parser_result,
                                              parsed_entry*,
                                              parsed_entry&,
                                              false>;
 
  using non_option_const_iterator = result_iterator<const parser_result,
                                                    const parsed_entry*,
                                                    const parsed_entry&,
                                                    false>;
 
} // End namespace
 
 
/* Implementation */
 
template <typename T,
          typename Ptr, typename Ref, bool IsOption>
Ref optionpp::result_iterator<T, Ptr, Ref, IsOption>::operator*() const {
  if (!m_result)
    throw bad_dereference{"tried to dereference a nullptr",
                          "optionpp::non_option_iterator::operator*"};
  if (m_index == m_result->size())
    throw bad_dereference{"tried to dereference past-the-end iterator",
        "optionpp::non_option_iterator::operator*"};
  return (*m_result)[m_index];
}
 
template <typename T,
          typename Ptr, typename Ref, bool IsOption>
auto optionpp::result_iterator<T, Ptr, Ref, IsOption>::operator++()
  -> result_iterator<T, Ptr, Ref, IsOption>& {
  if (m_result) {
    do {
      ++m_index;
    } while (m_index < m_result->size()
             && (*m_result)[m_index].is_option != IsOption);
  }
  return *this;
}
 
template <typename T,
          typename Ptr, typename Ref, bool IsOption>
auto optionpp::result_iterator<T, Ptr, Ref, IsOption>::operator--()
  -> result_iterator<T, Ptr, Ref, IsOption>& {
  if (m_result) {
    do {
      if (m_index == 0)
        throw out_of_range{"out of bounds parser_result access",
                           "optionpp::non_option_iterator::operator--"};
      --m_index;
    } while ((*m_result)[m_index].is_option != IsOption);
  }
  return *this;
}
 
template <typename T,
          typename Ptr, typename Ref, bool IsOption>
bool optionpp::result_iterator<T, Ptr, Ref, IsOption>
::operator==(const result_iterator<T, Ptr, Ref, IsOption>& other) const {
  bool left_default = !m_result;
  bool right_default = !other.m_result;
  bool left_at_end = left_default || m_result->size() == m_index;
  bool right_at_end = right_default
    || other.m_result->size() == other.m_index;
 
  // If neither iterator was default-constructed, compare contents
  if (!left_default && !right_default)
    return m_index == other.m_index && m_result == other.m_result;
  // If both are `end()` iterators, they're equal
  else if (left_at_end && right_at_end)
    return true;
  else // Otherwise, not equal
    return false;
}
 
#endif