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 "canvas/Utilities/InputTag.h"
#include "canvas/Persistency/Provenance/EventID.h"
#include "art/Framework/Principal/Event.h"

// C/C++ standard libraries
#include <string> // std::to_string()
#include <ostream>
#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