ScriptableProcessComponent.hpp

#pragma once
#include <State/Address.hpp>
 
#include <Process/ProcessComponent.hpp>
 
#include <LocalTree/ScriptableReference.hpp>
 
 
#include <score/model/Component.hpp>
#include <score/model/EntityMap.hpp>
#include <score/plugins/Interface.hpp>
#include <score/plugins/InterfaceList.hpp>
 
#include <ossia/network/base/node.hpp>
#include <ossia/network/base/parameter.hpp>
 
#include <ossia/detail/hash_map.hpp>
 
#include <QMetaObject>
 
#include <score_lib_process_export.h>
 
#include <nano_observer.hpp>
 
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace score
{
class ModelMetadata;
}
namespace Process
{
class Port;
class ControlInlet;
}
 
namespace LocalTree
{
class ScriptableTreeBase;
enum class ControlWrites
{
  Edit,
  Execution,
  Record,
  Drop
};
 
struct ScriptableRoots
{
  ossia::net::node_base& controls;
  ossia::net::node_base& triggers;
  ossia::net::node_base& conditions;
 
  std::function<void(ossia::net::node_base&)> retire;
 
  std::function<void(ossia::net::node_base&)> hide;
 
  std::function<ossia::net::node_base*(ossia::net::node_base&, const std::string&)> revive;
 
  std::function<void(ossia::net::node_base&, const QObject&, const QString&)> tag;
 
  std::function<void(QObject&)> referrer;
 
  ScriptableTreeBase* tree{};
 
  std::function<ControlWrites(Recall)> writes;
 
  std::function<void(Process::ControlInlet&, const ossia::value&)> recorded;
 
  std::function<void(Process::ControlInlet&, const ossia::value&)> played;
};
 
inline void announceReferrer(const ScriptableRoots& roots, QObject& object)
{
  if(roots.referrer)
    roots.referrer(object);
}
 
inline void tagNode(
    const ScriptableRoots& roots, ossia::net::node_base& node, const QObject& object,
    const QString& member = {})
{
  if(roots.tag)
    roots.tag(node, object, member);
}
 
inline void retireNode(const ScriptableRoots& roots, ossia::net::node_base& node)
{
  if(roots.retire)
    roots.retire(node);
  else if(auto parent = node.get_parent())
    parent->remove_child(node);
}
 
struct ParameterBinding
{
  ossia::net::parameter_base& param;
  std::optional<ossia::net::parameter_base::callback_index> callback;
  QMetaObject::Connection connection;
  std::shared_ptr<bool> alive = std::make_shared<bool>(true);
 
  explicit ParameterBinding(ossia::net::parameter_base& p)
      : param{p}
  {
  }
  ParameterBinding(const ParameterBinding&) = delete;
  ParameterBinding& operator=(const ParameterBinding&) = delete;
  virtual void write(const ossia::value&) { }
  virtual ~ParameterBinding()
  {
    *alive = false;
    QObject::disconnect(connection);
    if(callback)
      param.remove_callback(*callback);
  }
};
 
SCORE_LIB_PROCESS_EXPORT ::State::Address addressOfNode(const ossia::net::node_base& n);
 
struct GivenName
{
  QString name;
  std::function<void()> restore;
  bool active{};
 
  void follow(const QString& current) { active = restore && current == name; }
  void operator()()
  {
    if(std::exchange(active, false))
      restore();
  }
};
 
SCORE_LIB_PROCESS_EXPORT
void giveName(
    GivenName& given, score::ModelMetadata& metadata, const QString& own,
    const QString& name);
SCORE_LIB_PROCESS_EXPORT
void giveName(GivenName& given, Process::Port& port, const QString& name);
 
template <typename F>
ossia::net::node_base* createScriptableNode(
    const ScriptableRoots& roots, ossia::net::node_base& parent, const QString& name,
    F&& writeBack)
{
  ossia::net::node_base* node{};
  if(roots.revive)
    node = roots.revive(parent, name.toStdString());
  if(!node)
    node = parent.create_child(name.toStdString());
  if(!node)
    return nullptr;
  if(auto real = QString::fromStdString(node->get_name()); real != name)
    writeBack(real);
  return node;
}
 
template <typename F>
void renameScriptableNode(ossia::net::node_base& node, const QString& name, F&& writeBack)
{
  const auto wanted = name.toStdString();
  if(node.get_name() == wanted)
    return;
  node.set_name(wanted);
  if(auto real = QString::fromStdString(node.get_name()); real != name)
    writeBack(real);
}
 
class SCORE_LIB_PROCESS_EXPORT ScriptableProcessBase
    : public Process::GenericProcessComponent<const score::DocumentContext>
{
  ABSTRACT_COMPONENT_METADATA(
      ScriptableProcessBase, "ffd963c1-07f3-445f-b914-d36f59a08edf")
public:
  static constexpr bool is_unique = true;
  ScriptableProcessBase(
      ScriptableRoots roots, Process::ProcessModel& proc,
      const score::DocumentContext& ctx, QObject* parent);
  ~ScriptableProcessBase() override;
 
  ossia::net::node_base* node() const noexcept { return m_node; }
  ossia::net::node_base* node(const Process::Port& port) const noexcept;
  ossia::net::node_base* stateNode() const noexcept;
 
  ossia::net::parameter_base* reserve(const std::string& name, const ossia::value& sample);
 
private:
  struct PortEntry;
  struct Kept;
 
  void keep(ossia::net::node_base& node, bool withValue);
  ossia::net::node_base* takeKept(const QString& name, std::optional<ossia::value>& written);
  void dropKept(const QString& name);
 
  void refresh();
  void renameNode();
  void removeNode(bool restoreNames);
  void publish(PortEntry& e);
  void unpublish(PortEntry& e, bool restoreName);
  void syncState();
 
protected:
  ScriptableRoots m_roots;
 
private:
  ossia::net::node_base* m_node{};
  GivenName m_given;
  std::unique_ptr<ParameterBinding> m_state;
  std::vector<std::unique_ptr<PortEntry>> m_ports;
  ossia::hash_map<const Process::Port*, PortEntry*> m_byPort;
  std::vector<std::unique_ptr<Kept>> m_kept;
};
 
class SCORE_LIB_PROCESS_EXPORT ScriptableProcessComponent final
    : public ScriptableProcessBase
{
  COMPONENT_METADATA("ed8196b3-c432-4405-a89b-ffc98a1e8f08")
public:
  using ScriptableProcessBase::ScriptableProcessBase;
};
 
class SCORE_LIB_PROCESS_EXPORT ScriptableProcessFactory : public score::InterfaceBase
{
  SCORE_INTERFACE(ScriptableProcessFactory, "a6313dd7-00a4-4c65-afb7-3552f0c84216")
public:
  ~ScriptableProcessFactory() override;
  virtual bool matches(const Process::ProcessModel&) const noexcept = 0;
  virtual ScriptableProcessBase* make(
      ScriptableRoots roots, Process::ProcessModel& proc,
      const score::DocumentContext& ctx, QObject* parent) const = 0;
};
 
class SCORE_LIB_PROCESS_EXPORT ScriptableProcessFactoryList final
    : public score::InterfaceList<ScriptableProcessFactory>
{
public:
  ~ScriptableProcessFactoryList();
};
 
SCORE_LIB_PROCESS_EXPORT ScriptableProcessBase* makeScriptableProcess(
    ScriptableRoots roots, Process::ProcessModel& proc, const score::DocumentContext& ctx,
    QObject* parent);
 
class SCORE_LIB_PROCESS_EXPORT ScriptableProcessGroup final
    : public ScriptableProcessBase
    , public Nano::Observer
{
  COMPONENT_METADATA("9b9f1041-3cda-46ea-b94b-aa0d113cea83")
public:
  ScriptableProcessGroup(
      ScriptableRoots roots, Process::ProcessModel& proc,
      score::EntityMap<Process::ProcessModel>& children,
      const score::DocumentContext& ctx, QObject* parent);
  ~ScriptableProcessGroup();
 
private:
  void add(Process::ProcessModel& proc);
  void remove(const Process::ProcessModel& proc);
 
  std::vector<std::pair<Process::ProcessModel*, ScriptableProcessBase*>> m_children;
};
 
struct SCORE_LIB_PROCESS_EXPORT ScriptableSnapshot
{
  struct Entry
  {
    QString kind; 
    QString address;
    QStringList children;
  };
  ossia::hash_map<QString, Entry> entries;
 
  static std::shared_ptr<const ScriptableSnapshot> build(const ScriptableRoots& roots);
};
 
SCORE_LIB_PROCESS_EXPORT ::State::Address scriptableAddress(const Process::ProcessModel&);
SCORE_LIB_PROCESS_EXPORT ::State::Address scriptableAddress(const Process::Port&);
SCORE_LIB_PROCESS_EXPORT bool publishedWithProcess(const Process::Port&) noexcept;
SCORE_LIB_PROCESS_EXPORT bool wantsPublished(const Process::Port&) noexcept;
SCORE_LIB_PROCESS_EXPORT ::State::Address
scriptableStateAddress(const Process::ProcessModel&);
}