EventSlot.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2024 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, 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 EVENTSLOT_H_
#define EVENTSLOT_H_
 
// Framework includes
#include "AlgsExecutionStates.h"
#include <GaudiKernel/EventContext.h>
 
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
 
struct EventSlot {
  EventSlot( unsigned int numberOfAlgorithms, unsigned int numberOfControlFlowNodes, SmartIF<IMessageSvc> MS )
      : algsStates( numberOfAlgorithms, MS ), controlFlowState( numberOfControlFlowNodes, -1 ) {}
 
  EventSlot( const EventSlot& ) = delete;
  EventSlot& operator=( const EventSlot& ) = delete;
  EventSlot( EventSlot&& ) = default;
  EventSlot& operator=( EventSlot&& ) = default;
 
  EventSlot( EventSlot& original, std::unique_ptr<EventContext> theeventContext, const std::string& nodeName )
      : eventContext( std::move( theeventContext ) )
      , algsStates( original.algsStates )
      , controlFlowState( original.controlFlowState )
      , entryPoint( nodeName )
      , parentSlot( &original ) {
    algsStates.reset();
  }
 
  void reset( EventContext* theeventContext ) {
    eventContext.reset( theeventContext );
    algsStates.reset();
    controlFlowState.assign( controlFlowState.size(), -1 );
    complete = false;
    entryPoint.clear();
    parentSlot = nullptr;
    subSlotsByNode.clear();
    allSubSlots.clear();
  }
 
  void addSubSlot( std::unique_ptr<EventContext> viewContext, const std::string& nodeName ) {
    unsigned int lastIndex = allSubSlots.size();
 
    auto search = subSlotsByNode.find( nodeName );
    if ( search != subSlotsByNode.end() )
      subSlotsByNode[nodeName].push_back( lastIndex );
    else
      subSlotsByNode.emplace( std::piecewise_construct, std::forward_as_tuple( nodeName ),
                              std::forward_as_tuple( 1, lastIndex ) );
 
    // Make new slot and nest it into the top slot
    viewContext->setSubSlot( lastIndex );
    allSubSlots.emplace_back( *this, std::move( viewContext ), nodeName );
  }
 
  void disableSubSlots( const std::string& nodeName ) {
    subSlotsByNode.emplace( std::piecewise_construct, std::forward_as_tuple( nodeName ), std::forward_as_tuple() );
  }
 
  std::unique_ptr<EventContext> eventContext;
  AlgsExecutionStates algsStates;
  std::vector<int> controlFlowState;
  bool complete = false;
 
 
  std::string entryPoint;
  EventSlot* parentSlot = nullptr;
  std::unordered_map<std::string, std::vector<unsigned int>> subSlotsByNode;
  std::vector<EventSlot> allSubSlots;
};
 
#endif /* EVENTSLOT_H_ */