TrigTSerializer Class Reference

#include <TrigTSerializer.h>

Inheritance diagram for TrigTSerializer:

Collaboration diagram for TrigTSerializer:

Public Member Functions
	TrigTSerializer (const std::string &name, const std::string &type, const IInterface *parent)
virtual	~TrigTSerializer ()
StatusCode	initialize ()
StatusCode	finalize ()
std::vector< uint32_t >	serialize (const std::string &nameOfClass, const void *instance)
	serializes an object of a class nameOfClass pointed to by instance and recursively also other objects which object may point to
void	serialize (const std::string &nameOfClass, const void *instance, std::vector< uint32_t > &v)
	serializes an object of a class nameOfClass pointed to by instance and recursively also other objects which object may point to
void *	deserialize (const std::string &nameOfClass, const std::vector< uint32_t > &v)
	deserializes an object of a class nameOfClass (and recursively other objects) found in std::vector<uint32_t>& v
StatusCode	initClass (const std::string &nameOfClass) const
	initialize framework to be ready to serialize a given class method to be called to prevent delayed initializations on the first event
void	reset ()
	clean internal serializer state.
StatusCode	peekCLID (const std::vector< uint32_t > &v, uint32_t *guid) const
	access clid of the payload (stored in BS)
void	setCLID (const uint32_t *guid)
	access clid of the payload virtual CLID getCLID() const = 0;
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	do_persistify (const std::string &nameOfClass, void *instance)
void	do_persistify_obj (const std::string &nameOfClass, void *instance)
void	do_follow_ptr (const std::string &nameOfClass, void *instance)
void	add_previous_streamerinfos ()
void	prepareForTBuffer (const std::string &nameOfClass)
void	restoreAfterTBuffer (const std::string &nameOfClass)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static bool	streamerErrorHandler (Int_t level, Bool_t abort_bool, const char *location, const char *msg)
static bool	bsDictWarningFilter (Int_t level, Bool_t abort_bool, const char *location, const char *msg)

Private Attributes
bool	m_onlineMode
uint32_t	m_guid [4]
uint32_t	m_IgnoreErrLvl {}
std::map< std::string, uint32_t >	m_errCount
StringArrayProperty	m_ignoreMissingDicts
	IgnoreMissingDicts.
TList *	m_streamersList
	Remember streamer info list for cleaning up later.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static bool	s_decodingError = false
static std::vector< std::string >	s_dictsToIgnore
	static copy of the IgnoreMissingDicts property for the static error handler

Detailed Description

Author

Jiri Masik Jiri..nosp@m.Masi.nosp@m.k@cer.nosp@m.n.ch

Definition at line 37 of file TrigTSerializer.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TrigTSerializer()

TrigTSerializer::TrigTSerializer	(	const std::string &	name,
		const std::string &	type,
		const IInterface *	parent )

Definition at line 235 of file TrigTSerializer.cxx.

                                                                                                           : AthAlgTool(toolname, type, parent), m_streamersList{nullptr} {
  declareInterface<ITrigSerializerToolBase>( this );
  declareProperty("OnlineMode", m_onlineMode=false, "avoid initializations not needed in the online");
 
  for (size_t i=0; i<4; i++) m_guid[i]=0;
}

~TrigTSerializer()

TrigTSerializer::~TrigTSerializer ( )

virtual

Definition at line 242 of file TrigTSerializer.cxx.

                                 {
  if (m_streamersList){
    delete m_streamersList;
    m_streamersList = nullptr;
  }
}

Member Function Documentation

add_previous_streamerinfos()

void TrigTSerializer::add_previous_streamerinfos ( )

private

Definition at line 303 of file TrigTSerializer.cxx.

{
  RootUtils::WithRootErrorHandler hand( bsDictWarningFilter );
  //temporary 
  std::string extStreamerInfos = "bs-streamerinfos.root";
  std::string extFile = PathResolver::find_file (extStreamerInfos, "DATAPATH");
  ATH_MSG_DEBUG( "Using " << extFile );
  TFile f(extFile.c_str());
  m_streamersList = f.GetStreamerInfoList();
  TIter nextinfo(m_streamersList);
  while (TObject* obj = nextinfo()) {
    TStreamerInfo *inf = dynamic_cast<TStreamerInfo*> (obj);
    if (!inf) continue;
    TString t_name=inf->GetName();
 
    if (t_name.BeginsWith("listOfRules")){
        ATH_MSG_WARNING( "Could not re-load  class " << t_name );
        continue;
    }
 
    inf->BuildCheck();
    //this triggers a crash on lcg60
    TClass *cl = inf->GetClass();
    if (cl)
      ATH_MSG_DEBUG( "external TStreamerInfo for " << cl->GetName()
                     << " checksum: " << inf->GetCheckSum()  );
  }
  f.Close();
}

bsDictWarningFilter()

bool TrigTSerializer::bsDictWarningFilter ( Int_t level, Bool_t abort_bool, const char * location, const char * msg )

staticprivate

Definition at line 286 of file TrigTSerializer.cxx.

{
   if( level == kWarning and gDebug == 0 ) {
      if( strstr(msg, "no dictionary for class") ) {
         for( std::string &type : s_dictsToIgnore ) {
            if( strstr(msg, type.c_str()) ) {
               return false;
            }
         }
      }
   }
   DefaultErrorHandler(level,abort_bool, location, msg);
   return false;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

deserialize()

void * TrigTSerializer::deserialize ( const std::string & nameOfClass, const std::vector< uint32_t > & v )

virtual

deserializes an object of a class nameOfClass (and recursively other objects) found in std::vector<uint32_t>& v

Returns

pointer to a deserialized object

Implements ITrigSerializer.

Definition at line 477 of file TrigTSerializer.cxx.

                                                                                            {
 
  size_t rootDebug = gDebug;
  if (msgLvl(MSG::DEBUG)){
    ATH_MSG_DEBUG( "in deserialize for " << nameOfClass   );
    /*
    //cannot be used in production 
    //higher gDebug seems to interfere with ErrorHandler
    if (m_outputlevel<=MSG::VERBOSE &&rootDebug<5)
      gDebug=5;
    */
  }
 
  const size_t vsize = v.size();
  uint32_t rVersion(0);
  size_t bufsiz(0);
  bool newFormatOK=true;
  bool decodeOldFormat=true;
  size_t pBuffOffset(3);      //adjust below
  //
  //
 
  if (vsize>2){
    if (v.at(0)==TRIGTSERHEADER){
      rVersion = v.at(1);
      bufsiz = v.at(2);
      if (rVersion>3)
    pBuffOffset++;
      if (rVersion>4)
    pBuffOffset += 3;   //wrt ver 4
 
      //check size with vsize
      size_t expectsize = pBuffOffset + bufsiz/4 + bufsiz%4;
 
      if (expectsize!=vsize){
    newFormatOK = false;
    ATH_MSG_WARNING( "expected payload length "<<expectsize
                         << "  does not match the container size " << vsize
                         << " for " << nameOfClass << " fallback to the old format:" );
      }
      ATH_MSG_DEBUG( bufsiz << "bytes of payload version " << std::hex << rVersion << std::dec
                     << " for " << nameOfClass   );
    }
    else {
      ATH_MSG_WARNING( "not a versioned payload of "
                       <<  nameOfClass << " trying initial TrigTSerializer"  );
      newFormatOK = false;
    }
 
  } else {
    ATH_MSG_WARNING( "zero bytes of payload for " << nameOfClass   );
    gDebug=rootDebug;
    return NULL;
  }
 
  //
  char *pbuf = NULL;
 
  if (newFormatOK){
    union {
      uint32_t uint;
      char pp[4];
    } pbytes;
 
    //  const size_t bufsiz = v.size();
    pbuf = new char[bufsiz];
    size_t bufpos=0;
    const size_t nints = bufsiz/4;
    for (size_t i=pBuffOffset; i<nints+pBuffOffset; i++){
      pbytes.uint = v.at(i);
      for (size_t c=0; c<4; c++){
    pbuf[bufpos] = pbytes.pp[3-c];
    bufpos++;
      }
    }
 
    for (size_t i=nints+pBuffOffset; i<vsize; i++){
      pbuf[bufpos] = (char)v.at(i);
      bufpos++;
    }
 
    if (msgLvl(MSG::VERBOSE)){
      msg(MSG::VERBOSE) << "deserialized dump: ";
      for (size_t i=0; i<v.size(); i++){
    msg(MSG::VERBOSE) << std::hex << v.at(i) <<std::dec << " ";
      }
      msg(MSG::VERBOSE) << endmsg;
    }
 
  } else if (!newFormatOK && decodeOldFormat){
    bufsiz = v.size();
    pbuf = new char[bufsiz];
    
    for (size_t i=0; i<bufsiz; i++)
      pbuf[i] = v.at(i);
  } else {
    gDebug=rootDebug;
    return NULL;
  }
 
  /*
  if (newFormatOK && rVersion >3)
    setCLID(v.at(3));
  */
 
  //common part
  TBufferFile *buff = new TBufferFile(TBuffer::kRead, bufsiz, pbuf, kTRUE);
  
  std::string noc= TrigSerializeResult::remapToDictName(nameOfClass);
  TClass *pclass = gROOT->GetClass(noc.c_str());
  
  TObject *pobj = NULL;
  if (pclass){
    prepareForTBuffer(noc);
    {
      RootUtils::WithRootErrorHandler hand (streamerErrorHandler);
      //pobj = (TObject *)(buff->ReadObjectAny(pclass));
      pobj = (TObject *)(ROOT8367Workaround::TBufferFileWorkaround::doReadObjectAny (buff, pclass));
    }
    restoreAfterTBuffer(noc);
    //ErrorHandlerFunc_t oldhandler= ::SetErrorHandler(streamerErrorHandler);
    //SetErrorHandler(oldhandler);
    //buff->StreamObject(instance, pclass);
  }
  else {
    ATH_MSG_ERROR( "gROOT->GetClass failed for" << nameOfClass  );
  }
  
  delete buff;   //this also deletes pbuf owned by buff
  gDebug=rootDebug;
 
  return (void *)pobj;
}

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

do_follow_ptr()

void TrigTSerializer::do_follow_ptr ( const std::string & nameOfClass, void * instance )

private

Definition at line 668 of file TrigTSerializer.cxx.

                                                                   {
 
  ATH_MSG_VERBOSE("Entering do_follow_ptr for "  << name << " at " << ptr  );
  
  
  if (ptr){
    const std::string classname = name.substr(0, name.find_last_of('*'));
    ATH_MSG_DEBUG( "going deeper for " << classname << " at " << ptr  );
    do_persistify(classname, ptr);
  }
  
}

do_persistify()

void TrigTSerializer::do_persistify ( const std::string & nameOfClass, void * instance )

private

Definition at line 664 of file TrigTSerializer.cxx.

{ TrigTSerializerUnimplError(); }

do_persistify_obj()

void TrigTSerializer::do_persistify_obj ( const std::string & nameOfClass, void * instance )

private

Definition at line 665 of file TrigTSerializer.cxx.

{ TrigTSerializerUnimplError(); }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode TrigTSerializer::finalize

(

)

Definition at line 270 of file TrigTSerializer.cxx.

                                    {
 
  std::map<std::string,uint32_t>::const_iterator mitr(m_errCount.begin());
  std::map<std::string,uint32_t>::const_iterator mend(m_errCount.end());
  bool reported(false);
  while (mitr!=mend){
    reported=true;
    ATH_MSG_WARNING( "Could not interpret persistent object " << (*mitr).first
                     << " /" << (*mitr).second << " times." );
    ++mitr;
  }
  if (!reported)
    ATH_MSG_INFO( name() << " no problems encountered" );
  return StatusCode::SUCCESS;
}

initClass()

StatusCode TrigTSerializer::initClass ( const std::string & nameOfClass ) const

virtual

initialize framework to be ready to serialize a given class method to be called to prevent delayed initializations on the first event

Returns

StatusCode

Implements ITrigSerializer.

Definition at line 612 of file TrigTSerializer.cxx.

                                                                        {
 
  TClass *pclass = gROOT->GetClass(nameOfClass.c_str());
 
 
  StatusCode sc(StatusCode::FAILURE); 
 
  if (pclass)
    sc = StatusCode::SUCCESS;
 
 
  return sc;
 
}

initialize()

StatusCode TrigTSerializer::initialize

(

)

Definition at line 249 of file TrigTSerializer.cxx.

                                      {
  ATH_MSG_DEBUG( "TrigTSerializer::initialize " << name() );
 
  // copy missing dictionary names from the property to the static member
  s_dictsToIgnore.insert( std::end(s_dictsToIgnore), std::begin(m_ignoreMissingDicts.value()), std::end(m_ignoreMissingDicts.value()) );
  std::string msg;
  for( const auto& n:s_dictsToIgnore ) {
     if( not msg.empty() ) msg += ", ";
     msg += n;
  }
  ATH_MSG_DEBUG( "Suppressing missing dictionary warnings for: " << msg );
     
  if (!m_onlineMode)
    add_previous_streamerinfos();
 
  m_IgnoreErrLvl = gErrorIgnoreLevel;
 
  return StatusCode::SUCCESS;
 
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & ITrigSerializerToolBase::interfaceID ( )

inlinestaticinherited

Definition at line 92 of file ITrigSerializerToolBase.h.

{ return IID_ITrigSerializerToolBase; }

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

peekCLID()

StatusCode TrigTSerializer::peekCLID ( const std::vector< uint32_t > & v, uint32_t * guid ) const

virtual

access clid of the payload (stored in BS)

Implements ITrigSerializer.

Definition at line 633 of file TrigTSerializer.cxx.

                                                                                       {
  if (v.size()>2){
    if (v.at(0)==TRIGTSERHEADER){
      const uint32_t rVersion = v.at(1);
      if (rVersion>4){
    guid[0] = v.at(3);
    guid[1] = v.at(4);
    guid[2] = v.at(5);
    guid[3] = v.at(6);
    return StatusCode::SUCCESS;
      }
    }
  }
  return StatusCode::FAILURE;
}

prepareForTBuffer()

void TrigTSerializer::prepareForTBuffer ( const std::string & nameOfClass )

private

Definition at line 350 of file TrigTSerializer.cxx.

                                                                   {
  m_IgnoreErrLvl = gErrorIgnoreLevel;
  //MN: this setting does not play well with ROOTDEBUG:
  //  gErrorIgnoreLevel = kInfo+1;
  //had this class a problem before?
  if (m_errCount.find(nameOfClass)!=m_errCount.end()){
    gErrorIgnoreLevel = kError+1;   
  } 
  s_decodingError = false;
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

reset()

void TrigTSerializer::reset ( )

virtual

clean internal serializer state.

To be used between (de)serialization of unrelated data (for example of a new event)

Implements ITrigSerializer.

Definition at line 629 of file TrigTSerializer.cxx.

                           {
  m_guid[0] = m_guid[1] = m_guid[2] = m_guid[3] = 0;
}

restoreAfterTBuffer()

void TrigTSerializer::restoreAfterTBuffer ( const std::string & nameOfClass )

private

Definition at line 361 of file TrigTSerializer.cxx.

                                                                     {
  if (s_decodingError){
    s_decodingError = false;
    
 
    if (m_errCount.find(nameOfClass)!=m_errCount.end()){
      ++m_errCount[nameOfClass];
    } else {
      ATH_MSG_ERROR( "Errors while decoding " << nameOfClass
                     << " any further ROOT messages for this class will be suppressed"  );
      m_errCount[nameOfClass] = 1;
    }
  }
 
  gErrorIgnoreLevel = m_IgnoreErrLvl;
}

serialize() [1/2]

std::vector< uint32_t > TrigTSerializer::serialize ( const std::string & nameOfClass, const void * instance )

virtual

serializes an object of a class nameOfClass pointed to by instance and recursively also other objects which object may point to

Returns

std::vector<uint32_t>

Implements ITrigSerializer.

Definition at line 378 of file TrigTSerializer.cxx.

                                                                                                {
  std::vector<uint32_t> serialized;
  serialize(nameOfClass, instance, serialized);
  return serialized;
}

serialize() [2/2]

void TrigTSerializer::serialize ( const std::string & nameOfClass, const void * instance, std::vector< uint32_t > & v )

virtual

serializes an object of a class nameOfClass pointed to by instance and recursively also other objects which object may point to

Returns

std::vector<uint32_t>

Implements ITrigSerializer.

Definition at line 384 of file TrigTSerializer.cxx.

                                                                                                                  {
 
  serialized.clear();
 
  size_t rootDebug = gDebug;
 
  if (msgLvl(MSG::DEBUG)){
    ATH_MSG_DEBUG( "in serialize for " << nameOfClass   );
    /*
    //cannot be used in production 
    //higher gDebug seems to interfere with ErrorHandler
    if (m_outputlevel<=MSG::VERBOSE && rootDebug<5)
      gDebug=5;
    */
  }
 
  std::string noc= TrigSerializeResult::remapToDictName(nameOfClass);
  TClass *pclass = gROOT->GetClass(noc.c_str());
 
  //  do_persistify(noc, instance);
 
  TBufferFile *buff = new TBufferFile(TBuffer::kWrite);
 
  //std::vector<uint32_t> serialized;
 
  if (pclass){
    //buff->StreamObject(instance, pclass);
    
    ATH_MSG_DEBUG( "writing instance " << instance << " to buffer for noc " << noc   );
    
    prepareForTBuffer(noc);
    {
      RootUtils::WithRootErrorHandler hand (streamerErrorHandler);
      buff->WriteObjectAny(instance, pclass);
    }
    restoreAfterTBuffer(noc);
    
    ATH_MSG_DEBUG( "wrote buffer of length " << buff->Length()  );
    
 
    const char *pbuff = buff->Buffer();
    const size_t bufsiz = buff->Length();
 
    serialized.push_back(TRIGTSERHEADER);
    serialized.push_back(TRIGTSERVERSION);
    serialized.push_back(bufsiz);
    serialized.push_back(m_guid[0]);
    serialized.push_back(m_guid[1]);
    serialized.push_back(m_guid[2]);
    serialized.push_back(m_guid[3]);
 
    //inefficient - to be compatible with Serializer for the moment can be avoided later
    union {
      uint32_t uint;
      char pp[4];
    } pbytes;
 
    for (size_t i=0; i<bufsiz/4; i++){
      pbytes.uint = 0;
      for (size_t j=0; j<4; j++){
    pbytes.pp[3-j] = pbuff[4*i+j];
      }
      // ATH_MSG_DEBUG( "packed " << std::hex << pbytes <<  std::dec  );
      
      serialized.push_back(pbytes.uint);
    }
 
    //send rest of chars as one int each
    const size_t modb = bufsiz%4;
    for (size_t i=0; i<modb; i++){
      pbytes.uint = 0;
      pbytes.pp[0] = pbuff[bufsiz-modb+i];
      serialized.push_back(pbytes.uint);
    }
 
    if (msgLvl(MSG::VERBOSE)){
      msg(MSG::VERBOSE) << "serialized dump: ";
      for (size_t i=0; i<serialized.size(); i++){
    msg(MSG::VERBOSE) << std::hex << serialized.at(i) <<std::dec << " ";
      }
      msg(MSG::VERBOSE) << endmsg;
    }
  }
  else {
    ATH_MSG_ERROR( "gROOT->GetClass failed for" << nameOfClass  );
  } 
  
  delete buff;
  gDebug=rootDebug;
  
  //  return serialized;
}

setCLID()

void TrigTSerializer::setCLID ( const uint32_t * guid )

virtual

access clid of the payload virtual CLID getCLID() const = 0;

set clid of the persistent class to be stored in data

Implements ITrigSerializer.

Definition at line 649 of file TrigTSerializer.cxx.

                                                 {
  for (size_t i=0; i<4; i++)
    m_guid[i] = guid[i];
}

streamerErrorHandler()

bool TrigTSerializer::streamerErrorHandler ( Int_t level, Bool_t abort_bool, const char * location, const char * msg )

staticprivate

Definition at line 334 of file TrigTSerializer.cxx.

                                                             {
   if( level > kInfo ) {
      //MN: ignore stuff below kWarning
      s_decodingError = true;
   }
   int oldLvl = gErrorIgnoreLevel;
   if( gDebug > 0 ) {
      gErrorIgnoreLevel = kPrint;
   }
   ::DefaultErrorHandler(level,abort_bool, location, msg);
   gErrorIgnoreLevel = oldLvl;
 
   return false;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_errCount

std::map<std::string, uint32_t> TrigTSerializer::m_errCount

private

Definition at line 81 of file TrigTSerializer.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_guid

uint32_t TrigTSerializer::m_guid[4]

private

Definition at line 76 of file TrigTSerializer.h.

m_IgnoreErrLvl

uint32_t TrigTSerializer::m_IgnoreErrLvl {}

private

Definition at line 80 of file TrigTSerializer.h.

{};

m_ignoreMissingDicts

StringArrayProperty TrigTSerializer::m_ignoreMissingDicts

private

Initial value:

{
     this, "IgnoreMissingDicts", {},
     "Suppress warining about missing dictionaries", "OrderedSet<std::string>" }

IgnoreMissingDicts.

Definition at line 84 of file TrigTSerializer.h.

                                             {
     this, "IgnoreMissingDicts", {},
     "Suppress warining about missing dictionaries", "OrderedSet<std::string>" };

m_onlineMode

bool TrigTSerializer::m_onlineMode

private

Definition at line 75 of file TrigTSerializer.h.

m_streamersList

TList* TrigTSerializer::m_streamersList

private

Remember streamer info list for cleaning up later.

Definition at line 91 of file TrigTSerializer.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

s_decodingError

bool TrigTSerializer::s_decodingError = false

staticprivate

Definition at line 79 of file TrigTSerializer.h.

s_dictsToIgnore

std::vector< std::string > TrigTSerializer::s_dictsToIgnore

staticprivate

Initial value:

= {
   "CosmicMuonCollection_tlp1", "MdtTrackSegmentCollection_tlp1",
   "CosmicMuonCollection_p1", "CosmicMuon_p1", "MdtTrackSegmentCollection_p1",
   "MdtTrackSegment_p1", "MdtTrackSegmentCollection_p2", "PanTauDetails_p1",
   "SG::IAuxStoreCompression"
}

static copy of the IgnoreMissingDicts property for the static error handler

Definition at line 228 of file TrigTSerializer.h.

                                            : virtual public ITrigSerializerToolBase, public AthAlgTool {
public:
  TrigTSerializer(const std::string& name, const std::string& type,
          const IInterface* parent);
  virtual ~TrigTSerializer();
 
  StatusCode initialize();
  StatusCode finalize();
 
  std::vector<uint32_t> serialize(const std::string &nameOfClass, const void* instance);
 
  void serialize(const std::string &nameOfClass, const void* instance, std::vector<uint32_t> &v);
 
  void* deserialize(const std::string &nameOfClass, const std::vector<uint32_t>& v);
 
  StatusCode initClass(const std::string &nameOfClass) const;
 
  //reset Serializer internal data between running serialize methods with unrelated data
  void reset();
 
  StatusCode peekCLID(const std::vector<uint32_t>& v, uint32_t *guid) const;
  
  void setCLID(const uint32_t *guid);
 
private:
  void do_persistify(const std::string& nameOfClass, void* instance);
  void do_persistify_obj(const std::string& nameOfClass, void* instance);
  void do_follow_ptr(const std::string& nameOfClass, void* instance);
  void add_previous_streamerinfos();
  
  static bool streamerErrorHandler(Int_t level, Bool_t abort_bool,
                   const char* location, const char *msg);
  static bool bsDictWarningFilter(Int_t level, Bool_t abort_bool,
                   const char* location, const char *msg);
 
  void prepareForTBuffer(const std::string &nameOfClass);
  void restoreAfterTBuffer(const std::string &nameOfClass);
 
  bool      m_onlineMode;
  uint32_t  m_guid[4];  
 
  // for error handling
  static   bool       s_decodingError;
  uint32_t  m_IgnoreErrLvl{};
  std::map<std::string, uint32_t>   m_errCount;

  StringArrayProperty m_ignoreMissingDicts   {
     this, "IgnoreMissingDicts", {},
     "Suppress warining about missing dictionaries", "OrderedSet<std::string>" };
  static std::vector<std::string>    s_dictsToIgnore;

  TList* m_streamersList;
};
 
#undef REFLEX_NS
 
 
#endif

---

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

• TrigTSerializer.h
• TrigTSerializer.cxx