geometry_iterators.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_DETAILS_GEOMETRY_ITERATORS_H
#define LARCOREALG_GEOMETRY_DETAILS_GEOMETRY_ITERATORS_H

// LArSoft libraries
#include "larcorealg/Geometry/details/helpers.h"
#include "larcorealg/Geometry/fwd.h"
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
#include "larcoreobj/SimpleTypesAndConstants/readout_types.h"

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

namespace geo::details {

  class geometry_iterator_base {
  public:
    geometry_iterator_base(GeometryCore const* geom) : pGeo(geom) {}

  protected:
    GeometryCore const* geometry() const { return pGeo; }

    geometry_iterator_base() = default;

  private:
    GeometryCore const* pGeo = nullptr; 

  }; // class geometry_iterator_base

  template <typename LocalID, typename GEOID>
  class id_iterator_base;

  template <typename GEOID>
  class id_iterator_base<CryostatID, GEOID> : public geometry_iterator_base {
  public:
    using GeoID_t = GEOID; 

    using LocalID_t = CryostatID;                          
    using iterator = id_iterator_base<LocalID_t, GeoID_t>; 

    static_assert(std::is_base_of<LocalID_t, GEOID>{}, "template type GEOID is not a LocalID_t");

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

    id_iterator_base() = default;

    id_iterator_base(GeometryCore const* geom, GeoID_t const& start_from)
      : geometry_iterator_base{geom}, id{start_from}, limit{NSiblings(geom, localID())}
    {}

    bool operator==(id_iterator_base const& as) const { return localID() == as.localID(); }

    bool operator!=(id_iterator_base const& as) const { return localID() != as.localID(); }

    reference operator*() const { return localID(); }

    pointer operator->() const { return &(localID()); }

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

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

  protected:
    using ID_t = typename LocalID_t::CryostatID_t;

    GeoID_t const& ID() const { return id; }
    GeoID_t& ID() { return id; }

    void next()
    {
      if (at_end()) return;
      if (++local_index() < limit) return;
      localID().isValid = false;
    }

    bool at_end() const { return local_index() == limit; }

  private:
    GeoID_t id{};                      
    ID_t limit = LocalID_t::InvalidID; 

    LocalID_t const& localID() const { return ID(); }
    LocalID_t& localID() { return ID(); }

    ID_t const& local_index() const { return localID().deepestIndex(); }
    ID_t& local_index() { return localID().deepestIndex(); }
  }; // class id_iterator_base<CryostatID>

  template <typename LocalID, typename GEOID>
  class id_iterator_base : protected id_iterator_base<typename LocalID::ParentID_t, GEOID> {
    using upper_iterator = id_iterator_base<typename LocalID::ParentID_t, GEOID>;

  public:
    using GeoID_t = typename upper_iterator::GeoID_t;

    using LocalID_t = LocalID; 
    static_assert(std::is_base_of<LocalID_t, GEOID>{}, "template type GEOID is not a LocalID_t");

    using iterator = id_iterator_base<LocalID_t, GeoID_t>; 

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

    id_iterator_base() = default;

    id_iterator_base(GeometryCore const* geo, GeoID_t const& start_from)
      : upper_iterator{geo, start_from}, geom{geo}, limit(NSiblings(geom, localID()))
    {}

    bool operator==(id_iterator_base const& as) const { return localID() == as.localID(); }

    bool operator!=(id_iterator_base const& as) const { return !operator==(as); }

    reference operator*() const { return localID(); }

    pointer operator->() const { return &(localID()); }

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

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

  protected:
    LocalID_t const& localID() const { return upper_iterator::ID(); }

    using ID_t = std::remove_reference_t<
      decltype(std::declval<LocalID_t>().deepestIndex())>; 

    void next()
    {
      // if at end (checked in the inherited context), do nothing
      if (upper_iterator::at_end()) return;

      // if after incrementing we haven't reached the limit, we are done
      if (++local_index() < limit) return;

      // we reached the end of the current elements list, we need to escalate:
      // - go to the next parent; if that becomes invalid, too bad, but we go on
      upper_iterator::next();
      // - set the index to the first element of the new parent
      local_index() = 0;
      // - update how many elements there are
      //   (expect 0 if it is now at_end() -- and it does not even matter)
      limit = NSiblings(geom, localID());
    }

    ID_t const& local_index() const { return localID().deepestIndex(); }

  private:
    geo::GeometryCore const* geom;
    ID_t limit = LocalID_t::InvalidID;

    LocalID_t& localID() { return upper_iterator::ID(); }

    ID_t& local_index() { return localID().deepestIndex(); }
  }; // class id_iterator_base

  template <typename LocalID>
  using id_iterator = id_iterator_base<LocalID, LocalID>;

  template <typename GEOIT>
  std::enable_if_t<std::is_base_of_v<geometry_iterator_base, GEOIT>, std::ostream&> operator<<(
    std::ostream& out,
    GEOIT const& it)
  {
    return out << "geometry_iterator{ " << *it << " }";
  }

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

    static_assert(std::is_base_of<geometry_iterator_base, id_iterator_t>{},
                  "template class for geometry_element_iterator"
                  " must be a geometry iterator");

    using iterator = geometry_element_iterator<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(GeometryCore const* geo, id_iterator_t const& iter)
      : geom{geo}, id_iterator(iter)
    {}

    geometry_element_iterator(GeometryCore const* geo, id_iterator_t&& iter)
      : geom{geo}, id_iterator(iter)
    {}

    geometry_element_iterator(GeometryCore const* geo, GeoID_t const& start_from)
      : geom{geo}, id_iterator(geom, start_from)
    {}

    bool operator==(iterator const& as) const { return id_iterator == as.id_iterator; }

    bool operator!=(iterator const& as) const { return id_iterator != as.id_iterator; }

    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());
    } // operator*()

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

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

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

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

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

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

  private:
    geo::GeometryCore const* geom;
    id_iterator_t id_iterator;
  }; // class geometry_element_iterator<>

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

} // namespace geo::details

#endif // LARCOREALG_GEOMETRY_DETAILS_GEOMETRY_ITERATORS_H