IFileCatalog.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef APR_IFILECATALOG_H
#define APR_IFILECATALOG_H
 
#include "GaudiUtils/IFileCatalog.h"
#include "GaudiUtils/IFileCatalogMgr.h"
#include "GaudiKernel/SmartIF.h"
 
#include "AthenaBaseComps/AthMessaging.h"
#include "GaudiKernel/IMessageSvc.h"
 
#include <iostream>
 
namespace pool {
 
   namespace FileCatalog {
      typedef std::string FileID;
   }
   
   class IFileCatalog : public AthMessaging  {
    public:
 
     typedef Gaudi::IFileCatalog::Files         Files;
     typedef Gaudi::IFileCatalog::Strings       Strings;
     typedef Gaudi::IFileCatalogMgr::Catalogs   Catalogs;
     
     
     IFileCatalog();
     ~IFileCatalog() {}
     
     // ------------------------------ Catalog interface  
     
     std::string createFID() const;
 
     void connect() { /* not doing anything in Gaudi FC */ }
     void disconnect() { /* not doing anything in Gaudi FC */ }
     const std::string& connectInfo() const { return m_fc->connectInfo(); }
       
     void start() { init(); }
     void init() { m_fc->init(); }
     void commit() { m_fc->commit(); }
     void rollback() { m_fc->rollback(); }
     bool readOnly() const { return m_fc->readOnly(); }
     bool dirty() const  { return m_fc->dirty(); }

     void getFIDs( Strings& fids ) const { m_fc->getFID(fids); }
     
     void getLFNs( const std::string& fid, Files& files ) const { m_fc->getLFN(fid, files); }

     void getPFNs( const std::string& fid, Files& files ) const { m_fc->getPFN(fid, files); }

     void getFirstPFN( const std::string& fid, std::string& pfn, std::string& tech ) const;

     void lookupFileByPFN( const std::string& pfn, std::string& fid, std::string& tech ) const;

     bool existsPFN( const std::string& pfn ) const { return m_fc->existsPFN(pfn); }

     std::string lookupPFN( const std::string& pfn ) const { return m_fc->lookupPFN(pfn); }

     //    bool existsLFN( const std::string& lfn ) const = 0;

     void lookupFileByLFN( const std::string& lfn, std::string& fid ) const { fid = lookupLFN(lfn); }
     std::string lookupLFN( const std::string& lfn ) const { return m_fc->lookupLFN(lfn); }

     //    bool existsFID( const std::string& fid ) const = 0;

     void deleteFID( const std::string& FileID ) { m_fc->deleteFID(FileID); }

     void deletePFN( const std::string& pfn ) { m_fc->deletePFN(pfn); }

     void registerPFN( const std::string& pfn, const std::string& ftype, std::string& fid );

     void renamePFN( const std::string& pfn, const std::string& newpfn ) { m_fc->renamePFN(pfn, newpfn); }

     void addReplicaPFN( const std::string& pfn, const std::string& replica_pfn );
     
     void addReplicaFID( const std::string& fid,
                         const std::string& replica_pfn,
                         const std::string& replica_tech = "ROOT_All" );

     // NOTE!  this method requires FID! (and not PFN)
     void registerLFN( const std::string& fid, const std::string& lfn ) const { m_fc->registerLFN(fid, lfn ); }
 
 
     // ------------------------- Catalog Manager interface

     void addReadCatalog( const std::string& connect ) { addCatalog(connect); }
     void addCatalog( const std::string& connect );

     //void addCatalog(  Gaudi::IFileCatalog* cat )  { m_mgr->addCatalog(cat); }

     void removeCatalog( const std::string& connect )  { m_mgr->removeCatalog(connect); }
     
     //void removeCatalog( const  Gaudi::IFileCatalog* cat )  { m_mgr->removeCatalog(cat); }
     Catalogs& catalogs() { return m_mgr->catalogs(); }
     const Catalogs& catalogs() const  { return m_mgr->catalogs(); }
     //Gaudi::IFileCatalog* writeCatalog( const std::string& fid = "" ) const  { return m_mgr->writeCatalog(fid); }
     //void setWriteCatalog(  Gaudi::IFileCatalog* cat )  { m_mgr->setWriteCatalog(cat); }
     void setWriteCatalog( const std::string& connect );
     
 
  protected:
     SmartIF<Gaudi::IFileCatalogMgr>    m_mgr;
     SmartIF<Gaudi::IFileCatalog>       m_fc;
   };
 
}
 
#endif