lar::util::details::FindAllP< Source, Dest > Class Template Reference

Query object reading all the associations between two classes. More...

#include "FindAllP.h"

Public Types
using	Source_t = Source
using	Dest_t = Dest

Public Member Functions
	FindAllP ()=default
	Default constructor: empty query, read information with Read() More...
	FindAllP (art::Event &event)
	Constructor: reads all associations from the specified event. More...
	FindAllP (art::Event &event, art::InputTag assnTag)
	Constructor: reads one association from the specified event. More...
art::Ptr< Dest_t > const &	operator[] (art::Ptr< Dest_t > const &src) const
	Returns the object associated to the specified one. More...
bool	hasProduct (art::ProductID const &id) const
	Returns whether there are associations from objects in product id. More...
bool	hasProduct (art::Ptr< Source_t > const &ptr) const
	Returns if there are associations from objects with product as ptr. More...
unsigned int	Read (art::Event &event)
	Reads all the associations from the event. More...
unsigned int	Read (art::Event &event, art::InputTag const &assnTag)
	Reads the specified association from the event. More...
unsigned int	Add (art::Event &event, art::InputTag const &assnTag)
	Reads the specified association from the event. More...

Protected Types
using	Assns_t = art::Assns< Source_t, Dest_t >
using	Cache_t = UniqueAssociationCache< Source_t, Dest_t >
	Type of the cache. More...

Protected Member Functions
unsigned int	Merge (art::Handle< Assns_t > &handle)
	Adds all associations in the specified handle; returns their number. More...

Protected Attributes
Cache_t	cache
	set of associations, keyed by product ID and key More...

Detailed Description

template<typename Source, typename Dest>
class lar::util::details::FindAllP< Source, Dest >

Query object reading all the associations between two classes.

---

Template Parameters

Source	type of the object we use as query key (indexing object)
Dest	type of the object we query for

When assigned an event, this object reads all the associations from Source type classes to Dest type classes in the event, and stores their information in a map to track a Dest object from its Source one. In fact, it assumes that only one Dest object is associated, event-wise, to each single Source object.

Definition at line 112 of file FindAllP.h.

Member Typedef Documentation

template<typename Source , typename Dest >

using lar::util::details::FindAllP< Source, Dest >::Assns_t = art::Assns<Source_t, Dest_t>

protected

Definition at line 175 of file FindAllP.h.

template<typename Source , typename Dest >

using lar::util::details::FindAllP< Source, Dest >::Cache_t = UniqueAssociationCache<Source_t, Dest_t>

protected

Type of the cache.

Definition at line 178 of file FindAllP.h.

template<typename Source , typename Dest >

using lar::util::details::FindAllP< Source, Dest >::Dest_t = Dest

Definition at line 115 of file FindAllP.h.

template<typename Source , typename Dest >

using lar::util::details::FindAllP< Source, Dest >::Source_t = Source

Definition at line 114 of file FindAllP.h.

Constructor & Destructor Documentation

template<typename Source , typename Dest >

lar::util::details::FindAllP< Source, Dest >::FindAllP ( )

default

Default constructor: empty query, read information with Read()

template<typename Source , typename Dest >

lar::util::details::FindAllP< Source, Dest >::FindAllP ( art::Event &  event )

inline

Constructor: reads all associations from the specified event.

Definition at line 121 of file FindAllP.h.

References Read().

: FindAllP() { Read(event); }

template<typename Source , typename Dest >

lar::util::details::FindAllP< Source, Dest >::FindAllP ( art::Event &  event, art::InputTag  assnTag  )

inline

Constructor: reads one association from the specified event.

Definition at line 124 of file FindAllP.h.

References Read().

: FindAllP() { Read(event, assnTag); }

Member Function Documentation

template<typename Source , typename Dest >

unsigned int lar::util::details::FindAllP< Source, Dest >::Add	(	art::Event &	event,
		art::InputTag const &	assnTag
	)

Reads the specified association from the event.

Parameters

event	the event to read the associations from
assnTag	the input tag for the association

Exceptions

art::Exception

if multiple dest objects are found for one source object

The existing associations already in cache are not removed.

The input tag for the association is usually simply a string with the name of the module that produced the association, and often the same module has also produced the source objects as well.

Definition at line 267 of file FindAllP.h.

References art::ProductRetriever::getByLabel(), and art::errors::ProductNotFound.

      {

        // read the association between source and destination class types
        art::Handle<Assns_t> handle;
        if (!event.getByLabel(assnTag, handle)) {
          throw art::Exception(art::errors::ProductNotFound)
            << "no association found with input tag '" << assnTag << "'";
        }

        return Merge(handle);
      } // FindAllP::Add(Event, InputTag)

template<typename Source , typename Dest >

bool lar::util::details::FindAllP< Source, Dest >::hasProduct ( art::ProductID const &  id ) const

inline

Returns whether there are associations from objects in product id.

Definition at line 226 of file FindAllP.h.

      {
        return cache.AssnCache.count(id) > 0;
      }

template<typename Source , typename Dest >

bool lar::util::details::FindAllP< Source, Dest >::hasProduct ( art::Ptr< Source_t > const &  ptr ) const

inline

Returns if there are associations from objects with product as ptr.

Definition at line 232 of file FindAllP.h.

References art::Ptr< T >::id().

      {
        return hasProduct(ptr.id());
      }

template<typename Source , typename Dest >

unsigned int lar::util::details::FindAllP< Source, Dest >::Merge ( art::Handle< Assns_t > &  handle )

protected

Adds all associations in the specified handle; returns their number.

Definition at line 281 of file FindAllP.h.

References art::Ptr< T >::id(), art::errors::InvalidNumber, art::Ptr< T >::isNonnull(), art::Ptr< T >::isNull(), art::Ptr< T >::key(), MF_LOG_DEBUG, MF_LOG_ERROR, art::Handle< T >::provenance(), and lar::util::details::ResizeToPower2().

      {
        // product ID of the last source object; initialized invalid
        art::ProductID LastProductID = art::Ptr<Source_t>().id();
        typename Cache_t::InProductCache_t const* AssnsList = nullptr;

        unsigned int count = 0;

        MF_LOG_DEBUG("FindAllP") << "Merge(): importing " << handle->size() << " associations from "
                                 << handle.provenance();

        for (auto const& assn : *handle) {
          // assn is a std::pair<art::Ptr<Source_t>, art::Ptr<Dest_t>>
          art::Ptr<Source_t> const& src = assn.first;

          if (src.isNull()) {
            MF_LOG_ERROR("FindAllP")
              << "Empty pointer found in association " << handle.provenance();
            continue; // this should not happen
          }

          art::Ptr<Dest_t> const& dest = assn.second;

          // if we have changed product (that should be fairly rare),
          // update the running pointers
          if (src.id() != LastProductID) {
            LastProductID = src.id();
            AssnsList = &(cache.AssnCache[LastProductID]);

            // if the list is empty, it means we have just created it!
            if (AssnsList->empty()) {
              // allocate enough space to accomodate all the associations,
              // (provided that source IDs are sequencial);
              // in fact typically all the associations in the same handle
              // have the same product ID
              ResizeToPower2(*AssnsList, handle->size());
            }
          } // if different product ID

          // make sure there is enough room in the vector
          typename art::Ptr<Source_t>::key_type key = src.key();
          if (key >= AssnsList->size()) ResizeToPower2(*AssnsList, key + 1);

          // store the association to dest
          art::Ptr<Dest_t>& dest_cell = (*AssnsList)[key];
          if (dest_cell.isNonnull() && (dest_cell != dest)) {
            throw art::Exception(art::errors::InvalidNumber)
              << "Object Ptr" << src << " is associated with at least two objects: " << dest
              << " and " << dest_cell;
          }
          dest_cell = dest;
          ++count;
        } // for all associations in a list

        MF_LOG_DEBUG("FindAllP") << "Merged " << count << " associations from "
                                 << handle.provenance();
        return count;
      } // FindAllP::Merge()

template<typename Source , typename Dest >

auto lar::util::details::FindAllP< Source, Dest >::operator[]

(

art::Ptr< Dest_t > const &

src

)

const

Returns the object associated to the specified one.

Parameters

src	a art pointer to the source object

Returns

a pointer to the associated object, or a null pointer if none

Definition at line 213 of file FindAllP.h.

      {
        // we expect a missing match to be exceptional
        try {
          return cache.AssnCache.at(src.id()).at(src.key());
        }
        catch (std::out_of_range) {
          return {};
        }
      } // FindAllP<>::operator[]

template<typename Source , typename Dest >

unsigned int lar::util::details::FindAllP< Source, Dest >::Read

(

art::Event &

event

)

Reads all the associations from the event.

Exceptions

art::Exception

if multiple dest objects are found for one source object

Definition at line 238 of file FindAllP.h.

References MF_LOG_DEBUG.

      {

        // read all the associations between source and destination class types
        //std::vector<art::Handle<Assns_t>> assns_list;
        //event.getManyByType(assns_list);
        auto assns_list = event.getMany<Assns_t>();

        MF_LOG_DEBUG("FindAllP") << "Read(): read " << assns_list.size() << " association sets";

        unsigned int count = 0;
        // parse all the associations, and translate them into a local cache
        for (art::Handle<Assns_t> handle : assns_list)
          count += Merge(handle);

        MF_LOG_DEBUG("FindAllP") << "Read " << count << " associations for " << cache.NProductIDs()
                                 << " product IDs";

        return count;
      } // FindAllP::Read(Event)

template<typename Source , typename Dest >

unsigned int lar::util::details::FindAllP< Source, Dest >::Read	(	art::Event &	event,
		art::InputTag const &	assnTag
	)

Reads the specified association from the event.

Parameters

event	the event to read the associations from
assnTag	the input tag for the association

Exceptions

art::Exception

if multiple dest objects are found for one source object

The input tag for the association is usually simply a string with the name of the module that produced the association, and often the same module has also produced the source objects as well.

Definition at line 260 of file FindAllP.h.

      {
        cache.clear();
        return Add(event, assnTag);
      } // FindAllP::Read(Event, InputTag)

Member Data Documentation

template<typename Source , typename Dest >

Cache_t lar::util::details::FindAllP< Source, Dest >::cache

protected

set of associations, keyed by product ID and key

Definition at line 180 of file FindAllP.h.

---

The documentation for this class was generated from the following file:

• lardata/v09_16_03/source/lardata/ArtDataHelper/FindAllP.h