#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

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 124 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 135 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 136 of file Assns.h.

template<typename L , typename R >

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

Definition at line 126 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 128 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 132 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 131 of file Assns.h.

template<typename L , typename R >

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

Definition at line 127 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 138 of file Assns.h.

Constructor & Destructor Documentation

template<typename L , typename R >

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

inline

Definition at line 302 of file Assns.h.

303 {}

template<typename L , typename R >

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

inline

Definition at line 306 of file Assns.h.

References art::Assns< L, R, D >::size().

 {
   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 370 of file Assns.h.

References art::Assns< L, R, D >::addSingle(), and art::left().

 {
   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 384 of file Assns.h.

References art::Assns< L, R, D >::addSingle(), and art::right().

 {
   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 361 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 174 of file Assns.h.

References fhicl::other.

175 {}

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 339 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 318 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 168 of file Assns.h.

   {
     return 11;
   }

template<typename L , typename R >

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

inline

Definition at line 353 of file Assns.h.

References art::TypeID::className().

 {
   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 ( void ) const

inline

Definition at line 325 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 465 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 443 of file Assns.h.

References util::cbegin(), util::cend(), e, art::Ptr< T >::id(), r, and art::Assns< L, R, D >::swap().

 {
   // 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 434 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 404 of file Assns.h.

References art::Assns< L, R, D >::makePartner_().

 {
   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 422 of file Assns.h.

References art::detail::throwPartnerException().

 {
   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 332 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 ( void ) const

inline

Definition at line 346 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 397 of file Assns.h.

References art::Assns< L, R, D >::swap_().

 {
   swap_(other);
 }

template<typename L , typename R >

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

inlineprotectedvirtual

Definition at line 412 of file Assns.h.

References ptr_data_1_, ptr_data_2_, ptrs_, and art::swap().

 {
   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 185 of file Assns.h.

template<typename L , typename R >

friend class detail::AssnsStreamer

friend

Definition at line 184 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 209 of file Assns.h.

Referenced by swap_().

template<typename L , typename R >

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

private

Definition at line 210 of file Assns.h.

Referenced by swap_().

template<typename L , typename R >

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

private

Definition at line 208 of file Assns.h.

Referenced by swap_().

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

canvas/Persistency/Common/Assns.h

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

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

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

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