EventSlot.h

Go to the documentation of this file.

#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_ */