自学教程：C++ CMSetStatus函数代码示例

static struct native_enum * __new_enumeration (    int mm_add,    CMPIArray * array,    CMPIStatus * rc ){    static CMPIEnumerationFT eft = {        NATIVE_FT_VERSION,        __eft_release,        __eft_clone,        __eft_getNext,        __eft_hasNext,        __eft_toArray    };    static CMPIEnumeration e = {        "CMPIEnumeration",        &eft    };    struct native_enum * enumeration =        (struct native_enum *)    tool_mm_alloc ( mm_add, sizeof ( struct native_enum ) );    enumeration->enumeration = e;    enumeration->mem_state   = mm_add;    enumeration->data =        ( mm_add == TOOL_MM_NO_ADD )?        CMClone ( array, rc ): array;    CMSetStatus ( rc, CMPI_RC_OK );    return enumeration;}

static CMPIEnumeration * __eft_clone (    CONST CMPIEnumeration * enumeration,    CMPIStatus * rc ){    CMPIStatus tmp;    struct native_enum * e = (struct native_enum *) enumeration;    CMPIArray * data;    if (!checkArgs(enumeration, rc))    {        return 0;    }    data = CMClone ( e->data, &tmp );    if (tmp.rc != CMPI_RC_OK)    {        CMSetStatus ( rc, CMPI_RC_ERR_FAILED );        return NULL;    }    return        (CMPIEnumeration *) __new_enumeration (        TOOL_MM_NO_ADD,        data,        rc );}

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 CMPIArray * __eft_toArray ( CMPIEnumeration * enumeration,				   CMPIStatus * rc ){	struct native_enum * e = (struct native_enum *) enumeration;	CMSetStatus ( rc, CMPI_RC_OK );	return e->data;}

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 struct native_selectexp * __new_exp (     int mm_add,    CMPIUint64 id,    CMPIStatus * rc ){    static CMPISelectExpFT eft = {        NATIVE_FT_VERSION,        __eft_release,        __eft_clone,        __eft_evaluate,        __eft_getString,        __eft_getDOC,        __eft_getCOD,        __eft_evaluateUsingAccessor    };    static CMPISelectExp e = {        "CMPISelectExp",        &eft    };    struct native_selectexp * exp =        (struct native_selectexp *)        tool_mm_alloc ( mm_add, sizeof ( struct native_selectexp ) );    exp->exp         = e;    exp->mem_state   = mm_add;    exp->id          = id;    CMSetStatus ( rc, CMPI_RC_OK );    return exp;}

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 struct native_enum * __new_enumeration ( CMPIArray * array,						CMPIStatus * rc ){	static CMPIEnumerationFT eft = {		NATIVE_FT_VERSION,		__eft_release,		__eft_clone,		__eft_getNext,		__eft_hasNext,		__eft_toArray	};	static const CMPIEnumeration e = {		"CMPIEnumeration",		&eft	};	struct native_enum * enumeration = (struct native_enum *)		calloc ( 1, sizeof ( struct native_enum ) );	enumeration->enumeration = e;	enumeration->data = array; 	/* CMClone ( array, rc ) ? */	CMSetStatus ( rc, CMPI_RC_OK );	return enumeration;}

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 CMPIUint64 dtGetBinaryFormat(const CMPIDateTime* eDt, CMPIStatus* rc) {      CIMDateTime* dt=(CIMDateTime*)eDt->hdl;      if (!dt) {		if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);	    return 0;      }      CMPIUint64 days,hours,mins,secs,usecs,utc,lTime;      struct tm tm,tmt;      CString tStr=dt->toString().getCString();      char cStr[26];      memset( cStr, 0, 26);      memcpy (cStr, (const char*)tStr, 25);      if (dt->isInterval()) {         cStr[21]=0;         usecs=atoi(cStr+15);         cStr[15]=0;         secs=atoi(cStr+12);         cStr[12]=0;         mins=atoi(cStr+10);         cStr[10]=0;         hours=atoi(cStr+8);         cStr[8]=0;         days=atoi(cStr);         lTime=(days*PEGASUS_UINT64_LITERAL(86400000000))+               (hours*PEGASUS_UINT64_LITERAL(3600000000))+               (mins*60000000)+(secs*1000000)+usecs;      }      else {         time_t tt=time(NULL);   #ifdef PEGASUS_PLATFORM_WIN32_IX86_MSVC         tmt=*localtime(&tt);   #else         localtime_r(&tt,&tmt);   #endif         memset(&tm,0,sizeof(tm));         tm.tm_isdst=tmt.tm_isdst;         utc=atoi(cStr+21);         cStr[21]=0;         usecs=atoi(cStr+15);         cStr[15]=0;         tm.tm_sec=atoi(cStr+12);         cStr[12]=0;         tm.tm_min=atoi(cStr+10);         cStr[10]=0;         tm.tm_hour=atoi(cStr+8);         cStr[8]=0;         tm.tm_mday=atoi(cStr+6);         cStr[6]=0;         tm.tm_mon=(atoi(cStr+4)-1);         cStr[4]=0;         tm.tm_year=(atoi(cStr)-1900);         lTime=mktime(&tm);         lTime*=1000000;         lTime+=usecs;      }      return lTime;   }

static CMPIBoolean__eft_evaluate(const CMPIPredicate *pred,               CMPIAccessor * acc, void *v, CMPIStatus *rc){  if (rc)    CMSetStatus(rc, CMPI_RC_ERR_NOT_SUPPORTED);  return 0;}

CMPIData KFindProperty(    const CMPIInstance* ci,     const char* name,    CMPIStatus* status){    CMPICount count;    CMPICount i;    CMPIData cd;    count = CMGetPropertyCount(ci, NULL);    for (i = 0; i < count; i++)    {        CMPIString* pn = NULL;        CMPIStatus st;        cd = CMGetPropertyAt(ci, i, &pn, &st);        if (!KOkay(st) || !pn)        {            memset(&cd, 0, sizeof(cd));            if (status)                CMSetStatus(status, CMPI_RC_ERR_FAILED);            return cd;        }        if (strcasecmp(KChars(pn), name) == 0)        {            if (status)                CMSetStatus(status, CMPI_RC_OK);            return cd;        }    }    /* Not found! */    memset(&cd, 0, sizeof(cd));    if (status)        CMSetStatus(status, CMPI_RC_ERR_NOT_FOUND);    return cd;}

static CMPICountgetQualifierCount(CMPIConstClass * cc, CMPIStatus *rc){  ClClass        *cls = (ClClass *) cc->hdl;  if (rc)    CMSetStatus(rc, CMPI_RC_OK);  return (CMPICount) ClClassGetQualifierCount(cls);}

 static CMPIData mbInvokeMethod(const CMPIBroker *mb, const CMPIContext *ctx,                const CMPIObjectPath *cop, const char *method, const CMPIArgs *in, CMPIArgs *out,       CMPIStatus *rc) {    CMPIData data={0,CMPI_nullValue,{0}};    mb=CM_BROKER;    if (rc) CMSetStatus(rc,CMPI_RC_ERR_NOT_SUPPORTED);    return data; }

static unsigned int__aft_getArgCount(const CMPIArgs * args, CMPIStatus *rc){  ClArgs         *ca = (ClArgs *) args->hdl;  if (rc)    CMSetStatus(rc, CMPI_RC_OK);  return (CMPICount) ClArgsGetArgCount(ca);}

    CMPIPredicate* sbcGetPredicateAt(const CMPISubCond* eSbc,     unsigned int index, CMPIStatus* rc)    {        PEG_METHOD_ENTER(            TRC_CMPIPROVIDERINTERFACE,            "CMPI_SubCond:sbcGetPredicateAt()");        const CMPI_SubCond *sbc = (CMPI_SubCond*)eSbc->hdl;        if( !sbc )        {            PEG_TRACE_CSTRING(                TRC_CMPIPROVIDERINTERFACE,                Tracer::LEVEL1,                "Invalid handle in CMPI_SubCond:sbcGetPredicateAt");            CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);            PEG_METHOD_EXIT();            return 0;        }        CMPI_TableauRow* row = (CMPI_TableauRow* )sbc->priv;        if( row )        {            if( index<=row->size() )            {                const CMPI_term_el *term=(row->getData())+index;                CMPIPredicate *prd=(CMPIPredicate*)new CMPI_Predicate(term);                /**                   CMPI_Object puts in the hdl the pointer to the                    CMPI_Predicate The sbcRelease will use that pointer to                    de-allocate the CMPI_Predicate                   structure.                   */                CMPI_Object *obj = new CMPI_Object(prd);                CMSetStatus(rc,CMPI_RC_OK);                CMPIPredicate* cmpiPredicate =                     reinterpret_cast<CMPIPredicate*>(obj);                PEG_METHOD_EXIT();                return cmpiPredicate;            }        }        CMSetStatus(rc, CMPI_RC_ERR_NO_SUCH_PROPERTY);        PEG_METHOD_EXIT();        return NULL;     }

    static CMPIErrorType errGetErrorType(const CMPIError* eErr, CMPIStatus* rc)    {        PEG_METHOD_ENTER(            TRC_CMPIPROVIDERINTERFACE,            "CMPI_Error:errGetErrorType()");        CIMError* cer=(CIMError*)eErr->hdl;        if (!cer)        {            PEG_TRACE_CSTRING(                TRC_CMPIPROVIDERINTERFACE,                Tracer::LEVEL1,                "Received invalid Handle - cer...");            CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);            PEG_METHOD_EXIT();            return UnknownErrorType;        }        CMPIBoolean notNull;        CIMError::ErrorTypeEnum pgErrorType;        try        {            notNull = cer->getErrorType(pgErrorType);            if (!notNull)            {                PEG_TRACE_CSTRING(                    TRC_CMPIPROVIDERINTERFACE,                    Tracer::LEVEL1,                    "Received invalid Parameter...");                CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);                PEG_METHOD_EXIT();                return UnknownErrorType;            }        }        catch (...)        {            CMSetStatus(rc, CMPI_RC_ERR_FAILED);            PEG_METHOD_EXIT();            return UnknownErrorType;        }        CMSetStatus(rc,CMPI_RC_OK);        PEG_METHOD_EXIT();        return(CMPIErrorType)pgErrorType;    }

static CMPIContext * __cft_clone ( CONST CMPIContext * ctx, CMPIStatus * rc ){    if (!checkArgs(ctx, rc))    {        return 0;    }    CMSetStatus ( rc, CMPI_RC_ERR_NOT_SUPPORTED );    return NULL;}

static CMPIString *__dtft_getStringFormat(const CMPIDateTime *dt, CMPIStatus *rc){  struct native_datetime *ndt = (struct native_datetime *) dt;  if (rc)    CMSetStatus(rc, CMPI_RC_OK);  return sfcb_native_new_CMPIString(ndt->cimDt, rc, 0);}

voiddateTime2chars(CMPIDateTime *dt, CMPIStatus *rc, char *str_time){  struct native_datetime *ndt = (struct native_datetime *) dt;  strcpy(str_time, ndt->cimDt);  if (rc)    CMSetStatus(rc, CMPI_RC_OK);}

/* * ! /param dt the native CMPIDateTime to be extracted. /param rc return * code pointer *  * /return an amount of microseconds.  */static CMPIUint64__dtft_getBinaryFormat(const CMPIDateTime *dt, CMPIStatus *rc){  struct native_datetime *ndt = (struct native_datetime *) dt;  if (rc)    CMSetStatus(rc, CMPI_RC_OK);  return chars2bin(ndt->cimDt, rc);}

static voidbin2chars(CMPIUint64 msecs, CMPIBoolean interval, CMPIStatus *rc,          char *str_time){/** /brief bin2chars(): Converts microseconds since epoch to a string time. * *  Uses the current timezone as the basis for the conversion, but will determine *  if DST was in effect at the time in the input.*/  time_t          secs = msecs / 1000000ULL;  unsigned long   usecs = msecs % 1000000ULL;  if (interval) {    unsigned long long useconds,                    seconds,                    mins,                    hrs,                    days;    /* ddddddddhhmmss.mmmmmm:000, at most 8 characters for day */    const unsigned long long day_limit = 99999999;    seconds = msecs / 1000000ULL;    useconds = msecs % 1000000ULL;    mins = seconds / 60ULL;    seconds %= 60ULL;    hrs = mins / 60ULL;    mins %= 60ULL;    /* Modify to avoid datetime string overflow when the time duration overflow */    days = ((hrs / 24ULL) > day_limit) ? day_limit : (hrs / 24ULL);    hrs %= 24ULL;    sprintf(str_time, "%8.8llu%2.2llu%2.2llu%2.2llu.%6.6llu:000",            days, hrs, mins, seconds, useconds);  }  else {    struct tm       tm_time;    char            us_utc_time[11];    if (localtime_r(&secs, &tm_time) == NULL) {      if (rc)        CMSetStatus(rc, CMPI_RC_ERR_FAILED);      return;    }    tzset();    snprintf(us_utc_time, 11, "%6.6ld%+4.3ld",             usecs, (tm_time.tm_isdst != 0) * 60 - timezone / 60);    strftime(str_time, 26, "%Y%m%d%H%M%S.", &tm_time);    strcat(str_time, us_utc_time);  }}

static CMPIBoolean__dtft_isInterval(const CMPIDateTime *dt, CMPIStatus *rc){  struct native_datetime *ndt = (struct native_datetime *) dt;  if (rc)    CMSetStatus(rc, CMPI_RC_OK);  return ndt->cimDt[21] == ':' ? 1 : 0;}

CMPIDatagetPropertyQualsAt(CMPIConstClass * cc, CMPICount i, CMPIString **name,                   unsigned long *quals, CMPIString **refName,                   CMPIStatus *rc){  ClClass        *cls = (ClClass *) cc->hdl;  char           *n;  char           *rName = NULL;  CMPIData        rv = { 0, CMPI_notFound, {0} };  if (ClClassGetPropertyAt(cls, i, &rv, name ? &n : NULL, quals, &rName)) {    if (rc)      CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND);    return rv;  }  if (rv.type == CMPI_chars) {    rv.value.string = sfcb_native_new_CMPIString(rv.value.chars, NULL, 0);    rv.type = CMPI_string;  } else if (rv.type == CMPI_ref) {    if ((rv.state & CMPI_nullValue) == 0)      rv.value.ref = getObjectPath((char *)                                   ClObjectGetClString(&cls->hdr,                                                       (ClString *) &                                                       rv.value.chars),                                   NULL);  }  if (rv.type & CMPI_ARRAY && rv.value.array) {    rv.value.array =        native_make_CMPIArray((CMPIData *) rv.value.array, NULL,                              &cls->hdr);  }  if (name) {    *name = sfcb_native_new_CMPIString(n, NULL, 0);  }  if (refName && rName) {    *refName = sfcb_native_new_CMPIString(rName, NULL, 0);  } else {    if (refName) {      *refName = NULL;    }  }  if (rc)    CMSetStatus(rc, CMPI_RC_OK);  return rv;}

/** * cmciRelease**/CMPIStatus cmciRelease(CMCIClient* cmciClient){	CMPIStatus rc;	cmciClient->ft->release (cmciClient);	CMSetStatus(&rc, CMPI_RC_OK);	return rc;}

static CMPICount __eft_getCount(const CMPISubCond* cond, CMPIStatus* rc){   NativeSubCond *c = (NativeSubCond *) cond;   CMPIArray *conds=(CMPIArray*)c->cond.ptr;   CMPICount count=0;      if (conds) count=CMGetArrayCount(conds,NULL);    if (rc) CMSetStatus(rc, CMPI_RC_OK);   return count;}

 PEGASUS_STATIC CMPIType arrayGetType(     const CMPIArray* eArray,     CMPIStatus* rc) {     CMPI_Array *arr = (CMPI_Array*)eArray->hdl;     if (!arr)     {         CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);         return 0;     }     CMPIData *dta = (CMPIData*)arr->hdl;     if (!dta)     {         CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);         return CMPI_null;     }     CMSetStatus(rc,CMPI_RC_OK);     return dta->type; }

 PEGASUS_STATIC CMPICount arrayGetSize(     const CMPIArray* eArray,     CMPIStatus* rc) {     CMPI_Array *arr = (CMPI_Array*)eArray->hdl;     if (!arr)     {         CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);         return 0;     }     CMPIData *dta = (CMPIData*)arr->hdl;     if (!dta)     {         CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);         return 0;     }     CMSetStatus(rc,CMPI_RC_OK);     return dta->value.uint32; }

static CMPIDateTime* dtClone(const CMPIDateTime* eDt, CMPIStatus* rc) {	OpenWBEM::CIMDateTime * dt=(OpenWBEM::CIMDateTime*)eDt->hdl;	//OpenWBEM::CIMDateTime * cDt=new OpenWBEM::CIMDateTime(dt->toString());	OpenWBEM::CIMDateTime * cDt = new OpenWBEM::CIMDateTime(*dt);	CMPIDateTime* neDt=(CMPIDateTime*)new CMPI_Object(cDt,CMPI_DateTime_Ftab);	CMSetStatus(rc,CMPI_RC_OK);	return neDt;}

    static CMPIBoolean enumHasNext(        const CMPIEnumeration* eEnumObj,        CMPIStatus* rc)    {        const CMPIEnumeration* eEnum = (CMPIEnumeration*)eEnumObj->hdl;        if (!eEnum || !eEnum->hdl)        {            PEG_TRACE_CSTRING(                TRC_CMPIPROVIDERINTERFACE,                Tracer::LEVEL1,                "Received invalid Handle - eEnum || eEnum->hdl...");            CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);            return false;        }        CMSetStatus(rc, CMPI_RC_OK);        if ((void*)eEnum->ft == (void*)CMPI_ObjEnumeration_Ftab)        {            CMPI_ObjEnumeration* ie = (CMPI_ObjEnumeration*)eEnum;            if (ie->cursor<ie->max)            {                return true;            }        }        else if ((void*)eEnum->ft == (void*)CMPI_InstEnumeration_Ftab)        {            CMPI_InstEnumeration* ie = (CMPI_InstEnumeration*)eEnum;            if (ie->cursor<ie->max)            {                return true;            }        }        else        {            CMPI_OpEnumeration* oe = (CMPI_OpEnumeration*)eEnum;            if (oe->cursor<oe->max)            {                return true;            }        }        return false;    }