---

monitor.c

 /*
  * plint/misc/monitor.c : monitors
  * 
  * Time-stamp: <2003-01-07 20:10:44 gseba>
  * 
  * Copyright (C) Sebastian Glita, email: gseba@users.sourceforge.net
  * 
  * This file is part of plint.
  * 
  * plint 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, or (at your option) any later version.
  *
  * plint  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  plint; see  the file  COPYING.  If  not, write  to the  Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA USA.
  *
  */

#include "plint.h"
#include "monitor.h"

#include "share/hash.h"

typedef struct _plint_subscriber_event * plint_subscriber_event_t;
typedef struct _plint_subscriber_real * plint_subscriber_real_t;
typedef struct _plint_subscriber_proxy * plint_subscriber_proxy_t;
typedef struct _plint_event_real * plint_event_real_t;


struct _plint_subscriber_event
{
  plint_monitor_t monitor;
  plint_event_t event;
  bit_t enable:1;

  void * data;
  plint_announce_t announce;
};

struct _plint_subscriber_proxy
{
  plint_subscriber_t subscriber;
  plint_subscriber_event_t event;
};

struct _plint_subscriber_real
{
  plint_monitor_t monitor;
  slot_key_t events;
};

struct _plint_event_real
{
  hashindex_t name;
  slot_key_t subs;
  plint_announce_t done;
};


plint_monitor_t plint_monitor_create()
{
  return (plint_monitor_t)slot_register(plint->monitor.moni,
                                        slot_create(), slot_delete);
}

void plint_monitor_delete(plint_monitor_t m)
{
  slot_unregister(plint->monitor.moni, (int)m);
}


static void event_free(plint_event_real_t e)
{
  hash_remstr(plint->monitor.evnt, e->name);
  slot_delete(e->subs);
  FREE(e);
}

static void * done_ignore(plint_monitor_t m,
                          plint_event_t r,
                          plint_subscriber_t s, void * d,
                          vargs_t a)
{
  return 0;
}

plint_event_t plint_monitor_event_register(plint_monitor_t m, plint_str_t s, plint_announce_t d)
{
  plint_event_real_t e;
  NEW(e);
  e->name = hash_putstr(NS_GLOBAL(plint->monitor.evnt), plint_str_sn(s), 0);
  e->subs = slot_create();
  e->done = d ? : done_ignore;
  return (plint_event_t)slot_register((slot_key_t)slot_getdata(plint->monitor.moni, (int)m),
                                      e, (slot_ffree_t)event_free);
}

void plint_monitor_event_unregister(plint_monitor_t m, plint_event_t e)
{
  slot_unregister((slot_key_t)slot_getdata(plint->monitor.moni, (int)m), (int)e);
}

plint_str_t plint_monitor_event_name(plint_monitor_t m, plint_event_t e)
{
  plint_event_real_t r;
  plint_str_t s;

  r = (plint_event_real_t)slot_getdata((slot_key_t)slot_getdata(plint->monitor.moni, (int)m), (int)e);
  plint_hash_str(plint->monitor.evnt, r->name, s);

  return s;
}

int plint_monitor_event_match(plint_monitor_t m, plint_event_t e, plint_str_t n)
{
  plint_event_real_t r = (plint_event_real_t)slot_getdata((slot_key_t)slot_getdata(plint->monitor.moni,
                                                                                   (int)m),
                                                          (int)e);

  return HASH_INDEX_EQU(r->name, hash_getindex(plint->monitor.evnt, plint_str_sn(n)));
}

inline int plint_monitor_announce(plint_monitor_t m, plint_event_t e, ...)
{
  int i;
  plint_event_real_t r;
  plint_subscriber_proxy_t p;
  vargs_t a;
  slot_key_t s;

  s = (slot_key_t)slot_getdata(plint->monitor.moni, (int)m);

  if (!slot_lock(s))
    return 0;

  vargstart(a, e);

  r = (plint_event_real_t)slot_getdata(s, (int)e);
  for (i = slot_first(r->subs); i; i = slot_next(r->subs, i))
    {
      p = (plint_subscriber_proxy_t)slot_getdata(r->subs, i);
      if (p->event->enable)
        (void)r->done(m, e, p->subscriber, p->event->announce(m, e, p->subscriber, p->event->data, a), a);
    }

  vargsdone(a);

  slot_unlock(s);

  return !0;
}

plint_subscriber_t plint_monitor_subscribe(plint_monitor_t m)
{
  plint_subscriber_real_t r;

  NEW(r);
  r->monitor = m;
  r->events = slot_create();
  return (plint_subscriber_t)r;
}

void plint_monitor_unsubscribe(plint_subscriber_t s)
{
  plint_subscriber_real_t r;

  r = (plint_subscriber_real_t)s;
  slot_delete(r->events);
  FREE(r);
}

int plint_monitor_subscribed(plint_monitor_t m, plint_subscriber_t s)
{
  return ((plint_subscriber_real_t)s)->monitor == m;
}

static void subscribe_xxxx(plint_subscriber_real_t s, bit_t x)
{
  int i;
  plint_subscriber_event_t e;

  for (i = slot_first(s->events); i; i = slot_next(s->events, i))
    {
      e = (plint_subscriber_event_t)slot_getdata(s->events, i);
      e->enable = x;
    }
}

inline void plint_monitor_subscribe_none(plint_subscriber_t s)
{
  subscribe_xxxx((plint_subscriber_real_t)s, 0);
}

inline void plint_monitor_subscribe_each(plint_subscriber_t s)
{
  subscribe_xxxx((plint_subscriber_real_t)s, 1);
}

static int event_find_in_moni(plint_event_real_t l, plint_str_t *r)
{
  plint_str_t s;
  int x;

  plint_hash_str(plint->monitor.evnt, l->name, s);
  x = plint_str_equ(s, *r);
  plint_str_fre(s);

  return x;
}

static int lookup_event_in_moni(plint_subscriber_real_t s, plint_str_t e)
{
  return slot_find((slot_key_t)slot_getdata(plint->monitor.moni, (int)s->monitor),
                   (void *)&e,
                   (slot_ffind_t)event_find_in_moni);
}

static int proxy_find(plint_subscriber_proxy_t p, plint_event_t e)
{
  return p->event == e;
}

static void free_event(plint_subscriber_event_t e)
{
  slot_key_t s = ((plint_event_real_t)slot_getdata((slot_key_t)slot_getdata(plint->monitor.moni, (int)e->monitor),
                                                   (int)e->event))->subs;
  slot_unregister(s, slot_find(s, e->event, (slot_ffind_t)proxy_find));
  FREE(e);
}

static void free_proxy(plint_subscriber_proxy_t p)
{
  /* MUST NOT trigger a free_event!
     because, if everything goes well in case of a fatal signal,
     the subscribers should have unsubscribed by know...
     ... not to mention the normal flow case.
  */
  FREE(p);
}

static int event_find_in_subs(plint_subscriber_event_t e, plint_event_t i)
{
  return (e->event == (plint_event_t)i);
}

static int lookup_event_in_subs(plint_subscriber_real_t s, plint_event_t e)
{
  return slot_find(s->events, e, (slot_ffind_t)event_find_in_subs);
}

int plint_monitor_subscribe_event(plint_subscriber_t s, plint_str_t es, plint_announce_t a, void * d)
{
  int i, j;
  plint_subscriber_event_t e;
  plint_subscriber_real_t r;
  plint_subscriber_proxy_t p;

  r = (plint_subscriber_real_t)s;

  i = lookup_event_in_moni(r, es);
  if (i == 0)
    return -1;

  j = lookup_event_in_subs(r, (plint_event_t)i);
  if (j != 0)
    return +1;

  NEW(e);
  e->monitor = r->monitor;
  e->event = (plint_event_t)i;
  e->enable = 1;

  e->data = d;
  e->announce = a;
  slot_register(r->events, e, (slot_ffree_t)free_event);

  NEW(p);
  p->subscriber = s;
  p->event = e;
  (void)slot_register(((plint_event_real_t)slot_getdata(
                                                        (slot_key_t)slot_getdata(plint->monitor.moni, (int)r->monitor),
                                                        i))->subs,
                      p, (slot_ffree_t)free_proxy);

  return 0;
}

static int endis_event(plint_subscriber_real_t s, plint_str_t e, bit_t x)
{
  int i;

  i = lookup_event_in_moni(s, e);
  if (i == 0)
    return -1;

  i = lookup_event_in_subs(s, (plint_event_t)i);
  if (i == 0)
    return +1;

  ((plint_subscriber_event_t)slot_getdata(s->events, i))->enable = x;

  return 0;
}

inline int plint_monitor_disable_event(plint_subscriber_t s, plint_str_t e)
{
  return endis_event((plint_subscriber_real_t)s, e, 0);
}

inline int plint_monitor_enable_event(plint_subscriber_t s, plint_str_t e)
{
  return endis_event((plint_subscriber_real_t)s, e, 1);
}

int plint_monitor_event(plint_subscriber_t s, plint_str_t e)
{
  int i;
  plint_subscriber_real_t r;

  r = (plint_subscriber_real_t)s;

  i = lookup_event_in_moni(r, e);
  if (i == 0)
    return -1;

  i = lookup_event_in_subs(r, (plint_event_t)i);
  if (i == 0)
    return -1;

  return ((plint_subscriber_event_t)slot_getdata(r->events, i))->enable ? 1 : 0;
}

int plint_monitor_unsubscribe_event(plint_subscriber_t s, plint_str_t e, void ** p)
{
  int i;
  plint_subscriber_real_t r;

  r = (plint_subscriber_real_t)s;

  i = lookup_event_in_moni(r, e);
  if (i == 0)
    return -1;

  i = lookup_event_in_subs(r, (plint_event_t)i);
  if (i == 0)
    return +1;

  if (p)
    *p = slot_getdata(r->events, i);
  slot_unregister(r->events, i);

  return 0;
}

---