observable.h

Go to the documentation of this file.

/*************************************************************************
 *
 *
 * Copyright (C) 2022 - 2025 Alec Leamas
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses/>.
 **************************************************************************/
 
#ifndef OBSERVABLE_H
#define OBSERVABLE_H
 
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <utility>
#include <vector>
 
#include <wx/event.h>
 
#include "event.h"
 
#ifndef DECL_EXP
#if defined(_MSC_VER) || defined(__CYGWIN__)
#define DECL_EXP __declspec(dllexport)
#elif defined(__GNUC__) || defined(__clang__)
#define DECL_EXP __attribute__((visibility("default")))
#else
#define DECL_EXP
#endif
#endif  // DECL_EXP
 
class ObservableListener;   // forward
 
namespace  obs {
class Listener;   // forward
 
std::string PtrKey(const void* ptr);
 
class Observable;   // forward
 
class KeyProvider {
public:
  virtual ~KeyProvider() = default;
 
  [[nodiscard]] virtual std::string GetKey() const = 0;
};
 
class ListenersByKey {
  friend class Observable;
  friend ListenersByKey& GetInstance(const std::string& key);
 
public:
  ListenersByKey() = default;
  ListenersByKey(const ListenersByKey&) = delete;
 
private:
  static ListenersByKey& GetInstance(const std::string& key);
 
  ListenersByKey& operator=(const ListenersByKey&) = default;
 
  std::vector<std::pair<wxEvtHandler*, wxEventType>> listeners;
};
 
class Observable : public KeyProvider {
  friend class ::ObservableListener;
 
public:
  explicit Observable(const std::string& _key)
      : key(_key), m_list(ListenersByKey::GetInstance(_key)) {}
 
  explicit Observable(const KeyProvider& kp) : Observable(kp.GetKey()) {}
 
  ~Observable() override = default;
 
  virtual void Notify();
 
  virtual void Notify(const std::shared_ptr<const void>& p) {
    Notify(p, "", 0, nullptr);
  }
 
  bool Unlisten(wxEvtHandler* listener, wxEventType ev);
 
  std::string GetKey() const override { return key; }
 
  const std::string key;
 
protected:
  void Notify(const std::shared_ptr<const void>& ptr, const std::string& s,
                    int num, void* client_data);
 
  void Notify(const std::string& s, void* client_data){
    Notify(nullptr, s, 0, client_data);
  }
 
private:
  void Listen(wxEvtHandler* listener, wxEventType ev_type);
 
  ListenersByKey& m_list;
 
  mutable std::mutex m_mutex;
};
 
}   // namespace
 
class DECL_EXP ObservableListener final {
  friend class obs::Listener;
 
public:
  ObservableListener() : m_listener(nullptr), m_ev_type(wxEVT_NULL) {}
 
  ObservableListener (std::string k, wxEvtHandler* l, wxEventType e)
      : m_key(std::move(k)), m_listener(l), m_ev_type(e) {
    Listen();
  }
 
  ObservableListener(const obs::KeyProvider& kp, wxEvtHandler* l, wxEventType e)
      : ObservableListener(kp.GetKey(), l, e) {}
 
  ~ObservableListener() { Unlisten(); }
 
  ObservableListener(ObservableListener&& other) noexcept {
    m_key = other.m_key;
    m_listener = other.m_listener;
    m_ev_type = other.m_ev_type;
    other.Unlisten();
    Listen();
  }
 
  ObservableListener& operator=(ObservableListener&& other) noexcept {
    m_key = other.m_key;
    m_listener = other.m_listener;
    m_ev_type = other.m_ev_type;
    other.Unlisten();
    Listen();
    return *this;
  }
 
  ObservableListener(const ObservableListener& other) = delete;
 
  ObservableListener& operator=(ObservableListener&) = delete;
 
  void Listen(const std::string& key, wxEvtHandler* listener, wxEventType evt);
 
  void Listen(const obs::KeyProvider& kp, wxEvtHandler* l, wxEventType evt) {
    Listen(kp.GetKey(), l, evt);
  }
 
private:
  void Listen();
  void Unlisten();
 
  std::string m_key;
  wxEvtHandler* m_listener;
  wxEventType m_ev_type;
};
 
namespace obs {
 
class Listener : public wxEvtHandler {
public:
  Listener() : m_obs_evt(wxNewEventType()) {}
 
  Listener(Listener&& other) noexcept: m_obs_evt(wxNewEventType()) {
    m_listener.Unlisten();
    Unbind(other.m_obs_evt, other.m_action);
    m_action = other.m_action;
    Bind(m_obs_evt, m_action);
    m_listener.Listen(other.m_listener.m_key, this, m_obs_evt);
  }
 
  Listener& operator=(Listener&& other) noexcept {
    m_listener.Unlisten();
    Unbind(other.m_obs_evt, other.m_action);
    m_action = other.m_action;
    Bind(m_obs_evt, m_action);
    m_listener.Listen(other.m_listener.m_key, this, m_obs_evt);
    return *this;
  }
 
  Listener(const Listener&) = delete;
 
  Listener& operator=(Listener&) = delete;
 
  Listener(const KeyProvider& kp,
           const std::function<void(ObservedEvt& ev)>& action)
      : m_obs_evt(wxNewEventType()) {
    Init(kp, action);
  }
 
  Listener(const KeyProvider& kp, const std::function<void()>& action)
      : Listener(kp, [&](ObservedEvt&) { action(); }) {}
 
  void Init(const KeyProvider& kp,
            const std::function<void(ObservedEvt& ev)>& action) {
    m_action = action;
    const wxEventTypeTag<ObservedEvt> EvtObs(wxNewEventType());
    // i. e. wxDEFINE_EVENT(), avoiding the evil macro.
    m_listener.Listen(kp, this, EvtObs);
    Bind(EvtObs, action);
  }
 
private:
  ::ObservableListener m_listener;
  std::function<void(ObservedEvt& ev)> m_action;
  const wxEventTypeTag<ObservedEvt> m_obs_evt;
};
 
template <typename T>
std::shared_ptr<const T> UnpackEvtPointer(const ObservedEvt& ev) {
  return std::static_pointer_cast<const T>(ev.GetSharedPtr());
}
 
}  // namespace
#endif  // OBSERVABLE_H