Mercurial > repos > rliterman > csp2

comparison CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/verto-module.h @ 69:33d812a61356

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
planemo upload commit 2e9511a184a1ca667c7be0c6321a36dc4e3d116d
author jpayne
date Tue, 18 Mar 2025 17:55:14 -0400
parents
children
comparison
equal deleted inserted replaced
67:0e9998148a16 69:33d812a61356
1 /*
2 * Copyright 2011 Red Hat, Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person
5 * obtaining a copy of this software and associated documentation files
6 * (the "Software"), to deal in the Software without restriction,
7 * including without limitation the rights to use, copy, modify, merge,
8 * publish, distribute, sublicense, and/or sell copies of the Software,
9 * and to permit persons to whom the Software is furnished to do so,
10 * subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25 /*** THE FOLLOWING ARE FOR IMPLEMENTATION MODULES ONLY ***/
26
27 #ifndef VERTO_MODULE_H_
28 #define VERTO_MODULE_H_
29
30 #include <verto.h>
31
32 #ifndef VERTO_MODULE_TYPES
33 #define VERTO_MODULE_TYPES
34 typedef void verto_mod_ctx;
35 typedef void verto_mod_ev;
36 #endif
37
38 #define VERTO_MODULE_VERSION 3
39 #define VERTO_MODULE_TABLE(name) verto_module_table_ ## name
40 #define VERTO_MODULE(name, symb, types) \
41 static verto_ctx_funcs name ## _funcs = { \
42 name ## _ctx_new, \
43 name ## _ctx_default, \
44 name ## _ctx_free, \
45 name ## _ctx_run, \
46 name ## _ctx_run_once, \
47 name ## _ctx_break, \
48 name ## _ctx_reinitialize, \
49 name ## _ctx_set_flags, \
50 name ## _ctx_add, \
51 name ## _ctx_del \
52 }; \
53 verto_module VERTO_MODULE_TABLE(name) = { \
54 VERTO_MODULE_VERSION, \
55 # name, \
56 # symb, \
57 types, \
58 &name ## _funcs, \
59 }; \
60 verto_ctx * \
61 verto_new_ ## name() \
62 { \
63 return verto_convert(name, 0, NULL); \
64 } \
65 verto_ctx * \
66 verto_default_ ## name() \
67 { \
68 return verto_convert(name, 1, NULL); \
69 }
70
71 typedef struct {
72 /* Required */ verto_mod_ctx *(*ctx_new)();
73 /* Optional */ verto_mod_ctx *(*ctx_default)();
74 /* Required */ void (*ctx_free)(verto_mod_ctx *ctx);
75 /* Optional */ void (*ctx_run)(verto_mod_ctx *ctx);
76 /* Required */ void (*ctx_run_once)(verto_mod_ctx *ctx);
77 /* Optional */ void (*ctx_break)(verto_mod_ctx *ctx);
78 /* Optional */ void (*ctx_reinitialize)(verto_mod_ctx *ctx);
79 /* Optional */ void (*ctx_set_flags)(verto_mod_ctx *ctx,
80 const verto_ev *ev,
81 verto_mod_ev *modev);
82 /* Required */ verto_mod_ev *(*ctx_add)(verto_mod_ctx *ctx,
83 const verto_ev *ev,
84 verto_ev_flag *flags);
85 /* Required */ void (*ctx_del)(verto_mod_ctx *ctx,
86 const verto_ev *ev,
87 verto_mod_ev *modev);
88 } verto_ctx_funcs;
89
90 typedef struct {
91 unsigned int vers;
92 const char *name;
93 const char *symb;
94 verto_ev_type types;
95 verto_ctx_funcs *funcs;
96 } verto_module;
97
98 /**
99 * Converts an existing implementation specific loop to a verto_ctx.
100 *
101 * This function also sets the internal default implementation so that future
102 * calls to verto_new(NULL) or verto_default(NULL) will use this specific
103 * implementation if it was not already set.
104 *
105 * @param name The name of the module (unquoted)
106 * @param deflt Whether the ctx is the default context or not
107 * @param ctx The context to store
108 * @return A new verto_ctx, or NULL on error. Call verto_free() when done.
109 */
110 #define verto_convert(name, deflt, ctx) \
111 verto_convert_module(&VERTO_MODULE_TABLE(name), deflt, ctx)
112
113 /**
114 * Converts an existing implementation specific loop to a verto_ctx.
115 *
116 * If you are a module implementation, you probably want the macro above. This
117 * function is generally used directly only when an application is attempting
118 * to expose a home-grown event loop to verto.
119 *
120 * If deflt is non-zero and a default ctx was already defined for this module
121 * and ctx is not NULL, than ctx will be free'd and the previously defined
122 * default will be returned.
123 *
124 * If ctx is non-NULL, than the pre-existing verto_mod_ctx will be converted to
125 * to a verto_ctx; if deflt is non-zero than this verto_mod_ctx will also be
126 * marked as the default loop for this process. If ctx is NULL, than the
127 * appropriate constructor will be called: either module->ctx_new() or
128 * module->ctx_default() depending on the boolean value of deflt. If
129 * module->ctx_default is NULL and deflt is non-zero, than module->ctx_new()
130 * will be called and the resulting verto_mod_ctx will be utilized as the
131 * default.
132 *
133 * This function also sets the internal default implementation so that future
134 * calls to verto_new(NULL) or verto_default(NULL) will use this specific
135 * implementation if it was not already set.
136 *
137 * @param name The name of the module (unquoted)
138 * @param ctx The context private to store
139 * @return A new verto_ctx, or NULL on error. Call verto_free() when done.
140 */
141 verto_ctx *
142 verto_convert_module(const verto_module *module, int deflt, verto_mod_ctx *ctx);
143
144 /**
145 * Calls the callback of the verto_ev and then frees it via verto_del().
146 *
147 * The verto_ev is not freed (verto_del() is not called) if it is a signal event.
148 *
149 * @see verto_add_read()
150 * @see verto_add_write()
151 * @see verto_add_timeout()
152 * @see verto_add_idle()
153 * @see verto_add_signal()
154 * @see verto_add_child()
155 * @see verto_del()
156 * @param ev The verto_ev
157 */
158 void
159 verto_fire(verto_ev *ev);
160
161 /**
162 * Sets the status of the pid/handle which caused this event to fire.
163 *
164 * This function does nothing if the verto_ev is not a child type.
165 *
166 * @see verto_add_child()
167 * @param ev The verto_ev to set the status in.
168 * @param status The pid/handle status.
169 */
170 void
171 verto_set_proc_status(verto_ev *ev, verto_proc_status status);
172
173 /**
174 * Sets the state of the fd which caused this event to fire.
175 *
176 * This function does nothing if the verto_ev is not a io type.
177 *
178 * Only the flags VERTO_EV_FLAG_IO_(READ|WRITE|ERROR) are supported. All other
179 * flags are unset.
180 *
181 * @see verto_add_io()
182 * @param ev The verto_ev to set the state in.
183 * @param state The fd state.
184 */
185 void
186 verto_set_fd_state(verto_ev *ev, verto_ev_flag state);
187
188 #endif /* VERTO_MODULE_H_ */