HLTNavDetails::IHolder Class Reference

#include <Holder.h>

Inheritance diagram for HLTNavDetails::IHolder:

Collaboration diagram for HLTNavDetails::IHolder:

Public Member Functions
	IHolder ()
	IHolder (const std::string &prefix, const std::string &label, uint16_t idx)
virtual	~IHolder ()
virtual IHolder *	clone (const std::string &prefix, const std::string &label, uint16_t idx) const =0
virtual void	prepare (const asg::AsgMessaging &logger, HLT::AccessProxy *sg, IConversionSvc *objSerializer, bool readonly)
	prepares this holder by setting messaging, StoreGate access and providing serializer
virtual bool	syncWithSG (SG::OwnershipPolicy policy=SG::OWN_ELEMENTS)=0
virtual CLID	typeClid () const =0
	returns the CLID of objects stores by this holder
virtual CLID	containerClid () const =0
virtual CLID	auxClidOrZero () const =0
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
virtual const std::string &	key () const =0
	returns the containers StoreGate key
virtual const std::string &	typeName () const =0
	returns the object's name stored by this holder
virtual const std::string &	collectionName () const =0
	returns the collection's name stored by this holder
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)
virtual bool	serialize (std::vector< uint32_t > &output) const
	serializes this Holder
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
virtual void	print (MsgStream &m) const
bool	deserializePayload (const std::vector< uint32_t > &dataBlob, int version)
	deserialization of holder payload
virtual DataObject *	getDataObject ()=0
virtual DataObject *	getAuxDataObject ()=0
virtual bool	setDataObject (DataObject *dobj)=0
virtual bool	setAuxDataObject (DataObject *dobjaux)=0
virtual const ITypeProxy &	containerTypeProxy () const =0
	Get the proxy for the container.
virtual bool	checkAndSetOwnership (SG::OwnershipPolicy policy)=0
virtual std::string	getUniqueKey ()=0
virtual std::string	getNextKey ()=0

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)

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_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

Definition at line 58 of file Holder.h.

Constructor & Destructor Documentation

IHolder() [1/2]

IHolder::IHolder

(

)

Definition at line 38 of file Holder.cxx.

  : m_serializer("TrigTSerializer/TrigTSerializer")
{}

IHolder() [2/2]

IHolder::IHolder	(	const std::string &	prefix,
		const std::string &	label,
		uint16_t	idx )

Definition at line 42 of file Holder.cxx.

  : m_prefix(prefix),
    m_label(label),
    m_subTypeIndex(idx),
    m_serializer("TrigTSerializer/TrigTSerializer")
{
}

~IHolder()

IHolder::~IHolder ( )

virtual

Definition at line 51 of file Holder.cxx.

                  {
  if ( m_aux ) { delete m_aux; }
}

Member Function Documentation

auxClidOrZero()

virtual CLID HLTNavDetails::IHolder::auxClidOrZero ( ) const

pure virtual

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

checkAndSetOwnership()

virtual bool HLTNavDetails::IHolder::checkAndSetOwnership ( SG::OwnershipPolicy policy )

pure virtual

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

clone()

virtual IHolder * HLTNavDetails::IHolder::clone ( const std::string & prefix, const std::string & label, uint16_t idx ) const

pure virtual

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

collectionName()

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

pure virtual

returns the collection's name stored by this holder

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

containerClid()

virtual CLID HLTNavDetails::IHolder::containerClid ( ) const

pure virtual

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

containerTypeProxy()

virtual const ITypeProxy & HLTNavDetails::IHolder::containerTypeProxy ( ) const

pure virtual

Get the proxy for the container.

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

deserializeDynVars() [1/2]

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

private

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 )

private

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 )

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 )

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;
}

getAuxDataObject()

virtual DataObject * HLTNavDetails::IHolder::getAuxDataObject ( )

pure virtual

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

getDataObject()

virtual DataObject * HLTNavDetails::IHolder::getDataObject ( )

pure virtual

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

getElementType()

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

private

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()

virtual std::string HLTNavDetails::IHolder::getNextKey ( )

pure virtual

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

getUniqueKey()

virtual std::string HLTNavDetails::IHolder::getUniqueKey ( )

pure virtual

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

key()

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

pure virtual

returns the containers StoreGate key

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

label()

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

inlinevirtual

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

inlineprotected

Definition at line 169 of file Holder.h.

{ return m_logger->msg(); }

msg() [2/2]

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

inlineprotected

Definition at line 170 of file Holder.h.

{ return msg() << lvl; }

msgLvl()

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

inlineprotected

Definition at line 171 of file Holder.h.

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

prefix()

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

inlinevirtual

returns the containers StoreGate prefix

Definition at line 90 of file Holder.h.

{ return m_prefix; }

prepare()

void IHolder::prepare ( const asg::AsgMessaging & logger, HLT::AccessProxy * sg, IConversionSvc * objSerializer, bool readonly )

virtual

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

Reimplemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

Definition at line 55 of file Holder.cxx.

                                                                                                                     {
  m_storeGate = sg;
  m_logger = &logger;
  m_objectserializerSvc = objSerializer;
  m_readonly = readonly;
}

print()

void IHolder::print ( MsgStream & m ) const

virtual

Reimplemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

Definition at line 107 of file Holder.cxx.

                                      {
  m << "type: " << typeName() << "(" << typeClid() << ")" << " container: " << collectionName() << "(" << containerClid() << ")"
    << "label: \"" << label() << "\" subTypeIndex: " << subTypeIndex();
}

serialize()

bool IHolder::serialize ( std::vector< uint32_t > & output ) const

virtual

serializes this Holder

Reimplemented from HLT::BaseHolder.

Reimplemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

Definition at line 62 of file Holder.cxx.

                                                          {
 
  ATH_MSG_DEBUG("Holder<T> serialize, " << *this );
  // if feature to be forgotten then indication of it is simply 0 size of serialized vector
 
  output.push_back( typeClid() );
  output.push_back( m_subTypeIndex );
 
  // label
  std::vector<uint32_t> serializedLabel;
  StringSerializer ss;
  ss.serialize( m_label, serializedLabel );
  output.push_back( serializedLabel.size() );
  output.insert(output.end(), serializedLabel.begin(), serializedLabel.end());
  return true;
}

serializeDynVars()

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

private

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 )

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 )

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()

virtual bool HLTNavDetails::IHolder::setAuxDataObject ( DataObject * dobjaux )

pure virtual

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

setDataObject()

virtual bool HLTNavDetails::IHolder::setDataObject ( DataObject * dobj )

pure virtual

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

subTypeIndex()

uint16_t HLTNavDetails::IHolder::subTypeIndex ( ) const

inlinevirtual

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()

virtual bool HLTNavDetails::IHolder::syncWithSG ( SG::OwnershipPolicy policy = SG::OWN_ELEMENTS )

pure virtual

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

typeClid()

virtual CLID HLTNavDetails::IHolder::typeClid ( ) const

pure virtual

returns the CLID of objects stores by this holder

Implements HLT::BaseHolder.

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

typeName()

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

pure virtual

returns the object's name stored by this holder

Implemented in HLTNavDetails::HolderImp< STORED, CONTAINER >, and HolderImp< STORED, CONTAINER >.

Member Data Documentation

m_aux

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

protected

Definition at line 166 of file Holder.h.

{0};

m_label

std::string HLTNavDetails::IHolder::m_label

private

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}

protected

Definition at line 161 of file Holder.h.

{0};

m_objectserializerSvc

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

protected

pointer to object serializer

Definition at line 162 of file Holder.h.

{0};     

m_prefix

std::string HLTNavDetails::IHolder::m_prefix

private

prefix for key given to the objects

Definition at line 241 of file Holder.h.

m_readonly

bool HLTNavDetails::IHolder::m_readonly {false}

protected

Definition at line 165 of file Holder.h.

{false};

m_serializer

ToolHandle<ITrigSerializerToolBase> HLTNavDetails::IHolder::m_serializer

private

Serializer tool; used for dynamic variables.

Definition at line 247 of file Holder.h.

m_storeGate

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

protected

pointer to SG

Definition at line 163 of file Holder.h.

{0};               

m_subTypeIndex

uint16_t HLTNavDetails::IHolder::m_subTypeIndex {0}

private

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}

private

Definition at line 244 of file Holder.h.

{0};

---

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

• Holder.h
• Holder.cxx