element_iterators.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_DETAILS_ELEMENT_ITERATORS_H
#define LARCOREALG_GEOMETRY_DETAILS_ELEMENT_ITERATORS_H

// LArSoft libraries
#include "larcorealg/Geometry/details/GeometryIterationPolicy.h"
#include "larcorealg/Geometry/details/ReadoutIterationPolicy.h"
#include "larcorealg/Geometry/details/id_iterators.h"
#include "larcorealg/Geometry/fwd.h"
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"

// Framework libraries
#include "cetlib_except/exception.h"

// C/C++ standard libraries
#include <iterator> // std::forward_iterator_tag
#include <string>
#include <utility>

namespace geo::details {

  template <typename Owner, typename Element, typename GEOIDITER>
  class geometry_element_iterator {
  public:
    using id_iterator_t = GEOIDITER;

    static_assert(has_geometry_id_iterator_tag<id_iterator_t>::value,
                  "template class for geometry_element_iterator must be a geometry iterator");

    using iterator = geometry_element_iterator<Owner, Element, id_iterator_t>; 

    using LocalID_t = typename id_iterator_t::LocalID_t;
    using GeoID_t = typename id_iterator_t::GeoID_t;
    using ElementPtr_t = Element const*;

    using difference_type = std::ptrdiff_t;
    using value_type = Element;
    using reference = value_type const&;
    using pointer = value_type const*;
    using iterator_category = std::forward_iterator_tag;

    geometry_element_iterator() = default;

    geometry_element_iterator(Owner const* owner, id_iterator_t const& iter)
      : geom{owner}, id_iter(iter)
    {}

    reference operator*() const
    {
      ElementPtr_t ptr = get();
      if (ptr) return *ptr;
      throw cet::exception("geometry_iterator")
        << "iterator attempted to obtain geometry element " << std::string(ID());
    }

    pointer operator->() const { return get(); }

    iterator& operator++()
    {
      ++id_iter;
      return *this;
    }

    iterator operator++(int)
    {
      iterator old(*this);
      ++id_iter;
      return old;
    }

    operator bool() const { return validElement(geom, *id_iter); }

    ElementPtr_t get() const { return getElementPtr(geom, *id_iter); }

    LocalID_t const& ID() const { return *id_iter; }

    auto id_iterator() const { return id_iter; }

  private:
    Owner const* geom;
    id_iterator_t id_iter;
  }; // class geometry_element_iterator<>

  // Element here supports types like CryostatGeo, etc.
  template <typename Owner, typename Element, typename IterationPolicy>
  using element_iterator_for =
    geometry_element_iterator<Owner, Element, id_iterator<typename Element::ID_t, IterationPolicy>>;

  template <typename Element>
  using element_sentinel_for = id_sentinel<typename Element::ID_t>;

  // Element iterator/sentinel comparisons
  template <typename Owner, typename Element, typename GEOIDITER>
  bool operator==(geometry_element_iterator<Owner, Element, GEOIDITER> const& a,
                  geometry_element_iterator<Owner, Element, GEOIDITER> const& b)
  {
    return a.id_iterator() == b.id_iterator();
  }

  template <typename Owner, typename Element, typename GEOIDITER>
  bool operator!=(geometry_element_iterator<Owner, Element, GEOIDITER> const& a,
                  geometry_element_iterator<Owner, Element, GEOIDITER> const& b)
  {
    return !(a == b);
  }

  template <typename Owner, typename Element, typename GEOIDITER>
  bool operator==(geometry_element_iterator<Owner, Element, GEOIDITER> const& a,
                  id_sentinel<typename Element::ID_t> const& b)
  {
    return a.id_iterator() == b;
  }

  template <typename Owner, typename Element, typename GEOIDITER>
  bool operator!=(geometry_element_iterator<Owner, Element, GEOIDITER> const& a,
                  id_sentinel<typename Element::ID_t> const& b)
  {
    return !(a == b);
  }

  template <typename Owner, typename Element, typename GEOIDITER>
  bool operator==(id_sentinel<typename Element::ID_t> const& a,
                  geometry_element_iterator<Owner, Element, GEOIDITER> const& b)
  {
    return a == b.id_iterator();
  }

  template <typename Owner, typename Element, typename GEOIDITER>
  bool operator!=(id_sentinel<typename Element::ID_t> const& a,
                  geometry_element_iterator<Owner, Element, GEOIDITER> const& b)
  {
    return !(a == b);
  }

} // namespace geo::details

#endif // LARCOREALG_GEOMETRY_DETAILS_ELEMENT_ITERATORS_H