DataProcessingContext.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_DATAPROCESSORCONTEXT_H_
#define O2_FRAMEWORK_DATAPROCESSORCONTEXT_H_
 
#include "Framework/DataRelayer.h"
#include "Framework/AlgorithmSpec.h"
#include <functional>
 
namespace o2::framework
{
 
struct DeviceContext;
struct ServiceRegistry;
struct DataAllocator;
struct DataProcessorSpec;
 
struct DataProcessorContext {
  DataProcessorContext(DataProcessorContext const&) = delete;
  DataProcessorContext() = default;
 
  bool allDone = false;
  int64_t lastRunNumberProcessed = -1;
 
  // These are pointers to the one owned by the DataProcessingDevice
  // but they are fully reentrant / thread safe and therefore can
  // be accessed without a lock.
 
  // FIXME: move stuff here from the list below... ;-)
  ServiceRegistry* registry = nullptr;
  std::vector<DataRelayer::RecordAction> completed;
  std::vector<ExpirationHandler> expirationHandlers;
  AlgorithmSpec::InitCallback init;
  AlgorithmSpec::ProcessCallback statefulProcess;
  AlgorithmSpec::ProcessCallback statelessProcess;
  AlgorithmSpec::ErrorCallback error = nullptr;
  AlgorithmSpec::InitErrorCallback initError = nullptr;
 
  DataProcessorSpec* spec = nullptr; 
 
  void preStartCallbacks(ServiceRegistryRef);
  void preProcessingCallbacks(ProcessingContext&);
  void finaliseOutputsCallbacks(ProcessingContext&);
  void postProcessingCallbacks(ProcessingContext&);
  void preDanglingCallbacks(DanglingContext&);
  void postDanglingCallbacks(DanglingContext&);
  void preEOSCallbacks(EndOfStreamContext&);
  void postEOSCallbacks(EndOfStreamContext&);
  void postDispatchingCallbacks(ProcessingContext&);
  void postForwardingCallbacks(ProcessingContext&);
 
  void postStopCallbacks(ServiceRegistryRef);
 
  void preLoopCallbacks(ServiceRegistryRef);
 
  static void preExitCallbacks(std::vector<ServiceExitHandle>, ServiceRegistryRef);
 
  void domainInfoUpdatedCallback(ServiceRegistryRef, size_t oldestPossibleTimeslice, ChannelIndex channelIndex);
 
  void preSendingMessagesCallbacks(ServiceRegistryRef, fair::mq::Parts& parts, ChannelIndex channelindex);
 
  mutable std::vector<ServiceProcessingHandle> preProcessingHandlers;
  mutable std::vector<ServiceProcessingHandle> finaliseOutputsHandles;
  mutable std::vector<ServiceProcessingHandle> postProcessingHandlers;
  mutable std::vector<ServiceDanglingHandle> preDanglingHandles;
  mutable std::vector<ServiceDanglingHandle> postDanglingHandles;
  mutable std::vector<ServiceEOSHandle> preEOSHandles;
  mutable std::vector<ServiceEOSHandle> postEOSHandles;
  mutable std::vector<ServiceDispatchingHandle> postDispatchingHandles;
  mutable std::vector<ServiceForwardingHandle> postForwardingHandles;
  mutable std::vector<ServiceStartHandle> preStartHandles;
  mutable std::vector<ServiceStopHandle> postStopHandles;
  mutable std::vector<ServiceExitHandle> preExitHandles;
  mutable std::vector<ServiceDomainInfoHandle> domainInfoHandles;
  mutable std::vector<ServicePreSendingMessagesHandle> preSendingMessagesHandles;
  mutable std::vector<ServicePreLoopHandle> preLoopHandles;
 
  bool canForwardEarly = true;
  bool isSink = false;
  bool balancingInputs = true;
 
  std::function<void(o2::framework::RuntimeErrorRef e, InputRecord& record)> errorHandling;
  std::function<void(o2::framework::RuntimeErrorRef e)> initErrorHandling;
};
 
} // namespace o2::framework
#endif // O2_FRAMEWORK_DATAPROCESSINGCONTEXT_H_