MetadataProvider.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2019 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Martin Ritter                                            *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <framework/database/PayloadMetadata.h>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace Belle2::Conditions {
  class MetadataProvider {
  public:
    using PayloadMap = std::unordered_map<std::string, PayloadMetadata>;
 
    class PayloadMetadataCache {
    public:
      struct CacheEntry {
        int exp{ -1}; 
        int run{ -1}; 
        PayloadMap map; 
      };
      std::tuple<bool, PayloadMap*> get(int exp, int run)
      {
        using std::get;
        // if run mismatch swap current and last entry
        if (current.exp != exp || current.run != run) std::swap(current, previous);
        // still mismatch? if so clear, otherwise just return
        const bool found = current.exp == exp and current.run == run;
        if (!found) {
          current.exp = exp;
          current.run = run;
          current.map.clear();
        }
        return {found, &current.map};
      }
    private:
      CacheEntry current; 
      CacheEntry previous; 
    };
 
    MetadataProvider() = default;
    explicit MetadataProvider(const std::set<std::string>& usableTagStates): m_payloads{nullptr}, m_usableTagStates(usableTagStates) {}
    virtual ~MetadataProvider() = default;
    bool setTags(const std::vector<std::string>& tags);
    bool getPayloads(int exp, int run, std::vector<PayloadMetadata>& info);
    std::set<std::string> getUsableTagStates() { return m_usableTagStates; }
    void setUsableTagStates(const std::set<std::string>& states)
    {
      m_usableTagStates = states;
      m_usableTagStates.erase("INVALID");
    }
  protected:
    virtual std::string getGlobaltagStatus(const std::string& name) = 0;
    virtual bool updatePayloads(const std::string& globaltag, int exp, int run) = 0;
    void addPayload(PayloadMetadata&& payload, const std::string& messagePrefix = "");
 
    std::vector<std::string> m_tags;
    std::unordered_map<std::string, PayloadMetadataCache> m_cache;
    PayloadMap* m_payloads{nullptr};
    std::set<std::string> m_usableTagStates{"TESTING", "VALIDATED", "RUNNING", "PUBLISHED"};
  };
 
  class NullMetadataProvider: public MetadataProvider {
    bool updatePayloads([[maybe_unused]] const std::string& globaltag, [[maybe_unused]] int exp,
                        [[maybe_unused]] int run) override
    {
      return false;
    }
    std::string getGlobaltagStatus(const std::string& name) override;
    bool m_errorShown{false};
  };
} // namespace Belle2::Conditions