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;
}
