signals.hpp

Go to the documentation of this file.

//
// Copyright (C) 2014, 2015 Ableton AG, Berlin. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//

#pragma once

#include <ableton/build_system/Warnings.hpp>
ABL_DISABLE_WARNINGS
#include <boost/signals2/signal.hpp>
ABL_RESTORE_WARNINGS
#include <memory>
#include <vector>
#include <functional>

namespace atria {
namespace funken {

namespace detail {

constexpr struct
{
  template <typename T1, typename T2>
  bool operator() (const T1& a, const T2& b)
  {
    return
      !a.owner_before(b) &&
      !b.owner_before(a);
  }
} owner_equals {};

struct down_signal_base
{
  virtual ~down_signal_base();
  virtual void send_down() = 0;
  virtual void notify() = 0;
};

template <typename T>
struct up_signal_base
{
  virtual ~up_signal_base() {}
  virtual void send_up(const T&) = 0;
  virtual void send_up(T&&) = 0;
};

template <typename T>
class down_signal
  : public std::enable_shared_from_this<down_signal<T> >
  , public down_signal_base
{
public:
  using value_type = T;

  down_signal(down_signal&&) = default;
  down_signal(const down_signal&) = delete;
  down_signal& operator=(down_signal&&) = default;
  down_signal& operator=(const down_signal&) = delete;

  down_signal(T value)
    : current_(std::move(value))
    , last_(current_)
    , last_notified_(current_)
  {}

  virtual void recompute() {}
  virtual void recompute_deep() {}

  const value_type& current() const { return current_; }
  const value_type& last() const { return last_; }

  void link(std::weak_ptr<down_signal_base> child)
  {
    using namespace std;
    using std::placeholders::_1;
    assert(find_if(begin(children_), end(children_),
                   bind(owner_equals, child, _1))
           == end(children_) &&
           "Child signal must not be linked twice");
    children_.push_back(child);
  }

  template <typename U>
  void push_down(U&& value)
  {
    if (value != current_)
    {
      current_ = std::forward<U>(value);
      needs_send_down_ = true;
    }
  }

  void send_down() final
  {
    recompute();
    if (needs_send_down_)
    {
      last_ = current_;
      needs_send_down_ = false;
      needs_notify_ = true;

      for (auto& wchild : children_)
      {
        if (auto child = wchild.lock())
        {
          child->send_down();
        }
      }
    }
  }

  void notify() final
  {
    using namespace std;
    if (!needs_send_down_ && needs_notify_)
    {
      needs_notify_ = false;
      observers_(last_notified_, last_);
      last_notified_ = last_;

      auto garbage = false;
      for (std::size_t i = 0, size = children_.size(); i < size; ++i)
      {
        if (auto child = children_[i].lock())
        {
          child->notify();
        }
        else
        {
          garbage = true;
        }
      }

      if (garbage)
      {
        collect();
      }
    }
  }

  template <typename Fn>
  auto observe(Fn&& f)
    -> boost::signals2::connection
  {
    return observers_.connect(std::forward<Fn>(f));
  }

  auto observers()
    -> boost::signals2::signal<void(const value_type&,
                                    const value_type&)>&
  {
    return observers_;
  }

private:
  void collect()
  {
    using namespace std;
    children_.erase(
      remove_if(
        begin(children_),
        end(children_),
        mem_fn(&weak_ptr<down_signal_base>::expired)),
      end(children_));
  }

  bool needs_send_down_ = false;
  bool needs_notify_ = false;
  value_type current_;
  value_type last_;
  value_type last_notified_;
  std::vector<std::weak_ptr<down_signal_base> > children_;
  boost::signals2::signal<void(const value_type&,
                               const value_type&)> observers_;
};

template <typename T>
class up_down_signal
  : public down_signal<T>
  , public up_signal_base<T>
{
  using down_signal<T>::down_signal;
};

} // namespace detail

} // namespace funken
} // namespace atria