IROBDataProviderSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef IROBDATAPROVIDERSVC_H
#define IROBDATAPROVIDERSVC_H
 
#include "GaudiKernel/IInterface.h"
#include "ByteStreamData/RawEvent.h"
#include "GaudiKernel/EventContext.h"
 
#include <cstdint>
#include <vector>
#include <string>
#include <string_view>
#include <stdexcept>
#include <functional>
 
// Declaration of the interface ID ( interface id, major version, minor version)
//static const InterfaceID IID_IROBDataProviderSvc("IROBDataProviderSvc", 1 , 0);
 
class IROBDataProviderSvc : virtual public IInterface {
 
public:
  typedef OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment ROBF;
  typedef std::vector<const ROBF*> VROBFRAG;
 
  //   static const InterfaceID& interfaceID() { return IID_IROBDataProviderSvc; }
  DeclareInterfaceID(IROBDataProviderSvc, 1, 1);
 
   virtual void addROBData(const std::vector<uint32_t>& robIds, const std::string_view callerName="UNKNOWN") = 0 ;
 
   virtual void setNextEvent(const std::vector<ROBF>& result) = 0 ;
 
 
   virtual void setNextEvent(const RawEvent* re) = 0 ;
 
 
   virtual void getROBData(const std::vector<uint32_t>& robIds, VROBFRAG& robFragments, const std::string_view callerName="UNKNOWN") = 0;
 
 
   virtual const RawEvent* getEvent() = 0;
 
 
   virtual void setEventStatus(uint32_t status) = 0;
 
 
   virtual uint32_t getEventStatus() = 0;
 
 
   // variants for MT, it has an implementation for now in order not to require change in all implementations yet, they will all become pure virtual methods
   virtual void addROBData(const EventContext& /*context*/, const std::vector<uint32_t>& /*robIds*/, const std::string_view callerName="UNKNOWN") { 
     throw std::runtime_error( std::string(callerName)+ std::string(" is using unimplemented ") + __FUNCTION__ ) ; 
   }
   virtual void setNextEvent(const EventContext& /*context*/, const std::vector<ROBF>& /*result*/) {
     throw std::runtime_error( std::string("Unimplemented ") + __FUNCTION__ ); 
   }
   virtual void setNextEvent( const EventContext& /*context*/, const RawEvent* /*re*/) {
     throw std::runtime_error(std::string("Unimplemented ") + __FUNCTION__ ); 
   }
   virtual void getROBData(const EventContext& /*context*/, const std::vector<uint32_t>& /*robIds*/, VROBFRAG& /*robFragments*/, 
               const std::string_view callerName="UNKNOWN") { 
     throw std::runtime_error( std::string(callerName)+ std::string(" is using unimplemented ") + __FUNCTION__ ) ; 
   }
   virtual const RawEvent* getEvent(const EventContext& /*context*/) {
     throw std::runtime_error(std::string("Unimplemented ") + __FUNCTION__ ); 
   }
   virtual void setEventStatus(const EventContext& /*context*/, uint32_t /*status*/) {
     throw std::runtime_error(std::string("Unimplemented ") + __FUNCTION__ ); 
   }
   virtual uint32_t getEventStatus(const EventContext& /*context*/) {
     throw std::runtime_error(std::string("Unimplemented ") + __FUNCTION__ ); 
     return 0;
   }
   
   virtual void processCachedROBs(const EventContext& /*context*/, 
                  const std::function< void(const ROBF* )>& /*fn*/ ) const {
     throw std::runtime_error(std::string("Unimplemented ") + __FUNCTION__ ); 
   }
  
  virtual bool isEventComplete(const EventContext& /*context*/) const {
    throw std::runtime_error(std::string("Unimplemented ") + __FUNCTION__ );      
  } 
  
  virtual int collectCompleteEventData(const EventContext& /*context*/, const std::string_view callerName="UNKNOWN") {
    throw std::runtime_error(std::string(callerName) + std::string(" is using unimplemented ") + __FUNCTION__ );
    return 0;
  }
 
};
 
#endif