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.4 2007-08-28 17:08:12 pippijn Exp $";

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