IoComponentMgr.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.                                             *
\***********************************************************************************/
// IoComponentMgr.h
// Header file for class IoComponentMgr
// Author: S.Binet<binet@cern.ch>
#ifndef GAUDIMP_IOCOMPONENTMGR_H
#define GAUDIMP_IOCOMPONENTMGR_H 1
 
// Python includes
#include <Python.h>
 
// STL includes
#include <list>
#include <map>
#include <string>
#include <vector>
 
// FrameWork includes
#include <GaudiKernel/Service.h>
 
// GaudiKernel
#include <GaudiKernel/IIncidentListener.h>
#include <GaudiKernel/IIoComponent.h>
#include <GaudiKernel/IIoComponentMgr.h>
 
// Forward declaration
class ISvcLocator;
 
class IoComponentMgr : public extends<Service, IIoComponentMgr, IIncidentListener> {
  // Public methods:
public:
  using extends::extends;
 
 
  StatusCode initialize() override;
  StatusCode finalize() override;
 
  void handle( const Incident& ) override;
 
  // Const methods:
 
  bool io_hasitem( IIoComponent* iocomponent ) const override;
 
  bool io_contains( IIoComponent* iocomponent, const std::string& fname ) const override;
 
  // Non-const methods:
 
  StatusCode io_register( IIoComponent* iocomponent ) override;
 
  StatusCode io_register( IIoComponent* iocomponent, IIoComponentMgr::IoMode::Type iomode, const std::string& fname,
                          const std::string& pfn ) override;
 
  StatusCode io_update( IIoComponent* iocomponent, const std::string& old_fname,
                        const std::string& new_fname ) override;
 
  StatusCode io_update( IIoComponent* iocomponent, const std::string& work_dir ) override;
 
  StatusCode io_update_all( const std::string& work_dir ) override;
 
  std::vector<std::string> io_retrieve( IIoComponent* iocomponent ) override;
 
  StatusCode io_retrieve( IIoComponent* iocomponent, std::string& fname ) override;
 
  StatusCode io_reinitialize() override;
 
  StatusCode io_finalize() override;
 
  // Private data:
private:
  struct IoComponentEntry {
    std::string                   m_oldfname;
    std::string                   m_oldabspath;
    std::string                   m_newfname;
    IIoComponentMgr::IoMode::Type m_iomode;
 
    IoComponentEntry()
        : m_oldfname( "" ), m_oldabspath( "" ), m_newfname( "" ), m_iomode( IIoComponentMgr::IoMode::INVALID ) {}
    IoComponentEntry( const std::string& f, const std::string& p, const IIoComponentMgr::IoMode::Type& t )
        : m_oldfname( f ), m_oldabspath( p ), m_newfname( "" ), m_iomode( t ) {}
    IoComponentEntry( const IoComponentEntry& rhs )
        : m_oldfname( rhs.m_oldfname )
        , m_oldabspath( rhs.m_oldabspath )
        , m_newfname( rhs.m_newfname )
        , m_iomode( rhs.m_iomode ) {}
    bool operator<( IoComponentEntry const& rhs ) const {
      if ( m_oldfname == rhs.m_oldfname ) {
        return ( m_iomode < rhs.m_iomode );
      } else {
        return ( m_oldfname < rhs.m_oldfname );
      }
    }
 
    friend std::ostream& operator<<( std::ostream& os, const IoComponentEntry& c ) {
      os << "old: \"" << c.m_oldfname << "\"  absolute path: \"" << c.m_oldabspath << "\"  new: \"" << c.m_newfname
         << "\"  m: " << ( ( c.m_iomode == IIoComponentMgr::IoMode::READ ) ? "R" : "W" );
      return os;
    }
  };
 
  IoComponentMgr() = delete;
 
  typedef std::map<std::string, IIoComponent*> IoRegistry_t;
  IoRegistry_t m_ioregistry;
 
  typedef std::list<IIoComponent*> IoStack_t;
  IoStack_t m_iostack;
 
  // This is the registry
  typedef std::multimap<IIoComponent*, IoComponentEntry> IoDict_t;
  typedef IoDict_t::const_iterator                       iodITR;
 
  IoDict_t m_cdict;
 
  std::string m_dict_location;
 
  Gaudi::Property<std::vector<std::string>> m_directio_patterns{ this,
                                                                 "DirectIOPatterns",
                                                                 {
                                                                     "://",
                                                                 },
                                                                 "Search patterns for direct I/O input names" };
 
  bool findComp( IIoComponent*, const std::string&, iodITR& ) const;
  bool findComp( IIoComponent*, std::pair<iodITR, iodITR>& ) const;
  bool findComp( const std::string&, std::pair<iodITR, iodITR>& ) const;
 
  std::string list() const;
};
 
#endif //> !GAUDIMP_IOCOMPONENTMGR_H