ChargedSpacePointCreator.h

Go to the documentation of this file.

#ifndef LARDATA_ARTDATAHELPER_CHARGEDSPACEPOINTCREATOR_H
#define LARDATA_ARTDATAHELPER_CHARGEDSPACEPOINTCREATOR_H

// LArSoft libraries
#include "lardataobj/RecoBase/SpacePoint.h"
#include "lardataobj/RecoBase/PointCharge.h"

// framework libraries
#include "art/Framework/Core/ProducerBase.h"
#include "art/Framework/Principal/Event.h"
#include "art/Persistency/Common/PtrMaker.h"
#include "canvas/Persistency/Common/Ptr.h"

// C/C++ standard libraries
#include <vector>
#include <memory> // std::unique_ptr<>
#include <type_traits> // std::enable_if_t, ...
#include <cstdlib> // std::size_t


namespace recob {
  
  namespace details {
    
    template <typename T, typename = void>
    struct is_art_module;
    
    template <typename T>
    constexpr bool is_art_module_v = is_art_module<T>();
    
  } // namespace details
  
  
  class ChargedSpacePointCollectionCreator {
    
      public:
    
    //--- BEGIN Constructors ---------------------------------------------------
    
    ChargedSpacePointCollectionCreator
      (art::Event& event, std::string const& instanceName = {});
    
    template <typename Producer>
    ChargedSpacePointCollectionCreator(
      art::Event& event, Producer const& producer,
      std::string const& instanceName = {},
      std::enable_if_t<details::is_art_module_v<Producer>>* = nullptr
      );
    
    //--- END Constructors ---------------------------------------------------
    
    
    //--- BEGIN Insertion and finish operations --------------------------------
    

    void add
      (recob::SpacePoint const& spacePoint, recob::PointCharge const& charge);
    void add(recob::SpacePoint&& spacePoint, recob::PointCharge&& charge);
    

    void addAll(
      std::vector<recob::SpacePoint>&& spacePoints,
      std::vector<recob::PointCharge>&& charges
      );
    void addAll(
      std::vector<recob::SpacePoint> const& spacePoints,
      std::vector<recob::PointCharge> const& charges
      );
    
    void put();
    
    
    //--- END Insertion and finish operations --------------------------------
    
    
    //--- BEGIN Queries and operations -----------------------------------------
    
    bool empty() const { return spent() || fSpacePoints->empty(); }
    
    std::size_t size() const { return spent()? 0U: fSpacePoints->size(); }
    
    void clear();
    
    bool spent() const { return !fSpacePoints; }
    
    bool canMakePointers() const { return bool(fSpacePointPtrMaker); }
    
    //--- END Queries and operations -------------------------------------------
    
    
    //--- BEGIN Complimentary unchecked element access -------------------------
    
    recob::SpacePoint const& spacePoint(std::size_t i) const
      { return fSpacePoints->operator[](i); }
    
    recob::SpacePoint const& lastSpacePoint() const
      { return spacePoint(lastIndex()); }
    
    art::Ptr<recob::SpacePoint> spacePointPtr(std::size_t i) const;
    
    art::Ptr<recob::SpacePoint> lastSpacePointPtr() const
      { return spacePointPtr(lastIndex()); }
    
    
    recob::PointCharge const& charge(std::size_t i) const
      { return fCharges->operator[](i); }
    
    recob::PointCharge const& lastCharge() const
      { return charge(lastIndex()); }
    
    art::Ptr<recob::PointCharge> chargePtr(std::size_t i) const;
    
    art::Ptr<recob::PointCharge> lastChargePtr() const
      { return chargePtr(lastIndex()); }
    
    //--- END Complimentary unchecked element access ---------------------------
    
    
    //--- BEGIN Static constructor interface -----------------------------------

    static void produces
      (art::ProducerBase& producer, std::string const& instanceName = {});
    
    //--- END Static constructor interface -------------------------------------
    
    
      private:
    art::Event& fEvent; 
    
    std::string fInstanceName; 
    
    std::unique_ptr<std::vector<recob::SpacePoint>> fSpacePoints;
    std::unique_ptr<art::PtrMaker<recob::SpacePoint>> fSpacePointPtrMaker;
    std::unique_ptr<std::vector<recob::PointCharge>> fCharges;
    std::unique_ptr<art::PtrMaker<recob::PointCharge>> fChargePtrMaker;
    
    std::size_t lastIndex() const { return size() - 1U; }
    
  }; // class ChargedSpacePointCollectionCreator
  
} // namespace recob


//------------------------------------------------------------------------------
//--- template implementation
//------------------------------------------------------------------------------
namespace recob {
  
  namespace details {
    
    //--------------------------------------------------------------------------
    template <typename T>
    constexpr bool always_true_v = true;
    
    template <typename T, typename /* = void */>
    struct is_art_module: public std::false_type {};
    
    template <typename T>
    struct is_art_module
      <T, std::enable_if_t<always_true_v<typename T::ModuleType>>>
      : public std::true_type
      {};
    
    //--------------------------------------------------------------------------
    
  } // namespace details
  
} // namespace recob


//------------------------------------------------------------------------------
template <typename Producer>
recob::ChargedSpacePointCollectionCreator::ChargedSpacePointCollectionCreator(
  art::Event& event,
  Producer const& producer,
  std::string const& instanceName /* = {} */,
  std::enable_if_t<details::is_art_module_v<Producer>>* /* = nullptr */
)
  : ChargedSpacePointCollectionCreator(event, instanceName)
{
  
  fSpacePointPtrMaker = std::make_unique<art::PtrMaker<recob::SpacePoint>>
    (fEvent, producer, fInstanceName);
  fChargePtrMaker = std::make_unique<art::PtrMaker<recob::PointCharge>>
    (fEvent, producer, fInstanceName);
  
} // ChargedSpacePointCollectionCreator(Producer)


//------------------------------------------------------------------------------

#endif // LARDATA_ARTDATAHELPER_CHARGEDSPACEPOINTCREATOR_H