CallbackService.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
#ifndef O2_FRAMEWORK_CALLBACKSERVICE_H_
#define O2_FRAMEWORK_CALLBACKSERVICE_H_
 
#include "Framework/CallbackRegistry.h"
#include "Framework/ServiceHandle.h"
#include "Framework/DataProcessingHeader.h"
#include "ServiceRegistry.h"
 
#include <fairmq/FwdDecls.h>
 
namespace o2::header
{
struct DataHeader;
}
 
namespace o2::framework
{
 
struct ConcreteDataMatcher;
struct EndOfStreamContext;
 
// A service that data processors can register callback functions invoked by the
// framework at defined steps in the process flow
class CallbackService
{
 public:
  constexpr static ServiceKind service_kind = ServiceKind::Global;
  enum struct Id : int {
    Start = 0,    
    Stop,         
    Reset,        
    Idle,         
    ClockTick,    
    DataConsumed, 
    EndOfStream,
 
    RegionInfoCallback,
    NewTimeslice,
    PreProcessing,
    FinaliseOutputs,
    PostProcessing,
    CCDBDeserialised,
    DomainInfoUpdated,
    DeviceStateChanged,
    ExitRequested,
  };
 
  using StartCallback = std::function<void()>;
  using StopCallback = std::function<void()>;
  using ResetCallback = std::function<void()>;
  using IdleCallback = std::function<void()>;
  using ClockTickCallback = std::function<void()>;
  using DataConsumedCallback = std::function<void(ServiceRegistryRef)>;
  using EndOfStreamCallback = std::function<void(EndOfStreamContext&)>;
  using RegionInfoCallback = std::function<void(fair::mq::RegionInfo const&)>;
  using NewTimesliceCallback = std::function<void(o2::header::DataHeader&, DataProcessingHeader&)>;
  using PreProcessingCallback = std::function<void(ServiceRegistryRef, int)>;
  using FinaliseOutputsCallback = std::function<void(ServiceRegistryRef, int)>;
  using PostProcessingCallback = std::function<void(ServiceRegistryRef, int)>;
  using CCDBDeserializedCallback = std::function<void(ConcreteDataMatcher&, void*)>;
  using DomainInfoUpdatedCallback = std::function<void(ServiceRegistryRef, size_t timeslice, ChannelIndex index)>;
  using DeviceStateChangedCallback = std::function<void(ServiceRegistryRef, int newState)>;
  using ExitRequestedCallback = std::function<void(ServiceRegistryRef)>;
 
  using Callbacks = CallbackRegistry<Id,                                                                   //
                                     RegistryPair<Id, Id::Start, StartCallback>,                           //
                                     RegistryPair<Id, Id::Stop, StopCallback>,                             //
                                     RegistryPair<Id, Id::Reset, ResetCallback>,                           //
                                     RegistryPair<Id, Id::Idle, IdleCallback>,                             //
                                     RegistryPair<Id, Id::ClockTick, ClockTickCallback>,                   //
                                     RegistryPair<Id, Id::DataConsumed, DataConsumedCallback>,             //
                                     RegistryPair<Id, Id::EndOfStream, EndOfStreamCallback>,               //
                                     RegistryPair<Id, Id::RegionInfoCallback, RegionInfoCallback>,         //
                                     RegistryPair<Id, Id::NewTimeslice, NewTimesliceCallback>,             //
                                     RegistryPair<Id, Id::PreProcessing, PreProcessingCallback>,           //
                                     RegistryPair<Id, Id::FinaliseOutputs, FinaliseOutputsCallback>,       //
                                     RegistryPair<Id, Id::PostProcessing, PostProcessingCallback>,         //
                                     RegistryPair<Id, Id::CCDBDeserialised, CCDBDeserializedCallback>,     //
                                     RegistryPair<Id, Id::DomainInfoUpdated, DomainInfoUpdatedCallback>,   //
                                     RegistryPair<Id, Id::DeviceStateChanged, DeviceStateChangedCallback>, //
                                     RegistryPair<Id, Id::ExitRequested, ExitRequestedCallback>            //
                                     >;                                                                    //
 
  template <Id ID, typename U>
  void set(U&& cb)
  {
    mCallbacks.set<ID>(std::forward<U>(cb));
  }
 
  // execute callback for specified processing step with argument pack
  template <Id ID, typename... TArgs>
  auto call(TArgs&&... args)
  {
    mCallbacks.call<ID>(std::forward<TArgs>(args)...);
  }
 
 private:
  Callbacks mCallbacks;
};
 
} // namespace o2::framework
#endif // O2_FRAMEWORK_CALLBACKSERVICE_H_