00001
00002
00003
00004 #ifdef HAVE_CONFIG_H
00005 # include "config.h"
00006 #endif
00007
00008 #include "request_p.h"
00009 #include <gwenhywfar/misc.h>
00010 #include <gwenhywfar/db.h>
00011 #include <gwenhywfar/debug.h>
00012 #include <assert.h>
00013 #include <stdlib.h>
00014 #include <strings.h>
00015
00016 #include <gwenhywfar/types.h>
00017 #include <gwenhywfar/gwentime.h>
00018
00019
00020 GWEN_INHERIT_FUNCTIONS(GWEN_IPC_REQUEST)
00021 GWEN_LIST_FUNCTIONS(GWEN_IPC_REQUEST, GWEN_IpcRequest)
00022 GWEN_LIST2_FUNCTIONS(GWEN_IPC_REQUEST, GWEN_IpcRequest)
00023
00024
00025 GWEN_IPC_REQUEST_STATUS GWEN_IpcRequest_Status_fromString(const char *s) {
00026 if (s) {
00027 if (strcasecmp(s, "new")==0)
00028 return GWEN_IpcRequest_StatusNew;
00029 else if (strcasecmp(s, "sent")==0)
00030 return GWEN_IpcRequest_StatusSent;
00031 else if (strcasecmp(s, "partial")==0)
00032 return GWEN_IpcRequest_StatusPartial;
00033 else if (strcasecmp(s, "answered")==0)
00034 return GWEN_IpcRequest_StatusAnswered;
00035 else if (strcasecmp(s, "finished")==0)
00036 return GWEN_IpcRequest_StatusFinished;
00037 }
00038 return GWEN_IpcRequest_StatusUnknown;
00039 }
00040
00041
00042 const char *GWEN_IpcRequest_Status_toString(GWEN_IPC_REQUEST_STATUS v) {
00043 switch(v) {
00044 case GWEN_IpcRequest_StatusNew:
00045 return "new";
00046
00047 case GWEN_IpcRequest_StatusSent:
00048 return "sent";
00049
00050 case GWEN_IpcRequest_StatusPartial:
00051 return "partial";
00052
00053 case GWEN_IpcRequest_StatusAnswered:
00054 return "answered";
00055
00056 case GWEN_IpcRequest_StatusFinished:
00057 return "finished";
00058
00059 default:
00060 return "unknown";
00061 }
00062 }
00063
00064
00065
00066
00067 GWEN_IPC_REQUEST *GWEN_IpcRequest_new() {
00068 GWEN_IPC_REQUEST *st;
00069
00070 GWEN_NEW_OBJECT(GWEN_IPC_REQUEST, st)
00071 st->_usage=1;
00072 GWEN_INHERIT_INIT(GWEN_IPC_REQUEST, st)
00073 GWEN_LIST_INIT(GWEN_IPC_REQUEST, st)
00074 st->subRequests=GWEN_IpcRequest_List_new();
00075 return st;
00076 }
00077
00078
00079 void GWEN_IpcRequest_free(GWEN_IPC_REQUEST *st) {
00080 if (st) {
00081 assert(st->_usage);
00082 if (--(st->_usage)==0) {
00083 GWEN_INHERIT_FINI(GWEN_IPC_REQUEST, st)
00084 if (st->name)
00085 free(st->name);
00086 if (st->expires)
00087 GWEN_Time_free(st->expires);
00088 if (st->subRequests)
00089 GWEN_IpcRequest_List_free(st->subRequests);
00090 GWEN_LIST_FINI(GWEN_IPC_REQUEST, st)
00091 GWEN_FREE_OBJECT(st);
00092 }
00093 }
00094
00095 }
00096
00097
00098 GWEN_IPC_REQUEST *GWEN_IpcRequest_dup(const GWEN_IPC_REQUEST *d) {
00099 GWEN_IPC_REQUEST *st;
00100
00101 assert(d);
00102 st=GWEN_IpcRequest_new();
00103 st->id=d->id;
00104 if (d->name)
00105 st->name=strdup(d->name);
00106 st->ipcId=d->ipcId;
00107 if (d->expires)
00108 st->expires=GWEN_Time_dup(d->expires);
00109 if (d->subRequests)
00110 st->subRequests=GWEN_IpcRequest_List_dup(d->subRequests);
00111 st->status=d->status;
00112 return st;
00113 }
00114
00115
00116 int GWEN_IpcRequest_toDb(const GWEN_IPC_REQUEST *st, GWEN_DB_NODE *db) {
00117 assert(st);
00118 assert(db);
00119 if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "id", st->id))
00120 return -1;
00121 if (st->name)
00122 if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "name", st->name))
00123 return -1;
00124 if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "ipcId", st->ipcId))
00125 return -1;
00126 if (st->expires)
00127 if (GWEN_Time_toDb(st->expires, GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "expires")))
00128 return -1;
00129 if (st->subRequests)
00130 if (1) {
00131 GWEN_DB_NODE *dbT;
00132 GWEN_IPC_REQUEST *e;
00133
00134 dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_CREATE_GROUP, "subRequests");
00135 assert(dbT);
00136 e=GWEN_IpcRequest_List_First(st->subRequests);
00137 while(e) {
00138 if (GWEN_IpcRequest_toDb(e, GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_CREATE_GROUP, "element")))
00139 return -1;
00140 e=GWEN_IpcRequest_List_Next(e);
00141 }
00142 }
00143 if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "status", GWEN_IpcRequest_Status_toString(st->status)))
00144 return -1;
00145 return 0;
00146 }
00147
00148
00149 int GWEN_IpcRequest_ReadDb(GWEN_IPC_REQUEST *st, GWEN_DB_NODE *db) {
00150 assert(st);
00151 assert(db);
00152 GWEN_IpcRequest_SetId(st, GWEN_DB_GetIntValue(db, "id", 0, 0));
00153 GWEN_IpcRequest_SetName(st, GWEN_DB_GetCharValue(db, "name", 0, 0));
00154 GWEN_IpcRequest_SetIpcId(st, GWEN_DB_GetIntValue(db, "ipcId", 0, 0));
00155 if (1) {
00156 GWEN_DB_NODE *dbT;
00157
00158 dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "expires");
00159 if (dbT) {
00160 if (st->expires)
00161 GWEN_Time_free(st->expires);
00162 st->expires=GWEN_Time_fromDb(dbT);
00163 }
00164 }
00165 st->subRequests=GWEN_IpcRequest_List_new();
00166 if (1) {
00167 GWEN_DB_NODE *dbT;
00168 GWEN_IPC_REQUEST *e;
00169
00170 dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "subRequests");
00171 if (dbT) {
00172 GWEN_DB_NODE *dbT2;
00173
00174 dbT2=GWEN_DB_FindFirstGroup(dbT, "element");
00175 while(dbT2) {
00176 e=GWEN_IpcRequest_fromDb(dbT2);
00177 if (!e) {
00178 DBG_ERROR(0, "Bad element for type \"GWEN_IPC_REQUEST\"");
00179 if (GWEN_Logger_GetLevel(0)>=GWEN_LoggerLevel_Debug)
00180 GWEN_DB_Dump(dbT2, stderr, 2);
00181 GWEN_IpcRequest_free(st);
00182 return 0;
00183 }
00184 GWEN_IpcRequest_List_Add(e, st->subRequests); dbT2=GWEN_DB_FindNextGroup(dbT2, "element");
00185 }
00186 }
00187 }
00188 GWEN_IpcRequest_SetStatus(st, GWEN_IpcRequest_Status_fromString(GWEN_DB_GetCharValue(db, "status", 0, 0)));
00189 return 0;
00190 }
00191
00192
00193 GWEN_IPC_REQUEST *GWEN_IpcRequest_fromDb(GWEN_DB_NODE *db) {
00194 GWEN_IPC_REQUEST *st;
00195
00196 assert(db);
00197 st=GWEN_IpcRequest_new();
00198 GWEN_IpcRequest_ReadDb(st, db);
00199 st->_modified=0;
00200 return st;
00201 }
00202
00203
00204
00205
00206 uint32_t GWEN_IpcRequest_GetId(const GWEN_IPC_REQUEST *st) {
00207 assert(st);
00208 return st->id;
00209 }
00210
00211
00212 void GWEN_IpcRequest_SetId(GWEN_IPC_REQUEST *st, uint32_t d) {
00213 assert(st);
00214 st->id=d;
00215 st->_modified=1;
00216 }
00217
00218
00219
00220
00221 const char *GWEN_IpcRequest_GetName(const GWEN_IPC_REQUEST *st) {
00222 assert(st);
00223 return st->name;
00224 }
00225
00226
00227 void GWEN_IpcRequest_SetName(GWEN_IPC_REQUEST *st, const char *d) {
00228 assert(st);
00229 if (st->name)
00230 free(st->name);
00231 if (d && *d)
00232 st->name=strdup(d);
00233 else
00234 st->name=0;
00235 st->_modified=1;
00236 }
00237
00238
00239
00240
00241 uint32_t GWEN_IpcRequest_GetIpcId(const GWEN_IPC_REQUEST *st) {
00242 assert(st);
00243 return st->ipcId;
00244 }
00245
00246
00247 void GWEN_IpcRequest_SetIpcId(GWEN_IPC_REQUEST *st, uint32_t d) {
00248 assert(st);
00249 st->ipcId=d;
00250 st->_modified=1;
00251 }
00252
00253
00254
00255
00256 const GWEN_TIME *GWEN_IpcRequest_GetExpires(const GWEN_IPC_REQUEST *st) {
00257 assert(st);
00258 return st->expires;
00259 }
00260
00261
00262 void GWEN_IpcRequest_SetExpires(GWEN_IPC_REQUEST *st, const GWEN_TIME *d) {
00263 assert(st);
00264 if (st->expires)
00265 GWEN_Time_free(st->expires);
00266 if (d)
00267 st->expires=GWEN_Time_dup(d);
00268 else
00269 st->expires=0;
00270 st->_modified=1;
00271 }
00272
00273
00274
00275
00276 GWEN_IPC_REQUEST_LIST *GWEN_IpcRequest_GetSubRequests(const GWEN_IPC_REQUEST *st) {
00277 assert(st);
00278 return st->subRequests;
00279 }
00280
00281
00282 void GWEN_IpcRequest_SetSubRequests(GWEN_IPC_REQUEST *st, GWEN_IPC_REQUEST_LIST *d) {
00283 assert(st);
00284 if (st->subRequests)
00285 GWEN_IpcRequest_List_free(st->subRequests);
00286 if (d) {
00287 GWEN_IPC_REQUEST *e;
00288
00289 st->subRequests=GWEN_IpcRequest_List_new();
00290 e=GWEN_IpcRequest_List_First(d);
00291 while(e) {
00292 GWEN_IPC_REQUEST *ne;
00293
00294 ne=GWEN_IpcRequest_dup(e);
00295 assert(ne);
00296 GWEN_IpcRequest_List_Add(ne, st->subRequests);
00297 e=GWEN_IpcRequest_List_Next(e);
00298 }
00299 }
00300 else
00301 st->subRequests=0;
00302 st->_modified=1;
00303 }
00304
00305
00306
00307
00308 GWEN_IPC_REQUEST_STATUS GWEN_IpcRequest_GetStatus(const GWEN_IPC_REQUEST *st) {
00309 assert(st);
00310 return st->status;
00311 }
00312
00313
00314 void GWEN_IpcRequest_SetStatus(GWEN_IPC_REQUEST *st, GWEN_IPC_REQUEST_STATUS d) {
00315 assert(st);
00316 st->status=d;
00317 st->_modified=1;
00318 }
00319
00320
00321 GWEN_IPC_REQUEST_WORK_FN GWEN_IpcRequest_GetWorkFn(const GWEN_IPC_REQUEST *st) {
00322 assert(st);
00323 return st->workFn;
00324 }
00325
00326
00327 void GWEN_IpcRequest_SetWorkFn(GWEN_IPC_REQUEST *st, GWEN_IPC_REQUEST_WORK_FN d) {
00328 assert(st);
00329 st->workFn=d;
00330 }
00331
00332
00333 int GWEN_IpcRequest_WorkFn(GWEN_IPC_REQUEST *st) {
00334 assert(st);
00335 if (st->workFn)
00336 return st->workFn(st);
00337 return 1;
00338 }
00339
00340
00341
00342
00343 int GWEN_IpcRequest_IsModified(const GWEN_IPC_REQUEST *st) {
00344 assert(st);
00345 return st->_modified;
00346 }
00347
00348
00349 void GWEN_IpcRequest_SetModified(GWEN_IPC_REQUEST *st, int i) {
00350 assert(st);
00351 st->_modified=i;
00352 }
00353
00354
00355 void GWEN_IpcRequest_Attach(GWEN_IPC_REQUEST *st) {
00356 assert(st);
00357 st->_usage++;
00358 }
00359 GWEN_IPC_REQUEST *GWEN_IpcRequest_List2__freeAll_cb(GWEN_IPC_REQUEST *st, void *user_data) {
00360 GWEN_IpcRequest_free(st);
00361 return 0;
00362 }
00363
00364
00365 void GWEN_IpcRequest_List2_freeAll(GWEN_IPC_REQUEST_LIST2 *stl) {
00366 if (stl) {
00367 GWEN_IpcRequest_List2_ForEach(stl, GWEN_IpcRequest_List2__freeAll_cb, 0);
00368 GWEN_IpcRequest_List2_free(stl);
00369 }
00370 }
00371
00372
00373 GWEN_IPC_REQUEST_LIST *GWEN_IpcRequest_List_dup(const GWEN_IPC_REQUEST_LIST *stl) {
00374 if (stl) {
00375 GWEN_IPC_REQUEST_LIST *nl;
00376 GWEN_IPC_REQUEST *e;
00377
00378 nl=GWEN_IpcRequest_List_new();
00379 e=GWEN_IpcRequest_List_First(stl);
00380 while(e) {
00381 GWEN_IPC_REQUEST *ne;
00382
00383 ne=GWEN_IpcRequest_dup(e);
00384 assert(ne);
00385 GWEN_IpcRequest_List_Add(ne, nl);
00386 e=GWEN_IpcRequest_List_Next(e);
00387 }
00388 return nl;
00389 }
00390 else
00391 return 0;
00392 }
00393
00394
00395
00396