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 extends<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 A1, class F>
    std::string _find( A1& arg1, F pmf ) const
    {
      std::string result;
      for ( const auto& i : m_catalogs ) {
        result = ( i->*pmf )( arg1 );
        if ( !result.empty() ) break;
      }
      return result;
    }
    template <class A1, class F>
    void _collect( A1& arg1, F f ) const
    {
      A1 tmp;
      for ( const auto& i : m_catalogs ) {
        f( i, tmp ); // tmp = f(i)
        arg1.insert( arg1.end(), tmp.begin(), tmp.end() );
        tmp.clear();
      }
    }
    template <class A2, class A1, class F>
    void _collect( const A2& arg2, A1& arg1, F f ) const
    {
      A1 tmp;
      for ( const auto& i : m_catalogs ) {
        f( i, arg2, tmp ); // tmp = f(i,arg2)
        arg1.insert( arg1.end(), tmp.begin(), tmp.end() );
        tmp.clear();
      }
    }

  public:
    MultiFileCatalog( const std::string& nam, ISvcLocator* svc );

    StatusCode initialize() override;
    StatusCode finalize() override;

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

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

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

  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( Details::PropertyBase& /* p */ );

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

    Catalogs m_catalogs;

    Gaudi::Property<CatalogNames> m_catalogNames{
        this, "Catalogs", {{"xmlcatalog_file:test_catalog.xml"}}, "catalog names"};

    bool m_started = false;
    CatalogNames m_oldNames;
  };
} /* End namespace Gaudi                 */
#endif /* GAUDIUTILS_MULTIFILECATALOG_H */