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 std::iterator<std::forward_iterator_tag, ValueType>  {
  public:
    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 std::iterator<std::forward_iterator_tag, ValueType> {
    static ValueType& deref_if_needed(ValueType& t) { return t; }
    static ValueType& deref_if_needed(ValueType* t) { return *t; }
  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:
    const ArrayType* m_array; 
    int m_index; 
  };
}