DBStoreEntry.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/IntraRunDependency.h>
 
#include <string>
#include <unordered_set>
 
class TFile;
 
namespace Belle2 {
  class EventMetaData;
  class DBAccessorBase;

  class DBStoreEntry {
  public:
    enum EPayloadType {
      c_RawFile,
      c_ROOTFile,
      c_Object
    };

    DBStoreEntry(EPayloadType type, const std::string& name, const TClass* objClass, bool isArray, bool isRequired):
      m_payloadType(type), m_name(name), m_objClass(objClass), m_isArray(isArray), m_isRequired(isRequired) {}

    static DBStoreEntry fromObject(const std::string& name, const TObject* obj, bool isRequired);
    DBStoreEntry(const DBStoreEntry&) = delete;
    DBStoreEntry& operator=(const DBStoreEntry&) = delete;
    DBStoreEntry(DBStoreEntry&&) = default;
    ~DBStoreEntry();
    const std::string& getName() const { return m_name; }
    const std::string& getGlobaltag() const { return m_globaltag; }
    unsigned int getRevision() const { return m_revision; }
    IntervalOfValidity getIoV() const { return m_iov; }
    const std::string& getFilename() const { return m_filename; }
    const std::string& getChecksum() const { return m_checksum; }
    const TObject* getObject() const { return m_object; }
    const TFile* getTFile() const { return m_tfile; }
    const TClass* getClass() const { return m_objClass; }
    bool isArray() const { return m_isArray; }
    bool isRequired() const { return m_isRequired; }
    bool keepUntilExpired() const { return m_keep; }
    bool isIntraRunDependent() const { return (bool)m_intraRunDependency; }
    const std::vector<unsigned int> getIntraRunBoundaries() const { if (isIntraRunDependent()) return m_intraRunDependency->getBoundaries(); return std::vector<unsigned int> {}; }
    void registerAccessor(DBAccessorBase* object) { m_accessors.insert(object); }
    void removeAccessor(DBAccessorBase* object) { m_accessors.erase(object); }
 
  private:
    void resetPayload();
    void updatePayload(unsigned int revision, const IntervalOfValidity& iov, const std::string& filename, const std::string& checksum,
                       const std::string& globaltag, const EventMetaData& event);
    void loadPayload(const EventMetaData& event);
    void updateObject(const EventMetaData& event);
    void overrideObject(TObject* obj, const IntervalOfValidity& iov);
    TObject* releaseObject() { TObject* obj{nullptr}; std::swap(obj, m_object); return obj; }
    bool checkType(const TObject* object) const;
    bool checkType(EPayloadType type, const TClass* objClass, bool array, bool inverse = false) const;
    void notifyAccessors(bool onDestruction = false);
    void require() { m_isRequired = true; }
    const EPayloadType m_payloadType;
    const std::string m_name;
    const TClass* const m_objClass;
    const bool m_isArray;
    bool m_isRequired{false};
    bool m_keep{false};
    std::string m_globaltag{""};
    unsigned int m_revision{0};
    IntervalOfValidity m_iov{0, 0, 0, 0};
    std::string m_filename{""};
    std::string m_checksum;
    TFile* m_tfile{nullptr};
    TObject* m_object{nullptr};
    IntraRunDependency* m_intraRunDependency{nullptr};
    std::unordered_set<DBAccessorBase*> m_accessors;
    friend class DBStore;
    friend class Database;
  };

}