xAOD::detail Namespace Reference

Internal implementation details and type concepts for container merging. More...

Concepts
concept	AuxContainerConcept
	Define that the templated class needs to inherit from the AuxContainerBase class.
concept	DataVectorConcept
	Define a data vector.
concept	isMuonMeasurement
	Concept that verifies a type is derived from xAOD::MuonMeasurement.
concept	isMuonMeasurementCont
	Concept that verifies a type is a valid MuonMeasurement container.
concept	PrimaryContainerConcept
	Define the primary container.

Functions
template<class T>
std::pair< std::unique_ptr< T >, std::unique_ptr< ShallowAuxContainer > >	shallowCopyContainerImpl (const T &cont, DataLink< SG::IConstAuxStore > &link)
	Impl function for shallow copy container.
template<class VARTYPE, class AUXBASE>
VARTYPE	initAuxVar2 (AUXBASE *auxcont, std::true_type)
template<class VARTYPE, class AUXBASE>
VARTYPE	initAuxVar2 (AUXBASE *, std::false_type)
template<class VARTYPE, class AUXBASE>
VARTYPE	initAuxVar1 (AUXBASE *auxcont)
template<const char * NAME, class AUXBASE, class VARTYPE>
VARTYPE	initAuxVar (AUXBASE *auxcont, VARTYPE &var, SG::AuxVarFlags flags=SG::AuxVarFlags::None)
template<class ELT, const char * NAME, class AUXBASE, class LINKS, class LINKED>
LINKED	initLinkedVar (AUXBASE *auxcont, LINKS &links, LINKED &linked)

Detailed Description

Internal implementation details and type concepts for container merging.

Auxiliary class to create a xAOD container together with its associated AuxContainer without manually instantiating the corresponding pointers.

Further, methods are provided to write the container to store gate using a passed WriteHandle key object

Function Documentation

initAuxVar()

template<const char * NAME, class AUXBASE, class VARTYPE>

VARTYPE xAOD::detail::initAuxVar	(	AUXBASE *	auxcont,
		VARTYPE &	var,
		SG::AuxVarFlags	flags = SG::AuxVarFlags::None )

Definition at line 82 of file AuxVariable.h.

{
  static const SG::auxid_t auxid = auxcont->getAuxID( NAME, var, flags );
  auxcont->regAuxVar (auxid, NAME, var);
  return initAuxVar1<VARTYPE>( auxcont );
}

initAuxVar1()

template<class VARTYPE, class AUXBASE>

VARTYPE xAOD::detail::initAuxVar1

(

AUXBASE *

auxcont

)

Definition at line 75 of file AuxVariable.h.

{
  return initAuxVar2<VARTYPE> ( auxcont, std::is_constructible<VARTYPE, std::pmr::memory_resource*>() );
}

initAuxVar2() [1/2]

template<class VARTYPE, class AUXBASE>

VARTYPE xAOD::detail::initAuxVar2	(	AUXBASE *	,
		std::false_type	)

Definition at line 67 of file AuxVariable.h.

{
  return VARTYPE();
}

initAuxVar2() [2/2]

template<class VARTYPE, class AUXBASE>

VARTYPE xAOD::detail::initAuxVar2	(	AUXBASE *	auxcont,
		std::true_type	)

Definition at line 59 of file AuxVariable.h.

{
  return VARTYPE (auxcont->memResource());
}

initLinkedVar()

template<class ELT, const char * NAME, class AUXBASE, class LINKS, class LINKED>

LINKED xAOD::detail::initLinkedVar	(	AUXBASE *	auxcont,
		LINKS &	links,
		LINKED &	linked )

Definition at line 97 of file AuxVariable.h.

{
  // Use the @c ConstAccessor specialization to get the variable
  // declared properly.
  static const SG::ConstAccessor<ELT> acc( NAME );
  auxcont->regAuxVar( acc.linkedAuxid(), SG::AuxTypeRegistry::linkedName (NAME), linked );
  auxcont->regAuxVar( acc.auxid(), NAME, links );
  return xAOD::detail::initAuxVar1<LINKED>( auxcont );
}

shallowCopyContainerImpl()

template<class T>

std::pair< std::unique_ptr< T >, std::unique_ptr< ShallowAuxContainer > > xAOD::detail::shallowCopyContainerImpl	(	const T &	cont,
		DataLink< SG::IConstAuxStore > &	link )

Impl function for shallow copy container.

Parameters

cont	The container to make a shallow copy of
ctx	The currentEventContext

Returns

A pair of unique_ptr to the created objects.

Definition at line 145 of file ShallowCopy.h.

                                                            {
 
    if (!link.cptr()) {
      // This can happen when we read the input file in standalone
      // mode in branch access mode. That's unfortunately not
      // compatible with using a shallow copy auxiliary store.
      std::cout << "xAOD::shallowCopyContainer ERROR Couldn't set up "
                << "DataLink to the original container's auxiliary store"
                << std::endl;
      std::cout << "xAOD::shallowCopyContainer ERROR Are you using the "
                << "xAOD::TEvent::kBranchAccess access mode?" << std::endl;
      return {};
    }
 
    // Create the new DV container:
    auto newCont = std::make_unique<T>();
 
    // Add the required number of elements to it:
    newCont->reserve(cont.size());
    for (size_t i = 0; i < cont.size(); ++i) {
      newCont->push_back(prepareElementForShallowCopy(cont[i]));
    }
 
    // Create a new shallow auxiliary container:
    auto aux = std::make_unique<ShallowAuxContainer>(link);
 
    // Connect it to the interface container:
    newCont->setStore(aux.get());
 
    // Return the new objects:
    return std::make_pair(std::move(newCont), std::move(aux));
  }