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

#include <Assns.h>

Public Types
using	left_t = typename base::left_t
using	right_t = typename base::right_t
using	data_t = D
using	partner_t = art::Assns< right_t, left_t, data_t >
using	const_iterator = typename art::const_AssnsIter< L, R, D, Direction::Forward >
using	const_reverse_iterator = typename art::const_AssnsIter< L, R, D, Direction::Reverse >
using	size_type = typename base::size_type

Public Member Functions
	Assns ()
	Assns (partner_t const &other)
size_type	size () const
const_iterator	begin () const
const_iterator	end () const
const_reverse_iterator	rbegin () const
const_reverse_iterator	rend () const
data_t const &	data (typename std::vector< data_t >::size_type index) const
data_t const &	data (const_iterator it) const
void	addSingle (Ptr< left_t > const &left, Ptr< right_t > const &right, data_t const &data)
template<typename Ls , typename Ds >
void	addMany (Ls const &lefts, Ptr< right_t > const &right, Ds const &data)
template<typename Rs , typename Ds >
void	addMany (Ptr< left_t > const &left, Rs const &rights, Ds const &data)
void	swap (art::Assns< L, R, D > &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 ()

Private Types
using	base = Assns< L, R >

Private Member Functions
void	swap_ (art::Assns< L, R, void > &other) override
std::unique_ptr< EDProduct >	makePartner_ (std::type_info const &wanted_wrapper_type) const override

Private Attributes
std::vector< data_t >	data_

Friends
class	art::Assns< right_t, left_t, data_t >

Detailed Description

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

Definition at line 102 of file Assns.h.

Member Typedef Documentation

template<typename L, typename R, typename D>

using art::Assns< L, R, D >::base = Assns<L, R>

private

Definition at line 217 of file Assns.h.

template<typename L, typename R, typename D>

using art::Assns< L, R, D >::const_iterator = typename art::const_AssnsIter<L, R, D, Direction::Forward>

Definition at line 237 of file Assns.h.

template<typename L, typename R, typename D>

using art::Assns< L, R, D >::const_reverse_iterator = typename art::const_AssnsIter<L, R, D, Direction::Reverse>

Definition at line 239 of file Assns.h.

template<typename L, typename R, typename D>

using art::Assns< L, R, D >::data_t = D

Definition at line 234 of file Assns.h.

template<typename L, typename R, typename D>

using art::Assns< L, R, D >::left_t = typename base::left_t

Definition at line 232 of file Assns.h.

template<typename L, typename R, typename D>

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

Definition at line 235 of file Assns.h.

template<typename L, typename R, typename D>

using art::Assns< L, R, D >::right_t = typename base::right_t

Definition at line 233 of file Assns.h.

template<typename L, typename R, typename D>

using art::Assns< L, R, D >::size_type = typename base::size_type

Definition at line 240 of file Assns.h.

Constructor & Destructor Documentation

template<typename L , typename R , typename D >

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

inline

Definition at line 484 of file Assns.h.

{
  static_assert(!std::is_pointer_v<D>,
                "Data template argument must not be pointer type!");
}

template<typename L , typename R , typename D >

art::Assns< L, R, D >::Assns

(

partner_t const &

other

)

Definition at line 491 of file Assns.h.

  : base(other), data_(other.data_)
{}

Member Function Documentation

template<typename L , typename R , typename D >

template<typename Ls , typename Ds >

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

inline

Definition at line 557 of file Assns.h.

{
  static_assert(std::is_same_v<typename Ds::value_type, D>,
                "\n\nart error: The data argument must be a container whose "
                "value_type is D corresponding\n"
                "           to an Assns<L, R, D> object.\n");
  assert(lefts.size() == data.size());
  base::addMany(lefts, right);
  data_.insert(data_.end(), data.begin(), data.end());
}

template<typename L , typename R , typename D >

template<typename Rs , typename Ds >

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

Definition at line 573 of file Assns.h.

{
  static_assert(std::is_same_v<typename Ds::value_type, D>,
                "\n\nart error: The data argument must be a container whose "
                "value_type is D corresponding\n"
                "           to an Assns<L, R, D> object.\n");
  assert(rights.size() == data.size());
  base::addMany(left, rights);
  data_.insert(data_.end(), data.begin(), data.end());
}

template<typename L , typename R , typename D >

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

inline

Definition at line 546 of file Assns.h.

{
  base::addSingle(left, right);
  data_.push_back(data);
}

template<typename L, typename R, typename D>

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

inline

Definition at line 282 of file Assns.h.

  {}

template<typename L , typename R , typename D >

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

inline

Definition at line 504 of file Assns.h.

{
  return const_iterator{*this, 0};
}

template<typename L, typename R, typename D>

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

inlinestatic

Definition at line 276 of file Assns.h.

  {
    return 11;
  }

template<typename L , typename R , typename D >

art::Assns< L, R, D >::data_t const & art::Assns< L, R, D >::data ( typename std::vector< data_t >::size_type  index ) const

inline

Definition at line 532 of file Assns.h.

{
  return data_.at(index);
}

template<typename L , typename R , typename D >

art::Assns< L, R, D >::data_t const & art::Assns< L, R, D >::data ( const_iterator  it ) const

inline

Definition at line 539 of file Assns.h.

{
  return data_.at(it.getIndex());
}

template<typename L , typename R , typename D >

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

inline

Definition at line 511 of file Assns.h.

{
  return const_iterator{*this};
}

template<typename L , typename R , typename D >

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

inline

Definition at line 597 of file Assns.h.

{
  return makePartner_(wanted_wrapper_type);
}

template<typename L , typename R , typename D >

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

overrideprivate

Definition at line 618 of file Assns.h.

{
  using bp = typename base::partner_t;
  std::unique_ptr<art::EDProduct> result;
  if (wanted_wrapper_type == typeid(Wrapper<partner_t>)) { // Partner.
    result =
      std::make_unique<Wrapper<partner_t>>(std::make_unique<partner_t>(*this));
  } else if (wanted_wrapper_type == typeid(Wrapper<base>)) { // Base.
    result = std::make_unique<Wrapper<base>>(
      std::make_unique<base>(static_cast<base>(*this)));
  } else if (wanted_wrapper_type == typeid(Wrapper<bp>)) { // Base of partner.
    result = std::make_unique<Wrapper<bp>>(
      std::make_unique<bp>(static_cast<base>(*this)));
  } else { // Oops.
    detail::throwPartnerException(typeid(*this), wanted_wrapper_type);
  }
  return result;
}

template<typename L , typename R , typename D >

art::Assns< L, R, D >::const_reverse_iterator art::Assns< L, R, D >::rbegin ( ) const

inline

Definition at line 518 of file Assns.h.

{
  return const_reverse_iterator{*this, size()};
}

template<typename L , typename R , typename D >

art::Assns< L, R, D >::const_reverse_iterator art::Assns< L, R, D >::rend ( ) const

inline

Definition at line 525 of file Assns.h.

{
  return const_reverse_iterator{*this, 0};
}

template<typename L , typename R , typename D >

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

inline

Definition at line 497 of file Assns.h.

{
  return base::size();
}

template<typename L, typename R, typename D>

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

inline

Definition at line 588 of file Assns.h.

{
  using std::swap;
  base::swap_(other);
  swap(data_, other.data_);
}

template<typename L, typename R, typename D >

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

inlineoverrideprivate

Definition at line 605 of file Assns.h.

{
  try {
    swap(dynamic_cast<Assns<L, R, D>&>(other));
  }
  catch (std::bad_cast const&) {
    throw Exception(errors::LogicError, "AssnsBadCast")
      << "Attempt to swap base with derived!\n";
  }
}

Friends And Related Function Documentation

template<typename L, typename R, typename D>

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

friend

Definition at line 286 of file Assns.h.

Member Data Documentation

template<typename L, typename R, typename D>

std::vector<data_t> art::Assns< L, R, D >::data_

private

Definition at line 292 of file Assns.h.

---

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

• canvas/canvas/Persistency/Common/Assns.h