DBAccessorBase.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/DBStore.h>
#include <framework/logging/Logger.h>
 
#include <string>
#include <vector>
#include <functional>
 
class TClass;
 
namespace Belle2 {

  class DBAccessorBase {
  public:

    DBAccessorBase(const std::string& name, const TClass* objClass, bool isArray, bool isRequired) :
      m_type(DBStoreEntry::c_Object), m_name(name), m_objClass(objClass), m_isArray(isArray), m_isRequired(isRequired),
      m_entry{DBStore::Instance().getEntry(name, objClass, isArray, isRequired)}, m_changed{isValid()}
    {
      if (m_entry) m_entry->registerAccessor(this);
    }
    DBAccessorBase(const std::string& name, const TClass* objClass, bool isArray, bool isRequired) : {…}

    DBAccessorBase(DBStoreEntry::EPayloadType type, const std::string& name, bool isRequired):
      m_type(type), m_name(name), m_objClass(nullptr), m_isArray(false), m_isRequired(isRequired),
      m_entry{DBStore::Instance().getEntry(type, name, nullptr, false, isRequired)}, m_changed{isValid()}
    {
      if (m_entry) m_entry->registerAccessor(this);
    }
    DBAccessorBase(DBStoreEntry::EPayloadType type, const std::string& name, bool isRequired): {…}

    virtual ~DBAccessorBase()
    {
      if (m_entry) m_entry->removeAccessor(this);
    }
    virtual ~DBAccessorBase() {…}

    const std::string& getName() const { return m_name; }

    inline bool isValid() const {if (!ensureAttached()) return false; return (m_entry->getObject() != nullptr);}
 
    inline operator bool()  const {return isValid();}   

    virtual bool operator==(const DBAccessorBase& other) const
    {
      return getName() == other.getName();
    }
    virtual bool operator==(const DBAccessorBase& other) const {…}

    virtual bool operator!=(const DBAccessorBase& other) const
    {
      return !(*this == other);
    }
    virtual bool operator!=(const DBAccessorBase& other) const {…}

    bool hasChanged()
    {
      const bool ret = m_changed;
      m_changed = false;
      return ret;
    }
    bool hasChanged() {…}

    void addCallback(std::function<void(const std::string&)> callback, bool onDestruction = false)
    {
      m_callbacks.emplace_back(callback, onDestruction);
    }
    void addCallback(std::function<void(const std::string&)> callback, bool onDestruction = false) {…}

    void addCallback(std::function<void()> callback, bool onDestruction = false)
    {
      addCallback([callback](const std::string&) -> void { callback(); }, onDestruction);
    }
    void addCallback(std::function<void()> callback, bool onDestruction = false) {…}

    template<class T> void addCallback(T* object, void(T::*callback)())
    {
      addCallback([ = ](const std::string&) {(*object.*callback)();});
    }
    template<class T> void addCallback(T* object, void(T::*callback)()) {…}

    const std::string& getGlobaltag() const { ensureAttached(); return m_entry->getGlobaltag(); }

    unsigned int getRevision() const { ensureAttached(); return m_entry->getRevision(); }

    IntervalOfValidity getIoV() const { ensureAttached(); return m_entry->getIoV(); }

    const std::string& getChecksum() const { ensureAttached(); return m_entry->getChecksum(); }

    const std::string& getFilename() const { ensureAttached(); return m_entry->getFilename(); }

    bool isIntraRunDependent() const { ensureAttached(); return m_entry->isIntraRunDependent(); }

    const std::vector<unsigned int> getIntraRunBoundaries() const { ensureAttached(); return m_entry->getIntraRunBoundaries(); }

    bool isRequired() const { ensureAttached(); return m_entry->isRequired(); }
 
  protected:
    template<class T = TObject> const T * getObject() const
    {
      if (!ensureAttached()) return nullptr;
      return reinterpret_cast<const T*>(m_entry->getObject());
    }
    template<class T = TObject> const T * getObject() const {…}

    bool ensureAttached() const
    {
      if (!m_entry) {
        B2DEBUG(32, "DBAccessor " << m_name << " lost connection, reattaching");
        m_entry = DBStore::Instance().getEntry(m_type, m_name, m_objClass, m_isArray, m_isRequired);
        m_changed = true;
        if (!m_entry) return false;
        m_entry->registerAccessor(const_cast<DBAccessorBase*>(this));
      }
      return true;
    }
    bool ensureAttached() const {…}

    void storeEntryChanged(bool destructed)
    {
      // we obviously changed
      m_changed = true;
      // StoreEntry is destructed, remove reference
      if (destructed) m_entry = nullptr;
      // Now run all registered callbacks
      // TODO: We could guard m_callbacks against insertions during callback
      // execution to prevent exponential growth of callbacks
      for (const auto& cb : m_callbacks) {
        if (destructed == cb.second) cb.first(m_name);
      }
    }
    void storeEntryChanged(bool destructed) {…}

    const DBStoreEntry::EPayloadType m_type;
    const std::string m_name;
    const TClass* m_objClass;
    const bool m_isArray;
    const bool m_isRequired;
    mutable DBStoreEntry* m_entry;
    mutable bool m_changed{false};
    std::vector<std::pair<std::function<void(const std::string&)>, bool>> m_callbacks;
    friend class DBStoreEntry;
  };
  class DBAccessorBase {…};

}