ReferenceIndex.hpp

#pragma once
#include <State/Address.hpp>
 
#include <LocalTree/ScriptableReference.hpp>
 
#include <ossia/detail/hash_map.hpp>
 
#include <QObject>
#include <QPointer>
#include <QTimer>
 
#include <score_plugin_engine_export.h>
 
#include <verdigris>
 
#include <functional>
#include <optional>
#include <vector>
 
namespace score
{
struct DocumentContext;
}
namespace LocalTree
{
class DocumentPlugin;
 
class SCORE_PLUGIN_ENGINE_EXPORT ReferenceIndex final : public QObject
{
  W_OBJECT(ReferenceIndex)
public:
  explicit ReferenceIndex(DocumentPlugin& tree);
  ~ReferenceIndex();
 
  void add(QObject& referrer);
 
  std::vector<QObject*> referrers(const QObject& target) const;
  std::vector<QObject*> targets(const QObject& referrer) const;
  struct Broken
  {
    ::State::Address address;
    QObject* referrer{};
    AddressStatus status{};
  };
  std::vector<Broken> broken() const;
  void watchExplorer();
 
  void refresh(const QObject& target);
  void recover(const ::State::Address& published);
  void unpublished(const QObject* target);
 
  void changed() E_SIGNAL(SCORE_PLUGIN_ENGINE_EXPORT, changed)
 
public:
  using Mapping = std::function<std::optional<::State::AddressAccessor>(
      const ::State::AddressAccessor&)>;
  void rewrite(QObject& referrer, const Mapping& map);
 
private:
  void update(QObject& referrer);
  void remove(QObject* referrer);
  void notify(QObject* referrer);
  void schedule();
  void unlink(const QObject* target, QObject* referrer);
  void unlinkAddress(const ::State::Address& address, QObject* referrer);
  void unlinkDevice(const QString& device, QObject* referrer);
  void explorerChanged(const QString& device);
  void explorerDevicesChanged();
  bool namesOther(const ::State::Address& a, const QObject* target) const;
 
  struct Ref
  {
    ::State::Address address;
    QPointer<QObject> target;
    const QObject* key{};
    bool anchored{};
    bool local{};
    bool misanchored{};
    bool dangling() const noexcept { return local && !target; }
  };
  struct Entry
  {
    std::vector<Ref> refs;
  };
 
  DocumentPlugin& m_tree;
  ossia::hash_map<QObject*, Entry> m_entries;
  ossia::hash_map<const QObject*, std::vector<QObject*>> m_byTarget;
  ossia::hash_set<const QObject*> m_watched;
  ossia::hash_map<::State::Address, ossia::hash_set<QObject*>, std::hash<::State::Address>>
      m_byAddress;
  ossia::hash_map<QString, ossia::hash_set<QObject*>> m_byDevice;
  ossia::hash_set<QString> m_changedDevices;
  bool m_allDevicesChanged{};
  bool m_missingDevicesChanged{};
  QTimer m_explorerChanges;
  ossia::hash_set<QObject*> m_pending;
  bool m_pendingAll{};
  bool m_scheduled{};
};
}