MultiFileCatalog.h

Go to the documentation of this file.

#ifndef GAUDIUTILS_MULTIFILECATALOG_H
#define GAUDIUTILS_MULTIFILECATALOG_H

#include "GaudiKernel/Service.h"
#include "GaudiUtils/IFileCatalog.h"
#include "GaudiUtils/IFileCatalogMgr.h"

/*
 *   Gaudi namespace declaration
 */
namespace Gaudi {

  class MultiFileCatalog: public extends2<Service, IFileCatalog, IFileCatalogMgr>
  {
  public:
    // disambiguate between Service::Factory and IFileCatalog::Factory
    typedef Service::Factory Factory;

  protected:
    typedef const std::string&         CSTR;
    typedef std::vector<IFileCatalog*> Catalogs;
    typedef std::vector<std::string>   CatalogNames;

    template <class T> void _exec(T pmf)  const  {
      for(Catalogs::const_iterator i=m_catalogs.begin(); i != m_catalogs.end(); ++i)
        ((*i)->*pmf)();
    }
    template <class A1,class F> std::string _find(A1& arg1,F pmf)  const {
      std::string result;
      for(Catalogs::const_iterator i=m_catalogs.begin(); i != m_catalogs.end(); ++i)
        if ( !(result= ((*i)->*pmf)(arg1)).empty() ) break;
      return result;
    }
    template <class A1,class F> void _collect(A1 arg1,F pmf)  const {
      A1 tmp;
      for(Catalogs::const_iterator i=m_catalogs.begin();i!=m_catalogs.end();++i,tmp.clear()) {
        ((*i)->*pmf)(tmp);
        arg1.insert(arg1.end(),tmp.begin(),tmp.end());
      }
    }
    template <class A1,class A2,class F> void _collect(A1 arg1,A2& arg2,F pmf)  const {
      A2 tmp;
      for(Catalogs::const_iterator i=m_catalogs.begin();i!=m_catalogs.end();++i,tmp.clear()) {
        ((*i)->*pmf)(arg1,tmp);
        arg2.insert(arg2.end(),tmp.begin(),tmp.end());
      }
    }
  public:
    MultiFileCatalog(const std::string& nam, ISvcLocator* svc);
    virtual ~MultiFileCatalog();

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

    virtual std::string createFID() const;
    virtual CSTR connectInfo() const;
    virtual void init()
    {  _exec(&IFileCatalog::init); m_started=true;                           }
    virtual void commit()                   { _exec(&IFileCatalog::commit);   }
    virtual void rollback()                 { _exec(&IFileCatalog::rollback); }
    virtual bool readOnly() const;
    virtual bool dirty() const;
    virtual bool existsPFN(CSTR pfn)  const
    { return !lookupPFN(pfn).empty();                                         }
    virtual std::string lookupPFN(CSTR pfn) const
    {  return _find(pfn,&IFileCatalog::lookupPFN);                            }
    virtual bool existsLFN(CSTR lfn)  const
    { return !lookupLFN(lfn).empty();                                         }
    virtual std::string lookupLFN(CSTR lfn) const
    {  return _find(lfn,&IFileCatalog::lookupLFN);                            }
    virtual bool existsFID(CSTR fid)  const
    {  return 0 != getCatalog(fid,false,false,false);                          }
    virtual void getPFN(CSTR fid, Files& files) const
    {  _collect(fid,files,&IFileCatalog::getPFN);                             }
    virtual void getLFN(CSTR fid, Files& files) const
    {  _collect(fid,files,&IFileCatalog::getLFN);                             }

    virtual void getFID(Strings& fids)  const
    {  _collect(fids,&IFileCatalog::getFID);                                  }
    virtual void deleteFID(CSTR fid)  const
    {  writeCatalog(fid)->deleteFID(fid);                                     }
    virtual void registerPFN(CSTR fid, CSTR pfn, CSTR ftype) const;
    virtual void registerLFN(CSTR fid, CSTR lfn) const;
    virtual void registerFID(CSTR fid) const
    {  writeCatalog()->registerFID(fid);                                      }
    virtual void getMetaData(CSTR fid, Attributes& attr) const
    {  _collect(fid,attr,&IFileCatalog::getMetaData);                         }
    virtual std::string getMetaDataItem(CSTR fid, CSTR name) const;
    virtual void setMetaData(CSTR fid, CSTR attr, CSTR val) const
    {  writeCatalog(fid)->setMetaData(fid,attr,val);                          }
    virtual void dropMetaData(CSTR fid) const
    {  writeCatalog(fid)->dropMetaData(fid);                                  }
    virtual void dropMetaData(CSTR fid, CSTR attr) const
    {  writeCatalog(fid)->dropMetaData(fid,attr);                             }

    virtual IFileCatalog* findCatalog(CSTR connect, bool must_be_writable) const;
    virtual void addCatalog(CSTR connect);
    virtual void addCatalog(IFileCatalog* cat);
    virtual void removeCatalog(CSTR connect);
    virtual void removeCatalog(const IFileCatalog* cat);
    virtual Catalogs& catalogs()                    { return m_catalogs;      }
    virtual const Catalogs& catalogs()  const       { return m_catalogs;      }
    virtual IFileCatalog* writeCatalog(CSTR fid="") const
    {  return getCatalog(fid,true,true,false);                                }
    virtual void setWriteCatalog(IFileCatalog* cat);
    virtual void setWriteCatalog(CSTR connect);

  private:
    IFileCatalog* getCatalog(CSTR fid, bool throw_if_not, bool writable=true, bool prt=true) const;
    Catalogs::iterator i_findCatalog(CSTR connect, bool must_be_writable);

    void propHandler(Property& /* p */);

    void printError(CSTR msg, bool throw_exc=true) const;
    std::string lookupFID(CSTR lfn) const;

    Catalogs        m_catalogs;
    CatalogNames    m_catalogNames;
    bool            m_started;
    CatalogNames    m_oldNames;
  };
}         /* End namespace Gaudi                 */
#endif    /* GAUDIUTILS_MULTIFILECATALOG_H */