ermyth/src/event.C

/*
 * event.C: Event subsystem.
 * 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$";

#include "atheme.h"
#include "internal.h"

const char *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 (const char *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);

          claro_state.event++;

          return i;
        }
    }

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

  return -1;
}

/* adds an event to the table to be ran only once */
unsigned int
event_add_once (const char *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);

          claro_state.event++;

          return i;
        }
    }

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

  return -1;
}

/* 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;

  claro_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;

              claro_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 -1;
}

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