ScriptableReference.hpp

#pragma once
#include <State/Address.hpp>
#include <State/Expression.hpp>
 
#include <Process/State/MessageNode.hpp>
 
#include <score/plugins/documentdelegate/plugin/DocumentPlugin.hpp>
 
#include <score_lib_process_export.h>
 
#include <ossia/detail/hash_map.hpp>
 
#include <QPointer>
 
#include <verdigris>
 
#include <atomic>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
 
namespace ossia::net
{
class device_base;
class node_base;
class parameter_base;
}
 
namespace LocalTree
{
struct ScriptableSnapshot;
 
enum class Recall : uint8_t
{
  None,
  Stop,
  State
};
 
class SCORE_LIB_PROCESS_EXPORT ScriptableTreeBase : public score::DocumentPlugin
{
  W_OBJECT(ScriptableTreeBase)
public:
  using score::DocumentPlugin::DocumentPlugin;
  ~ScriptableTreeBase() override;
 
  virtual ossia::net::device_base& device() const noexcept = 0;
  virtual std::shared_ptr<const ScriptableSnapshot> snapshot() const noexcept = 0;
  void snapshotChanged() E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, snapshotChanged)
 
  virtual QObject*
  objectAt(const ossia::net::node_base& node, QString& member) const noexcept = 0;
  virtual ossia::net::node_base*
  nodeOf(const QObject& object, const QString& member) const noexcept = 0;
 
  virtual std::vector<QObject*> referrers(const QObject& target) const = 0;
  virtual std::vector<QObject*> targets(const QObject& referrer) const = 0;
 
  virtual void follow(QObject& referrer) = 0;
 
  virtual ossia::net::parameter_base*
  reserve(const ::State::Address& address, const ossia::value& sample) = 0;
 
  void setEmphasized(std::vector<const QObject*> objects);
  bool emphasized(const QObject& object) const noexcept;
  void emphasisChanged() E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, emphasisChanged)
  void published(QObject* object) E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, published, object)
  void referencesChanged(QObject* referrer)
      E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, referencesChanged, referrer)
  void executionStarted() E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, executionStarted)
  void executionStopped() E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, executionStopped)
 
  virtual bool hasPlayedValues() const noexcept = 0;
  virtual void keepPlayedValues() = 0;
  void playedValuesChanged() E_SIGNAL(SCORE_LIB_PROCESS_EXPORT, playedValuesChanged)
 
  Recall recall() const noexcept { return m_recall.load(std::memory_order_acquire); }
  uint32_t runsEnded() const noexcept
  {
    return m_runsEnded.load(std::memory_order_acquire);
  }
  Recall recallAt(Recall recall, uint32_t run) const noexcept
  {
    return (recall == Recall::None && run != runsEnded()) ? Recall::Stop : recall;
  }
 
protected:
  std::atomic<Recall> m_recall{Recall::None};
  std::atomic<uint32_t> m_runsEnded{};
 
private:
  ossia::hash_map<const QObject*, QPointer<const QObject>> m_emphasized;
};
 
SCORE_LIB_PROCESS_EXPORT bool anchor(::State::Address& a, const score::DocumentContext& ctx);
SCORE_LIB_PROCESS_EXPORT bool
anchor(::State::AddressAccessor& a, const score::DocumentContext& ctx);
SCORE_LIB_PROCESS_EXPORT void anchor(::State::Expression& e, const score::DocumentContext& ctx);
 
SCORE_LIB_PROCESS_EXPORT void settle(::State::Address& a, const score::DocumentContext& ctx);
SCORE_LIB_PROCESS_EXPORT void
settle(::State::AddressAccessor& a, const score::DocumentContext& ctx);
SCORE_LIB_PROCESS_EXPORT void settle(::State::Expression& e, const score::DocumentContext& ctx);
SCORE_LIB_PROCESS_EXPORT bool
settle(Process::MessageNode& node, const score::DocumentContext& ctx);
 
SCORE_LIB_PROCESS_EXPORT ::State::Address
derive(const ::State::Anchor& a, const score::DocumentContext& ctx);
 
SCORE_LIB_PROCESS_EXPORT QObject* publishedObject(
    const ::State::Address& a, const score::DocumentContext& ctx, QString& member);
 
SCORE_LIB_PROCESS_EXPORT std::optional<bool>
published(const ::State::Address& a, const score::DocumentContext& ctx);
enum class AddressStatus
{
  Found,
  Unpublished,
  NoDevice,
  NoNode
};
SCORE_LIB_PROCESS_EXPORT AddressStatus
addressStatus(const ::State::Address& a, const score::DocumentContext& ctx);
SCORE_LIB_PROCESS_EXPORT QString describe(AddressStatus s);
SCORE_LIB_PROCESS_EXPORT bool broken(const ::State::Address& a, const score::DocumentContext& ctx);
SCORE_LIB_PROCESS_EXPORT bool
isProcessState(const ::State::Address& a, const score::DocumentContext& ctx);
 
using AnchorMapping = std::function<std::shared_ptr<const ::State::Anchor>(
    const std::shared_ptr<const ::State::Anchor>&)>;
SCORE_LIB_PROCESS_EXPORT void mapAnchors(Process::MessageNode& n, const AnchorMapping& f);
SCORE_LIB_PROCESS_EXPORT void mapAnchors(::State::Expression& e, const AnchorMapping& f);
 
using AddressMapping
    = std::function<std::optional<::State::AddressAccessor>(const ::State::AddressAccessor&)>;
SCORE_LIB_PROCESS_EXPORT void
mapAddresses(::State::Expression& e, const AddressMapping& map, bool& changed);
 
SCORE_LIB_PROCESS_EXPORT ::State::Address
derived(const ::State::Address& a, const score::DocumentContext& ctx);
SCORE_LIB_PROCESS_EXPORT ::State::AddressAccessor
derived(const ::State::AddressAccessor& a, const score::DocumentContext& ctx);
}