ermyth/src/event.C

/*
 * event.C: Event subsystem.
 *
 * Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
 * Rights to this code are as documented in COPYING.
 *
 *
 * Portions of this file were derived from sources bearing the following license:
 * Rights to this code are documented in doc/pod/license.pod.
 * Copyright © 2005-2007 Atheme Project (http://www.atheme.org)           
 */

static char const rcsid[] = "$Id: event.C,v 1.5 2007-09-16 18:54:44 pippijn Exp $";

#include "atheme.h"
#include <libermyth.h>
#include <ermyth/system.h>
#include "internal.h"

char const *last_event_ran = NULL;
struct ev_entry event_table[MAX_EVENTS];
static time_t event_time_min = -1;

/* add an event to the table to be continually ran */
unsigned int
event_add (char const * const name, EVH * func, void *arg, time_t when)
{
  unsigned int i;

  /* find the first inactive index */
  for (i = 0; i < MAX_EVENTS; i++)
    {
      if (!event_table[i].active)
        {
          event_table[i].func = func;
          event_table[i].name = name;
          event_table[i].arg = arg;
          event_table[i].when = NOW + when;
          event_table[i].frequency = when;
          event_table[i].active = true;

          if ((event_table[i].when < event_time_min) || (event_time_min == -1))
            event_time_min = event_table[i].when;

          slog (LG_DEBUG, "event_add(): \"%s\"", name);

          system_state.event++;

          return i;
        }
    }

  /* failed to add it... */
  slog (LG_DEBUG, "event_add(): failed to add \"%s\" to event table", name);

  return UINT_MAX;
}

/* adds an event to the table to be ran only once */
unsigned int
event_add_once (char const * const name, EVH * func, void *arg, time_t when)
{
  unsigned int i;

  /* find the first inactive index */
  for (i = 0; i < MAX_EVENTS; i++)
    {
      if (!event_table[i].active)
        {
          event_table[i].func = func;
          event_table[i].name = name;
          event_table[i].arg = arg;
          event_table[i].when = NOW + when;
          event_table[i].frequency = 0;
          event_table[i].active = true;

          if ((event_table[i].when < event_time_min) || (event_time_min == -1))
            event_time_min = event_table[i].when;

          slog (LG_DEBUG, "event_add_once(): \"%s\"", name);

          system_state.event++;

          return i;
        }
    }

  /* failed to add it... */
  slog (LG_DEBUG, "event_add(): failed to add \"%s\" to event table", name);

  return UINT_MAX;
}

/* delete an event from the table */
void
event_delete (EVH * func, void *arg)
{
  int i = event_find (func, arg);

  if (i == -1)
    return;

  slog (LG_DEBUG, "event_delete(): removing \"%s\"", event_table[i].name);

  event_table[i].name = NULL;
  event_table[i].func = NULL;
  event_table[i].arg = NULL;
  event_table[i].active = false;

  system_state.event--;
}

/* checks all pending events */
void
event_run (void)
{
  unsigned int i;

  for (i = 0; i < MAX_EVENTS; i++)
    {
      if (event_table[i].active && (event_table[i].when <= NOW))
        {
          /* now we call it */
          last_event_ran = event_table[i].name;
          event_table[i].func (event_table[i].arg);
          event_time_min = -1;

          /* event is scheduled more than once */
          if (event_table[i].frequency)
            event_table[i].when = NOW + event_table[i].frequency;
          else
            {
              event_table[i].name = NULL;
              event_table[i].func = NULL;
              event_table[i].arg = NULL;
              event_table[i].active = false;

              system_state.event--;
            }
        }
    }
}

/* returns the time the next event_run() should happen */
time_t
event_next_time (void)
{
  unsigned int i;

  if (event_time_min == -1)
    {
      for (i = 0; i < MAX_EVENTS; i++)
        {
          if (event_table[i].active && ((event_table[i].when < event_time_min) || event_time_min == -1))
            event_time_min = event_table[i].when;
        }
    }

  return event_time_min;
}

/* initializes event system */
void
event_init (void)
{
  last_event_ran = NULL;
  memset ((void *) event_table, 0, sizeof (event_table));
}

/* finds an event in the table */
unsigned int
event_find (EVH * func, void *arg)
{
  unsigned int i;

  for (i = 0; i < MAX_EVENTS; i++)
    {
      if ((event_table[i].func == func) && (event_table[i].arg == arg))
        return i;
    }

  return UINT_MAX;
}
Revision:	1.6
Committed:	Sat Sep 22 14:27:30 2007 UTC (16 years, 8 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.5:	+3 -1 lines
Log Message:	split up ermyth into ermyth-modules, libermyth (currently just ermyth-util) and ermyth-core
#	User	Rev	Content
1	pippijn	1.1	/*
2			* event.C: Event subsystem.
3	pippijn	1.5	*
4			* Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
5			* Rights to this code are as documented in COPYING.
6			*
7			*
8			* Portions of this file were derived from sources bearing the following license:
9	pippijn	1.2	* Rights to this code are documented in doc/pod/license.pod.
10	pippijn	1.4	* Copyright © 2005-2007 Atheme Project (http://www.atheme.org)
11	pippijn	1.1	*/
12
13	pippijn	1.6	static char const rcsid[] = "$Id: event.C,v 1.5 2007-09-16 18:54:44 pippijn Exp $";
14	pippijn	1.1
15			#include "atheme.h"
16	pippijn	1.6	#include <libermyth.h>
17			#include <ermyth/system.h>
18	pippijn	1.1	#include "internal.h"
19
20	pippijn	1.4	char const *last_event_ran = NULL;
21	pippijn	1.1	struct ev_entry event_table[MAX_EVENTS];
22			static time_t event_time_min = -1;
23
24			/* add an event to the table to be continually ran */
25			unsigned int
26	pippijn	1.4	event_add (char const * const name, EVH * func, void *arg, time_t when)
27	pippijn	1.1	{
28			unsigned int i;
29
30			/* find the first inactive index */
31			for (i = 0; i < MAX_EVENTS; i++)
32			{
33			if (!event_table[i].active)
34			{
35			event_table[i].func = func;
36			event_table[i].name = name;
37			event_table[i].arg = arg;
38			event_table[i].when = NOW + when;
39			event_table[i].frequency = when;
40			event_table[i].active = true;
41
42			if ((event_table[i].when < event_time_min) \|\| (event_time_min == -1))
43			event_time_min = event_table[i].when;
44
45			slog (LG_DEBUG, "event_add(): \"%s\"", name);
46
47	pippijn	1.4	system_state.event++;
48	pippijn	1.1
49			return i;
50			}
51			}
52
53			/* failed to add it... */
54			slog (LG_DEBUG, "event_add(): failed to add \"%s\" to event table", name);
55
56	pippijn	1.4	return UINT_MAX;
57	pippijn	1.1	}
58
59			/* adds an event to the table to be ran only once */
60			unsigned int
61	pippijn	1.4	event_add_once (char const * const name, EVH * func, void *arg, time_t when)
62	pippijn	1.1	{
63			unsigned int i;
64
65			/* find the first inactive index */
66			for (i = 0; i < MAX_EVENTS; i++)
67			{
68			if (!event_table[i].active)
69			{
70			event_table[i].func = func;
71			event_table[i].name = name;
72			event_table[i].arg = arg;
73			event_table[i].when = NOW + when;
74			event_table[i].frequency = 0;
75			event_table[i].active = true;
76
77			if ((event_table[i].when < event_time_min) \|\| (event_time_min == -1))
78			event_time_min = event_table[i].when;
79
80			slog (LG_DEBUG, "event_add_once(): \"%s\"", name);
81
82	pippijn	1.4	system_state.event++;
83	pippijn	1.1
84			return i;
85			}
86			}
87
88			/* failed to add it... */
89			slog (LG_DEBUG, "event_add(): failed to add \"%s\" to event table", name);
90
91	pippijn	1.4	return UINT_MAX;
92	pippijn	1.1	}
93
94			/* delete an event from the table */
95			void
96			event_delete (EVH * func, void *arg)
97			{
98			int i = event_find (func, arg);
99
100			if (i == -1)
101			return;
102
103			slog (LG_DEBUG, "event_delete(): removing \"%s\"", event_table[i].name);
104
105			event_table[i].name = NULL;
106			event_table[i].func = NULL;
107			event_table[i].arg = NULL;
108			event_table[i].active = false;
109
110	pippijn	1.4	system_state.event--;
111	pippijn	1.1	}
112
113			/* checks all pending events */
114			void
115			event_run (void)
116			{
117			unsigned int i;
118
119			for (i = 0; i < MAX_EVENTS; i++)
120			{
121			if (event_table[i].active && (event_table[i].when <= NOW))
122			{
123			/* now we call it */
124			last_event_ran = event_table[i].name;
125			event_table[i].func (event_table[i].arg);
126			event_time_min = -1;
127
128			/* event is scheduled more than once */
129			if (event_table[i].frequency)
130			event_table[i].when = NOW + event_table[i].frequency;
131			else
132			{
133			event_table[i].name = NULL;
134			event_table[i].func = NULL;
135			event_table[i].arg = NULL;
136			event_table[i].active = false;
137
138	pippijn	1.4	system_state.event--;
139	pippijn	1.1	}
140			}
141			}
142			}
143
144			/* returns the time the next event_run() should happen */
145			time_t
146			event_next_time (void)
147			{
148			unsigned int i;
149
150			if (event_time_min == -1)
151			{
152			for (i = 0; i < MAX_EVENTS; i++)
153			{
154			if (event_table[i].active && ((event_table[i].when < event_time_min) \|\| event_time_min == -1))
155			event_time_min = event_table[i].when;
156			}
157			}
158
159			return event_time_min;
160			}
161
162			/* initializes event system */
163			void
164			event_init (void)
165			{
166			last_event_ran = NULL;
167			memset ((void *) event_table, 0, sizeof (event_table));
168			}
169
170			/* finds an event in the table */
171			unsigned int
172			event_find (EVH * func, void *arg)
173			{
174			unsigned int i;
175
176			for (i = 0; i < MAX_EVENTS; i++)
177			{
178			if ((event_table[i].func == func) && (event_table[i].arg == arg))
179			return i;
180			}
181
182	pippijn	1.4	return UINT_MAX;
183	pippijn	1.1	}