counter.h

Go to the documentation of this file.

#ifndef LARCOREALG_COREUTILS_COUNTER_H
#define LARCOREALG_COREUTILS_COUNTER_H

// LArSoft libraries
#include "larcorealg/CoreUtils/span.h"

// C/C++ libraries
#include <cstddef> // std::size_t
#include <utility> // std::move()

namespace util {

  // -- BEGIN -- Counted iterations --------------------------------------------

  template <typename T = std::size_t>
  class count_iterator {

  public:
    // --- BEGIN -- Traits and data types --------------------------------------

    using iterator_type = count_iterator<T>; 

    using difference_type = std::ptrdiff_t;
    using value_type = T;       
    using reference = T const&; 
    using pointer = T*;
    using iterator_category = std::bidirectional_iterator_tag;

    // --- END -- Traits and data types ----------------------------------------

    // --- BEGIN Constructors --------------------------------------------------

    count_iterator() = default;

    count_iterator(value_type count) : fCount(count) {}

    // --- END Constructors ----------------------------------------------------

    // --- BEGIN -- Data access ------------------------------------------------

    reference operator*() const { return fCount; }

    // --- END -- Data access --------------------------------------------------

    // --- BEGIN -- Modification -----------------------------------------------

    iterator_type& operator++()
    {
      ++fCount;
      return *this;
    }

    iterator_type operator++(int) const
    {
      iterator_type const old = *this;
      operator++();
      return old;
    }

    iterator_type& operator--()
    {
      --fCount;
      return *this;
    }

    iterator_type operator--(int) const
    {
      iterator_type const old = *this;
      operator--();
      return old;
    }

    // --- END -- Modification -------------------------------------------------

    // --- BEGIN -- Comparisons ------------------------------------------------

    template <typename U>
    bool operator==(count_iterator<U> const& other) const
    {
      return fCount == other.fCount;
    }

    template <typename U>
    bool operator!=(count_iterator<U> const& other) const
    {
      return fCount != other.fCount;
    }

    // --- END -- Comparisons --------------------------------------------------

  private:
    value_type fCount{}; 

  }; // class count_iterator<>

  template <typename T>
  auto counter(T begin, T end);

  template <typename T>
  auto counter(T end)
  {
    return counter(T{}, end);
  }

  template <typename T = std::size_t>
  auto infinite_counter(T begin = T{});

  // -- END -- Counted iterations ----------------------------------------------

} // namespace util

//==============================================================================
//=== template implementation
//==============================================================================
//------------------------------------------------------------------------------
//--- util::counter()
//------------------------------------------------------------------------------
namespace util::details {

  template <typename T>
  class infinite_endcount_iterator {
    using this_iterator_t = infinite_endcount_iterator<T>;
    using count_iterator_t = count_iterator<T>;

  public:
    // mock-up of stuff required by `util::span`
    using value_type = T;
    using reference = T const&;
    using pointer = T const*;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::forward_iterator_tag; // this is a lie

    bool operator==(this_iterator_t const&) const { return true; }

    bool operator!=(this_iterator_t const&) const { return false; }

  }; // class infinite_endcount_iterator

  template <typename T>
  bool operator!=(infinite_endcount_iterator<T> const&, count_iterator<T> const&)
  {
    return true;
  }

  template <typename T>
  bool operator!=(count_iterator<T> const&, infinite_endcount_iterator<T> const&)
  {
    return true;
  }

  template <typename T>
  bool operator==(infinite_endcount_iterator<T> const&, count_iterator<T> const&)
  {
    return false;
  }

  template <typename T>
  bool operator==(count_iterator<T> const&, infinite_endcount_iterator<T> const&)
  {
    return false;
  }

  //----------------------------------------------------------------------------

} // namespace util::details

//------------------------------------------------------------------------------
template <typename T>
auto util::counter(T begin, T end)
{
  return util::span(count_iterator(begin), count_iterator(end));
}

//------------------------------------------------------------------------------
template <typename T>
auto util::infinite_counter(T begin)
{
  return util::span(count_iterator(begin), details::infinite_endcount_iterator<T>());
} // util::infinite_counter()

//------------------------------------------------------------------------------

#endif // LARCOREALG_COREUTILS_COUNTER_H