engines.h

Go to the documentation of this file.

/*
** Copyright (C) 2005 by Kevin L. Mitchell <klmitch@mit.edu>
**
** This program 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 of the License, or
** (at your option) any later version.
**
** This program 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 this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**
** @(#)$Id: engines.h,v 1.18 2005/12/29 04:33:58 klmitch Exp $
*/
#ifndef __include_event_engines_h__
#define __include_event_engines_h__

#ifndef __EVENT_LIBRARY__
# include <event/event.h>
# include <event/sock.h>
# include <event/sig.h>
# include <event/tim.h>
#endif /* __EVENT_LIBRARY__ */

EV_BEGIN_C_DECLS

struct timeval;

#if DOXYGEN
#define ENGINE_MODULE
#endif /* DOXYGEN */

#define _ev__p(l, r)    l ## r

#define _ev_paste(l, r) _ev__p(l, r)

#if DOXYGEN
extern ev_engine_t *engine_mod_init(ev_ctx_t *ctx);
#else
#define engine_mod_init _ev_paste(ENGINE_MODULE, _LTX_engine_mod_init)
#endif /* DOXYGEN */

#if DOXYGEN
extern ev_engine_t *engine_module;
#else
#define engine_module   _ev_paste(ENGINE_MODULE, _LTX_engine_module)
#endif /* DOXYGEN */

typedef struct _ev_engine_s ev_engine_t;

typedef struct _ev_englink_s _ev_englink_t;

typedef struct _ev_sockets_s _ev_sockets_t;

typedef struct _ev_signals_s _ev_signals_t;

typedef struct _ev_timers_s _ev_timers_t;

typedef ev_engine_t *(*ev_modinit_t)(ev_ctx_t *ctx);

typedef ev_err_t (*ev_init_t)(ev_ctx_t *ctx, ev_engine_t *engine,
                              ev_flags_t *eng_flags);

typedef ev_err_t (*ev_poll_t)(ev_ctx_t *ctx, ev_engine_t *engine,
                              struct timeval *timeout);

typedef void (*ev_fini_t)(ev_ctx_t *ctx, ev_engine_t *engine);

typedef ev_err_t (*ev_sockadd_t)(ev_ctx_t *ctx, ev_engine_t *engine,
                                 ev_sock_t *sock);

typedef ev_err_t (*ev_sockrem_t)(ev_ctx_t *ctx, ev_engine_t *engine,
                                 ev_sock_t *sock);

typedef ev_err_t (*ev_sockev_t)(ev_ctx_t *ctx, ev_engine_t *engine,
                                ev_sock_t *sock, ev_flags_t evs);

typedef ev_err_t (*ev_sigadd_t)(ev_ctx_t *ctx, ev_engine_t *engine,
                                ev_sig_t *sig);

typedef ev_err_t (*ev_sigrem_t)(ev_ctx_t *ctx, ev_engine_t *engine,
                                ev_sig_t *sig);

typedef ev_err_t (*ev_timadd_t)(ev_ctx_t *ctx, ev_engine_t *engine,
                                ev_tim_t *tim);

typedef ev_err_t (*ev_timrem_t)(ev_ctx_t *ctx, ev_engine_t *engine,
                                ev_tim_t *tim);

struct _ev_englink_s {
  ev_engine_t          *el_next;        
  ev_engine_t          *el_prev;        
};

struct _ev_sockets_s {
  _ev_englink_t         eso_active;     
  void                 *eso_data;       
  ev_sockadd_t          eso_add;        
  ev_sockrem_t          eso_rem;        
  ev_sockev_t           eso_ev;         
};

struct _ev_signals_s {
  _ev_englink_t         esi_active;     
  void                 *esi_data;       
  ev_sigadd_t           esi_add;        
  ev_sigrem_t           esi_rem;        
};

struct _ev_timers_s {
  _ev_englink_t         eti_active;     
  void                 *eti_data;       
  ev_timadd_t           eti_add;        
  ev_timrem_t           eti_rem;        
};

struct _ev_engine_s {
  ev_magic_t            eng_magic;      
  const char           *eng_name;       
  const char           *eng_desc;       
  ev_flags_t            eng_flags;      
  ev_flags_t            eng_runfl;      
  _ev_englink_t         eng_list;       
  void                 *eng_handle;     
  void                 *eng_data;       
  ev_init_t             eng_init;       
  ev_poll_t             eng_poll;       
  ev_fini_t             eng_fini;       
  _ev_sockets_t         eng_socket;     
  _ev_signals_t         eng_signal;     
  _ev_timers_t          eng_timer;      
};

#define EV_ENGINE_MAGIC 0x909ca8e5

#define EV_ENGINE_INIT(name, desc, flags, init, poll, fini, so_add, so_rem,   \
                       so_ev, si_add, si_rem, ti_add, ti_rem)                 \
        { EV_ENGINE_MAGIC, (name), (desc), (flags), 0, { 0, 0 }, 0,           \
          0, (init), (poll), (fini),                                          \
          { { 0, 0 }, 0, (so_add), (so_rem), (so_ev) },                       \
          { { 0, 0 }, 0, (si_add), (si_rem) },                                \
          { { 0, 0 }, 0, (ti_add), (ti_rem) } }

#define EV_ENGINE_SOCKET        0x00000001

#define EV_ENGINE_SIGNAL        0x00000002

#define EV_ENGINE_TIMER         0x00000004

#define EV_ENGINE_COMPMASK      (EV_ENGINE_SOCKET | EV_ENGINE_SIGNAL |        \
                                 EV_ENGINE_TIMER)

#define EV_ENGINE_REGISTERED    0x00000008

#define EV_ENGINE_RUNNING       0x00000010

#define eng_verify(eng)         ((eng) && (eng)->eng_magic == EV_ENGINE_MAGIC)

#define eng_name(eng)           ((eng)->eng_name)

#define eng_desc(eng)           ((eng)->eng_desc)

#define eng_flags(eng)          ((eng)->eng_flags)

#define eng_runfl(eng)          ((eng)->eng_runfl)

#define eng_runfl_set(eng, fl)  ((eng)->eng_runfl |= (fl))

#define eng_runfl_clr(eng, fl)  ((eng)->eng_runfl &= ~(fl))

#define eng_data(eng)           ((eng)->eng_data)

#define eng_data_set(eng, data) ((eng)->eng_data = (data))

#define eng_sockdata(eng)       ((eng)->eng_socket.eso_data)

#define eng_sockdata_set(eng, data)                                           \
                                ((eng)->eng_socket.eso_data = (data))

#define eng_sigdata(eng)        ((eng)->eng_signal.esi_data)

#define eng_sigdata_set(eng, data)                                            \
                                ((eng)->eng_signal.esi_data = (data))

#define eng_timdata(eng)        ((eng)->eng_timer.eti_data)

#define eng_timdata_set(eng, data)                                            \
                                ((eng)->eng_timer.eti_data = (data))

#define so_eevents_set(sock, flags)                                           \
                                _so_set((sock), _so_encev((flags),            \
                                                          _EV_SOCK_EEVENTS))

#define so_eevents_clr(sock, flags)                                           \
                                _so_clr((sock), _so_encev((flags),            \
                                                          _EV_SOCK_EEVENTS))

extern ev_err_t engine_register(ev_ctx_t *ctx, ev_engine_t *engine)
     _gca_nonnull((1, 2));

extern ev_err_t engine_activate(ev_ctx_t *ctx, ev_engine_t *engine,
                                ev_flags_t comps)
     _gca_nonnull((1, 2));

extern ev_err_t event_attr_engine(ev_attr_t *attr, ev_engine_t *engine)
     _gca_nonnull((1, 2));

EV_END_C_DECLS

#endif /* __include_event_engines_h__ */

---