Database.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <framework/database/IntervalOfValidity.h>
#include <framework/database/PayloadMetadata.h>
#include <framework/database/TestingPayloadStorage.h>
#include <framework/database/DBStore.h>
#include <framework/utilities/ScopeGuard.h>
#include <TClonesArray.h>
 
#include <string>
#include <utility>
#include <list>
#include <memory>
 
class TObject;
 
 
namespace Belle2 {
  class EventMetaData;
  namespace Conditions {
    class MetadataProvider;
    class PayloadProvider;
  }
 
  class Database {
  public:
    enum EDatabaseState {
      c_PreInit = 0,
      c_InitGlobaltagList = 1,
      c_Ready = 2,
    };
 
    static Database& Instance();
 
    static void reset(bool keepConfig = false);
 
    using DBQuery = Conditions::PayloadMetadata;
 
    struct DBImportQuery {
      explicit DBImportQuery(const std::string& aName, TObject* aObject = nullptr,
                             const IntervalOfValidity& aIov = IntervalOfValidity()): name(aName), object(aObject), iov(aIov) {};
      std::string        name;   
      TObject*           object; 
      IntervalOfValidity iov;    
    };
 
    std::pair<TObject*, IntervalOfValidity> getData(const EventMetaData& event, const std::string& name);
 
 
    bool getData(const EventMetaData& event, DBQuery& query)
    {
      std::vector<DBQuery> container{query};
      bool found = getData(event, container);
      query = container[0];
      return found;
    }
 
    bool getData(const EventMetaData& event, std::vector<DBQuery>& query);
 
    const TObject* getData(const std::string& name, int experiment, int run)
    {
      EventMetaData eventMetaData(1, run, experiment);
      return getData(eventMetaData, name).first;
    }
 
    std::set<std::string> getAllDataNames() { return DBStore::Instance().getAllEntryNames(); };
 
    bool storeData(const std::string& name, TObject* object, const IntervalOfValidity& iov);
 
    bool storeData(TClonesArray* array, const IntervalOfValidity& iov) {return storeData(DataStore::defaultArrayName(array->ClassName()), array, iov);};
 
    template<class T> bool storeData(T* object, const IntervalOfValidity& iov) {return storeData(DBStore::objectName<T>(""), object, iov);};
 
    bool storeData(std::list<DBImportQuery>& query);
 
    bool addPayload(const std::string& name, const std::string& fileName, const IntervalOfValidity& iov)
    {
      if (!m_payloadCreation) initialize();
      return m_payloadCreation->storePayload(name, fileName, iov);
    }
 
    static void exposePythonAPI();
 
    std::string getGlobalTags();
 
    ScopeGuard createScopedUpdateSession();
 
    void initialize(const EDatabaseState target = c_Ready);
 
  protected:
    Database() = default;
    Database(const Database&) = delete;
    ~Database();
    void nextMetadataProvider();
    std::vector<std::string> m_metadataConfigurations;
    std::string m_currentProvider;
    std::vector<std::string> m_globalTags;
    std::set<std::string> m_usableTagStates;
    std::unique_ptr<Conditions::MetadataProvider> m_metadataProvider;
    std::unique_ptr<Conditions::PayloadProvider> m_payloadProvider;
    std::unique_ptr<Conditions::TestingPayloadStorage> m_payloadCreation;
    std::vector<Conditions::TestingPayloadStorage> m_testingPayloads;
    EDatabaseState m_configState{c_PreInit};
  };
} // namespace Belle2