art::Assns< L, R, void > Class Template Reference

#include <Assns.h>

Inheritance diagram for art::Assns< L, R, void >:

Public Types
using	left_t = L

using	right_t = R

using	partner_t = art::Assns< right_t, left_t, void >

using	assn_t = typename ptrs_t::value_type

using	const_iterator = typename ptrs_t::const_iterator

using	size_type = typename ptrs_t::size_type

Public Member Functions
	Assns ()

	Assns (partner_t const &other)

virtual	~Assns ()=default

const_iterator	begin () const

const_iterator	end () const

assn_t const &	operator[] (size_type index) const

assn_t const &	at (size_type index) const

size_type	size () const

std::string	className () const

void	addSingle (Ptr< left_t > const &left, Ptr< right_t > const &right)

template<typename Ls >
void	addMany (Ls const &lefts, Ptr< right_t > const &right)

template<typename Rs >
void	addMany (Ptr< left_t > const &left, Rs const &rights)

void	swap (art::Assns< L, R, void > &other)

std::unique_ptr< EDProduct >	makePartner (std::type_info const &wanted_wrapper_type) const

void	aggregate (Assns const &) const

Public Member Functions inherited from art::detail::AssnsBase
virtual	~AssnsBase () noexcept=default

Static Public Member Functions
static short	Class_Version ()

Protected Member Functions
virtual void	swap_ (art::Assns< L, R, void > &other)

virtual std::unique_ptr< EDProduct >	makePartner_ (std::type_info const &wanted_wrapper_type) const

Private Types
using	ptrs_t = std::vector< std::pair< Ptr< left_t >, Ptr< right_t >>>

using	ptr_data_t = std::vector< std::pair< RefCore, std::size_t >>

Private Member Functions
virtual bool	left_first () const

void	fill_transients () override

void	fill_from_transients () override

Private Attributes
ptrs_t	ptrs_ {}

ptr_data_t	ptr_data_1_ {}
	transient More...

ptr_data_t	ptr_data_2_ {}

Friends
class	detail::AssnsStreamer

class	art::Assns< right_t, left_t, void >

Detailed Description

template<typename L, typename R>
class art::Assns< L, R, void >

Definition at line 123 of file Assns.h.

Member Typedef Documentation

template<typename L , typename R >

using art::Assns< L, R, void >::assn_t = typename ptrs_t::value_type

Definition at line 134 of file Assns.h.

template<typename L , typename R >

using art::Assns< L, R, void >::const_iterator = typename ptrs_t::const_iterator

Definition at line 135 of file Assns.h.

template<typename L , typename R >

using art::Assns< L, R, void >::left_t = L

Definition at line 125 of file Assns.h.

template<typename L , typename R >

using art::Assns< L, R, void >::partner_t = art::Assns<right_t, left_t, void>

Definition at line 127 of file Assns.h.

template<typename L , typename R >

using art::Assns< L, R, void >::ptr_data_t = std::vector<std::pair<RefCore, std::size_t>>

private

Definition at line 131 of file Assns.h.

template<typename L , typename R >

using art::Assns< L, R, void >::ptrs_t = std::vector<std::pair<Ptr<left_t>, Ptr<right_t>>>

private

Definition at line 130 of file Assns.h.

template<typename L , typename R >

using art::Assns< L, R, void >::right_t = R

Definition at line 126 of file Assns.h.

template<typename L , typename R >

using art::Assns< L, R, void >::size_type = typename ptrs_t::size_type

Definition at line 137 of file Assns.h.

Constructor & Destructor Documentation

template<typename L , typename R >

art::Assns< L, R, void >::Assns ( )

inline

Definition at line 299 of file Assns.h.

300 {}

template<typename L , typename R >

art::Assns< L, R, void >::Assns ( partner_t const & other )

inline

Definition at line 303 of file Assns.h.

 {
   ptrs_.reserve(other.ptrs_.size());
   cet::transform_all(
     other.ptrs_, std::back_inserter(ptrs_), [](auto const& pr) {
       using pr_t = typename ptrs_t::value_type;
       return pr_t{pr.second, pr.first};
     });
 }

template<typename L , typename R >

virtual art::Assns< L, R, void >::~Assns ( )

virtualdefault

Member Function Documentation

template<typename L , typename R >

template<typename Ls >

void art::Assns< L, R, void >::addMany	(	Ls const &	lefts,
		Ptr< right_t > const &	right
	)

inline

Definition at line 367 of file Assns.h.

 {
   static_assert(std::is_same_v<typename Ls::value_type, art::Ptr<L>>,
                 "\n\nart error: The first argument must be a container whose "
                 "value_type is art::Ptr<L>\n"
                 "           corresponding to an Assns<L, R(, D)> object.\n");
   for (auto const& left : lefts) {
     addSingle(left, right);
   }
 }

template<typename L , typename R >

template<typename Rs >

void art::Assns< L, R, void >::addMany	(	Ptr< left_t > const &	left,
		Rs const &	rights
	)

inline

Definition at line 381 of file Assns.h.

 {
   static_assert(std::is_same_v<typename Rs::value_type, art::Ptr<R>>,
                 "\n\nart error: The second argument must be a container whose "
                 "value_type is art::Ptr<R>\n"
                 "           corresponding to an Assns<L, R(, D)> object.\n");
   for (auto const& right : rights) {
     addSingle(left, right);
   }
 }

template<typename L , typename R >

void art::Assns< L, R, void >::addSingle	(	Ptr< left_t > const &	left,
		Ptr< right_t > const &	right
	)

inline

Definition at line 358 of file Assns.h.

 {
   ptrs_.emplace_back(left, right);
 }

template<typename L , typename R >

void art::Assns< L, R, void >::aggregate ( Assns< L, R, void > const & ) const

inline

Definition at line 173 of file Assns.h.

174 {}

template<typename L , typename R >

art::Assns< L, R, void >::assn_t const & art::Assns< L, R, void >::at ( size_type index ) const

inline

Definition at line 336 of file Assns.h.

 {
   return ptrs_.at(index);
 }

template<typename L , typename R >

art::Assns< L, R, void >::const_iterator art::Assns< L, R, void >::begin ( ) const

inline

Definition at line 315 of file Assns.h.

 {
   return ptrs_.begin();
 }

template<typename L , typename R >

static short art::Assns< L, R, void >::Class_Version ( )

inlinestatic

Definition at line 167 of file Assns.h.

   {
     return 11;
   }

template<typename L , typename R >

std::string art::Assns< L, R, void >::className ( ) const

inline

Definition at line 350 of file Assns.h.

 {
   TypeID const assns_type{typeid(Assns<L, R, void>)};
   return assns_type.className();
 }

template<typename L , typename R >

art::Assns< L, R, void >::const_iterator art::Assns< L, R, void >::end ( ) const

inline

Definition at line 322 of file Assns.h.

 {
   return ptrs_.end();
 }

template<typename L , typename R >

void art::Assns< L, R, void >::fill_from_transients ( )

overrideprivatevirtual

Implements art::detail::AssnsBase.

Definition at line 462 of file Assns.h.

 {
   if (!ptr_data_1_.empty()) {
     assert(ptr_data_1_.size() == ptr_data_2_.size() &&
            ptr_data_2_.size() == ptrs_.size() &&
            "Assns: internal inconsistency between transient and persistent "
            "member data.");
     // Multiple output modules: nothing to do on second and subsequent
     // calls.
     return;
   }
   ptr_data_t& l_ref = left_first() ? ptr_data_1_ : ptr_data_2_;
   ptr_data_t& r_ref = left_first() ? ptr_data_2_ : ptr_data_1_;
   l_ref.reserve(ptrs_.size());
   r_ref.reserve(ptrs_.size());
   for (auto const& pr : ptrs_) {
     l_ref.emplace_back(pr.first.refCore(), pr.first.key());
     r_ref.emplace_back(pr.second.refCore(), pr.second.key());
   }
 }

template<typename L , typename R >

void art::Assns< L, R, void >::fill_transients ( )

overrideprivatevirtual

Implements art::detail::AssnsBase.

Definition at line 440 of file Assns.h.

 {
   // Precondition: ptr_data_1_.size() = ptr_data_2_.size();
   ptrs_.clear();
   ptrs_.reserve(ptr_data_1_.size());
   ptr_data_t const& l_ref = left_first() ? ptr_data_1_ : ptr_data_2_;
   ptr_data_t const& r_ref = left_first() ? ptr_data_2_ : ptr_data_1_;
 
   for (auto l = cbegin(l_ref), e = cend(l_ref), r = cbegin(r_ref); l != e;
        ++l, ++r) {
     ptrs_.emplace_back(
       Ptr<left_t>{l->first.id(), l->second, l->first.productGetter()},
       Ptr<right_t>{r->first.id(), r->second, r->first.productGetter()});
   }
   // Empty persistent representation.
   ptr_data_t tmp1, tmp2;
   ptr_data_1_.swap(tmp1);
   ptr_data_2_.swap(tmp2);
 }

template<typename L , typename R >

bool art::Assns< L, R, void >::left_first ( ) const

inlineprivatevirtual

Definition at line 431 of file Assns.h.

 {
   static bool const lf_s = (art::TypeID{typeid(left_t)}.friendlyClassName() <
                             art::TypeID{typeid(right_t)}.friendlyClassName());
   return lf_s;
 }

template<typename L , typename R >

std::unique_ptr< art::EDProduct > art::Assns< L, R, void >::makePartner ( std::type_info const & wanted_wrapper_type ) const

inline

Definition at line 401 of file Assns.h.

 {
   return makePartner_(wanted_wrapper_type);
 }

template<typename L , typename R >

std::unique_ptr< art::EDProduct > art::Assns< L, R, void >::makePartner_ ( std::type_info const & wanted_wrapper_type ) const

protectedvirtual

Definition at line 419 of file Assns.h.

 {
   if (wanted_wrapper_type != typeid(Wrapper<partner_t>)) {
     detail::throwPartnerException(typeid(*this), wanted_wrapper_type);
   }
   return std::make_unique<Wrapper<partner_t>>(
     std::make_unique<partner_t>(*this));
 }

template<typename L , typename R >

art::Assns< L, R, void >::assn_t const & art::Assns< L, R, void >::operator[] ( size_type index ) const

inline

Definition at line 329 of file Assns.h.

 {
   return ptrs_[index];
 }

template<typename L , typename R >

art::Assns< L, R, void >::size_type art::Assns< L, R, void >::size ( ) const

inline

Definition at line 343 of file Assns.h.

 {
   return ptrs_.size();
 }

template<typename L , typename R >

void art::Assns< L, R, void >::swap ( art::Assns< L, R, void > & other )

inline

Definition at line 394 of file Assns.h.

 {
   swap_(other);
 }

template<typename L , typename R >

void art::Assns< L, R, void >::swap_ ( art::Assns< L, R, void > & other )

inlineprotectedvirtual

Definition at line 409 of file Assns.h.

 {
   using std::swap;
   swap(ptrs_, other.ptrs_);
   swap(ptr_data_1_, other.ptr_data_1_);
   swap(ptr_data_2_, other.ptr_data_2_);
 }

Friends And Related Function Documentation

template<typename L , typename R >

friend class art::Assns< right_t, left_t, void >

friend

Definition at line 184 of file Assns.h.

template<typename L , typename R >

friend class detail::AssnsStreamer

friend

Definition at line 183 of file Assns.h.

Member Data Documentation

template<typename L , typename R >

ptr_data_t art::Assns< L, R, void >::ptr_data_1_ {}

private

transient

Definition at line 207 of file Assns.h.

template<typename L , typename R >

ptr_data_t art::Assns< L, R, void >::ptr_data_2_ {}

private

Definition at line 208 of file Assns.h.

template<typename L , typename R >

ptrs_t art::Assns< L, R, void >::ptrs_ {}

private

Definition at line 206 of file Assns.h.

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

canvas/canvas/Persistency/Common/Assns.h