IoComponentMgr.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 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