int main()
{
std::thread worker(timer_thread);
// call some set_callback here
set_callback(std::chrono::seconds(1), 2);
set_callback(std::chrono::seconds(2), 4);
set_callback(std::chrono::seconds(3), 6);
std::this_thread::sleep_for(std::chrono::seconds(5));
isCancelled = true;
cv.notify_all();
worker.join();
}
EXPORT CLASS *init(CALLBACKS *fntable, MODULE *module, int argc, char *argv[])
{
if (set_callback(fntable)==NULL)
{
errno = EINVAL;
return NULL;
}
#ifdef OPTIONAL
/* TODO: publish global variables (see class_define_map() for details) */
//gl_global_create(char *name, ..., NULL);
/* TODO: use gl_global_setvar, gl_global_getvar, and gl_global_find for access */
#endif
/*** DO NOT EDIT NEXT LINE ***/
new bus(module);
//new line(module);
new branch(module);
new gen(module);
//new gen_cost(module);
//new areas(module);
//new baseMVA(module);
/* always return the first class registered */
/* TODO this module will not compile until a class has been defined */
return bus::oclass;
}
void init_buffer_socket(BufferSocket *bs, size_t item_count, size_t payload_len) {
// Initialize a BufferSocket
bs->buf = ring_buffer_create(item_count, payload_len);
set_callback(bs, &default_callback);
bs->run_threads = 0;
bs->userdata = NULL;
}
static VALUE watch_timer(VALUE self, VALUE delay)
{
set_callback(&timer_handler, "timer_handler");
if (timer_timeout != 0)
g_source_remove(timer_timeout);
timer_timeout = g_timeout_add_full( G_PRIORITY_HIGH, delay, do_timeout, timer_handler, NULL );
return delay;
}
static VALUE watch_timer(VALUE self, VALUE delay)
{
set_callback(&timer_handler, "timer_handler");
if (timer_timeout != 0)
g_source_remove(timer_timeout);
timer_timeout = g_timeout_add(delay, do_timeout, timer_handler);
return delay;
}
void set_callback(Function callback, cl_int status = CL_COMPLETE)
{
set_callback(
event_callback_invoker,
status,
new boost::function<void()>(callback)
);
}
static void join_symbol(join_t * x, t_symbol * s)
{
t_int* argv = getbytes(2*sizeof(t_int*));
argv[0] = (t_int)x->x_outlet;
argv[1] = (t_int)s;
set_callback(join_symbol_callback, argv, 2);
}
static void join_float(join_t * x, t_float f)
{
t_int* argv = getbytes(2*sizeof(t_int*));
argv[0] = (t_int)x->x_outlet;
argv[1] = (t_int)f;
set_callback(join_float_callback, argv, 2);
}
static void join_pointer(join_t * x, t_gpointer * gp)
{
t_int* argv = getbytes(2*sizeof(t_int*));
argv[0] = (t_int)x->x_outlet;
argv[1] = (t_int)gp;
set_callback(join_pointer_callback, argv, 2);
}
static VALUE watch_signed_off_event(VALUE self)
{
set_callback(&signed_off_handler, "signed_off_handler");
int handle;
purple_signal_connect(purple_connections_get_handle(), "signed-off", &handle,
PURPLE_CALLBACK(signed_off), NULL);
return signed_off_handler;
}
int
ncp_args_parseopt(struct ncp_args *na, int opt, char *optarg, ncp_setopt_t *set_callback) {
int len;
for (; na->opt; na++) {
if (na->opt != opt) continue;
switch (na->at) {
case NCA_STR:
na->str = optarg;
if (optarg) {
len = strlen(na->str);
if (len > na->ival) {
fprintf(stderr,"opt: Argument for option '%c' (%s) too long\n",na->opt,na->name);
return EINVAL;
}
set_callback(na);
}
break;
case NCA_BOOL:
na->ival = 0;
set_callback(na);
break;
case NCA_INT:
errno = 0;
na->ival = strtol(optarg, NULL, 0);
if (errno) {
fprintf(stderr,"opt: Invalid integer value for option '%c' (%s).\n",na->opt,na->name);
return EINVAL;
}
if (((na->flag & NAFL_HAVEMIN) &&
(na->ival < na->min)) ||
((na->flag & NAFL_HAVEMAX) &&
(na->ival > na->max))) {
fprintf(stderr,"opt: Argument for option '%c' (%s) should be in [%d-%d] range\n",na->opt,na->name,na->min,na->max);
return EINVAL;
}
set_callback(na);
break;
default:
break;
}
break;
}
return 0;
}
/** \brief Set the mandatory parameters and start the actions
*
* - This is only a helper function on top of the actual functions
*/
simuwan_err_t simuwan_t::start(simuwan_cb_t *callback, void *userptr) throw()
{
simuwan_err_t simuwan_err;
// set the callback
simuwan_err = set_callback(callback, userptr);
if( simuwan_err.failed() ) return simuwan_err;
// start the action
return start();
}
void UI_KEYTRAP::create(UI_WINDOW* wnd, int key, void (*_user_function)(void))
{
base_create(wnd, UI_KIND_BUTTON, 0, 0, 0, 0);
pressed_down = 0;
set_hotkey(key);
set_callback(_user_function);
parent = this; // Ugly. This keeps KEYTRAPS from getting keyboard control.
}
static void join_anything(join_t * x, t_symbol * s, int argc, t_atom* largv)
{
t_int* argv = getbytes(3*sizeof(t_int*));
t_atom* copied_argv = copybytes(largv, argc * sizeof(t_atom));
argv[0] = (t_int)x->x_outlet;
argv[1] = (t_int)argc;
argv[2] = (t_int)copied_argv;
set_callback(join_anything_callback, argv, 3);
}
static int tcp_read_start(lua_State* L) {
tcp_obj* self;
int r;
self = luaL_checkudata(L, 1, "uv.tcp");
set_callback(L, "on_read", 2);
r = uv_read_start((uv_stream_t*)&self->handle, on_alloc, on_read);
lua_pushinteger(L, r);
return 1;
}
static int tcp_listen(lua_State* L) {
tcp_obj* self;
int backlog;
int r;
self = luaL_checkudata(L, 1, "uv.tcp");
if (lua_isnumber(L, 2)) {
backlog = luaL_checkinteger(L, 2);
set_callback(L, "on_connection", 3);
}
else {
backlog = 128;
set_callback(L, "on_connection", 2);
}
r = uv_listen((uv_stream_t*)&self->handle, backlog, on_connection);
lua_pushinteger(L, r);
return 1;
}
/***********************************************************************
* RegisterBindStatusCallback (urlmon.@)
*
* Register a bind status callback.
*
* PARAMS
* pbc [I] Binding context
* pbsc [I] Callback to register
* ppbscPrevious [O] Destination for previous callback
* dwReserved [I] Reserved, must be 0.
*
* RETURNS
* Success: S_OK.
* Failure: E_INVALIDARG, if any argument is invalid, or
* E_OUTOFMEMORY if memory allocation fails.
*/
HRESULT WINAPI RegisterBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc,
IBindStatusCallback **ppbscPrevious, DWORD dwReserved)
{
BindStatusCallback *holder;
IBindStatusCallback *bsc, *prev = NULL;
IUnknown *unk;
HRESULT hres;
TRACE("(%p %p %p %x)\n", pbc, pbsc, ppbscPrevious, dwReserved);
if (!pbc || !pbsc)
return E_INVALIDARG;
hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, &unk);
if(SUCCEEDED(hres)) {
hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&bsc);
IUnknown_Release(unk);
if(SUCCEEDED(hres)) {
hres = IBindStatusCallback_QueryInterface(bsc, &IID_IBindStatusCallbackHolder, (void**)&holder);
if(SUCCEEDED(hres)) {
if(ppbscPrevious) {
IBindStatusCallback_AddRef(holder->callback);
*ppbscPrevious = holder->callback;
}
set_callback(holder, pbsc);
IBindStatusCallback_Release(bsc);
IBindStatusCallback_Release(STATUSCLB(holder));
return S_OK;
}else {
prev = bsc;
}
}
IBindCtx_RevokeObjectParam(pbc, BSCBHolder);
}
hres = wrap_callback(pbsc, &bsc);
if(SUCCEEDED(hres)) {
hres = IBindCtx_RegisterObjectParam(pbc, BSCBHolder, (IUnknown*)bsc);
IBindStatusCallback_Release(bsc);
}
if(FAILED(hres)) {
if(prev)
IBindStatusCallback_Release(prev);
return hres;
}
if(ppbscPrevious)
*ppbscPrevious = prev;
return S_OK;
}
/** \brief Helper function to start a ntudp_itor_t with the common parameter
*/
ntudp_err_t ntudp_itor_t::start(ntudp_peer_t *ntudp_peer, const ntudp_addr_t &m_remote_addr
, ntudp_itor_cb_t *callback, void *userptr) throw()
{
ntudp_err_t ntudp_err;
// set the callback
set_callback(callback, userptr);
// bind the socket
ntudp_err = set_remote_addr(ntudp_peer, m_remote_addr);
if( ntudp_err.failed() ) return ntudp_err;
// start the operation
return start();
}
static int tcp_close(lua_State* L) {
tcp_obj* self;
self = luaL_checkudata(L, 1, "uv.tcp");
if (!lua_isnil(L, 2))
set_callback(L, "on_close", 2);
uv_close((uv_handle_t*)&self->handle, on_close);
return 0;
}
/** \brief Setup all mandatory parameters and start the operation
*/
ntudp_err_t ntudp_client_t::start(ntudp_peer_t *ntudp_peer, const ntudp_addr_t &remote_addr
, ntudp_client_cb_t *callback, void * userptr) throw()
{
ntudp_err_t ntudp_err;
// set the remote_addr
ntudp_err = set_remote_addr(ntudp_peer, remote_addr);
if( ntudp_err.failed() ) return ntudp_err;
// set the callback
set_callback(callback, userptr);
// start the operation now
return start();
}
static VALUE watch_connection_error(VALUE self)
{
finch_connections_init();
purple_connections_set_ui_ops(&connection_ops);
set_callback(&connection_error_handler, "connection_error_handler");
/*int handle;
purple_signal_connect(purple_connections_get_handle(), "connection-error", &handle,
PURPLE_CALLBACK(connection_error), NULL);*/
return connection_error_handler;
}
/*
* misc options parsing routines
*/
int
ncp_args_parserc(struct ncp_args *na, char *sect, ncp_setopt_t *set_callback) {
int len, error;
for (; na->opt; na++) {
switch (na->at) {
case NCA_STR:
if (rc_getstringptr(ncp_rc,sect,na->name,&na->str) == 0) {
len = strlen(na->str);
if (len > na->ival) {
fprintf(stderr,"rc: Argument for option '%c' (%s) too long\n",na->opt,na->name);
return EINVAL;
}
set_callback(na);
}
break;
case NCA_BOOL:
error = rc_getbool(ncp_rc,sect,na->name,&na->ival);
if (error == ENOENT) break;
if (error) return EINVAL;
set_callback(na);
break;
case NCA_INT:
if (rc_getint(ncp_rc,sect,na->name,&na->ival) == 0) {
if (((na->flag & NAFL_HAVEMIN) &&
(na->ival < na->min)) ||
((na->flag & NAFL_HAVEMAX) &&
(na->ival > na->max))) {
fprintf(stderr,"rc: Argument for option '%c' (%s) should be in [%d-%d] range\n",na->opt,na->name,na->min,na->max);
return EINVAL;
}
set_callback(na);
};
break;
default:
break;
}
}
return 0;
}
/*
* Function: CODE
* RET Type: test_function
* Wait ptr: 14
* Rtry ptr: 0
*/
static int
act_test_state_15(test_test_state *state)
{
int test_test_return = TBEVENT_BLOCKDONE;
#line 111 "/Users/maxwell/code/gw/event/test/test.event"
{
log_debug("CODE FOR WAIT 0x%p", &act_test_wait_14);
set_callback(act_test_wait_14, (state));
return TBEVENT_CALLBACK;
}
#line 386 "/Users/maxwell/code/gw/event/test/generated/event_test.c"
return test_test_return;
}
/** \brief Set the mandatory parameters and start the actions
*
* - This is only a helper function on top of the actual functions
*/
inet_err_t udp_resp_t::start(const ipport_addr_t &m_listen_addr, udp_resp_cb_t *callback, void *userptr)
throw()
{
inet_err_t inet_err;
// set the remote address
inet_err = set_listen_addr(m_listen_addr);
if( inet_err.failed() ) return inet_err;
// set the callback
inet_err = set_callback(callback, userptr);
if( inet_err.failed() ) return inet_err;
// start the action
return start();
}
EXPORT CLASS *init(CALLBACKS *fntable, MODULE *module, int argc, char *argv[])
{
if (set_callback(fntable)==NULL)
{
errno = EINVAL;
return NULL;
}
new climate(module);
new weather(module);
new csv_reader(module);
/* always return the first class registered */
return climate::oclass;
}
/***********************************************************************
* RegisterBindStatusCallback (urlmon.@)
*
* Register a bind status callback.
*
* PARAMS
* pbc [I] Binding context
* pbsc [I] Callback to register
* ppbscPrevious [O] Destination for previous callback
* dwReserved [I] Reserved, must be 0.
*
* RETURNS
* Success: S_OK.
* Failure: E_INVALIDARG, if any argument is invalid, or
* E_OUTOFMEMORY if memory allocation fails.
*/
HRESULT WINAPI RegisterBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc,
IBindStatusCallback **ppbscPrevious, DWORD dwReserved)
{
BindStatusCallback *holder;
IBindStatusCallback *bsc, *prev = NULL;
HRESULT hres;
TRACE("(%p %p %p %x)\n", pbc, pbsc, ppbscPrevious, dwReserved);
if (!pbc || !pbsc)
return E_INVALIDARG;
bsc = bsch_from_bctx(pbc);
if(bsc) {
hres = IBindStatusCallback_QueryInterface(bsc, &IID_IBindStatusCallbackHolder, (void**)&holder);
if(SUCCEEDED(hres)) {
if(ppbscPrevious) {
IBindStatusCallback_AddRef(holder->callback);
*ppbscPrevious = holder->callback;
}
set_callback(holder, pbsc);
IBindStatusCallback_Release(bsc);
IBindStatusCallbackEx_Release(&holder->IBindStatusCallbackEx_iface);
return S_OK;
}else {
prev = bsc;
}
IBindCtx_RevokeObjectParam(pbc, bscb_holderW);
}
hres = wrap_callback(pbsc, &bsc);
if(SUCCEEDED(hres)) {
hres = IBindCtx_RegisterObjectParam(pbc, bscb_holderW, (IUnknown*)bsc);
IBindStatusCallback_Release(bsc);
}
if(FAILED(hres)) {
if(prev)
IBindStatusCallback_Release(prev);
return hres;
}
if(ppbscPrevious)
*ppbscPrevious = prev;
return S_OK;
}
int scpool_MGR(int TCBno,int poolno,T_Connect **connp,int (*call_back)(T_Connect *,T_NetHead *))
{
int ret;
pthread_t *tp;
if(TCBno<0) {
ShowLog(1,"%s:bad TCB no!",__FUNCTION__);
return -1;
}
ShowLog(3,"%s:get pool[%d],TCB_no=%d,tid:%lX,USEC=%llu",__FUNCTION__,
poolno,TCBno,pthread_self(),now_usec());
*connp=get_SC_connect(poolno,0);
if(*connp == (T_Connect *)-1) {
*connp=NULL;
return -1;
}
if(*connp) {
if((*connp)->only_do == (sdbcfunc)1) {
(*connp)->only_do=call_back;
TCB_add(NULL,TCBno); //加入到主任务队列
//ShowLog(5,"%s:tid=%lX,only_do=1,TCB_no=%d",__FUNCTION__,pthread_self(),TCBno);
return 1;
}
return 0;
}
set_callback(TCBno,call_back,120);
if(wpool.poolnum<=0) {
ret=get_scpoolnum();
pthread_mutex_lock(&wpool.mut);
wpool_init(&wpool,ret);
pthread_mutex_unlock(&wpool.mut);
}
if(poolno < 0 || poolno >= wpool.poolnum) {
ShowLog(1,"%s:TCB_no=%d bad poolno %d,poolnum=%d",__FUNCTION__,
TCBno,poolno,wpool.poolnum);
return -1;
}
pthread_mutex_lock(&wpool.QP[poolno].mut);
TCB_add(&wpool.QP[poolno].queue,TCBno);
tp=&wpool.QP[poolno].tid;
if(*tp==0) *tp=TCBno+1;
pthread_mutex_unlock(&wpool.QP[poolno].mut);
//new thread
if(*tp==(pthread_t)(TCBno+1)) {
pthread_create(&wpool.QP[poolno].tid,&wpool.attr,wait_sc,(void *)(long)poolno);
} else pthread_cond_signal(&wpool.QP[poolno].cond); //唤醒工作线程
return 1;
}
EXPORT CLASS *init(CALLBACKS *fntable, MODULE *module, int argc, char *argv[])
{
if (set_callback(fntable)==NULL)
{
errno = EINVAL;
return NULL;
}
new g_assert(module);
new double_assert(module);
new complex_assert(module);
new enum_assert(module);
/* always return the first class registered */
return g_assert::oclass;
}
void
LocalProperty::Set(void)
{
if (address == NULL) {
client->ORState(STATUS_MALFORMED_COMMAND);
return;
}
int new_var;
if (set_callback != NULL) {
client->ReadInt(&new_var);
set_callback(new_var);
} else if (var != NULL) {
client->ReadInt(var);
} else {
/* Shouldn't get here (tm) */
}
}
EXPORT CLASS *init(CALLBACKS *fntable, MODULE *module, int argc, char *argv[])
{
if (set_callback(fntable)==NULL)
{
errno = EINVAL;
return NULL;
}
new simple(module);
new particle_swarm_optimization(module);
/*** DO NOT EDIT NEXT LINE ***/
//NEWCLASS
/* always return the first class registered */
return simple::oclass;
}
