ArrayIterator.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <iterator>
 
class TObject;
 
namespace Belle2 {
  template <class ArrayType, class ValueType> class ObjArrayIterator {
 
  public:
 
    using iterator_category = std::forward_iterator_tag;
 
    using difference_type = std::ptrdiff_t;
 
    using value_type = ValueType;
 
    using pointer = ValueType*;
 
    using reference = ValueType&;
 
    ObjArrayIterator() = default;
    ObjArrayIterator(ArrayType& array, size_t index): m_array{array.GetObjectRef() + index} {}
 
    explicit ObjArrayIterator(ArrayType const* array, bool end = false)
    {
      if (array) {
        m_array = array->GetObjectRef() + (end ? array->GetEntriesFast() : 0);
      }
    }
 
    explicit ObjArrayIterator(ArrayType const* const* array, bool end = false): ObjArrayIterator(array ? * array : nullptr, end) {}
    ObjArrayIterator<ArrayType, ValueType>& operator++() { ++m_array; return *this; }
    ObjArrayIterator<ArrayType, ValueType> operator++(int) { auto old = *this; ++(*this); return old; }
    bool operator==(const ObjArrayIterator<ArrayType, ValueType>& rhs) const { return m_array == rhs.m_array; }
    bool operator!=(const ObjArrayIterator<ArrayType, ValueType>& rhs) const { return !(*this == rhs); }
 
    ValueType& operator*() const { return *static_cast<ValueType*>(*m_array); }
    ValueType* operator->() const { return &(operator*()); }
  private:
    TObject** m_array{nullptr};
  };
 
  template <class ArrayType, class ValueType> class ArrayIterator {
 
  public:
 
    using iterator_category = std::forward_iterator_tag;
 
    using difference_type = std::ptrdiff_t;
 
    using value_type = ValueType;
 
    using pointer = ValueType*;
 
    using reference = ValueType&;
 
  public:
 
    ArrayIterator(): m_array(nullptr), m_index(-1)
    {
    }
 
    explicit ArrayIterator(const ArrayType* array, int index):
      m_array(array), m_index(index)
    {
    }
 
    ArrayIterator<ArrayType, ValueType>& operator++()
    {
      ++m_index;
      return *this;
    }
 
    ArrayIterator<ArrayType, ValueType> operator++(int)
    {
      ArrayIterator<ArrayType, ValueType> old(*this);
      ++(*this);
      return old;
    }
 
    bool operator==(const ArrayIterator<ArrayType, ValueType>& rhs) const
    {
      return m_index == rhs.m_index && m_array == rhs.m_array;
    }
 
    bool operator!=(const ArrayIterator<ArrayType, ValueType>& rhs) const
    {
      return !(*this == rhs);
    }
 
    ValueType& operator*() const
    {
      return deref_if_needed((*m_array)[m_index]);
    }
 
    ValueType* operator->() const
    {
      return &(operator*());
    }
 
  private:
 
    static ValueType& deref_if_needed(ValueType& t)
    {
      return t;
    }
 
    static ValueType& deref_if_needed(ValueType* t)
    {
      return *t;
    }
 
    const ArrayType* m_array;
 
    int m_index;
 
  };
}