int main()
{
logpool_global_init(LOGPOOL_DEFAULT);
{
logpool_t *logpool = logpool_open(NULL, &LOGAPI, LOGAPI_PARAM);
logpool_test_write(logpool);
logpool_close(logpool);
}
return 0;
}
int main(void)
{
logpool_global_init(LOGPOOL_DEFAULT);
{
logpool_t *logpool = logpool_open(NULL, &LOGAPI, LOGAPI_PARAM);
int i;
for (i = 0; i < 5; ++i) {
logpool_test_write0(logpool);
logpool_test_write1(logpool);
}
logpool_close(logpool);
}
return 0;
}
int main(int argc, char const* argv[])
{
logpool_global_init(LOGAPI_INIT_FLAG);
logpool_t *logpool = logpool_open(NULL, &LOGAPI, LOGAPI_PARAM);
int i, size = LOGPOOL_TEST_COUNT(argc, argv);
for (i = 0; i < size; ++i) {
logpool_test_write(logpool);
if (i % 2) {
usleep(1);
}
}
logpool_close(logpool);
logpool_global_exit();
return 0;
}
int main(int argc, char **argv)
{
logpool_global_init(LOGPOOL_TRACE);
logpool_t *logpool = logpool_open(NULL, &LOGAPI, LOGAPI_PARAM);
void *logpool_args;
if (argc < 2) {
fprintf(stderr, "usage: %s key value key value ...\n", argv[0]);
goto L_error;
}
switch (argc) {
case 3:
logpool_record(logpool, &logpool_args, LOG_NOTICE, "logput",
KEYVALUE_s(argv[1], argv[2]),
LOG_END);
break;
case 5:
logpool_record(logpool, &logpool_args, LOG_NOTICE, "logput",
KEYVALUE_s(argv[1], argv[2]),
KEYVALUE_s(argv[3], argv[4]),
LOG_END);
break;
case 7:
logpool_record(logpool, &logpool_args, LOG_NOTICE, "logput",
KEYVALUE_s(argv[1], argv[2]),
KEYVALUE_s(argv[3], argv[4]),
KEYVALUE_s(argv[5], argv[6]),
LOG_END);
break;
case 9:
logpool_record(logpool, &logpool_args, LOG_NOTICE, "logput",
KEYVALUE_s(argv[1], argv[2]),
KEYVALUE_s(argv[3], argv[4]),
KEYVALUE_s(argv[5], argv[6]),
KEYVALUE_s(argv[6], argv[8]),
LOG_END);
break;
}
logpool_close(logpool);
logpool_global_exit();
return 0;
L_error:;
logpool_close(logpool);
logpool_global_exit();
return 1;
}
static kbool_t logpool_initPackage(KonohaContext *kctx, kNameSpace *ns, int argc, const char**args, kfileline_t pline)
{
int i;
static KDEFINE_CLASS Def0 = {
.structname = "LogPool"/*structname*/,
.typeId = TY_newid/*cid*/,
.init = RawPtr_init,
.free = Logpool_free,
};
KonohaClass *ct0 = KLIB Konoha_defineClass(kctx, ns->packageId, ns->packageDomain, NULL, &Def0, pline);
static KDEFINE_CLASS Def1 = {
.structname = "Log"/*structname*/,
.typeId = TY_newid/*cid*/,
.init = RawPtr_init,
.free = Log_free,
.p = Log_p,
};
KonohaClass *ct1 = KLIB Konoha_defineClass(kctx, ns->packageId, ns->packageDomain, NULL, &Def1, pline);
static KDEFINE_CLASS Def2 = {
.structname = "PoolPlugin",
.typeId = TY_newid,
.init = RawPtr_init,
.free = RawPtr_free,
};
KonohaClass *ct2 = KLIB Konoha_defineClass(kctx, ns->packageId, ns->packageDomain, NULL, &Def2, pline);
#define TY_Plugin ct2->typeId
static KDEFINE_CLASS Def3 = {
.structname = "",
.typeId = TY_newid,
.init = RawPtr_init,
.free = RawPtr_free,
};
Def3.superTypeId = ct2->typeId;
static const char *names[] = {
"Printer",
"KeyFilter",
"ValFilter",
"React",
"Timer",
"Statics",
"Copy",
"Response",
};
KonohaClass *tbls[8];
#define TY_Printer tbls[0]->typeId
#define TY_KeyFilter tbls[1]->typeId
#define TY_ValFilter tbls[2]->typeId
#define TY_React tbls[3]->typeId
#define TY_Timer tbls[4]->typeId
#define TY_Statics tbls[5]->typeId
#define TY_Copy tbls[6]->typeId
#define TY_Response tbls[7]->typeId
for (i = 0; i < 8; i++) {
Def3.structname = names[i];
tbls[i] = KLIB Konoha_defineClass(kctx, ns->packageId, ns->packageDomain, NULL, &Def3, pline);
}
int FN_x = FN_("x");
int FN_y = FN_("y");
int FN_z = FN_("z");
KDEFINE_METHOD MethodData[] = {
_P|_C, _F(LogPool_new), TY_Logpool, TY_Logpool, MN_("new"), 2, TY_String, FN_x, TY_Int, FN_y,
_P|_C, _F(LogPool_get), TY_Log, TY_Logpool, MN_("get"), 0,
_P|_C, _F(LogPool_loadFile), TY_void, TY_Logpool, MN_("loadFile"), 2, TY_String, FN_x, TY_String, FN_y,
_P|_C, _F(Log_get_), TY_String, TY_Log, MN_("get"), 1, TY_String, FN_x,
_P|_S, _F(Printer_create ), TY_Plugin, TY_Printer , MN_("create"), 0,
_P|_S, _F(KeyFilter_create), TY_Plugin, TY_KeyFilter, MN_("create"), 1, TY_String, FN_x,
_P|_S, _F(ValFilter_create), TY_Plugin, TY_ValFilter, MN_("create"), 3, TY_String, FN_x, TY_String, FN_y, TY_String, FN_z,
_P|_S, _F(React_create ), TY_Plugin, TY_React , MN_("create"), 2, TY_String, FN_x, TY_String, FN_y,
_P|_S, _F(Timer_create ), TY_Plugin, TY_Timer , MN_("create"), 3, TY_Int, FN_x, TY_Int, FN_y, TY_Int, FN_z,
_P|_S, _F(Statics_create ), TY_Plugin, TY_Statics , MN_("create"), 3, TY_Func, FN_x, TY_Func, FN_y, TY_Func, FN_z,
_P|_S, _F(Copy_create ), TY_Plugin, TY_Copy , MN_("create"), 0,
_P|_S, _F(Response_create ), TY_Plugin, TY_Response , MN_("create"), 1, TY_Object, FN_x,
_P , _F(PoolPlugin_apply ), TY_void, TY_Plugin , MN_("apply"), 1, TY_Plugin, FN_x,
_P , _F(PoolPlugin_failed), TY_void, TY_Plugin , MN_("failed"), 1, TY_Plugin, FN_x,
DEND,
};
KLIB kNameSpace_loadMethodData(kctx, ns, MethodData);
return true;
}
static kbool_t logpool_setupPackage(KonohaContext *kctx, kNameSpace *ns, isFirstTime_t isFirstTime, kfileline_t pline)
{
return true;
}
static kbool_t logpool_initNameSpace(KonohaContext *kctx, kNameSpace *ns, kfileline_t pline)
{
return true;
}
static kbool_t logpool_setupNameSpace(KonohaContext *kctx, kNameSpace *ns, kfileline_t pline)
{
return true;
}
KDEFINE_PACKAGE* logpool_init(void)
{
logpool_global_init(LOGPOOL_DEFAULT);
static KDEFINE_PACKAGE d = {
KPACKNAME("logpool", "1.0"),
.initPackage = logpool_initPackage,
.setupPackage = logpool_setupPackage,
.initNameSpace = logpool_initNameSpace,
.setupNameSpace = logpool_setupNameSpace,
};
return &d;
}
