int
want_timeout(motmot_event_callback_t func, void *arg, void *data, unsigned msecs)
{
g_timeout_add(msecs, call_callback, callback_new(func, arg, NULL, 0));
return 0;
}
Engine *
engine_new(Parser *parser, pstring *data_dir, long size, bool dedupe, pstring *auth) {
Engine *engine = calloc(1, sizeof(Engine));
engine->queries = dictCreate(getTermQueryNodeDict(), 0);
engine->parser = parser;
engine->query_id = 0;
engine->catchall_callbacks = NULL;
engine->after_on_document = NULL;
engine->stream = ring_buffer_new(size / 4);
engine->term_dictionary = lrw_dict_new(getTermPlistDict(), size / 32);
engine->postings = plist_pool_new(size / 4);
engine->docs = ring_buffer_new((size / 4 / sizeof(DocRef)) * sizeof(DocRef));
engine->data = NULL;
if(auth) {
engine->auth = pcpy(auth);
}
engine->ints_capacity = size / 4;
engine->ints = dictCreate(getPstrRingBufferDict(), 0);
if(data_dir) {
engine->data_dir = pcpy(data_dir);
engine_replay_journal(engine);
engine_reopen_journal(engine);
}
if(dedupe) {
engine->doc_set = dictCreate(getDocRefDict(), engine);
engine->docs->on_evict = callback_new(_doc_evict, engine);
} else {
engine->doc_set = NULL;
}
engine->error = NULL;
return engine;
}
static struct event_priv*
navfocus_new(struct event_methods *meth)
{
printf("Waiting for User Input!! Town:Street Please!\n");
*meth=navfocus_methods;
GIOChannel * ioch = g_new0(GIOChannel,1);
GIOCondition * cond = g_new0(GIOCondition,1);
gpointer * data = g_new0(gpointer,1);
void* io = ioch;
void* co = cond;
void* da = data;
void ** p = malloc(3*sizeof(void*));
p[0] = io;
p[1] = co;
p[2] = da;
struct callback * cb = callback_new(readUserInput_two,0, NULL);
navfocus_add_watch(0,event_watch_cond_read, cb);
return (struct event_priv *)navfocus_new;
}
int
want_write(int fd, enum motmot_fdtype fdtype, void *data,
motmot_event_callback_t func, void *arg)
{
GIOChannel *channel;
struct callback *cb;
int ephemeral = 0;
channel = (GIOChannel *)data;
if (channel == NULL) {
channel = g_io_channel_unix_new(fd);
ephemeral = 1;
}
cb = callback_new(func, arg, channel, ephemeral);
g_io_add_watch(channel, G_IO_OUT, socket_ready, cb);
return 0;
}
void application_callback(Application* application, CallbackFunc userCallback,
gpointer userData, gpointer userArgument, guint millisecondsDelay) {
MAGIC_ASSERT(application);
/* the application wants a callback. since we need it to happen in our
* application and plug-in context, we create a callback to our own
* function first, and then redirect and execute theirs
*/
ApplicationCallbackData* data = g_new0(ApplicationCallbackData, 1);
data->callback = userCallback;
data->data = userData;
data->argument = userArgument;
CallbackEvent* event = callback_new((CallbackFunc)_application_callbackTimerExpired, application, data);
SimulationTime nanos = SIMTIME_ONE_MILLISECOND * millisecondsDelay;
/* callback to our own node */
worker_scheduleEvent((Event*)event, nanos, 0);
}
