ChangeTrackers.h

Go to the documentation of this file.

#ifndef UTIL_CHANGETRACKERS_H
#define UTIL_CHANGETRACKERS_H

// LArSoft libraries
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h" // geo::PlaneID

// framework libraries
#include "art/Framework/Principal/Event.h"
#include "canvas/Persistency/Provenance/EventID.h"
#include "canvas/Utilities/InputTag.h"

// C/C++ standard libraries
#include <ostream>
#include <string>      // std::to_string()
#include <type_traits> // std::enable_if_t

namespace util {

  class EventChangeTracker_t {
  public:
    EventChangeTracker_t() = default;

    EventChangeTracker_t(art::Event const& evt) : state{evt.id()} {}

    EventChangeTracker_t(art::EventID const& evt_id) : state{evt_id} {}

    bool same(EventChangeTracker_t const& as) const { return as.eventID() == eventID(); }

    bool isValid() const { return eventID() != art::EventID(); }

    bool operator==(EventChangeTracker_t const& as) const { return same(as); }

    bool operator!=(EventChangeTracker_t const& than) const { return !same(than); }

    void clear() { set(art::EventID()); }

    void set(art::EventID const& evt_id) { state.event_id = evt_id; }

    void set(art::Event const& evt) { set(evt.id()); }

    bool update(EventChangeTracker_t const& trk)
    {
      if (same(trk)) return false;
      *this = trk;
      return true;
    }

    operator std::string() const
    {
      return "R:" + std::to_string(eventID().run()) + " S:" + std::to_string(eventID().subRun()) +
             " E:" + std::to_string(eventID().event());
    }

  protected:
    art::EventID const& eventID() const { return state.event_id; }

  private:
    struct LocalState_t {
      art::EventID event_id; 
    };

    LocalState_t state; 

  }; // EventChangeTracker_t

  inline std::ostream& operator<<(std::ostream& out, EventChangeTracker_t const& trk)
  {
    out << std::string(trk);
    return out;
  }

  class DataProductChangeTracker_t : private EventChangeTracker_t {
  public:
    DataProductChangeTracker_t() = default;

    DataProductChangeTracker_t(art::Event const& evt, art::InputTag const& label)
      : EventChangeTracker_t(evt), state{label}
    {}

    DataProductChangeTracker_t(art::EventID const& evt_id, art::InputTag const& label)
      : EventChangeTracker_t(evt_id), state{label}
    {}

    art::InputTag const& inputLabel() const { return state.input_label; }

    bool sameEvent(DataProductChangeTracker_t const& as) const
    {
      return EventChangeTracker_t::same(as);
    }

    bool same(DataProductChangeTracker_t const& as) const
    {
      return sameEvent(as) && (inputLabel() == as.inputLabel());
    }

    bool isValid() const
    {
      return EventChangeTracker_t::isValid() && !inputLabel().label().empty();
    }

    bool operator==(DataProductChangeTracker_t const& as) const { return same(as); }

    bool operator!=(DataProductChangeTracker_t const& than) const { return !same(than); }

    void clear()
    {
      EventChangeTracker_t::clear();
      SetInputLabel(art::InputTag());
    }

    void set(art::Event const& evt, art::InputTag const& label)
    {
      EventChangeTracker_t::set(evt);
      SetInputLabel(label);
    }

    bool update(DataProductChangeTracker_t const& new_prod)
    {
      if (same(new_prod)) return false;
      *this = new_prod;
      return true;
    }


    operator std::string() const
    {
      return EventChangeTracker_t::operator std::string() + " I{" + inputLabel().encode() + "}";
    }

  private:
    struct LocalState_t {
      art::InputTag input_label;
    }; // LocalState_t

    LocalState_t state;

    void SetInputLabel(art::InputTag const& label) { state.input_label = label; }

  }; // DataProductChangeTracker_t

  inline std::ostream& operator<<(std::ostream& out, DataProductChangeTracker_t const& trk)
  {
    out << std::string(trk);
    return out;
  }

  class PlaneDataChangeTracker_t : private DataProductChangeTracker_t {
  public:
    PlaneDataChangeTracker_t() = default;

    PlaneDataChangeTracker_t(art::Event const& evt,
                             art::InputTag const& label,
                             geo::PlaneID const& pid)
      : DataProductChangeTracker_t(evt, label), state{pid}
    {}

    PlaneDataChangeTracker_t(art::EventID const& evt_id,
                             art::InputTag const& label,
                             geo::PlaneID const& pid)
      : DataProductChangeTracker_t(evt_id, label), state{pid}
    {}

    using DataProductChangeTracker_t::inputLabel;

    geo::PlaneID const& planeID() const { return state.plane_id; }

    bool sameProduct(PlaneDataChangeTracker_t const& as) const
    {
      return DataProductChangeTracker_t::same(as);
    }

    bool sameTPC(PlaneDataChangeTracker_t const& as) const
    {
      return sameEvent(as) && (static_cast<geo::TPCID const&>(planeID()) == as.planeID());
    }

    bool same(PlaneDataChangeTracker_t const& as) const
    {
      return sameEvent(as) && (planeID() == as.planeID());
    }

    bool isValid() const { return DataProductChangeTracker_t::isValid() && planeID().isValid; }

    bool operator==(PlaneDataChangeTracker_t const& as) const { return same(as); }

    bool operator!=(PlaneDataChangeTracker_t const& than) const { return !same(than); }

    void clear()
    {
      DataProductChangeTracker_t::clear();
      SetPlaneID(geo::PlaneID());
    }

    void set(art::Event const& evt, art::InputTag const& label, geo::PlaneID const& pid)
    {
      DataProductChangeTracker_t::set(evt, label);
      SetPlaneID(pid);
    }

    bool update(PlaneDataChangeTracker_t const& new_prod)
    {
      if (same(new_prod)) return false;
      *this = new_prod;
      return true;
    }


    operator std::string() const
    {
      return DataProductChangeTracker_t::operator std::string() + " " + std::string(planeID());
    }

  private:
    struct LocalState_t {
      geo::PlaneID plane_id;
    }; // LocalState_t

    LocalState_t state;

    void SetPlaneID(geo::PlaneID const& pid) { state.plane_id = pid; }

  }; // PlaneDataChangeTracker_t

  inline std::ostream& operator<<(std::ostream& out, PlaneDataChangeTracker_t const& trk)
  {
    out << std::string(trk);
    return out;
  }

} // namespace util

#endif // UTIL_CHANGETRACKERS_H