MultiFileCatalog.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.                                             *
\***********************************************************************************/
#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:
    using extends::extends;

    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();

    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"}}, &MultiFileCatalog::propHandler, "catalog names"};

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