ByteStreamEventStorageInputSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef BYTESTREAMEVENTSTORAGEINPUTSVC_H
#define BYTESTREAMEVENTSTORAGEINPUTSVC_H
 
// Include files.
#include "ByteStreamCnvSvcBase/IByteStreamInputSvc.h"
#include "ByteStreamCnvSvcBase/IROBDataProviderSvc.h"
#include "ByteStreamData/RawEvent.h"
#include "AthenaBaseComps/AthService.h"
#include "AthenaKernel/SlotSpecificObj.h"
 
// FrameWork includes
#include "GaudiKernel/ServiceHandle.h"
 
namespace EventStorage
{
  class DataReader;
}
class StoreGateSvc;
class DataHeaderElement;
 
 
class ByteStreamEventStorageInputSvc
  : public extends<AthService, IByteStreamInputSvc>
{
public:
  ByteStreamEventStorageInputSvc(const std::string& name,
      ISvcLocator* pSvcLocator);
 
  virtual ~ByteStreamEventStorageInputSvc();
 
  virtual StatusCode initialize() override;
  virtual StatusCode stop      () override;
  virtual StatusCode finalize  () override;
 
  virtual const RawEvent* currentEvent () const override;
  virtual const RawEvent* nextEvent    () override; 
  virtual const RawEvent* previousEvent() override; 
  virtual void            setEvent     (void* data, unsigned int eventStatus) override;
 
  virtual unsigned int currentEventStatus() const override;
  virtual void         validateEvent     () override;
 
  virtual long positionInBlock   () override;
  virtual std::pair<long,std::string> getBlockIterator(const std::string& fileName) override;
  virtual void         closeBlockIterator(bool clearMetadata=true) override;
  virtual bool         setSequentialRead ();
  virtual bool         ready             () override;
  virtual StatusCode   generateDataHeader() override;
 
 
private: // data
  std::mutex m_readerMutex;
 
  struct EventCache {
    std::unique_ptr<RawEvent> rawEvent    = nullptr; 
    char*                     data        = nullptr; 
    unsigned int              eventStatus = 0;       
    long long int             eventOffset = 0;       
    void                      releaseEvent();        
    virtual                   ~EventCache();         
  };
 
  SG::SlotSpecificObj<EventCache> m_eventsCache;
 
  std::unique_ptr<EventStorage::DataReader>  m_reader; 
 
  std::vector<long long int> m_evtOffsets;  
  unsigned int       m_evtInFile;
  long long int      m_evtFileOffset;   
  // Event back navigation info
  std::string        m_fileGUID;      
 
 
 
private: // properties
  ServiceHandle<StoreGateSvc>                m_storeGate;     
  ServiceHandle<StoreGateSvc>                m_inputMetadata; 
  ServiceHandle<IROBDataProviderSvc>         m_robProvider;
  Gaudi::Property<bool>                      m_sequential{this, "EnableSequential", false, "enable sequential reading"};
  Gaudi::Property<bool>                      m_dump{this, "DumpFlag", false, "Dump fragments"};
  Gaudi::Property<float>                     m_wait{this, "WaitSecs", 0.0f, "Seconds to wait if input is in wait state"};
  Gaudi::Property<bool>                      m_valEvent{this, "ValidateEvent", false, "switch on check_tree when reading events"};
  Gaudi::Property<std::string>               m_eventInfoKey{this, "EventInfoKey", "EventInfo", "Key of EventInfo in metadata store"};
 
 
private: // internal helper functions
  StatusCode loadMetadata    ();
  void       buildFragment   (EventCache* cache, uint32_t eventSize, bool validate) const;
  bool       readerReady     ();
  bool       ROBFragmentCheck(const RawEvent*) const;
  unsigned   validateEvent   (const RawEvent* const rawEvent) const;
  void       setEvent        (const EventContext& context, void* data, unsigned int eventStatus);
 
  enum Advance{ PREVIOUS = -1, NEXT = 1 };
  const RawEvent* getEvent( Advance step );
  std::unique_ptr<DataHeaderElement> makeBSProvenance() const;
 
  template<typename T>
  StatusCode deleteEntry(const std::string& key)
  {
    if (m_storeGate->contains<T>(key)) {
      const T* tmp = m_storeGate->tryConstRetrieve<T>(key);
      if (tmp != nullptr) ATH_CHECK(m_storeGate->remove<T>(tmp));
    }
    return StatusCode::SUCCESS;
  }
 
};
 
#endif // BYTESTREAMEVENTSTORAGEINPUTSVC_H