InputFileIncidentGuard.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

 
#ifndef ATHENAKERNEL_INPUTFILEINCIDENTGUARD_H
#define ATHENAKERNEL_INPUTFILEINCIDENTGUARD_H

 
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/FileIncident.h"
 
#include <optional>
#include <string>
#include <string_view>
#include <utility>
 
class InputFileIncidentGuard {
public:
   [[nodiscard("End incident will not fire if the guard is discarded")]]
   static InputFileIncidentGuard begin(IIncidentSvc& incSvc,
                                       std::string_view source,
                                       std::string_view beginFileName,
                                       std::string_view guid,
                                       std::string_view endFileName = {},
                                       std::string_view beginType = IncidentType::BeginInputFile,
                                       std::string_view endType = IncidentType::EndInputFile) {
      return InputFileIncidentGuard(incSvc, source, beginFileName, guid,
                                    endFileName.empty() ? "FID:" + std::string(guid)
                                                        : std::string(endFileName),
                                    beginType, endType);
   }

   static void transition(std::optional<InputFileIncidentGuard>& guard,
                          IIncidentSvc& incSvc,
                          std::string_view source,
                          std::string_view beginFileName,
                          std::string_view guid,
                          std::string_view endFileName = {},
                          std::string_view beginType = IncidentType::BeginInputFile,
                          std::string_view endType = IncidentType::EndInputFile) {
      guard.reset();
      guard = begin(incSvc, source, beginFileName, guid,
                    endFileName, beginType, endType);
   }

   ~InputFileIncidentGuard() {
      if (m_incSvc) {
         m_incSvc->fireIncident(
            FileIncident(m_source, m_endType,
                         m_endFileName, m_guid));
      }
   }

   InputFileIncidentGuard(InputFileIncidentGuard&& other) noexcept
      : m_incSvc(std::exchange(other.m_incSvc, nullptr))
      , m_source(std::move(other.m_source))
      , m_guid(std::move(other.m_guid))
      , m_endFileName(std::move(other.m_endFileName))
      , m_endType(std::move(other.m_endType))
   {}

   InputFileIncidentGuard& operator=(InputFileIncidentGuard&& other) noexcept {
      if (this != &other) {
         if (m_incSvc) {
            m_incSvc->fireIncident(
               FileIncident(m_source, m_endType,
                            m_endFileName, m_guid));
         }
         m_incSvc = std::exchange(other.m_incSvc, nullptr);
         m_source = std::move(other.m_source);
         m_guid = std::move(other.m_guid);
         m_endFileName = std::move(other.m_endFileName);
         m_endType = std::move(other.m_endType);
      }
      return *this;
   }

   InputFileIncidentGuard(const InputFileIncidentGuard&) = delete;
   InputFileIncidentGuard& operator=(const InputFileIncidentGuard&) = delete;
 
private:
   InputFileIncidentGuard(IIncidentSvc& incSvc,
                          std::string_view source,
                          std::string_view beginFileName,
                          std::string_view guid,
                          std::string endFileName,
                          std::string_view beginType,
                          std::string_view endType)
      : m_incSvc(&incSvc)
      , m_source(source)
      , m_guid(guid)
      , m_endFileName(std::move(endFileName))
      , m_endType(endType)
   {
      m_incSvc->fireIncident(
         FileIncident(m_source, std::string(beginType),
                      std::string(beginFileName), m_guid));
   }

   IIncidentSvc* m_incSvc;
   std::string m_source;
   std::string m_guid;
   std::string m_endFileName;
   std::string m_endType;
};
 
#endif // ATHENAKERNEL_INPUTFILEINCIDENTGUARD_H