ByteStreamCnvSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef BYTESTREAMCNVSVC_BYTESTREAMCNVSVC_H
#define BYTESTREAMCNVSVC_BYTESTREAMCNVSVC_H
 
#include "ByteStreamCnvSvcBase/ByteStreamCnvSvcBase.h"
#include "ByteStreamCnvSvcBase/FullEventAssembler.h"
#include "StoreGate/StoreGateSvc.h"
#include "AthenaKernel/SlotSpecificObj.h"
#include "GaudiKernel/ThreadLocalContext.h"
#include "GaudiKernel/ServiceHandle.h"
 
#include <map>
 
class ByteStreamOutputSvc;
class FullEventAssemblerBase;
 
class ByteStreamCnvSvc : public ByteStreamCnvSvcBase/*, virtual public IService*/ {
 
public:
   ByteStreamCnvSvc(const std::string& name, ISvcLocator* svc);
 
   virtual ~ByteStreamCnvSvc();
 
   virtual StatusCode initialize() override;
   virtual StatusCode finalize() override;
 
   virtual StatusCode connectOutput(const std::string& t, const std::string& mode) override;
   virtual StatusCode connectOutput(const std::string& t) override;
 
   virtual StatusCode commitOutput(const std::string& outputConnection, bool b) override;
 
   virtual RawEventWrite* getRawEvent() override
   {
     return m_slots->m_rawEventWrite.get();
   }
 
   template <class T> StatusCode getFullEventAssembler(T*&t, const std::string& nm);
 
  virtual StatusCode queryInterface( const InterfaceID& riid, void** ppvInterface ) override;
  static const InterfaceID& interfaceID();
 
protected:
   RawEventWrite* setRawEvent (std::unique_ptr<RawEventWrite> rawEventWrite);
 
private:
   std::string m_ioSvcName;
 
   Gaudi::Property<std::vector<std::string>> m_ioSvcNameList{ this, "ByteStreamOutputSvcList", {}, "", "OrderedSet<T>"};
   
   Gaudi::Property<bool> m_fillTriggerBits{this, "FillTriggerBits", true, "Read in xTrigDecision and use it to fill Trigger bits in event header"};
 
   std::map<std::string, ByteStreamOutputSvc*> m_ioSvcMap;
 
   ServiceHandle<StoreGateSvc> m_evtStore;
 
   std::string m_userType;
 
   using FEAPtr_t = std::unique_ptr<FullEventAssemblerBase>;
   using FEAMap_t = std::map<std::string,  FEAPtr_t>;
 
   struct SlotData
   {
     std::unique_ptr<RawEventWrite> m_rawEventWrite;
     FEAMap_t m_feaMap;
     std::vector<uint32_t> m_tagBuff;
     std::vector<uint32_t> m_l1Buff;
     std::vector<uint32_t> m_l2Buff;
     std::vector<uint32_t> m_efBuff;
 
     void clear()
     {
       m_rawEventWrite.reset();
       m_feaMap.clear();
       m_tagBuff.clear();
       m_l1Buff.clear();
       m_l2Buff.clear();
       m_efBuff.clear();
     }
   };
   SG::SlotSpecificObj<SlotData> m_slots;
 
   void writeFEA (SlotData& slot);
};
 
// Implementation of template method:
template <class T> StatusCode ByteStreamCnvSvc::getFullEventAssembler(T*& t, const std::string& nm)
{
   const EventContext& ctx = Gaudi::Hive::currentContext();
   FEAMap_t& feaMap = m_slots.get (ctx)->m_feaMap;
   FEAPtr_t& fea = feaMap[nm];
   if (fea) {
      T* p = dynamic_cast<T*>(fea.get());
      if (p == 0) {
         ATH_MSG_WARNING(" Key = " << nm << " exists, but of different type");
         return(StatusCode::FAILURE);
      }
      t = p;
      return(StatusCode::SUCCESS);
   }
 
   // reach here if key does not exist
   auto ptr = std::make_unique<T>();
   t = ptr.get();
   fea = std::move (ptr);
   return(StatusCode::SUCCESS);
}
 
#endif