HLTNavDetails::HolderImp< STORED, CONTAINER > Class Template Reference

This is an implementation class for all Holders It is templated with 2 arguments STORED which is type of stored objects Another type is CONTAINER for that type. More...

#include <Holder.h>

Inheritance diagram for HLTNavDetails::HolderImp< STORED, CONTAINER >:

Collaboration diagram for HLTNavDetails::HolderImp< STORED, CONTAINER >:

Classes
struct	MemoryMgr

Public Types
typedef Holder< STORED >	base_type
typedef STORED	stored_type
typedef CONTAINER	container_type
typedef HLTNavDetails::TypeProxy< STORED >	FeatureProxy
typedef HLTNavDetails::TypeProxy< CONTAINER >	ContainerProxy
typedef std::multimap< HLT::TriggerElement::ObjectIndex, MemoryMgr >	MemoryMgrMap

Public Member Functions
	HolderImp ()
	HolderImp (const std::string &prefix, const std::string &label, uint16_t idx)
virtual	~HolderImp ()
virtual IHolder *	clone (const std::string &prefix, const std::string &label, uint16_t idx) const
virtual HLT::TriggerElement::ObjectIndex	add (const STORED *f, bool inSG=false, const std::string &="")
	adds object(s) to be holded
virtual bool	get (const STORED *&dest, HLT::TriggerElement::ObjectIndex idx)
	gets object(s) holded
virtual bool	contains (const STORED *obj, HLT::TriggerElement::ObjectIndex &idx)
	check if object(s) in dest are held by this holder
bool	getElementLinks (ElementLinkVector< CONTAINER > &cont, HLT::TriggerElement::ObjectIndex idx)
bool	getElementLinks (ElementLinkVector< CONTAINER > &cont)
bool	getWithLink (typename set_link< STORED, CONTAINER, std::is_same< STORED, CONTAINER >::value >::type &link, HLT::TriggerElement::ObjectIndex &idx)
virtual std::string	getUniqueKey ()
virtual std::string	getNextKey ()
virtual void	prepare (const asg::AsgMessaging &logger, HLT::AccessProxy *sg, IConversionSvc *objSerializer, bool readonly=false)
	prepares this holder by setting messaging, StoreGate access and providing serializer
virtual bool	syncWithSG (SG::OwnershipPolicy policy=SG::OWN_ELEMENTS)
virtual bool	checkAndSetOwnership (SG::OwnershipPolicy policy)
virtual bool	serialize (std::vector< uint32_t > &output) const
	serializes this Holder
virtual const std::string &	key () const
	returns the containers StoreGate key
virtual void	print (MsgStream &m) const
virtual DataObject *	getDataObject ()
virtual DataObject *	getAuxDataObject ()
virtual bool	setDataObject (DataObject *dobj)
virtual bool	setAuxDataObject (DataObject *dobjaux)
virtual CLID	typeClid () const
	returns the CLID of objects stores by this holder
virtual const std::string &	typeName () const
	returns the object's name stored by this holder
virtual CLID	containerClid () const
virtual const std::string &	collectionName () const
	returns the collection's name stored by this holder
virtual CLID	auxClidOrZero () const
virtual const ITypeProxy &	containerTypeProxy () const
	Get the proxy for the container.
virtual HLT::TriggerElement::ObjectIndex add	ATLAS_NOT_THREAD_SAFE (const STORED *f, bool inSG, const std::string &="")=0
	saved object in this holder
template<class CONTAINER2>
bool	get (ElementLinkVector< CONTAINER2 > &cont)
template<class CONTAINER2>
bool	get (ElementLinkVector< CONTAINER2 > &cont, HLT::TriggerElement::ObjectIndex idx)
template<class CONTAINER2>
bool	getWithLink (typename set_link< STORED, CONTAINER2, std::is_same< STORED, CONTAINER2 >::value >::type &link, HLT::TriggerElement::ObjectIndex &idx)
const std::string &	label () const
	returns the label of objects stores by this holder
virtual const std::string &	prefix () const
	returns the containers StoreGate prefix
uint16_t	subTypeIndex () const
	returns the index (short number used when linking object to the TE) of objects stores by this holder
std::string	generateAliasKey (CLID c, uint16_t sti, const std::string &label, unsigned size)
bool	serializeWithPayload (const xAOD::AuxSelection &sel, std::vector< uint32_t > &output, size_t &payloadsize)
	serializes this Holder including payload
bool	serializePayload (std::vector< uint32_t > &dataBlob, const xAOD::AuxSelection &sel)
	serializes the payload of this Holder
bool	deserializePayload (const std::vector< uint32_t > &dataBlob, int version)
	deserialization of holder payload

Static Public Member Functions
static bool	enquireSerialized (std::vector< uint32_t >::const_iterator &fromHere, const std::vector< uint32_t >::const_iterator &end, class_id_type &c, std::string &label, sub_index_type &subtypeIndex)

Public Attributes
ContainerProxy	m_containerProxy
MemoryMgrMap	m_memMgr

Protected Member Functions
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Attributes
const asg::AsgMessaging *	m_logger {0}
IConversionSvc *	m_objectserializerSvc {0}
	pointer to object serializer
HLT::AccessProxy *	m_storeGate {0}
	pointer to SG
bool	m_readonly {false}
ITypeProxy *	m_aux {0}

Private Member Functions
bool	serializeDynVars (const SG::IAuxStoreIO &iio, const xAOD::AuxSelection &sel, std::vector< uint32_t > &dataBlob)
	Serialize all selected dynamic variables for an xAOD object.
bool	deserializeDynVars (const std::vector< uint32_t > &dataBlob, size_t offs, SG::IAuxStore &store)
	Read dynamic auxiliary variables from a serialized buffer.
std::unique_ptr< SG::IAuxStore >	deserializeDynVars (const std::vector< uint32_t > &dataBlob, size_t offs)
	Read dynamic auxiliary variables from a serialized buffer.
const std::type_info *	getElementType (const std::string &tname, std::string &elementTypeName) const
	Find the type of an element of a vector.

Private Attributes
std::string	m_key
std::string	m_prefix
	prefix for key given to the objects
std::string	m_label
	label given to the objects in this holder (labels given at attachFeature)
uint16_t	m_subTypeIndex {0}
	index to notify how many objects of given type we have (we need to record it in case of slimming will be done latter)
int	m_uniqueCounter {0}
ToolHandle< ITrigSerializerToolBase >	m_serializer
	Serializer tool; used for dynamic variables.

Detailed Description

template<class STORED, class CONTAINER>
class HLTNavDetails::HolderImp< STORED, CONTAINER >

This is an implementation class for all Holders It is templated with 2 arguments STORED which is type of stored objects Another type is CONTAINER for that type.

Examples when it works are: HolderImp<A, DataVector > — typical HolderImp< A, Acontainer> > — as above, Acontainer is either typedef for DataVector or inherits from it HolderImp< DataVector, DataVector > — when both are of the same type HolderImp< Acontainer, Acontainer> > — as above

Definition at line 328 of file Holder.h.

Member Typedef Documentation

base_type

template<class STORED, class CONTAINER>

typedef Holder<STORED> HLTNavDetails::HolderImp< STORED, CONTAINER >::base_type

Definition at line 330 of file Holder.h.

container_type

template<class STORED, class CONTAINER>

typedef CONTAINER HLTNavDetails::HolderImp< STORED, CONTAINER >::container_type

Definition at line 332 of file Holder.h.

ContainerProxy

template<class STORED, class CONTAINER>

typedef HLTNavDetails::TypeProxy<CONTAINER> HLTNavDetails::HolderImp< STORED, CONTAINER >::ContainerProxy

Definition at line 334 of file Holder.h.

FeatureProxy

template<class STORED, class CONTAINER>

typedef HLTNavDetails::TypeProxy<STORED> HLTNavDetails::HolderImp< STORED, CONTAINER >::FeatureProxy

Definition at line 333 of file Holder.h.

MemoryMgrMap

template<class STORED, class CONTAINER>

typedef std::multimap<HLT::TriggerElement::ObjectIndex, MemoryMgr> HLTNavDetails::HolderImp< STORED, CONTAINER >::MemoryMgrMap

Definition at line 399 of file Holder.h.

stored_type

template<class STORED, class CONTAINER>

typedef STORED HLTNavDetails::HolderImp< STORED, CONTAINER >::stored_type

Definition at line 331 of file Holder.h.

Constructor & Destructor Documentation

HolderImp() [1/2]

template<class STORED, class CONTAINER>

HLTNavDetails::HolderImp< STORED, CONTAINER >::HolderImp

(

)

HolderImp() [2/2]

template<class STORED, class CONTAINER>

HLTNavDetails::HolderImp< STORED, CONTAINER >::HolderImp	(	const std::string &	prefix,
		const std::string &	label,
		uint16_t	idx )

~HolderImp()

template<class STORED, class CONTAINER>

virtual HLTNavDetails::HolderImp< STORED, CONTAINER >::~HolderImp ( )

virtual

Member Function Documentation

add()

template<class STORED, class CONTAINER>

virtual HLT::TriggerElement::ObjectIndex HLTNavDetails::HolderImp< STORED, CONTAINER >::add ( const STORED * f, bool inSG = false, const std::string & = "" )

virtual

adds object(s) to be holded

ATLAS_NOT_THREAD_SAFE()

template<class STORED>

virtual HLT::TriggerElement::ObjectIndex add HLTNavDetails::Holder< STORED >::ATLAS_NOT_THREAD_SAFE ( const STORED * f, bool inSG, const std::string & = "" )

pure virtualinherited

saved object in this holder

auxClidOrZero()

template<class STORED, class CONTAINER>

virtual CLID HLTNavDetails::HolderImp< STORED, CONTAINER >::auxClidOrZero ( ) const

virtual

Implements HLTNavDetails::IHolder.

checkAndSetOwnership()

template<class STORED, class CONTAINER>

virtual bool HLTNavDetails::HolderImp< STORED, CONTAINER >::checkAndSetOwnership ( SG::OwnershipPolicy policy )

virtual

Implements HLTNavDetails::IHolder.

clone()

template<class STORED, class CONTAINER>

virtual IHolder * HLTNavDetails::HolderImp< STORED, CONTAINER >::clone ( const std::string & prefix, const std::string & label, uint16_t idx ) const

virtual

Implements HLTNavDetails::IHolder.

collectionName()

template<class STORED, class CONTAINER>

virtual const std::string & HLTNavDetails::HolderImp< STORED, CONTAINER >::collectionName ( ) const

inlinevirtual

returns the collection's name stored by this holder

Implements HLTNavDetails::IHolder.

Definition at line 383 of file Holder.h.

{ return ClassID_traits<CONTAINER>::typeName(); }

containerClid()

template<class STORED, class CONTAINER>

virtual CLID HLTNavDetails::HolderImp< STORED, CONTAINER >::containerClid ( ) const

inlinevirtual

Implements HLTNavDetails::IHolder.

Definition at line 382 of file Holder.h.

{ return ClassID_traits<CONTAINER>::ID(); }

containerTypeProxy()

template<class STORED, class CONTAINER>

virtual const ITypeProxy & HLTNavDetails::HolderImp< STORED, CONTAINER >::containerTypeProxy ( ) const

inlinevirtual

Get the proxy for the container.

Implements HLTNavDetails::IHolder.

Definition at line 386 of file Holder.h.

{ return m_containerProxy; }

contains()

template<class STORED, class CONTAINER>

virtual bool HLTNavDetails::HolderImp< STORED, CONTAINER >::contains ( const STORED * obj, HLT::TriggerElement::ObjectIndex & idx )

virtual

check if object(s) in dest are held by this holder

Implements HLTNavDetails::Holder< STORED >.

deserializeDynVars() [1/2]

std::unique_ptr< SG::IAuxStore > IHolder::deserializeDynVars ( const std::vector< uint32_t > & dataBlob, size_t offs )

privateinherited

Read dynamic auxiliary variables from a serialized buffer.

Parameters

dataBlob	Serialized data.
offs	Offset in dataBlob where dynamic variables start.
sz	Number of elements in the xAOD container.

dataBlob should be formatted as described in the documentation for serializeDynVars starting at offs. Returns a new dynamic store.

Definition at line 452 of file Holder.cxx.

{
  StringSerializer ss;
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
  // New dynamic store.
  auto store = std::make_unique<HLTNavDetails::TrigAuxStore>();
 
  // Read through the buffer starting at @c offs.
  std::vector<uint32_t>::const_iterator it = dataBlob.begin() + offs;
  while (it < dataBlob.end()) {
    // Read the attribute and type names from the buffer.
    size_t name_size = *it++;
    std::string name;
    ss.deserialize (it, it+name_size, name);
    it += name_size;
 
    size_t tname_size = *it++;
    std::string tname;
    ss.deserialize (it, it+tname_size, tname);
    it += tname_size;
 
    // Object size.
    size_t var_size = *it++;
 
    const static char* const packed_pref = "SG::PackedContainer<";
    const static unsigned int packed_preflen = strlen(packed_pref);
    std::string vecname = tname;
    if (strncmp (vecname.c_str(), packed_pref, packed_preflen) == 0) {
      // Convert from SG::PackedContainer<T> to vector<T>.
      // Also strip out a std::allocator<T> argument, but leave
      // any other allocator.
      auto makeRules = []() {
        CxxUtils::ClassName::Rules rules;
        rules.add ("SG::PackedContainer<$T, std::allocator<$T> >",
                   "vector<$T>");
        rules.add ("SG::PackedContainer<$T, allocator<$T> >",
                   "vector<$T>");
        rules.add ("SG::PackedContainer<$T, $ALLOC>",
                   "vector<$T, $ALLOC>");
        return rules;
      };
      const static CxxUtils::ClassName::Rules rules = makeRules();
      vecname = rules.apply (vecname);
    }
 
    // Handle schema evolution.  If we're expecting a different
    // type for the variable, then use that name instead.
    SG::auxid_t id = r.findAuxID (name);
    if (id != SG::null_auxid && stripStdVec(r.getVecTypeName(id)) != stripStdVec(vecname)) {
      vecname = r.getVecTypeName (id);
      tname = vecname;
    }
 
    // Handle the case where we don't have a registered type for this
    // auxiliary variable.
    if (id == SG::null_auxid)
    {
      std::string elementTypeName;
      const std::type_info* elt_tinfo = getElementType (vecname, elementTypeName);
      if (elt_tinfo)
        id = SG::getDynamicAuxID (*elt_tinfo, name, elementTypeName, tname, false, SG::null_auxid);
      if (id == SG::null_auxid) {
        ATH_MSG_ERROR("deserialize aux dyn var failed; can't find auxid for:" << name);
        return std::unique_ptr<SG::IAuxStore> (std::move(store));
      }
    }
 
    // Read the object from the buffer.
    std::vector<uint32_t> buf (it, it+var_size);
    void* obj = m_serializer->deserialize (tname, buf);
    it += var_size;
 
    bool isPacked = (strncmp (tname.c_str(), packed_pref, packed_preflen) == 0);
    std::unique_ptr<SG::IAuxTypeVector> vec
      (r.makeVectorFromData (id, obj, nullptr, isPacked, true));
    store->addVector (std::move(vec), false);
  }
 
  return std::unique_ptr<SG::IAuxStore> (std::move(store));
}

deserializeDynVars() [2/2]

bool IHolder::deserializeDynVars ( const std::vector< uint32_t > & dataBlob, size_t offs, SG::IAuxStore & store )

privateinherited

Read dynamic auxiliary variables from a serialized buffer.

Parameters

	dataBlob	Serialized data.
	offs	Offset in dataBlob where dynamic variables start.
[out]	store	Auxiliary store for the object being read.

dataBlob should be formatted as described in the documentation for serializeDynVars starting at offs. store should be convertable to IAuxStoreHolder. A new dynamic store will be created and registered with store via setStore.

Returns true on success, false on failure.

Definition at line 405 of file Holder.cxx.

{
  SG::IAuxStoreHolder* holder = dynamic_cast<SG::IAuxStoreHolder*> (&store);
  if (!holder) {
    ATH_MSG_ERROR("deserialize aux dyn vars failed: can't convert to IAuxStoreHolder.");
    return false;
  }
  
  std::unique_ptr<SG::IAuxStore> newstore = deserializeDynVars (dataBlob, offs);
  if (!newstore) return false;
  holder->setStore (newstore.release());
  return true;
}

deserializePayload()

bool HLTNavDetails::IHolder::deserializePayload ( const std::vector< uint32_t > & dataBlob, int version )

inherited

deserialization of holder payload

Definition at line 148 of file Holder.cxx.

                                                                                             {
  const std::string sgkey = key();
  ::HLT::class_id_type feature_clid = typeClid();
  ::HLT::class_id_type container_clid = containerClid();
  const std::string container_typename = collectionName();
 
  if ( m_storeGate->transientContains(container_clid, sgkey) ) {
    ATH_MSG_VERBOSE("deserialize: while working on: " << container_typename << " and key: " << sgkey
                    << " from serialized form found it in SG already, sync with it");
    syncWithSG();
  }
 
  ATH_MSG_VERBOSE("deserializing a data blob of size " << dataBlob.size() << " navi version is " << version);
  ATH_MSG_DEBUG("holder type clid " << feature_clid<< " collection clid: " << container_clid);
 
  if (container_clid<1){
    ATH_MSG_WARNING("holder type clid " << feature_clid << " collection clid: " << container_clid);
  }  
  
  typedef std::vector<uint32_t>::const_iterator it_type;
  it_type it = std::begin(dataBlob);
  
  if(!dataBlob.size()) return false;
 
  std::vector<uint32_t> first, second;
 
  if(version == 4){
    auto firstsize = *(it++);
    ATH_MSG_VERBOSE("first part has size: " << firstsize);
  
    first = std::vector<uint32_t>(it,it+firstsize);
  
    std::advance(it,firstsize);  
  
    if(!(it!=dataBlob.end())){
      ATH_MSG_VERBOSE("this datablob only has a first part (non xAOD case)");
    }
    else{
      auto secondsize = *(it++);
      ATH_MSG_VERBOSE("second part has size: " << secondsize);
      second = std::vector<uint32_t>(it,it+secondsize);
      std::advance(it,secondsize);  
    }
  }
  else{
    first = std::vector<uint32_t>(dataBlob.begin(),dataBlob.end());
  }
 
  TrigStreamAddress addr(container_clid, sgkey, "", 0, 0);
  addr.add(first);
  DataObject* dobj(0);
 
  if (m_objectserializerSvc->createObj(&addr, dobj).isFailure() ){
    ATH_MSG_WARNING("deserialize main: failed");
    return false;
  }
 
  bool setcontainer = setDataObject(dobj);
  if (DataBucketBase* dbb = dynamic_cast<DataBucketBase*> (dobj)) {
    dbb->relinquish();
    delete dbb;
  }
  if(!setcontainer) return false;
 
  DataObject* dobjaux(0);
  if(!second.empty()){
    std::string sgkeyaux = sgkey+"Aux.";
    ATH_MSG_VERBOSE("aux clid was deduced to be: " << auxClidOrZero());
    TrigStreamAddress auxaddr(auxClidOrZero(), sgkeyaux, "", 0, 0);
    auxaddr.add(second);
 
    if (m_objectserializerSvc->createObj(&auxaddr, dobjaux).isFailure() ){
      ATH_MSG_WARNING("Aux Store deserialization failed");
      return false;
    }
 
    // Handle dynamic variables.
    if (it != dataBlob.end()) {
      DataBucketBase* dobjBaseAux = static_cast<DataBucketBase*>(dobjaux);
 
      SG::IAuxStore* istore = nullptr;
      if (xAOD::AuxContainerBase* auxstore =
          dobjBaseAux->template cast<xAOD::AuxContainerBase> (nullptr, false))
      {
        istore = auxstore;
      }
 
      if (!istore || !deserializeDynVars (dataBlob,
                                          it - dataBlob.begin(),
                                          *istore))
      {
        ATH_MSG_WARNING("Aux Store dynamic var deserialization failed");
        return false;
      }
    }
    
    bool setaux = setAuxDataObject(dobjaux);
    if (DataBucketBase* dbb = dynamic_cast<DataBucketBase*> (dobjaux)) {
      dbb->relinquish();
      delete dbb;
    }
    if(!setaux) return false;
  }
  return true;  
}

enquireSerialized()

bool BaseHolder::enquireSerialized ( std::vector< uint32_t >::const_iterator & fromHere, const std::vector< uint32_t >::const_iterator & end, class_id_type & c, std::string & label, sub_index_type & subtypeIndex )

staticinherited

Definition at line 12 of file BaseHolder.cxx.

                                                  {
  using namespace std;
  if ( fromHere == end )  return false;  
 
  c = *fromHere++;
  if ( fromHere == end )  return false;
 
  subtypeIndex = *fromHere++;
  if ( fromHere == end ) return false;
  
  unsigned labelSize = *fromHere++;
  if ( fromHere == end ) return false;
  if ( fromHere+labelSize > end ) return false;
  
  std::vector<uint32_t>::const_iterator stringEnd = fromHere+labelSize;
  HLT::StringSerializer::deserialize(fromHere, stringEnd, label);
 
  //advance iterator to end of label
  std::advance(fromHere,labelSize);
 
  return true;
}

generateAliasKey()

std::string IHolder::generateAliasKey ( CLID c, uint16_t sti, const std::string & label, unsigned size )

inherited

Definition at line 98 of file Holder.cxx.

                                                                                               {
  std::ostringstream ss;
  ss <<  "HLTAutoKey_" << label << "_" << c << "_" << sti << "_" << (size == 0xffffffff ? "back" : "to")  << "_" << m_uniqueCounter;
  std::string st = ss.str();
  ATH_MSG_DEBUG("IHolder::generateAliasKey generated key: " << st);
  m_uniqueCounter++;
  return st;
}

get() [1/3]

template<class STORED>

template<class CONTAINER2>

bool HLTNavDetails::Holder< STORED >::get ( ElementLinkVector< CONTAINER2 > & cont )

inherited

get() [2/3]

template<class STORED>

template<class CONTAINER2>

bool HLTNavDetails::Holder< STORED >::get ( ElementLinkVector< CONTAINER2 > & cont, HLT::TriggerElement::ObjectIndex idx )

inherited

get() [3/3]

template<class STORED, class CONTAINER>

virtual bool HLTNavDetails::HolderImp< STORED, CONTAINER >::get ( const STORED *& dest, HLT::TriggerElement::ObjectIndex idx )

virtual

gets object(s) holded

Implements HLTNavDetails::Holder< STORED >.

getAuxDataObject()

template<class STORED, class CONTAINER>

virtual DataObject * HLTNavDetails::HolderImp< STORED, CONTAINER >::getAuxDataObject ( )

virtual

Implements HLTNavDetails::IHolder.

getDataObject()

template<class STORED, class CONTAINER>

virtual DataObject * HLTNavDetails::HolderImp< STORED, CONTAINER >::getDataObject ( )

virtual

Implements HLTNavDetails::IHolder.

getElementLinks() [1/2]

template<class STORED, class CONTAINER>

bool HLTNavDetails::HolderImp< STORED, CONTAINER >::getElementLinks

(

ElementLinkVector< CONTAINER > &

cont

)

getElementLinks() [2/2]

template<class STORED, class CONTAINER>

bool HLTNavDetails::HolderImp< STORED, CONTAINER >::getElementLinks	(	ElementLinkVector< CONTAINER > &	cont,
		HLT::TriggerElement::ObjectIndex	idx )

getElementType()

const std::type_info * IHolder::getElementType ( const std::string & tname, std::string & elementTypeName ) const

privateinherited

Find the type of an element of a vector.

Parameters

tname	The name of the type to analyze.
[out[	elementTypeName The name of the type of an element of the vector.

Returns the type_info for an element of the vector.

Parameters

	tname_in	The name of the type to analyze.
[out]	elementTypeName	The name of the type of an element of the vector.

Returns the type_info for an element of the vector.

Definition at line 544 of file Holder.cxx.

{
  TClass* cls = TClass::GetClass (tname.c_str());
  if (!cls) return nullptr;
  TVirtualCollectionProxy* prox = cls->GetCollectionProxy();
  if (!prox) return nullptr;
  if (prox->GetValueClass()) {
     elementTypeName = prox->GetValueClass()->GetName();
     return prox->GetValueClass()->GetTypeInfo();
  }
  RootUtils::Type typ (prox->GetType());
  elementTypeName = typ.getTypeName();
  return typ.getTypeInfo();
}

getNextKey()

template<class STORED, class CONTAINER>

virtual std::string HLTNavDetails::HolderImp< STORED, CONTAINER >::getNextKey ( )

virtual

Implements HLTNavDetails::IHolder.

getUniqueKey()

template<class STORED, class CONTAINER>

virtual std::string HLTNavDetails::HolderImp< STORED, CONTAINER >::getUniqueKey ( )

virtual

Implements HLTNavDetails::IHolder.

getWithLink() [1/2]

template<class STORED>

template<class CONTAINER2>

bool HLTNavDetails::Holder< STORED >::getWithLink ( typename set_link< STORED, CONTAINER2, std::is_same< STORED, CONTAINER2 >::value >::type & link, HLT::TriggerElement::ObjectIndex & idx )

inlineinherited

Definition at line 305 of file Holder.h.

                                                        {
      
      bool result = static_cast<HolderImp<STORED,CONTAINER2>*>(this)->getWithLink(link,idx);
      return result;
    }       

getWithLink() [2/2]

template<class STORED, class CONTAINER>

bool HLTNavDetails::HolderImp< STORED, CONTAINER >::getWithLink	(	typename set_link< STORED, CONTAINER, std::is_same< STORED, CONTAINER >::value >::type &	link,
		HLT::TriggerElement::ObjectIndex &	idx )

key()

template<class STORED, class CONTAINER>

virtual const std::string & HLTNavDetails::HolderImp< STORED, CONTAINER >::key ( ) const

inlinevirtual

returns the containers StoreGate key

Implements HLTNavDetails::IHolder.

Definition at line 372 of file Holder.h.

{ return m_key; }

label()

const std::string & HLTNavDetails::IHolder::label ( ) const

inlinevirtualinherited

returns the label of objects stores by this holder

Implements HLT::BaseHolder.

Definition at line 85 of file Holder.h.

{ return  m_label; }

msg() [1/2]

MsgStream & HLTNavDetails::IHolder::msg ( ) const

inlineprotectedinherited

Definition at line 169 of file Holder.h.

{ return m_logger->msg(); }

msg() [2/2]

MsgStream & HLTNavDetails::IHolder::msg ( const MSG::Level lvl ) const

inlineprotectedinherited

Definition at line 170 of file Holder.h.

{ return msg() << lvl; }

msgLvl()

bool HLTNavDetails::IHolder::msgLvl ( const MSG::Level lvl ) const

inlineprotectedinherited

Definition at line 171 of file Holder.h.

{ return msg().level() <= lvl; }

prefix()

virtual const std::string & HLTNavDetails::IHolder::prefix ( ) const

inlinevirtualinherited

returns the containers StoreGate prefix

Definition at line 90 of file Holder.h.

{ return m_prefix; }

prepare()

template<class STORED, class CONTAINER>

virtual void HLTNavDetails::HolderImp< STORED, CONTAINER >::prepare ( const asg::AsgMessaging & logger, HLT::AccessProxy * sg, IConversionSvc * objSerializer, bool readonly = false )

virtual

prepares this holder by setting messaging, StoreGate access and providing serializer

Reimplemented from HLTNavDetails::IHolder.

print()

template<class STORED, class CONTAINER>

virtual void HLTNavDetails::HolderImp< STORED, CONTAINER >::print ( MsgStream & m ) const

virtual

Reimplemented from HLTNavDetails::IHolder.

serialize()

template<class STORED, class CONTAINER>

virtual bool HLTNavDetails::HolderImp< STORED, CONTAINER >::serialize ( std::vector< uint32_t > & output ) const

virtual

serializes this Holder

Reimplemented from HLTNavDetails::IHolder.

serializeDynVars()

bool IHolder::serializeDynVars ( const SG::IAuxStoreIO & iio, const xAOD::AuxSelection & sel, std::vector< uint32_t > & dataBlob )

privateinherited

Serialize all selected dynamic variables for an xAOD object.

Parameters

	iio	The auxiliary store for the xAOD object.
	sel	Selection object for variables to write.
[out]	dataBlob	Serialized data.

Returns true on success, false on failure.

Each selected dynamic variable is concatenated to dataBlob as follows.

• Length serialized name data (1 word).
• Serialized name data.
• Length of serialized type name (1 word).
• Serialized type name data.
• Length of serialized variable data (1 word).
• Serialized data for the variable, as produced by TrigTSerializer.

Definition at line 345 of file Holder.cxx.

{
  // Loop over all selected variables.
  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
  SG::auxid_set_t auxids = sel.getSelectedAuxIDs (iio.getDynamicAuxIDs());
  for (SG::auxid_t id : auxids) {
    // Get the TClass of the object being saved.
    const std::type_info* tinfo = iio.getIOType (id);
    if (!tinfo) {
      ATH_MSG_ERROR("serialize aux dyn vars failed: can't get type_info.");
      return false;
    }
    TClass* cls = TClass::GetClass (*tinfo);
    if (!cls) {
      ATH_MSG_ERROR("serialize aux dyn vars failed: can't get TClass.");
      return false;
    }
 
    // Serialize the object data to a temp buffer.
    std::vector<uint32_t> serialized =
      m_serializer->serialize (cls->GetName(), iio.getIOData (id));
 
    // Concatenate header header information to the output buffer:
    // attribute name and data type.
    StringSerializer ss;
    std::vector<uint32_t> serializedName;
    ss.serialize (r.getName(id), serializedName); // FIXME: handle class part?
    dataBlob.push_back (serializedName.size());
    dataBlob.insert(dataBlob.end(), serializedName.begin(), serializedName.end());
 
    std::vector<uint32_t> serializedType;
    ss.serialize (cls->GetName(), serializedType);
    dataBlob.push_back (serializedType.size());
    dataBlob.insert(dataBlob.end(), serializedType.begin(), serializedType.end());
 
    // Add the object data itself to the output buffer.
    dataBlob.push_back (serialized.size());
    dataBlob.insert(dataBlob.end(), serialized.begin(), serialized.end());
  }
 
  return true;
}

serializePayload()

bool HLTNavDetails::IHolder::serializePayload ( std::vector< uint32_t > & dataBlob, const xAOD::AuxSelection & sel )

inherited

serializes the payload of this Holder

Definition at line 254 of file Holder.cxx.

                                                                           {
  DataObject* dobj = getDataObject();
  
  if(!dobj){
    ATH_MSG_WARNING("data object points to null. can't serialize");
  }
 
  ATH_MSG_VERBOSE("creating serialized representation for " << dobj);
 
 
  TrigStreamAddress* addr(0);
  if ( m_objectserializerSvc->createRep(dobj, *pp_cast<IOpaqueAddress>(&addr) ).isSuccess() ) {
    ATH_MSG_VERBOSE("serialization of feature (object) successful, blob size: "  << addr->get().size());
    dataBlob.push_back(addr->get().size());
    dataBlob.insert(dataBlob.end(), addr->get().begin(), addr->get().end());
    // above should be optimized (need to know if in case of failed serialization addr->get() contains empty data vector)
  }
  else{
    ATH_MSG_ERROR("Container serialization Failure");
    return false;
  }
  DataBucketBase* dobjBase = static_cast<DataBucketBase*>(dobj);
  if ( dobjBase ) {
    dobjBase->relinquish();
    ATH_MSG_VERBOSE("serialization giving up the ownership");
  }
  delete dobj;
  delete addr;
  
  DataObject* dobjaux = getAuxDataObject();
 
  ATH_MSG_VERBOSE("aux object: " << dobjaux);
 
  TrigStreamAddress* auxaddr(0);
  if(dobjaux){
    ATH_MSG_VERBOSE("AuxStore serialization");
    if(m_objectserializerSvc->createRep(dobjaux,*pp_cast<IOpaqueAddress>(&auxaddr) ).isSuccess() ){
      ATH_MSG_VERBOSE("aux conversion success! aux blob has size: " << auxaddr->get().size());
      dataBlob.push_back(auxaddr->get().size());
      dataBlob.insert(dataBlob.end(), auxaddr->get().begin(), auxaddr->get().end());
    }
    else{
      ATH_MSG_ERROR("AuxStore serialization Failure");
      return false;
    }
    DataBucketBase* dobjBaseAux = static_cast<DataBucketBase*>(dobjaux);
 
    const SG::IAuxStoreIO* iio = nullptr;
    if (const xAOD::AuxContainerBase* auxstore =
        dobjBaseAux->template cast<xAOD::AuxContainerBase> (nullptr, true))
    {
      iio = auxstore;
    }
 
    dobjBaseAux->relinquish();
    ATH_MSG_VERBOSE("serialization giving up the ownership of Aux");
    delete dobjaux;
    delete auxaddr;
 
    // Handle dynamic variables.
    if (iio) {
      if (!serializeDynVars (*iio, sel, dataBlob)) {
        ATH_MSG_ERROR("Serialization of dynamic aux variables failed.");
        return false;
      }
    }
  }
  ATH_MSG_VERBOSE("finished serializing payload. size: " << dataBlob.size());
 
  return true;
}

serializeWithPayload()

bool IHolder::serializeWithPayload ( const xAOD::AuxSelection & sel, std::vector< uint32_t > & output, size_t & payloadsize )

inherited

serializes this Holder including payload

Definition at line 79 of file Holder.cxx.

                                                        {
  bool header_ser = serialize(output);
  if(!header_ser){
    ATH_MSG_ERROR(" header serialization failed ");
    return false;
  }
  std::vector<uint32_t> payload;
  bool payload_ser = serializePayload(payload, sel);
  if(!payload_ser){
    ATH_MSG_ERROR(" payload serialization failed ");
    return false;
  }
  payloadsize = payload.size();
  output.insert(output.end(), payload.begin(), payload.end());
  return true;
}

setAuxDataObject()

template<class STORED, class CONTAINER>

virtual bool HLTNavDetails::HolderImp< STORED, CONTAINER >::setAuxDataObject ( DataObject * dobjaux )

virtual

Implements HLTNavDetails::IHolder.

setDataObject()

template<class STORED, class CONTAINER>

virtual bool HLTNavDetails::HolderImp< STORED, CONTAINER >::setDataObject ( DataObject * dobj )

virtual

Implements HLTNavDetails::IHolder.

subTypeIndex()

uint16_t HLTNavDetails::IHolder::subTypeIndex ( ) const

inlinevirtualinherited

returns the index (short number used when linking object to the TE) of objects stores by this holder

Implements HLT::BaseHolder.

Definition at line 111 of file Holder.h.

{ return  m_subTypeIndex; }

syncWithSG()

template<class STORED, class CONTAINER>

virtual bool HLTNavDetails::HolderImp< STORED, CONTAINER >::syncWithSG ( SG::OwnershipPolicy policy = SG::OWN_ELEMENTS )

virtual

Implements HLTNavDetails::IHolder.

typeClid()

template<class STORED, class CONTAINER>

virtual CLID HLTNavDetails::HolderImp< STORED, CONTAINER >::typeClid ( ) const

inlinevirtual

returns the CLID of objects stores by this holder

Implements HLTNavDetails::IHolder.

Definition at line 380 of file Holder.h.

{ return ClassID_traits<STORED>::ID(); }

typeName()

template<class STORED, class CONTAINER>

virtual const std::string & HLTNavDetails::HolderImp< STORED, CONTAINER >::typeName ( ) const

inlinevirtual

returns the object's name stored by this holder

Implements HLTNavDetails::IHolder.

Definition at line 381 of file Holder.h.

{ return ClassID_traits<STORED>::typeName(); }

Member Data Documentation

m_aux

ITypeProxy* HLTNavDetails::IHolder::m_aux {0}

protectedinherited

Definition at line 166 of file Holder.h.

{0};

m_containerProxy

template<class STORED, class CONTAINER>

ContainerProxy HLTNavDetails::HolderImp< STORED, CONTAINER >::m_containerProxy

Definition at line 397 of file Holder.h.

m_key

template<class STORED, class CONTAINER>

std::string HLTNavDetails::HolderImp< STORED, CONTAINER >::m_key

private

Definition at line 403 of file Holder.h.

m_label

std::string HLTNavDetails::IHolder::m_label

privateinherited

label given to the objects in this holder (labels given at attachFeature)

Definition at line 242 of file Holder.h.

m_logger

const asg::AsgMessaging* HLTNavDetails::IHolder::m_logger {0}

protectedinherited

Definition at line 161 of file Holder.h.

{0};

m_memMgr

template<class STORED, class CONTAINER>

MemoryMgrMap HLTNavDetails::HolderImp< STORED, CONTAINER >::m_memMgr

Definition at line 400 of file Holder.h.

m_objectserializerSvc

IConversionSvc* HLTNavDetails::IHolder::m_objectserializerSvc {0}

protectedinherited

pointer to object serializer

Definition at line 162 of file Holder.h.

{0};     

m_prefix

std::string HLTNavDetails::IHolder::m_prefix

privateinherited

prefix for key given to the objects

Definition at line 241 of file Holder.h.

m_readonly

bool HLTNavDetails::IHolder::m_readonly {false}

protectedinherited

Definition at line 165 of file Holder.h.

{false};

m_serializer

ToolHandle<ITrigSerializerToolBase> HLTNavDetails::IHolder::m_serializer

privateinherited

Serializer tool; used for dynamic variables.

Definition at line 247 of file Holder.h.

m_storeGate

HLT::AccessProxy* HLTNavDetails::IHolder::m_storeGate {0}

protectedinherited

pointer to SG

Definition at line 163 of file Holder.h.

{0};               

m_subTypeIndex

uint16_t HLTNavDetails::IHolder::m_subTypeIndex {0}

privateinherited

index to notify how many objects of given type we have (we need to record it in case of slimming will be done latter)

Definition at line 243 of file Holder.h.

{0};   

m_uniqueCounter

int HLTNavDetails::IHolder::m_uniqueCounter {0}

privateinherited

Definition at line 244 of file Holder.h.

{0};

---

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

• Holder.h