xAOD::detail Namespace Reference

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

Concepts
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	AuxContainerConcept
	Define that the templated class needs to inherit from the AuxContainerBase class.
concept	DataVectorConcept
	Define a data vector.
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));
  }