IoComponentMgr.h

Go to the documentation of this file.

// 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 <string>
#include <map>
#include <list>

// FrameWork includes
#include "GaudiKernel/Service.h"

// GaudiKernel
#include "GaudiKernel/IIoComponent.h"
#include "GaudiKernel/IIoComponentMgr.h"
#include "GaudiKernel/IIncidentListener.h"

// Forward declaration
class ISvcLocator;

class IoComponentMgr: public extends2<Service, IIoComponentMgr,
              IIncidentListener> {
  // Public methods:
 public:

  // Copy constructor:

  IoComponentMgr( const std::string& name, ISvcLocator* pSvcLocator );

  virtual ~IoComponentMgr();

  // Assignment operator:
  //IoComponentMgr &operator=(const IoComponentMgr &alg);


  virtual StatusCode initialize();
  virtual StatusCode finalize();


  void handle(const Incident&);

  // Const methods:

  virtual
  bool io_hasitem (IIoComponent* iocomponent) const;

  virtual
  bool io_contains (IIoComponent* iocomponent,
            const std::string& fname) const;

  // Non-const methods:

  virtual
  StatusCode io_register (IIoComponent* iocomponent);

  virtual
  StatusCode io_register (IIoComponent* iocomponent,
              IIoComponentMgr::IoMode::Type iomode,
              const std::string& fname,
              const std::string& pfn);

  virtual
  StatusCode io_update (IIoComponent* iocomponent,
            const std::string& old_fname,
            const std::string& new_fname);

  virtual
  StatusCode io_update (IIoComponent* iocomponent,
            const std::string& work_dir);

  // VT. new method
  virtual
  StatusCode io_update_all (const std::string& work_dir);

  virtual
  StatusCode io_retrieve (IIoComponent* iocomponent,
              std::string& fname);

  virtual
  StatusCode io_reinitialize ();

  virtual
  StatusCode io_finalize ();

  // Private data:
 private:

  struct IoComponentEntry {
    std::string m_oldfname;
    std::string m_oldabspath; // VT. store absolute path
    std::string m_newfname;
    IIoComponentMgr::IoMode::Type m_iomode;

    IoComponentEntry():m_oldfname(""),m_oldabspath(""),m_newfname(""), // VT. changes
               m_iomode(IIoComponentMgr::IoMode::INVALID) {}
    IoComponentEntry(const std::string& f, const std::string& p,       // VT. changes
             const IIoComponentMgr::IoMode::Type& t)
      : m_oldfname(f), m_oldabspath(p),m_newfname(""), m_iomode(t){}   // VT. changes
    IoComponentEntry(const IoComponentEntry& rhs):m_oldfname(rhs.m_oldfname),
                          m_oldabspath(rhs.m_oldabspath), // VT. changes
                          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();

  mutable MsgStream m_log;

  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;

  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