notify.c

Go to the documentation of this file.

#include "config.h"
#include <stddef.h>
#include <stdbool.h>
#include "notify.h"
#include "memory.h"
#include "queue.h"

struct Notify
{
  struct Notify *parent;
  struct ObserverList observers;
};

struct Notify *notify_new(void)
{
  struct Notify *notify = mutt_mem_calloc(1, sizeof(*notify));

  STAILQ_INIT(&notify->observers);

  return notify;
}

void notify_free(struct Notify **ptr)
{
  if (!ptr || !*ptr)
    return;

  struct Notify *notify = *ptr;
  // NOTIFY observers

  notify_observer_remove(notify, NULL, NULL);

  FREE(ptr);
}

void notify_set_parent(struct Notify *notify, struct Notify *parent)
{
  if (!notify)
    return;

  notify->parent = parent;
}

static bool send(struct Notify *source, struct Notify *current,
                 enum NotifyType event_type, int event_subtype, void *event_data)
{
  if (!source || !current)
    return false;

  // mutt_debug(LL_NOTIFY, "send: %d, %ld\n", event_type, event_data);
  struct ObserverNode *np = NULL;
  struct ObserverNode *tmp = NULL;
  // We use the `_SAFE` version in case an event causes an observer to be deleted
  STAILQ_FOREACH_SAFE(np, &current->observers, entries, tmp)
  {
    struct Observer *o = np->observer;

    struct NotifyCallback nc = { event_type, event_subtype, event_data, o->global_data };
    o->callback(&nc);
  }

  if (current->parent)
    return send(source, current->parent, event_type, event_subtype, event_data);
  return true;
}

bool notify_send(struct Notify *notify, enum NotifyType event_type,
                 int event_subtype, void *event_data)
{
  return send(notify, notify, event_type, event_subtype, event_data);
}

bool notify_observer_add(struct Notify *notify, observer_t callback, void *global_data)
{
  if (!notify || !callback)
    return false;

  struct ObserverNode *np = NULL;
  STAILQ_FOREACH(np, &notify->observers, entries)
  {
    if (np->observer->callback == callback)
      return true;
  }

  struct Observer *o = mutt_mem_calloc(1, sizeof(*o));
  o->callback = callback;
  o->global_data = global_data;

  np = mutt_mem_calloc(1, sizeof(*np));
  np->observer = o;
  STAILQ_INSERT_HEAD(&notify->observers, np, entries);

  return true;
}

bool notify_observer_remove(struct Notify *notify, observer_t callback, void *global_data)
{
  if (!notify)
    return false;

  bool result = false;
  struct ObserverNode *np = NULL;
  struct ObserverNode *tmp = NULL;
  STAILQ_FOREACH_SAFE(np, &notify->observers, entries, tmp)
  {
    if (!callback || ((np->observer->callback == callback) &&
                      (np->observer->global_data == global_data)))
    {
      STAILQ_REMOVE(&notify->observers, np, ObserverNode, entries);
      FREE(&np->observer);
      FREE(&np);
      result = true;
      if (callback)
        break;
    }
  }

  return result;
}