add Node/ZipTie

CMakeLists.txt

@@ -151,6 +151,7 @@ target_sources(nf7
     file/node_network.cc
     file/node_ref.cc
     file/node_singleton.cc
+    file/node_ziptie.cc
     file/sequencer_adaptor.cc
     file/sequencer_call.cc
     file/sequencer_timeline.cc

common/squashed_history.hh

@@ -27,6 +27,11 @@ class SquashedHistory : public nf7::GenericHistory {
     if (staged_.size() == 0) {
       return false;
     }
+    if (++tick_ <= 2) {
+      return false;
+    }
+    tick_ = 0;
+
     nf7::GenericHistory::Add(
         std::make_unique<nf7::AggregateCommand>(std::move(staged_)));
     return true;
@@ -48,6 +53,8 @@ class SquashedHistory : public nf7::GenericHistory {
 
  private:
   std::vector<std::unique_ptr<Command>> staged_;
+
+  uint8_t tick_ = 0;
 };
 
 }  // namespace nf7

file/node_ziptie.cc

@@ -0,0 +1,541 @@
+#include <algorithm>
+#include <cassert>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <typeinfo>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include <imgui.h>
+#include <imgui_stdlib.h>
+
+#include <ImNodes.h>
+
+#include <magic_enum.hpp>
+
+#include <yas/serialize.hpp>
+#include <yas/types/std/string.hpp>
+#include <yas/types/std/vector.hpp>
+
+#include "nf7.hh"
+
+#include "common/file_base.hh"
+#include "common/generic_memento.hh"
+#include "common/generic_type_info.hh"
+#include "common/gui.hh"
+#include "common/life.hh"
+#include "common/node.hh"
+#include "common/ptr_selector.hh"
+#include "common/yas_enum.hh"
+
+
+namespace nf7 {
+
+class ZipTie final : public nf7::FileBase, public nf7::Node {
+ public:
+  static inline const nf7::GenericTypeInfo<ZipTie> kType = {
+    "Node/ZipTie", {"nf7::Node",},
+    "[N to 1] or [1 to N] node",
+  };
+
+  static constexpr size_t kMaxN = 64;
+  static inline const auto kIndexStrings = ([](){
+    std::vector<std::string> ret(kMaxN);
+    for (size_t i = 0; i < kMaxN; ++i) ret[i] = std::to_string(i);
+    return ret;
+  })();
+
+  class Lambda;
+
+  enum Algorithm {
+    // N to 1
+    kAwait,
+    kMakeTuple,
+    kUpdateTuple,
+
+    // 1 to N
+    kOrderedPulse,
+    kExtractTuple,
+  };
+  static bool IsNto1(Algorithm algo) noexcept {
+    return algo == kAwait || algo == kMakeTuple || algo == kUpdateTuple;
+  }
+  static bool IsNameRequired(Algorithm algo) noexcept {
+    return algo == kMakeTuple || algo == kUpdateTuple || algo == kExtractTuple;
+  }
+
+  struct AlgoMeta final {
+    std::string name;
+    std::string desc;
+  };
+  static inline const std::unordered_map<Algorithm, AlgoMeta> kAlgoMetas = {
+    {kAwait,        { .name = "await",         .desc = "awaits for all inputs satisfied"            }},
+    {kMakeTuple,    { .name = "make tuple",    .desc = "emits a tuple when all inputs satisfied"    }},
+    {kUpdateTuple,  { .name = "update tuple",  .desc = "emits a tuple when one input satisfied"     }},
+    {kOrderedPulse, { .name = "ordered pulse", .desc = "emits a pulse in order"                     }},
+    {kExtractTuple, { .name = "extract tuple", .desc = "extracts values from a tuple by thier name" }},
+  };
+
+  struct Data {
+   public:
+    Data() {}
+
+    Algorithm algo = kAwait;
+    std::vector<std::string> names = {"", ""};
+  };
+
+  ZipTie(nf7::Env& env, Data&& d = {}) noexcept :
+      nf7::FileBase(kType, env),
+      nf7::Node(nf7::Node::kCustomNode |
+                nf7::Node::kMenu),
+      life_(*this), mem_(*this, std::move(d)) {
+  }
+
+  ZipTie(nf7::Deserializer& ar) : ZipTie(ar.env()) {
+    ar(mem_.data());
+  }
+  void Serialize(nf7::Serializer& ar) const noexcept override {
+    ar(mem_.data());
+  }
+  std::unique_ptr<nf7::File> Clone(nf7::Env& env) const noexcept override {
+    return std::make_unique<ZipTie>(env, Data {mem_.data()});
+  }
+
+  std::shared_ptr<nf7::Node::Lambda> CreateLambda(
+      const std::shared_ptr<nf7::Node::Lambda>& parent) noexcept override;
+  nf7::Node::Meta GetMeta() const noexcept override {
+    const auto n = mem_->names.size();
+
+    std::vector<std::string> index(
+        kIndexStrings.begin(),
+        kIndexStrings.begin()+static_cast<intmax_t>(n));
+    if (IsNto1(mem_->algo)) {
+      return {std::move(index), {"out"}};
+    } else {
+      return {{"in"}, std::move(index)};
+    }
+  }
+
+  void UpdateNode(nf7::Node::Editor&) noexcept override;
+  void UpdateMenu(nf7::Node::Editor&) noexcept override;
+
+  nf7::File::Interface* interface(const std::type_info& t) noexcept override {
+    return nf7::InterfaceSelector<nf7::Memento, nf7::Node>(t).Select(this, &mem_);
+  }
+
+ private:
+  nf7::Life<ZipTie>         life_;
+  nf7::GenericMemento<Data> mem_;
+
+
+  // socket list manipulation
+  void InsertSocket(nf7::Node::Editor&, size_t) noexcept;
+  void RemoveSocket(nf7::Node::Editor&, size_t) noexcept;
+  void MoveLinks(nf7::Node::Editor&, std::string_view before, std::string_view after) noexcept;
+
+  // widgets
+  bool SocketMenu(nf7::Node::Editor&, size_t) noexcept;
+  bool AlgorithmComboItem(Algorithm);
+};
+
+
+class ZipTie::Lambda final : public nf7::Node::Lambda,
+    public std::enable_shared_from_this<Lambda> {
+ public:
+  Lambda(ZipTie& f, const std::shared_ptr<nf7::Node::Lambda>& parent) noexcept :
+      nf7::Node::Lambda(f, parent), f_(f.life_) {
+  }
+
+  void Handle(const nf7::Node::Lambda::Msg& in) noexcept override
+  try {
+    f_.EnforceAlive();
+
+    const auto& d = f_->mem_.data();
+    if (d.algo != std::exchange(prev_algo_, d.algo)) {
+      values_.clear();
+    }
+
+    if (IsNto1(d.algo)) {
+      const auto idx = static_cast<size_t>(std::stoul(in.name));
+      if (idx >= d.names.size()) {
+        throw nf7::Exception {"index overflow"};
+      }
+      values_.resize(d.names.size());
+      values_[idx] = in.value;
+    } else {
+      values_.clear();
+    }
+
+    switch (d.algo) {
+    case kAwait:
+      Await(in);
+      return;
+    case kMakeTuple:
+      MakeTuple(in, d);
+      return;
+    case kUpdateTuple:
+      UpdateTuple(in, d);
+      return;
+    case kOrderedPulse:
+      OrderedPulse(in, d);
+      return;
+    case kExtractTuple:
+      ExtractTuple(in, d);
+      return;
+    default:
+      assert(false);
+      return;
+    }
+  } catch (std::invalid_argument&) {
+  } catch (std::out_of_range&) {
+  } catch (nf7::ExpiredException&) {
+  } catch (nf7::Exception&) {
+  }
+
+ private:
+  nf7::Life<ZipTie>::Ref f_;
+
+  std::optional<Algorithm> prev_algo_;
+
+  std::vector<std::optional<nf7::Value>> values_;
+
+  void Await(const nf7::Node::Lambda::Msg& in) noexcept {
+    if (AllSatisifed()) {
+      in.sender->Handle("out", nf7::Value::Pulse {}, shared_from_this());
+      values_.clear();
+    }
+  }
+  void MakeTuple(const nf7::Node::Lambda::Msg& in, const Data& d) noexcept {
+    if (AllSatisifed()) {
+      UpdateTuple(in, d);
+      values_.clear();
+    }
+  }
+  void UpdateTuple(const nf7::Node::Lambda::Msg& in, const Data& d) noexcept {
+    std::vector<nf7::Value::TuplePair> pairs;
+    pairs.reserve(d.names.size());
+
+    for (size_t i = 0; i < d.names.size(); ++i) {
+      const auto& name = d.names[i];
+      if (name == "" || !values_[i]) continue;
+      pairs.emplace_back(name, *values_[i]);
+    }
+    in.sender->Handle("out", std::move(pairs), shared_from_this());
+  }
+  void OrderedPulse(const nf7::Node::Lambda::Msg& in, const Data& d) noexcept {
+    for (size_t i = 0; i < d.names.size(); ++i) {
+      in.sender->Handle(kIndexStrings[i], nf7::Value::Pulse {}, shared_from_this());
+    }
+  }
+  void ExtractTuple(const nf7::Node::Lambda::Msg& in, const Data& d) noexcept {
+    for (size_t i = 0; i < d.names.size(); ++i)
+    try {
+      in.sender->Handle(kIndexStrings[i], in.value.tuple(d.names[i]), shared_from_this());
+    } catch (nf7::Exception&) {
+    }
+  }
+
+
+  bool AllSatisifed() const noexcept {
+    return std::all_of(values_.begin(), values_.end(), [](auto& x) { return !!x; });
+  }
+};
+std::shared_ptr<nf7::Node::Lambda> ZipTie::CreateLambda(
+    const std::shared_ptr<nf7::Node::Lambda>& parent) noexcept {
+  return std::make_shared<Lambda>(*this, parent);
+}
+
+
+void ZipTie::InsertSocket(nf7::Node::Editor& ed, size_t idx) noexcept {
+  auto& names = mem_->names;
+  assert(names.size() < kMaxN);
+  assert(idx <= names.size());
+
+  for (size_t i = names.size()-1; i > idx; --i) {
+    MoveLinks(ed, kIndexStrings[i-1], kIndexStrings[i]);
+  }
+  env().ExecMain(nullptr, [&names, idx](){
+    names.insert(names.begin()+static_cast<intmax_t>(idx), std::string {});
+  });
+}
+void ZipTie::RemoveSocket(nf7::Node::Editor& ed, size_t idx) noexcept {
+  auto& names = mem_->names;
+  assert(names.size() >= 1);
+  assert(idx < names.size());
+
+  MoveLinks(ed, kIndexStrings[idx], "");
+  for (size_t i = idx; i < names.size()-1; ++i) {
+    MoveLinks(ed, kIndexStrings[i+1], kIndexStrings[i]);
+  }
+  env().ExecMain(nullptr, [&names, idx](){
+    names.erase(names.begin() + static_cast<intmax_t>(idx));
+  });
+}
+void ZipTie::MoveLinks(
+    nf7::Node::Editor& ed, std::string_view before, std::string_view after) noexcept {
+  const bool self_src = !IsNto1(mem_->algo);
+
+  const auto others =
+      self_src? ed.GetDstOf(*this, before): ed.GetSrcOf(*this, before);
+  for (const auto& other_ref : others) {
+    using P = std::pair<nf7::Node*, std::string_view>;
+    P self  = {this, before};
+    P other = {other_ref.first, other_ref.second};
+
+    // remove existing link
+    {
+      auto src = &self, dst = &other;
+      if (!self_src) std::swap(src, dst);
+      ed.RemoveLink(*src->first, src->second, *dst->first, dst->second);
+    }
+
+    // add removed link
+    self.second = after;
+    if (after != "") {
+      auto src = &self, dst = &other;
+      if (!self_src) std::swap(src, dst);
+      ed.AddLink(*src->first, src->second, *dst->first, dst->second);
+    }
+  }
+}
+
+
+void ZipTie::UpdateNode(nf7::Node::Editor& ed) noexcept {
+  const auto em = ImGui::GetFontSize();
+
+  auto meta_itr = kAlgoMetas.find(mem_->algo);
+  assert(meta_itr != kAlgoMetas.end());
+
+  const auto& meta = meta_itr->second;
+
+  bool mod = false;
+
+  ImGui::TextUnformatted("Node/ZipTie");
+  ImGui::SameLine();
+  const auto right_top = ImGui::GetCursorPos();
+  ImGui::NewLine();
+
+  const auto left_top = ImGui::GetCursorPos();
+  ImGui::AlignTextToFramePadding();
+  ImGui::NewLine();
+
+  // inputs
+  ImGui::BeginGroup();
+  if (IsNto1(mem_->algo)) {
+    for (size_t i = 0; i < mem_->names.size(); ++i) {
+      if (ImNodes::BeginInputSlot(kIndexStrings[i].c_str(), 1)) {
+        ImGui::AlignTextToFramePadding();
+        gui::NodeSocket();
+        ImNodes::EndSlot();
+      }
+      if (ImGui::BeginPopupContextItem()) {
+        mod |= SocketMenu(ed, i);
+        ImGui::EndPopup();
+      }
+    }
+  } else {
+    if (ImNodes::BeginInputSlot("in", 1)) {
+      ImGui::AlignTextToFramePadding();
+      gui::NodeSocket();
+      ImNodes::EndSlot();
+    }
+  }
+  ImGui::EndGroup();
+
+  // text input
+  ImGui::SameLine();
+  ImGui::BeginGroup();
+  for (size_t i = 0; i < mem_->names.size(); ++i) {
+    ImGui::AlignTextToFramePadding();
+    if (!IsNto1(mem_->algo)) {
+      ImGui::TextUnformatted("->");
+      ImGui::SameLine();
+    }
+    if (IsNameRequired(mem_->algo)) {
+      ImGui::SetNextItemWidth(6*em);
+
+      const auto id = "##text"+kIndexStrings[i];
+      ImGui::InputText(id.c_str(), &mem_->names[i]);
+
+      if (ImGui::IsItemDeactivatedAfterEdit()) {
+        mod = true;
+      }
+      if (ImGui::BeginPopupContextItem()) {
+        mod |= SocketMenu(ed, i);
+        ImGui::EndPopup();
+      }
+    } else {
+      ImGui::Text("%zu", i);
+    }
+    if (IsNto1(mem_->algo)) {
+      ImGui::SameLine();
+      ImGui::TextUnformatted("->");
+    }
+  }
+  ImGui::EndGroup();
+
+  // outputs
+  ImGui::SameLine();
+  ImGui::BeginGroup();
+  if (IsNto1(mem_->algo)) {
+    if (ImNodes::BeginOutputSlot("out", 1)) {
+      ImGui::AlignTextToFramePadding();
+      gui::NodeSocket();
+      ImNodes::EndSlot();
+    }
+  } else {
+    for (size_t i = 0; i < mem_->names.size(); ++i) {
+      if (ImNodes::BeginOutputSlot(kIndexStrings[i].c_str(), 1)) {
+        ImGui::AlignTextToFramePadding();
+        gui::NodeSocket();
+        ImNodes::EndSlot();
+      }
+      if (ImGui::BeginPopupContextItem()) {
+        mod |= SocketMenu(ed, i);
+        ImGui::EndPopup();
+      }
+    }
+  }
+  ImGui::EndGroup();
+  ImGui::SameLine();
+  const auto right_bottom = ImGui::GetCursorPos();
+  ImGui::NewLine();
+
+  // algorithm selection
+  ImGui::SetCursorPos(left_top);
+  auto w = std::max(right_bottom.x, right_top.x) - left_top.x;
+  ImGui::Button(meta.name.c_str(), {w, 0});
+  if (ImGui::BeginPopupContextItem(nullptr, ImGuiPopupFlags_MouseButtonLeft)) {
+    ImGui::TextDisabled("N to 1");
+    mod |= AlgorithmComboItem(kAwait);
+    mod |= AlgorithmComboItem(kMakeTuple);
+    mod |= AlgorithmComboItem(kUpdateTuple);
+
+    ImGui::TextDisabled("1 to N");
+    mod |= AlgorithmComboItem(kOrderedPulse);
+    mod |= AlgorithmComboItem(kExtractTuple);
+
+    ImGui::EndPopup();
+  }
+  if (ImGui::IsItemHovered()) {
+    ImGui::SetTooltip("choose algorithm");
+  }
+
+  // commit changes
+  if (mod) {
+    env().ExecMain(
+        std::make_shared<nf7::GenericContext>(*this, "memento commit"),
+        [this]() { mem_.Commit(); });
+  }
+}
+
+void ZipTie::UpdateMenu(nf7::Node::Editor&) noexcept {
+  if (ImGui::BeginMenu("config")) {
+    static int n;
+    if (ImGui::IsWindowAppearing()) {
+      n = static_cast<int>(mem_->names.size());
+    }
+    ImGui::PushItemWidth(6*ImGui::GetFontSize());
+
+    ImGui::DragInt("sockets", &n, 0.25f, 1, static_cast<int>(kMaxN));
+    if (ImGui::IsItemDeactivatedAfterEdit()) {
+      mem_->names.resize(static_cast<size_t>(n));
+      mem_.Commit();
+    }
+
+    ImGui::PopItemWidth();
+    ImGui::EndMenu();
+  }
+}
+
+bool ZipTie::SocketMenu(nf7::Node::Editor& ed, size_t i) noexcept {
+  bool mod = false;
+
+  ImGui::BeginDisabled(mem_->names.size() >= kMaxN);
+  if (ImGui::MenuItem("insert before")) {
+    InsertSocket(ed, i);
+    mod = true;
+  }
+  if (ImGui::MenuItem("insert after")) {
+    InsertSocket(ed, i+1);
+    mod = true;
+  }
+  ImGui::EndDisabled();
+
+  ImGui::BeginDisabled(mem_->names.size() == 1);
+  if (ImGui::MenuItem("remove")) {
+    RemoveSocket(ed, i);
+    mod = true;
+  }
+  ImGui::EndDisabled();
+  return mod;
+}
+
+bool ZipTie::AlgorithmComboItem(Algorithm algo) {
+  bool mod = false;
+
+  auto itr = kAlgoMetas.find(algo);
+  assert(itr != kAlgoMetas.end());
+
+  const auto& meta = itr->second;
+  if (ImGui::Selectable(meta.name.c_str(), mem_->algo == algo)) {
+    if (mem_->algo != algo) {
+      mem_->algo = algo;
+      mod = true;
+    }
+  }
+  if (ImGui::IsItemHovered()) {
+    ImGui::SetTooltip("%s", meta.desc.c_str());
+  }
+  return mod;
+}
+
+}  // namespace nf7
+
+
+namespace yas::detail {
+
+NF7_YAS_DEFINE_ENUM_SERIALIZER(nf7::ZipTie::Algorithm);
+
+template <size_t F>
+struct serializer<
+    type_prop::not_a_fundamental,
+    ser_case::use_internal_serializer,
+    F,
+    nf7::ZipTie::Data> {
+ public:
+  template <typename Archive>
+  static Archive& save(Archive& ar, const nf7::ZipTie::Data& d) {
+    ar(d.algo);
+    if (nf7::ZipTie::IsNameRequired(d.algo)) {
+      ar(d.names);
+    } else {
+      ar(d.names.size());
+    }
+    return ar;
+  }
+  template <typename Archive>
+  static Archive& load(Archive& ar, nf7::ZipTie::Data& d) {
+    ar(d.algo);
+    if (nf7::ZipTie::IsNameRequired(d.algo)) {
+      ar(d.names);
+    } else {
+      size_t n;
+      ar(n);
+      d.names.clear();
+      d.names.resize(n);
+    }
+    if (d.names.size() > nf7::ZipTie::kMaxN) {
+      throw nf7::DeserializeException {"Node/ZipTie maximum socket count exceeded"};
+    }
+    if (d.names.size() == 0) {
+      d.names.resize(1);
+    }
+    return ar;
+  }
+};
+
+}  // namespace yas::detail