filter_iterator.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
# ifndef FILTER_ITERATOR_H
# define FILTER_ITERATOR_H
 
# include <stdexcept>
# include <ah-errors.H>
# include <ah-errors.H>
 
namespace Aleph
{
 
template <class Container, class It, class Show_Item>
class Filter_Iterator : public It
{
  Show_Item show_item;
 
  const Container *container_ptr = nullptr;
 
  void *cookie = nullptr;
 
  void goto_first_valid_item()
  {
    try
      { // position at the first element that passes show_item filter
        while (true)
          {
            if (not this->It::has_curr() or show_item(this->It::get_curr()))
              return;
            this->It::next();
          }
      }
    catch (const std::overflow_error &) { /* continue in overflow; do not propagate */ }
  }
 
  void forward()
  {
    try
      { // advance to the next item that passes show_item filter
        this->It::next();
        for (; true; this->It::next())
            if (not this->It::has_curr() or show_item(this->It::get_curr()))
              return;
      }
    catch (const std::overflow_error &) { /* continue in overflow; do not propagate */ }
  }
 
  void goto_last_valid_item()
  {
    try
      {
        for (this->It::reset_last(); true; this->It::prev())
          if (not this->It::has_curr() or show_item(this->It::get_curr()))
            return;
      }
    catch (const std::underflow_error &) { /* continue in underflow; do not propagate */ }
  }
 
  void backward()
  {
    try
      {
        this->It::prev();
        for (; true; this->It::prev())
          if (not this->It::has_curr() or show_item(this->It::get_curr()))
            return;
      }
    catch (const std::underflow_error &) { /* continue in underflow; do not propagate */ }
  }
 
public:
  using Item_Type = typename It::Item_Type;
 
  using Iterator_Type = It;
 
  using Container_Type = Container;
 
  using Filter_Type = Show_Item;
 
  const Container & get_container() const
  {
    ah_domain_error_if(container_ptr == nullptr) << "Filter_Iterator: no container set";
    return *container_ptr;
  }
 
  bool has_container() const noexcept { return container_ptr != nullptr; }
 
  It & get_iterator() noexcept { return *this; }
 
  const It & get_iterator() const noexcept { return *this; }
 
  Show_Item & get_filter() noexcept { return show_item; }
 
  const Show_Item & get_filter() const noexcept { return show_item; }
 
  void set_filter(Show_Item si) { show_item = si; }
 
  void set_cookie(void *__cookie) noexcept { cookie = __cookie; }
 
  void * get_cookie() const noexcept { return cookie; }
 
  Filter_Iterator(Show_Item si = Show_Item()) noexcept
    : show_item(si)
  {
    // empty
  }
 
  Filter_Iterator(const Container & c, Show_Item si = Show_Item())
    : It(c), show_item(si), container_ptr(&c)
  {
    goto_first_valid_item();
  }
 
  Filter_Iterator(const Container & c, void *__cookie,
                  Show_Item si = Show_Item())
    : Filter_Iterator(c, si)
  {
    cookie = __cookie;
  }
 
  void next() { forward(); }
 
  void next_ne() noexcept
  {
    try
      {
        forward();
      }
    catch (...) {}
  }
 
  void prev() { backward(); }
 
  void prev_ne() noexcept
  {
    try
      {
        backward();
      }
    catch (...) {}
  }
 
  void reset_first()
  {
    this->It::reset_first();
    goto_first_valid_item();
  }
 
  void reset_last() { goto_last_valid_item(); }
 
  size_t count()
  {
    size_t n = 0;
    for (reset_first(); this->has_curr(); next())
      ++n;
    return n;
  }
 
  bool empty()
  {
    reset_first();
    return not this->has_curr();
  }
 
  template <typename Op>
  void for_each(Op op)
  {
    for (reset_first(); this->has_curr(); next())
      op(this->get_curr());
  }
 
  template <typename Pred>
  bool find_if(Pred pred)
  {
    for (reset_first(); this->has_curr(); next())
      if (pred(this->get_curr()))
        return true;
    return false;
  }
};
 
template <typename T>
struct Show_All
{
  bool operator()(const T &) const noexcept { return true; }
};
 
template <typename T>
struct Show_None
{
  bool operator()(const T &) const noexcept { return false; }
};
 
} // end namespace Aleph
 
# endif // FILTER_ITERATOR_H