observable.h

/*************************************************************************
 *
 * Project:  OpenCPN
 * Purpose: General observable implementation with several specializations.
 *
 * Copyright (C) 2022 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 std::string GetKey() const = 0;
};
 
class ListenersByKey {
  friend class Observable;
  friend ListenersByKey& GetInstance(const std::string& key);
 
public:
  ListenersByKey() {}
 
private:
  static ListenersByKey& GetInstance(const std::string& key);
 
  ListenersByKey(const ListenersByKey&) = delete;
  ListenersByKey& operator=(const ListenersByKey&) = default;
 
  std::vector<std::pair<wxEvtHandler*, wxEventType>> listeners;
};
 
class Observable : public KeyProvider {
  friend class ObservableListener;
 
public:
  Observable(const std::string& _key)
      : key(_key), m_list(ListenersByKey::GetInstance(_key)) {}
 
  Observable(const KeyProvider& kp) : Observable(kp.GetKey()) {}
 
  virtual const void Notify();
 
  const void Notify(std::shared_ptr<const void> p) { Notify(p, "", 0, 0); }
 
  bool Unlisten(wxEvtHandler* listener, wxEventType ev);
 
  std::string GetKey() const { return key; }
 
  const std::string key;
 
protected:
  const void Notify(std::shared_ptr<const void> ptr, const std::string& s,
                    int num, void* client_data);
 
  const 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 {
public:
  ObservableListener() : key(""), listener(0), ev_type(wxEVT_NULL) {}
 
  ObservableListener(const std::string& k, wxEvtHandler* l, wxEventType e)
      : key(k), listener(l), ev_type(e) {
    Listen();
  }
 
  ObservableListener(const KeyProvider& kp, wxEvtHandler* l, wxEventType e)
      : ObservableListener(kp.GetKey(), l, e) {}
 
  ObservableListener(ObservableListener&& other)
      : key(other.key), listener(other.listener), ev_type(other.ev_type) {
    other.Unlisten();
    Listen();
  }
 
  ObservableListener& operator=(ObservableListener&& other) {
    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() {}
 
  ObsListener(ObsListener&& other) {
    this->m_listener = std::move(other.m_listener);
  }
  ObsListener& operator=(ObsListener&& other) {
    m_listener = std::move(other.m_listener);
    return *this;
  }
  ObsListener(const ObsListener&) = delete;
  ObsListener& operator=(ObsListener&) = delete;
 
  ObsListener(const KeyProvider& kp,
              std::function<void(ObservedEvt& ev)> action) {
    Init(kp, action);
  }
 
  ObsListener(const KeyProvider& kp, std::function<void()> action)
      : ObsListener(kp, [&](ObservedEvt&) { action(); }) {}
 
  void Init(const KeyProvider& kp,
            std::function<void(ObservedEvt& ev)> 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;
};
 
template <typename T>
std::shared_ptr<const T> UnpackEvtPointer(ObservedEvt ev) {
  return std::static_pointer_cast<const T>(ev.GetSharedPtr());
}
 
#endif  // OBSERVABLE_H