static NativeResult *__new_empty_result(int mode, CMPIStatus * rc) { static CMPIResultFT rft = { NATIVE_FT_VERSION, __rft_release, __rft_clone, __rft_returnData, __rft_returnInstance, __rft_returnObjectPath, __rft_returnDone }; static CMPIResult r = { "CMPIResult", &rft }; int state; NativeResult result,*tRslt; memset(&result,0,sizeof(NativeResult)); result.result=r; tRslt=memAddEncObj(mode, &result, sizeof(result),&state); tRslt->mem_state=state; if (rc) CMSetStatus(rc, CMPI_RC_OK); return tRslt; }
static NativePredicate * __new_predicate(int mode, QLOperation * op, CMPIStatus *rc) { static CMPIPredicateFT eft = { NATIVE_FT_VERSION, __eft_release, __eft_clone, __eft_getData, __eft_evaluate }; static CMPIPredicate p = { "CMPIPredicate", &eft }; int state; NativePredicate pred, *tPred; memset(&pred, 0, sizeof(pred)); pred.pred = p; pred.op = op; tPred = memAddEncObj(mode, &pred, sizeof(pred), &state); tPred->mem_state = state; if (rc) CMSetStatus(rc, CMPI_RC_OK); return tPred; }
static NativeSubCond *__new_subcond(int mode, CMPIValuePtr ptr, CMPIStatus * rc) { static CMPISubCondFT eft = { NATIVE_FT_VERSION, __eft_release, __eft_clone, __eft_getCount, __eft_getPredicateAt, __eft_getPredicate }; static CMPISubCond c = { "CMPISubCond", &eft }; int state; NativeSubCond cond,*tCond; memset(&cond, 0, sizeof(cond)); cond.sc = c; cond.cond=ptr; tCond=memAddEncObj(mode, &cond, sizeof(cond),&state); tCond->mem_state=state; if (rc) CMSetStatus(rc, CMPI_RC_OK); return tCond; }
static NativeSelectExp * __new_exp(int mode, const char *queryString, const char *language, const char *sns, CMPIArray **projection, CMPIStatus *rc) { int state, irc; NativeSelectExp exp, *tExp; memset(&exp, 0, sizeof(exp)); exp.exp = eFt; /* * fprintf(stderr,"*** new select expression: %s %s\n",queryString, * language); */ exp.qs = parseQuery(mode, (char *) queryString, (char *) language, (char *) sns, &irc); if (irc) { if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_QUERY); return NULL; } exp.queryString = strdup(queryString); exp.language = strdup(language); if (sns) exp.sns = strdup(sns); if (projection) { char **list = exp.qs->spNames; int i; CMPIArray *ar = *projection = TrackedCMPIArray(exp.qs->spNext, CMPI_string, NULL); for (i = 0; *list; list++, i++) CMSetArrayElementAt(ar, i, (CMPIValue *) * list, CMPI_chars); } tExp = memAddEncObj(mode, &exp, sizeof(exp), &state); tExp->mem_state = state; if (rc) CMSetStatus(rc, CMPI_RC_OK); return tExp; }
static struct native_args * __new_empty_args(int mm_add, CMPIStatus *rc) { static CMPIArgs a = { "CMPIArgs", &aft }; struct native_args args, *tArgs; int state; args.args = a; tArgs = memAddEncObj(mm_add, &args, sizeof(args), &state); tArgs->mem_state = state; if (rc) CMSetStatus(rc, CMPI_RC_OK); return (struct native_args *) tArgs; }
/* * ! The newly allocated object's function table is initialized to point * to the native functions in this file. * * \param mm_add MEM_TRACKED for a regular object, MEM_NOT_TRACKED for * cloned ones \param msecs the binary time to be stored \param interval * the interval flag to be stored \param rc return code pointer * * \return a fully initialized native_datetime object pointer. */ static struct native_datetime * __new_datetime(int mm_add, const char *cimDt, CMPIStatus *rc) { static CMPIDateTime dt = { "CMPIDateTime", &dtft }; struct native_datetime ndt, *tNdt; int state; ndt.dt = dt; tNdt = memAddEncObj(mm_add, &ndt, sizeof(ndt), &state); tNdt->mem_state = state; tNdt->refCount = 0; strcpy(tNdt->cimDt, cimDt); if (rc) CMSetStatus(rc, CMPI_RC_OK); return (struct native_datetime *) tNdt; }