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, write to the
 * Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,  USA.
 **************************************************************************/
 
#ifndef OBSERVABLE_H
#define OBSERVABLE_H
 
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <utility>
#include <vector>
 
#include <wx/event.h>
 
#include "observable_evt.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
 
std::string ptr_key(const void* ptr);
 
class Observable;
class ObservableListener;
 
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();
 
  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;
};
 
class DECL_EXP ObservableListener final {
  friend class ObsListener;
 
public:
  ObservableListener() : listener(nullptr), ev_type(wxEVT_NULL) {}
 
  ObservableListener (std::string k, wxEvtHandler* l, wxEventType e)
      : key(std::move(k)), listener(l), ev_type(e) {
    Listen();
  }
 
  ObservableListener(const KeyProvider& kp, wxEvtHandler* l, wxEventType e)
      : ObservableListener(kp.GetKey(), l, e) {}
 
  ObservableListener(ObservableListener&& other) noexcept {
    key = other.key;
    listener = other.listener;
    ev_type = other.ev_type;
    other.Unlisten();
    Listen();
  }
 
  ObservableListener& operator=(ObservableListener&& other) noexcept {
    key = other.key;
    listener = other.listener;
    ev_type = other.ev_type;
    other.Unlisten();
    Listen();
    return *this;
  }
 
  ObservableListener(const ObservableListener& other) = delete;
  ObservableListener& operator=(ObservableListener&) = delete;
 
  ~ObservableListener() { Unlisten(); }
 
  void Listen(const std::string& key, wxEvtHandler* listener, wxEventType evt);
 
  void Listen(const KeyProvider& kp, wxEvtHandler* l, wxEventType evt) {
    Listen(kp.GetKey(), l, evt);
  }
 
private:
  void Listen();
  void Unlisten();
 
  std::string key;
  wxEvtHandler* listener;
  wxEventType ev_type;
};
 
class ObsListener : public wxEvtHandler {
public:
  ObsListener() : m_obs_evt(wxNewEventType()) {}
 
  ObsListener(ObsListener&& 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.key, this, m_obs_evt);
  }
 
  ObsListener& operator=(ObsListener&& 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.key, this, m_obs_evt);
    return *this;
  }
 
  ObsListener(const ObsListener&) = delete;
  ObsListener& operator=(ObsListener&) = delete;
 
  ObsListener(const KeyProvider& kp,
             const  std::function<void(ObservedEvt& ev)>& action)
      : m_obs_evt(wxNewEventType()) {
    Init(kp, action);
  }
 
  ObsListener(const KeyProvider& kp, const std::function<void()>& action)
      : ObsListener(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());
}
 
#endif  // OBSERVABLE_H