2.1.0/api/cmpift_8h_source.html

 /* ------------------------------------------------------------------------- */

 /*                                                                           */

 /* Copyright (c) 2006-2015 The Open Group                                    */

 /*                                                                           */

 /* Permission is hereby granted, free of charge, to any person obtaining a   */

 /* copy of this software (the "Software"), to deal in the Software without   */

 /* restriction, including without limitation the rights to use, copy,        */

 /* modify, merge, publish, distribute, sublicense, and/or sell copies of     */

 /* the Software, and to permit persons to whom the Software is furnished     */

 /* to do so, subject to the following conditions:                            */

 /*                                                                           */

 /* The above copyright notice and this permission notice shall be included   */

 /* in all copies or substantial portions of the Software.                    */

 /*                                                                           */

 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS   */

 /* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF                */

 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.    */

 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY      */

 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT */

 /* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR  */

 /* THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                */

 /*                                                                           */

 /* ------------------------------------------------------------------------- */


 #ifndef _CMPIFT_H_

 #define _CMPIFT_H_


 #include <cmpios.h>

 #include <cmpidt.h>


 #ifdef __cplusplus

 extern "C" {

 #endif


 typedef struct _CMPIBroker {


     const void* hdl;


     const CMPIBrokerFT* bft;


     const CMPIBrokerEncFT* eft;


     const CMPIBrokerExtFT* xft;


 #ifdef CMPI_VER_200


     const CMPIBrokerMemFT* mft;


 #endif /*CMPI_VER_200*/


 } CMPIBroker;


 typedef struct _CMPIBrokerFT {


     unsigned int brokerCapabilities;


     CMPIVersion brokerVersion;


     const char* brokerName;


     CMPIContext* (*prepareAttachThread) (const CMPIBroker* mb,

         const CMPIContext* ctx);


     CMPIStatus (*attachThread) (const CMPIBroker* mb, const CMPIContext* ctx);


     CMPIStatus (*detachThread) (const CMPIBroker* mb, const CMPIContext* ctx);


     CMPIStatus (*deliverIndication) (const CMPIBroker* mb,

         const CMPIContext* ctx, const char* ns, const CMPIInstance* ind);


     CMPIEnumeration* (*enumerateInstanceNames) (const CMPIBroker* mb,

         const CMPIContext* ctx, const CMPIObjectPath* classPath,

         CMPIStatus* rc);


     CMPIInstance* (*getInstance) (const CMPIBroker* mb, const CMPIContext* ctx,

         const CMPIObjectPath* instPath, const char** properties,

         CMPIStatus* rc);


     CMPIObjectPath* (*createInstance) (const CMPIBroker* mb,

         const CMPIContext* ctx, const CMPIObjectPath* classPath,

         const CMPIInstance* newInst, CMPIStatus* rc);


     CMPIStatus (*modifyInstance) (const CMPIBroker* mb, const CMPIContext* ctx,

         const CMPIObjectPath* instPath, const CMPIInstance* modInst,

         const char** properties);


     CMPIStatus (*deleteInstance) (const CMPIBroker* mb, const CMPIContext* ctx,

         const CMPIObjectPath* instPath);


     CMPIEnumeration* (*execQuery) (const CMPIBroker* mb,

         const CMPIContext* ctx, const CMPIObjectPath* classPath,

         const char* query, const char* lang, CMPIStatus* rc);


     CMPIEnumeration* (*enumerateInstances) (const CMPIBroker* mb,

         const CMPIContext* ctx, const CMPIObjectPath* classPath,

         const char** properties, CMPIStatus* rc);


     CMPIEnumeration* (*associators) (const CMPIBroker* mb,

         const CMPIContext* ctx, const CMPIObjectPath* instPath,

         const char* assocClass, const char* resultClass, const char* role,

         const char* resultRole, const char** properties, CMPIStatus* rc);


     CMPIEnumeration* (*associatorNames) (const CMPIBroker* mb,

         const CMPIContext* ctx, const CMPIObjectPath* instPath,

         const char* assocClass, const char* resultClass, const char* role,

         const char* resultRole, CMPIStatus* rc);


     CMPIEnumeration* (*references) (const CMPIBroker* mb,

         const CMPIContext* ctx, const CMPIObjectPath* instPath,

         const char* resultClass, const char* role, const char** properties,

         CMPIStatus* rc);


     CMPIEnumeration* (*referenceNames) (const CMPIBroker* mb,

         const CMPIContext* ctx, const CMPIObjectPath* instPath,

         const char* resultClass, const char* role, CMPIStatus* rc);


     CMPIData (*invokeMethod) (const CMPIBroker* mb, const CMPIContext* ctx,

         const CMPIObjectPath* objPath, const char* method,

         const CMPIArgs* in, CMPIArgs* out, CMPIStatus* rc);


     CMPIStatus (*setProperty) (const CMPIBroker* mb, const CMPIContext* ctx,

         const CMPIObjectPath* instPath, const char* name,

         const CMPIValue* value, CMPIType type);


     CMPIData (*getProperty) (const CMPIBroker* mb, const CMPIContext* ctx,

         const CMPIObjectPath* instPath, const char* name, CMPIStatus* rc);


     CMPIEnumeration* (*enumerateInstancesFiltered) (const CMPIBroker* mb,

         const CMPIContext* ctx, const CMPIObjectPath* classPath,

         const char** properties, const char* filterQueryLanguage,

         const char* filterQuery, CMPIStatus* rc);


     CMPIEnumeration* (*associatorsFiltered) (const CMPIBroker* mb,

         const CMPIContext* ctx, const CMPIObjectPath* instPath,

         const char* assocClass, const char* resultClass,

         const char* role, const char* resultRole,

         const char** properties, const char* filterQueryLanguage,

         const char* filterQuery, CMPIStatus* rc);


     CMPIEnumeration* (*referencesFiltered) (const CMPIBroker* mb,

         const CMPIContext* ctx, const CMPIObjectPath* instPath,

         const char* resultClass, const char* role,

         const char** properties, const char* filterQueryLanguage,

         const char* filterQuery, CMPIStatus* rc);


 } CMPIBrokerFT;


 typedef struct _CMPIBrokerEncFT {


     CMPIVersion ftVersion;


     CMPIInstance* (*newInstance) (const CMPIBroker* mb,

         const CMPIObjectPath* instPath, CMPIStatus* rc);


     CMPIObjectPath* (*newObjectPath) (const CMPIBroker* mb, const char* ns,

         const char* cn, CMPIStatus* rc);


     CMPIArgs* (*newArgs) (const CMPIBroker* mb, CMPIStatus* rc);


     CMPIString* (*newString) (const CMPIBroker* mb, const char* data,

         CMPIStatus* rc);


     CMPIArray* (*newArray) (const CMPIBroker* mb, CMPICount size,

         CMPIType type, CMPIStatus* rc);


     CMPIDateTime* (*newDateTime) (const CMPIBroker* mb, CMPIStatus* rc);


     CMPIDateTime* (*newDateTimeFromBinary) (const CMPIBroker* mb,

         CMPIUint64 binTime, CMPIBoolean interval, CMPIStatus* rc);


     CMPIDateTime* (*newDateTimeFromChars) (const CMPIBroker* mb,

         const char* datetime, CMPIStatus* rc);


     CMPISelectExp* (*newSelectExp) (const CMPIBroker* mb, const char* query,

         const char* lang, CMPIArray** projection, CMPIStatus* rc);


     CMPIBoolean (*classPathIsA) (const CMPIBroker* mb,

         const CMPIObjectPath* classPath, const char* className,

         CMPIStatus* rc);


     CMPIString* (*toString) (const CMPIBroker* mb, const void* object,

         CMPIStatus* rc);


     CMPIBoolean (*isOfType) (const CMPIBroker* mb, const void* object,

         const char* type, CMPIStatus* rc);


     CMPIString* (*getType) (const CMPIBroker* mb, const void* object,

         CMPIStatus* rc);


     CMPIString* (*getMessage) (const CMPIBroker* mb, const char* msgId,

         const char* defMsg, CMPIStatus* rc, CMPICount count, ...);


     CMPIStatus (*logMessage) (const CMPIBroker* mb, CMPISeverity severity,

         const char* id, const char* text, const CMPIString* string);


     CMPIStatus (*trace) (const CMPIBroker* mb, CMPILevel level,

         const char* component, const char* text, const CMPIString* string);


 #ifdef CMPI_VER_200


     CMPIError* (*newCMPIError) (const CMPIBroker* mb, const char* owner,

         const char* msgID, const char* msg, const CMPIErrorSeverity sev,

         const CMPIErrorProbableCause pc, const CMPIrc cimStatusCode,

         CMPIStatus* rc);


     CMPIStatus (*openMessageFile) (const CMPIBroker* mb, const char* msgFile,

         CMPIMsgFileHandle* msgFileHandle);


     CMPIStatus (*closeMessageFile) (const CMPIBroker* mb,

         const CMPIMsgFileHandle msgFileHandle);


     CMPIString* (*getMessage2) (const CMPIBroker* mb, const char* msgId,

         const CMPIMsgFileHandle msgFileHandle, const char* defMsg,

         CMPIStatus* rc, CMPICount count, ...);


 #endif /*CMPI_VER_200*/


 #ifdef CMPI_VER_210


     CMPIPropertyList* (*newPropertyList) (const CMPIBroker* mb,

         const char** properties, CMPIStatus* rc);


     CMPIString* (*newStringCP) (const CMPIBroker* mb, const char* data,

         const CMPICodepageID cpid, CMPIStatus* rc);


     CMPIEnumerationFilter* (*newEnumerationFilter) (const CMPIBroker* mb,

             const char* filterQueryLanguage, const char* filterQuery,

             CMPIStatus* rc);


 #endif /*CMPI_VER_210*/


 } CMPIBrokerEncFT;


 struct timespec;


 typedef struct _CMPIBrokerExtFT {


     CMPIVersion ftVersion;


     char* (*resolveFileName) (const char* libName);


     CMPI_THREAD_TYPE (*newThread) (CMPIThreadFunc start, void* parm,

         int detached);


     int (*joinThread) (CMPI_THREAD_TYPE thread, CMPI_THREAD_RETURN* retval);


     int (*exitThread) (CMPI_THREAD_RETURN return_code);


     int (*cancelThread) (CMPI_THREAD_TYPE thread);


     int (*threadSleep) (CMPIUint32 msec);


     int (*threadOnce) (int* once, CMPIThreadOnceFunc function);


     int (*createThreadKey) (CMPI_THREAD_KEY_TYPE* key,

         CMPIThreadKeyCleanupFunc cleanup);


     int (*destroyThreadKey) (CMPI_THREAD_KEY_TYPE key);


     void* (*getThreadSpecific) (CMPI_THREAD_KEY_TYPE key);


     int (*setThreadSpecific) (CMPI_THREAD_KEY_TYPE key, void* value);


     CMPI_MUTEX_TYPE (*newMutex) (int opt);


     void (*destroyMutex) (CMPI_MUTEX_TYPE mutex);


     void (*lockMutex) (CMPI_MUTEX_TYPE mutex);


     void (*unlockMutex) (CMPI_MUTEX_TYPE mutex);


     CMPI_COND_TYPE (*newCondition) (int opt);


     void (*destroyCondition) (CMPI_COND_TYPE cond);


     int (*condWait) (CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex);


     int (*timedCondWait) (CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex,

         struct timespec* wait);


     int (*signalCondition) (CMPI_COND_TYPE cond);


 #ifdef CMPI_VER_210


     int (*destroyMutex2) (CMPI_MUTEX_TYPE mutex);


     int (*lockMutex2) (CMPI_MUTEX_TYPE mutex);


     int (*unlockMutex2) (CMPI_MUTEX_TYPE mutex);


     int (*destroyCondition2) (CMPI_COND_TYPE cond);


 #endif /*CMPI_VER_210*/


 } CMPIBrokerExtFT;


 #ifdef CMPI_VER_200


 typedef struct _CMPIBrokerMemFT {


     CMPIVersion ftVersion;


     CMPIGcStat* (*mark) (const CMPIBroker* mb, CMPIStatus* rc);


     CMPIStatus (*release) (const CMPIBroker* mb, const CMPIGcStat* gc);


     void* (*cmpiMalloc) (const CMPIBroker* mb, size_t size);


     void* (*cmpiCalloc) (const CMPIBroker* mb, size_t nElems, size_t sizeElem);


     void* (*cmpiRealloc) (const CMPIBroker* mb, void* ptr, size_t size);


     char* (*cmpiStrDup) (const CMPIBroker* mb, const char* str);


     void (*cmpiFree) (const CMPIBroker* mb, void* ptr);


     void (*freeInstance) (const CMPIBroker* mb, CMPIInstance* inst);


     void (*freeObjectPath) (const CMPIBroker* mb, CMPIObjectPath* obj);


     void (*freeArgs) (const CMPIBroker* mb, CMPIArgs* args);


     void (*freeString) (const CMPIBroker* mb, CMPIString* str);


     void (*freeArray) (const CMPIBroker* mb, CMPIArray* array);


     void (*freeDateTime) (const CMPIBroker* mb, CMPIDateTime* dt);


     void (*freeSelectExp) (const CMPIBroker* mb, CMPISelectExp* se);


 #ifdef CMPI_VER_210


     void (*freeChars) (const CMPIBroker* mb, char* chars);


 #endif /*CMPI_VER_210*/


 } CMPIBrokerMemFT;


 #endif /*CMPI_VER_200*/


 typedef struct _CMPIContext {


     const void* hdl;


     const CMPIContextFT* ft;


 } CMPIContext;


 typedef struct _CMPIContextFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPIContext* ctx);


     CMPIContext* (*clone) (const CMPIContext* ctx, CMPIStatus* rc);


     CMPIData (*getEntry) (const CMPIContext* ctx, const char* name,

         CMPIStatus* rc);


     CMPIData (*getEntryAt) (const CMPIContext* ctx, CMPICount index,

         CMPIString** name, CMPIStatus* rc);


     CMPICount (*getEntryCount) (const CMPIContext* ctx, CMPIStatus* rc);


     CMPIStatus (*addEntry) (const CMPIContext* ctx, const char* name,

         const CMPIValue* value, const CMPIType type);


 } CMPIContextFT;


 typedef struct _CMPIResult {


     const void* hdl;


     const CMPIResultFT* ft;


 } CMPIResult;


 typedef struct _CMPIResultFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPIResult* rslt);


     CMPIResult* (*clone) (const CMPIResult* rslt, CMPIStatus* rc);


     CMPIStatus (*returnData) (const CMPIResult* rslt, const CMPIValue* value,

         const CMPIType type);


     CMPIStatus (*returnInstance) (const CMPIResult* rslt,

         const CMPIInstance* inst);


     CMPIStatus (*returnObjectPath) (const CMPIResult* rslt,

         const CMPIObjectPath* op);


     CMPIStatus (*returnDone) (const CMPIResult* rslt);


 #ifdef CMPI_VER_200


     CMPIStatus (*returnError) (const CMPIResult* rslt, const CMPIError* er);


 #endif /*CMPI_VER_200*/


 } CMPIResultFT;


 typedef struct _CMPIString {


     const void* hdl;


     const CMPIStringFT* ft;


 } CMPIString;


 typedef struct _CMPIStringFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPIString* str);


     CMPIString* (*clone) (const CMPIString* str, CMPIStatus* rc);


     const char* (*getCharPtr) (const CMPIString* str, CMPIStatus* rc);


 #ifdef CMPI_VER_210


     char* (*newCharsCP) (const CMPIString* str, const CMPICodepageID cpid,

         CMPIStatus* rc);


 #endif /*CMPI_VER_210*/


 } CMPIStringFT;


 typedef struct _CMPIArray {


     const void* hdl;


     const CMPIArrayFT* ft;


 } CMPIArray;


 typedef struct _CMPIArrayFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPIArray* ar);


     CMPIArray* (*clone) (const CMPIArray* ar, CMPIStatus* rc);


     CMPICount (*getSize) (const CMPIArray* ar, CMPIStatus* rc);


     CMPIType (*getSimpleType) (const CMPIArray* ar, CMPIStatus* rc);


     CMPIData (*getElementAt) (const CMPIArray* ar, CMPICount index,

         CMPIStatus* rc);


     CMPIStatus (*setElementAt) (const CMPIArray* ar, CMPICount index,

         const CMPIValue* value, CMPIType type);


 } CMPIArrayFT;


 typedef struct _CMPIEnumeration {


     const void* hdl;


     const CMPIEnumerationFT* ft;


 } CMPIEnumeration;


 typedef struct _CMPIEnumerationFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPIEnumeration* en);


     CMPIEnumeration* (*clone) (const CMPIEnumeration* en, CMPIStatus* rc);


     CMPIData (*getNext) (const CMPIEnumeration* en, CMPIStatus* rc);


     CMPIBoolean (*hasNext) (const CMPIEnumeration* en, CMPIStatus* rc);


     CMPIArray* (*toArray) (const CMPIEnumeration* en, CMPIStatus* rc);


 } CMPIEnumerationFT;


 typedef struct _CMPIInstance {


     const void* hdl;


     const CMPIInstanceFT* ft;


 } CMPIInstance;


 typedef struct _CMPIInstanceFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPIInstance* inst);


     CMPIInstance* (*clone) (const CMPIInstance* inst, CMPIStatus* rc);


     CMPIData (*getProperty) (const CMPIInstance* inst, const char* name,

         CMPIStatus* rc);


     CMPIData (*getPropertyAt) (const CMPIInstance* inst, CMPICount index,

         CMPIString** name, CMPIStatus* rc);


     CMPICount (*getPropertyCount) (const CMPIInstance* inst, CMPIStatus* rc);


     CMPIStatus (*setProperty) (const CMPIInstance* inst, const char* name,

         const CMPIValue* value, CMPIType type);


     CMPIObjectPath* (*getObjectPath) (const CMPIInstance* inst,

         CMPIStatus* rc);


     CMPIStatus (*setPropertyFilter) (const CMPIInstance* inst,

         const char** properties, const char** keyList);


     CMPIStatus (*setObjectPath) (const CMPIInstance* inst,

         const CMPIObjectPath* op);


 #ifdef CMPI_VER_200


     CMPIStatus (*setPropertyWithOrigin) (const CMPIInstance* inst,

         const char* name, const CMPIValue* value, const CMPIType type,

         const char* origin);


 #endif /*CMPI_VER_200*/


 } CMPIInstanceFT;


 typedef struct _CMPIObjectPath {


     const void* hdl;


     const CMPIObjectPathFT* ft;


 } CMPIObjectPath;


 typedef struct _CMPIObjectPathFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPIObjectPath* op);


     CMPIObjectPath* (*clone) (const CMPIObjectPath* op, CMPIStatus* rc);


     CMPIStatus (*setNameSpace) (const CMPIObjectPath* op, const char* ns);


     CMPIString* (*getNameSpace) (const CMPIObjectPath* op, CMPIStatus* rc);


     CMPIStatus (*setHostname) (const CMPIObjectPath* op, const char* hn);


     CMPIString* (*getHostname) (const CMPIObjectPath* op, CMPIStatus* rc);


     CMPIStatus (*setClassName) (const CMPIObjectPath* op, const char* cn);


     CMPIString* (*getClassName) (const CMPIObjectPath* op, CMPIStatus* rc);


     CMPIStatus (*addKey) (const CMPIObjectPath* op, const char* key,

         const CMPIValue* value, const CMPIType type);


     CMPIData (*getKey) (const CMPIObjectPath* op, const char* key,

         CMPIStatus* rc);


     CMPIData (*getKeyAt) (const CMPIObjectPath* op, CMPICount index,

             CMPIString** name, CMPIStatus* rc);


     CMPICount (*getKeyCount) (const CMPIObjectPath* op, CMPIStatus* rc);


     CMPIStatus (*setNameSpaceFromObjectPath) (const CMPIObjectPath* op,

         const CMPIObjectPath* src);


     CMPIStatus (*setHostAndNameSpaceFromObjectPath) (const CMPIObjectPath* op,

         const CMPIObjectPath* src);


     CMPIData (*getClassQualifier) (const CMPIObjectPath* op,

         const char* qName, CMPIStatus* rc);


     CMPIData (*getPropertyQualifier) (const CMPIObjectPath* op,

         const char* pName, const char* qName, CMPIStatus* rc);


     CMPIData (*getMethodQualifier) (const CMPIObjectPath* op,

         const char* methodName, const char* qName, CMPIStatus* rc);


     CMPIData (*getParameterQualifier) (const CMPIObjectPath* op,

         const char* mName, const char* pName, const char* qName,

         CMPIStatus* rc);


     CMPIString* (*toString) (const CMPIObjectPath* op, CMPIStatus* rc);


 } CMPIObjectPathFT;


 typedef struct _CMPIArgs {


     const void* hdl;


     const CMPIArgsFT* ft;


 } CMPIArgs;


 typedef struct _CMPIArgsFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPIArgs* args);


     CMPIArgs* (*clone) (const CMPIArgs* args, CMPIStatus* rc);


     CMPIStatus (*addArg) (const CMPIArgs* args, const char* name,

             const CMPIValue* value, const CMPIType type);


     CMPIData (*getArg) (const CMPIArgs* args, const char* name, CMPIStatus* rc);


     CMPIData (*getArgAt) (const CMPIArgs* args, CMPICount index,

         CMPIString** name, CMPIStatus* rc);


     CMPICount (*getArgCount) (const CMPIArgs* args, CMPIStatus* rc);


 } CMPIArgsFT;


 typedef struct _CMPIDateTime {


     const void* hdl;


     const CMPIDateTimeFT* ft;


 } CMPIDateTime;


 typedef struct _CMPIDateTimeFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPIDateTime* dt);


     CMPIDateTime* (*clone) (const CMPIDateTime* dt, CMPIStatus* rc);


     CMPIUint64 (*getBinaryFormat) (const CMPIDateTime* dt,

         CMPIStatus* rc);


     CMPIString* (*getStringFormat) (const CMPIDateTime* dt, CMPIStatus* rc);


     CMPIBoolean (*isInterval) (const CMPIDateTime* dt, CMPIStatus* rc);


 } CMPIDateTimeFT;


 typedef struct _CMPISelectExp {


     const void* hdl;


     const CMPISelectExpFT* ft;


 } CMPISelectExp;


 typedef struct _CMPISelectExpFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPISelectExp* se);


     CMPISelectExp* (*clone) (const CMPISelectExp* se, CMPIStatus* rc);


     CMPIBoolean (*evaluate) (const CMPISelectExp* se, const CMPIInstance* inst,

         CMPIStatus* rc);


     CMPIString* (*getString) (const CMPISelectExp* se, CMPIStatus* rc);


     CMPISelectCond* (*getDOC) (const CMPISelectExp* se, CMPIStatus* rc);


     CMPISelectCond* (*getCOD) (const CMPISelectExp* se, CMPIStatus* rc);


     CMPIBoolean (*evaluateUsingAccessor) (const CMPISelectExp* se,

         CMPIAccessor* accessor, void* parm, CMPIStatus* rc);


 } CMPISelectExpFT;


 typedef struct _CMPISelectCond {


     const void* hdl;


     const CMPISelectCondFT* ft;


 } CMPISelectCond;


 typedef struct _CMPISelectCondFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPISelectCond* sc);


     CMPISelectCond* (*clone) (const CMPISelectCond* sc, CMPIStatus* rc);


     CMPICount (*getCountAndType) (const CMPISelectCond* sc, int* type,

             CMPIStatus* rc);


     CMPISubCond* (*getSubCondAt) (const CMPISelectCond* sc, CMPICount index,

         CMPIStatus* rc);


 } CMPISelectCondFT;


 typedef struct _CMPISubCond {


     const void* hdl;


     const CMPISubCondFT* ft;


 } CMPISubCond;


 typedef struct _CMPISubCondFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPISubCond* sc);


     CMPISubCond* (*clone) (const CMPISubCond* sc, CMPIStatus* rc);


     CMPICount (*getCount) (const CMPISubCond* sc, CMPIStatus* rc);


     CMPIPredicate* (*getPredicateAt) (const CMPISubCond* sc, CMPICount index,

         CMPIStatus* rc);


     CMPIPredicate* (*getPredicate) (const CMPISubCond* sc, const char* name,

         CMPIStatus* rc);


 } CMPISubCondFT;


 typedef struct _CMPIPredicate {


     const void* hdl;


     const CMPIPredicateFT* ft;


 } CMPIPredicate;


 typedef struct _CMPIPredicateFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPIPredicate* pr);


     CMPIPredicate* (*clone) (const CMPIPredicate* pr, CMPIStatus* rc);


     CMPIStatus (*getData) (const CMPIPredicate* pr, CMPIType* type,

             CMPIPredOp* prop, CMPIString** lhs, CMPIString** rhs);


     CMPIBoolean (*evaluateUsingAccessor) (const CMPIPredicate* pr,

         CMPIAccessor* accessorFnc, void* parm, CMPIStatus* rc);


 } CMPIPredicateFT;


 #ifdef CMPI_VER_200


 typedef struct _CMPIError {


     const void* hdl;


     const CMPIErrorFT* ft;


 } CMPIError;


 typedef struct _CMPIErrorFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPIError* er);


     CMPIError* (*clone) (const CMPIError* er, CMPIStatus* rc);


     CMPIErrorType (*getErrorType) (const CMPIError* er, CMPIStatus* rc);


     CMPIString* (*getOtherErrorType) (const CMPIError* er, CMPIStatus* rc);


     CMPIString* (*getOwningEntity) (const CMPIError* er, CMPIStatus* rc);


     CMPIString* (*getMessageID) (const CMPIError* er, CMPIStatus* rc);


     CMPIString* (*getMessage) (const CMPIError* er, CMPIStatus* rc);


     CMPIErrorSeverity (*getPerceivedSeverity) (const CMPIError* er,

         CMPIStatus* rc);


     CMPIErrorProbableCause (*getProbableCause) (const CMPIError* er,

         CMPIStatus* rc);


     CMPIString* (*getProbableCauseDescription) (const CMPIError* er,

         CMPIStatus* rc);


     CMPIArray* (*getRecommendedActions) (const CMPIError* er, CMPIStatus* rc);


     CMPIString* (*getErrorSource) (const CMPIError* er, CMPIStatus* rc);


     CMPIErrorSrcFormat (*getErrorSourceFormat) (const CMPIError* er,

         CMPIStatus* rc);


     CMPIString* (*getOtherErrorSourceFormat) (const CMPIError* er,

         CMPIStatus* rc);


     CMPIrc (*getCIMStatusCode) (const CMPIError* er, CMPIStatus* rc);


     CMPIString* (*getCIMStatusCodeDescription) (const CMPIError* er,

         CMPIStatus* rc);


     CMPIArray* (*getMessageArguments) (const CMPIError* er, CMPIStatus* rc);


     CMPIStatus (*setErrorType) (const CMPIError* er, const CMPIErrorType et);


     CMPIStatus (*setOtherErrorType) (const CMPIError* er, const char* ot);


     CMPIStatus (*setProbableCauseDescription) (const CMPIError* er,

         const char* pcd);


     CMPIStatus (*setRecommendedActions) (const CMPIError* er,

         const CMPIArray* ra);


     CMPIStatus (*setErrorSource) (const CMPIError* er, const char* es);


     CMPIStatus (*setErrorSourceFormat) (const CMPIError* er,

         const CMPIErrorSrcFormat esf);


     CMPIStatus (*setOtherErrorSourceFormat) (const CMPIError* er,

         const char* oef);


     CMPIStatus (*setCIMStatusCodeDescription) (const CMPIError* er,

         const char* scd);


     CMPIStatus (*setMessageArguments) (const CMPIError* er,

         const CMPIArray* values);


 } CMPIErrorFT;


 #endif /*CMPI_VER_200*/


 #ifdef CMPI_VER_210


 typedef struct _CMPIPropertyList {


     const void* hdl;


     const CMPIPropertyListFT* ft;


 } CMPIPropertyList;


 typedef struct _CMPIPropertyListFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPIPropertyList* plist);


     CMPIPropertyList* (*clone) (const CMPIPropertyList* plist, CMPIStatus* rc);


     CMPIBoolean (*isPropertyInList) (const CMPIPropertyList* plist,

         const char* pname, CMPIStatus* rc);


     const char** (*getProperties) (const CMPIPropertyList* plist,

         CMPIStatus* rc);


 } CMPIPropertyListFT;


 #endif /*CMPI_VER_210*/


 #ifdef CMPI_VER_210


 typedef struct _CMPIEnumerationFilter {


     const void* hdl;


     const CMPIEnumerationFilterFT* ft;


 } CMPIEnumerationFilter;


 typedef struct _CMPIEnumerationFilterFT {


     CMPIVersion ftVersion;


     CMPIStatus (*release) (CMPIEnumerationFilter* ef);


     CMPIEnumerationFilter* (*clone) (const CMPIEnumerationFilter* ef,

         CMPIStatus* rc);


     CMPIBoolean (*match) (const CMPIEnumerationFilter* ef,

         const CMPIInstance* inst, CMPIStatus* rc);


 } CMPIEnumerationFilterFT;


 #endif /*CMPI_VER_210*/


 typedef struct _CMPIInstanceMI {


     const void* hdl;


     const CMPIInstanceMIFT* ft;


 } CMPIInstanceMI;


 typedef struct _CMPIInstanceMIFT {


     CMPIVersion ftVersion;


     int miVersion;


     const char* miName;


     CMPIStatus (*cleanup) (CMPIInstanceMI* mi, const CMPIContext* ctx,

         CMPIBoolean terminating);


     CMPIStatus (*enumerateInstanceNames) (CMPIInstanceMI* mi,

         const CMPIContext* ctx, const CMPIResult* rslt,

         const CMPIObjectPath* classPath);


     CMPIStatus (*enumerateInstances) (CMPIInstanceMI* mi,

         const CMPIContext* ctx, const CMPIResult* rslt,

         const CMPIObjectPath* classPath , const char** properties);


     CMPIStatus (*getInstance) (CMPIInstanceMI* mi, const CMPIContext* ctx,

         const CMPIResult* rslt, const CMPIObjectPath* instPath,

         const char** properties);


     CMPIStatus (*createInstance) (CMPIInstanceMI* mi, const CMPIContext* ctx,

         const CMPIResult* rslt, const CMPIObjectPath* classPath,

         const CMPIInstance* inst);


     CMPIStatus (*modifyInstance) (CMPIInstanceMI* mi, const CMPIContext* ctx,

         const CMPIResult* rslt, const CMPIObjectPath* instPath,

         const CMPIInstance* modInst, const char** properties);


     CMPIStatus (*deleteInstance) (CMPIInstanceMI* mi, const CMPIContext* ctx,

         const CMPIResult* rslt, const CMPIObjectPath* op);


     CMPIStatus (*execQuery) (CMPIInstanceMI* mi, const CMPIContext* ctx,

         const CMPIResult* rslt, const CMPIObjectPath* classPath,

         const char* query, const char* lang);


 #ifdef CMPI_VER_210


     CMPIStatus (*enumerateInstancesFiltered) (CMPIInstanceMI* mi,

         const CMPIContext* ctx, const CMPIResult* rslt,

         const CMPIObjectPath* classPath,

         const char** properties, const char*filterQuerylanguage,

         const char* filterQuery, CMPIStatus* rc);


 #endif /*CMPI_VER_210*/


 } CMPIInstanceMIFT;


 typedef struct _CMPIAssociationMI {


     const void* hdl;


     const CMPIAssociationMIFT* ft;


 } CMPIAssociationMI;


 typedef struct _CMPIAssociationMIFT {


     CMPIVersion ftVersion;


     int miVersion;


     const char* miName;


     CMPIStatus (*cleanup) (CMPIAssociationMI* mi, const CMPIContext* ctx,

         CMPIBoolean terminating);


     CMPIStatus (*associators) (CMPIAssociationMI* mi, const CMPIContext* ctx,

         const CMPIResult* rslt, const CMPIObjectPath* instPath,

         const char* assocClass, const char* resultClass, const char* role,

         const char* resultRole, const char** properties);


     CMPIStatus (*associatorNames) (CMPIAssociationMI* mi,

         const CMPIContext* ctx, const CMPIResult* rslt,

         const CMPIObjectPath* instPath, const char* assocClass,

         const char* resultClass, const char* role, const char* resultRole);


     CMPIStatus (*references) (CMPIAssociationMI* mi, const CMPIContext* ctx,

         const CMPIResult* rslt, const CMPIObjectPath* instPath,

         const char* resultClass, const char* role,

         const char** properties);


     CMPIStatus (*referenceNames) (CMPIAssociationMI* mi,

             const CMPIContext* ctx, const CMPIResult* rslt,

             const CMPIObjectPath* instPath, const char* resultClass,

             const char* role);


 #ifdef CMPI_VER_210


     CMPIStatus (*associatorsFiltered) (CMPIAssociationMI* mi,

         const CMPIContext* ctx, const CMPIResult* rslt,

         const CMPIObjectPath* instPath, const char* assocClass,

         const char* resultClass, const char* role, const char* resultRole,

         const char** properties, const char* filterQueryLanguage,

         const char* filterQuery, CMPIBoolean continueOnError);


     CMPIStatus (*referencesFiltered) (CMPIAssociationMI* mi,

         const CMPIContext* ctx, const CMPIResult* rslt,

         const CMPIObjectPath* instPath, const char* resultClass,

         const char* role, const char** properties,

         const char* filterQueryLanguage, const char* filterQuery,

         CMPIBoolean continueOnError);


 #endif /*CMPI_VER_210*/


 } CMPIAssociationMIFT;


 typedef struct _CMPIMethodMI {


     const void* hdl;


     const CMPIMethodMIFT* ft;


 } CMPIMethodMI;


 typedef struct _CMPIMethodMIFT {


     CMPIVersion ftVersion;


     int miVersion;


     const char* miName;


     CMPIStatus (*cleanup) (CMPIMethodMI* mi, const CMPIContext* ctx,

         CMPIBoolean terminating);


     CMPIStatus (*invokeMethod) (CMPIMethodMI* mi, const CMPIContext* ctx,

         const CMPIResult* rslt, const CMPIObjectPath* objPath,

         const char* method, const CMPIArgs* in, CMPIArgs* out);


 } CMPIMethodMIFT;


 #ifdef CMPI_VER_200


 typedef struct _CMPIPropertyMI {


     const void* hdl;


     const CMPIPropertyMIFT* ft;


 } CMPIPropertyMI;


 typedef struct _CMPIPropertyMIFT {


     CMPIVersion ftVersion;


     int miVersion;


     const char* miName;


     CMPIStatus (*cleanup) (CMPIPropertyMI* mi, const CMPIContext* ctx,

             CMPIBoolean terminating); /*Deprecated*/


     CMPIStatus (*setProperty) (CMPIPropertyMI* mi, const CMPIContext* ctx,

         const CMPIResult* rslt, const CMPIObjectPath* instPath,

         const char* name, const CMPIData data);


     CMPIStatus (*getProperty) (CMPIPropertyMI* mi, const CMPIContext* ctx,

         const CMPIResult* rslt, const CMPIObjectPath* instPath,

         const char* name);


     CMPIStatus (*setPropertyWithOrigin) (CMPIPropertyMI* mi,

         const CMPIContext* ctx, const CMPIResult* rslt,

         CMPIObjectPath* instPath, const char* name, const CMPIData data,

         const char* origin);


 } CMPIPropertyMIFT;


 #endif /*CMPI_VER_200*/


 typedef struct _CMPIIndicationMI {


     const void* hdl;


     const CMPIIndicationMIFT* ft;


 } CMPIIndicationMI;


 typedef struct _CMPIIndicationMIFT {


     CMPIVersion ftVersion;


     int miVersion;


     const char* miName;


     CMPIStatus (*cleanup) (CMPIIndicationMI* mi, const CMPIContext* ctx,

             CMPIBoolean terminating);


     CMPIStatus (*authorizeFilter) (CMPIIndicationMI* mi,

         const CMPIContext* ctx, const CMPISelectExp* filter,

         const char* className, const CMPIObjectPath* classPath,

         const char* owner);


     CMPIStatus (*mustPoll) (CMPIIndicationMI* mi, const CMPIContext* ctx,

         const CMPIResult* rslt, const CMPISelectExp* filter,

         const char* className, const CMPIObjectPath* classPath);


     CMPIStatus (*activateFilter) (CMPIIndicationMI* mi,

         const CMPIContext* ctx, const CMPISelectExp* filter,

         const char* className, const CMPIObjectPath* classPath,

         CMPIBoolean firstActivation);


     CMPIStatus (*deActivateFilter) (CMPIIndicationMI* mi,

         const CMPIContext* ctx, const CMPISelectExp* filter,

         const char* className, const CMPIObjectPath* classPath,

         CMPIBoolean lastDeActiviation);


     CMPIStatus (*enableIndications) (CMPIIndicationMI* mi,

         const CMPIContext* ctx);


     CMPIStatus (*disableIndications) (CMPIIndicationMI* mi,

         const CMPIContext* ctx);


     CMPIStatus (*authorizeFilterCollection) (CMPIIndicationMI* mi,

         const CMPIContext* ctx, const CMPIInstance* collInst);


     CMPIStatus (*activateFilterCollection) (CMPIIndicationMI* mi,

         const CMPIContext* ctx, const CMPIInstance* collInst,

         CMPIBoolean firstActivation);


     CMPIStatus (*deActivateFilterCollection) (CMPIIndicationMI* mi,

         const CMPIContext* ctx, const CMPIInstance* collInst,

         CMPIBoolean lastDeActivation);


 } CMPIIndicationMIFT;


 #ifdef __cplusplus

 }

 #endif


 #endif /*_CMPIFT_H_ */

CMPIArray::ft
const CMPIArrayFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:4747

CMPISelectCondFT
Function table of CMPISelectCond encapsulated data type object.
Definition: cmpift.h:6945

CMPIResult
CMPIResult encapsulated data type object.
Definition: cmpift.h:4340

CMPIMethodMI::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this MI object.
Definition: cmpift.h:10449

CMPIInstanceFT
Function table of CMPIInstance encapsulated data type object.
Definition: cmpift.h:5168

CMPIIndicationMIFT::miVersion
int miVersion
Informal MI-specific version number for this MI.
Definition: cmpift.h:11046

CMPIMethodMIFT::miVersion
int miVersion
Informal MI-specific version number for this MI.
Definition: cmpift.h:10476

CMPIResult::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:4345

CMPIStringFT
Function table of CMPIString encapsulated data type object.
Definition: cmpift.h:4588

CMPI_THREAD_RETURN
#define CMPI_THREAD_RETURN
Type for the return value of a thread function.
Definition: cmpios.h:74

CMPIPredicateFT
Function table of CMPIPredicate encapsulated data type object.
Definition: cmpift.h:7359

CMPISubCond::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:7119

CMPIArgs::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:6245

CMPIBrokerFT
Function table for some MB services (thread registration, indications services, and client services)...
Definition: cmpift.h:267

CMPIType
unsigned short CMPIType
A bitmask type representing a CMPI type.
Definition: cmpidt.h:393

CMPIPropertyMIFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MI for this function table.
Definition: cmpift.h:10690

CMPI_COND_TYPE
#define CMPI_COND_TYPE
Type for the handle of a condition.
Definition: cmpios.h:144

CMPIAssociationMI::ft
const CMPIAssociationMIFT * ft
Pointer to the function table for this MI object.
Definition: cmpift.h:9698

CMPIErrorSrcFormat
CMPIErrorSrcFormat
An enumeration type that defines possible values for the source format in a CMPIError object...
Definition: cmpidt.h:1610

CMPIBrokerEncFT
Function table for some MB services (factory and miscellaneous services).
Definition: cmpift.h:1857

CMPIData
A structure type representing a CMPI data item.
Definition: cmpidt.h:604

CMPICodepageID
CMPICodepageID
An enumeration type that identifies a codepage for CMPI codepage support.
Definition: cmpidt.h:1638

CMPIThreadOnceFunc
void(* CMPIThreadOnceFunc)(void)
A function pointer type for a function that is called once in a POSIX thread.
Definition: cmpidt.h:679

CMPISubCond
CMPISubCond encapsulated data type object.
Definition: cmpift.h:7114

CMPISelectExpFT
Function table of CMPISelectExp encapsulated data type object.
Definition: cmpift.h:6654

CMPIMethodMI::ft
const CMPIMethodMIFT * ft
Pointer to the function table for this MI object.
Definition: cmpift.h:10454

CMPIPropertyList
CMPIPropertyList encapsulated data type object.
Definition: cmpift.h:8686

CMPIVersion
int CMPIVersion
A type for CMPI version fields (mainly in function tables).
Definition: cmpidt.h:773

CMPIAssociationMI::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this MI object.
Definition: cmpift.h:9693

CMPIObjectPath::ft
const CMPIObjectPathFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:5565

CMPIResultFT
Function table of CMPIResult encapsulated data type object.
Definition: cmpift.h:4357

CMPIDateTime::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:6461

CMPIArrayFT
Function table of CMPIArray encapsulated data type object.
Definition: cmpift.h:4754

CMPIPropertyList::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:8691

CMPIArrayFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:4764

CMPIPredicateFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:7369

CMPIIndicationMI::ft
const CMPIIndicationMIFT * ft
Pointer to the function table for this MI object.
Definition: cmpift.h:11024

CMPIIndicationMIFT::miName
const char * miName
Informal MI-specific name for this MI.
Definition: cmpift.h:11051

CMPIArray::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:4742

CMPIContext::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:4103

CMPIEnumerationFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:4995

CMPIMethodMIFT::miName
const char * miName
Informal MI-specific name for this MI.
Definition: cmpift.h:10481

CMPIPropertyMI::ft
const CMPIPropertyMIFT * ft
Pointer to the function table for this MI object.
Definition: cmpift.h:10671

CMPIBoolean
unsigned char CMPIBoolean
CIM data type boolean.
Definition: cmpidt.h:242

CMPIArgs::ft
const CMPIArgsFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:6250

CMPIBroker::bft
const CMPIBrokerFT * bft
Pointer to the function table for some MB services (thread registration, indications services...
Definition: cmpift.h:225

CMPIArgsFT
Function table of CMPIArgs encapsulated data type object.
Definition: cmpift.h:6257

CMPIPropertyMI
CMPIPropertyMI object.
Definition: cmpift.h:10660

CMPIDateTimeFT
Function table of CMPIDateTime encapsulated data type object.
Definition: cmpift.h:6473

CMPIBrokerEncFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:1867

CMPIBroker::mft
const CMPIBrokerMemFT * mft
Pointer to the function table for MB memory enhancement services.
Definition: cmpift.h:247

CMPIEnumeration::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:4973

CMPIUint32
unsigned int CMPIUint32
CIM data type uint32.
Definition: cmpidt.h:246

CMPI_MUTEX_TYPE
#define CMPI_MUTEX_TYPE
Type for the handle of a mutex.
Definition: cmpios.h:133

CMPIEnumerationFilter
CMPIEnumerationFilter encapsulated data type object.
Definition: cmpift.h:8865

CMPIInstance::ft
const CMPIInstanceFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:5156

CMPIDateTimeFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:6483

CMPISubCond::ft
const CMPISubCondFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:7124

CMPIAssociationMIFT
Function table of CMPIAssociationMI object.
Definition: cmpift.h:9705

CMPIObjectPath
CMPIObjectPath encapsulated data type object.
Definition: cmpift.h:5555

CMPIAssociationMIFT::miVersion
int miVersion
Informal MI-specific version number for this MI.
Definition: cmpift.h:9720

CMPIString
CMPIString encapsulated data type object.
Definition: cmpift.h:4571

CMPIBrokerFT::brokerCapabilities
unsigned int brokerCapabilities
Bitmask representing the MB capabilities supported by this MB.
Definition: cmpift.h:275

CMPIIndicationMIFT
Function table of CMPIIndicationMI object.
Definition: cmpift.h:11031

CMPIGcStat
void CMPIGcStat
An opaque type that is used by the MB for use with the CMPIBrokerMemFT.mark() and CMPIBrokerMemFT...
Definition: cmpidt.h:715

CMPIPropertyListFT
Function table of CMPIPropertyList encapsulated data type object.
Definition: cmpift.h:8705

CMPIPropertyMIFT::miVersion
int miVersion
Informal MI-specific version number for this MI.
Definition: cmpift.h:10695

CMPISelectCondFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:6955

CMPIStringFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:4598

CMPIBrokerMemFT
Function table for MB memory enhancement services.
Definition: cmpift.h:3632

CMPIDateTime
CMPIDateTime encapsulated data type object.
Definition: cmpift.h:6456

CMPIError::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:7564

CMPIBroker
CMPIBroker structure.
Definition: cmpift.h:214

CMPIPredicate
CMPIPredicate encapsulated data type object.
Definition: cmpift.h:7340

CMPIThreadKeyCleanupFunc
void(* CMPIThreadKeyCleanupFunc)(void *key)
A function pointer type for a POSIX thread key cleanup function.
Definition: cmpidt.h:692

CMPIInstanceMI::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this MI object.
Definition: cmpift.h:9015

CMPIContext
CMPIContext encapsulated data type object.
Definition: cmpift.h:4098

CMPIContextFT
Function table of CMPIContext encapsulated data type object.
Definition: cmpift.h:4118

CMPICount
unsigned int CMPICount
An unsigned integer that specifies a number of elements or position in a sequential data type...
Definition: cmpidt.h:296

CMPIError
CMPIError encapsulated data type object.
Definition: cmpift.h:7559

CMPIInstance
CMPIInstance encapsulated data type object.
Definition: cmpift.h:5146

CMPIErrorProbableCause
CMPIErrorProbableCause
An enumeration type that defines possible values for the probable cause in a CMPIError object...
Definition: cmpidt.h:1335

CMPIBrokerFT::brokerName
const char * brokerName
Informal MB-specific name for this MB.
Definition: cmpift.h:294

CMPIError::ft
const CMPIErrorFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:7569

CMPIEnumerationFT
Function table of CMPIEnumeration encapsulated data type object.
Definition: cmpift.h:4985

CMPIUint64
unsigned long long CMPIUint64
CIM data type uint64.
Definition: cmpidt.h:256

CMPISelectCond::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:6931

CMPIPropertyMIFT::miName
const char * miName
Informal MI-specific name for this MI.
Definition: cmpift.h:10700

CMPIErrorFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:7590

CMPIValue
A union that can hold a value of any of the data types defined in CMPI.
Definition: cmpidt.h:335

CMPIArgsFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:6267

CMPIThreadFunc
CMPI_THREAD_RETURN(CMPI_THREAD_CDECL * CMPIThreadFunc)(void *parm)
A function pointer type for a POSIX thread function.
Definition: cmpidt.h:666

CMPIEnumerationFilter::ft
const CMPIEnumerationFilterFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:8875

CMPIMethodMIFT
Function table of CMPIMethodMI object.
Definition: cmpift.h:10461

CMPIPropertyMIFT
Function table of CMPIPropertyMI object.
Definition: cmpift.h:10680

CMPISelectExp::ft
const CMPISelectExpFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:6645

CMPIInstanceFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:5178

CMPIInstanceMIFT::miVersion
int miVersion
Informal MI-specific version number for this MI.
Definition: cmpift.h:9042

CMPIBroker::eft
const CMPIBrokerEncFT * eft
Pointer to the function table for some MB services (factory and miscellaneous services).
Definition: cmpift.h:231

CMPI_THREAD_KEY_TYPE
#define CMPI_THREAD_KEY_TYPE
Type for a thread key of a thread.
Definition: cmpios.h:121

CMPIDateTime::ft
const CMPIDateTimeFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:6466

CMPISelectExp
CMPISelectExp encapsulated data type object.
Definition: cmpift.h:6635

CMPIErrorType
CMPIErrorType
An enumeration type that defines possible values for the error type in a CMPIError object...
Definition: cmpidt.h:1274

CMPIAssociationMI
CMPIAssociationMI object.
Definition: cmpift.h:9687

CMPIEnumerationFilterFT
Function table of CMPIEnumerationFilter encapsulated data type object.
Definition: cmpift.h:8884

CMPIStatus
A structure that indicates success or failure of MB and MI functions.
Definition: cmpidt.h:974

CMPIInstanceMIFT::miName
const char * miName
Informal MI-specific name for this MI.
Definition: cmpift.h:9047

cmpios.h
Defines OS-specific symbols for threading structures, etc.

CMPISubCondFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:7143

CMPIInstance::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:5151

CMPIBroker::xft
const CMPIBrokerExtFT * xft
Pointer to the function table for MB operating system encapsulation services.
Definition: cmpift.h:237

CMPIPropertyListFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:8715

CMPIString::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:4576

CMPIEnumeration
CMPIEnumeration encapsulated data type object.
Definition: cmpift.h:4968

CMPIBrokerMemFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:3642

CMPIEnumerationFilterFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:8894

CMPIInstanceMI::ft
const CMPIInstanceMIFT * ft
Pointer to the function table for this MI object.
Definition: cmpift.h:9020

CMPIPropertyMI::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this MI object.
Definition: cmpift.h:10666

CMPIErrorSeverity
CMPIErrorSeverity
An enumeration type that defines possible values for the error severity in a CMPIError object...
Definition: cmpidt.h:1312

CMPIEnumeration::ft
const CMPIEnumerationFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:4978

CMPIBrokerExtFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:2944

CMPIErrorFT
Function table of CMPIError encapsulated data type object.
Definition: cmpift.h:7580

CMPISubCondFT
Function table of CMPISubCond encapsulated data type object.
Definition: cmpift.h:7133

CMPISelectCond
CMPISelectCond encapsulated data type object.
Definition: cmpift.h:6926

CMPIAccessor
CMPIData CMPIAccessor(const char *propertyName, void *parm)
A function type for accessing data during query processing.
Definition: cmpidt.h:645

CMPIPredicate::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:7345

CMPIrc
CMPIrc
An enumeration type that defines CMPI return code values.
Definition: cmpidt.h:883

CMPIResult::ft
const CMPIResultFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:4350

CMPIMsgFileHandle
void * CMPIMsgFileHandle
An opaque type representing a handle to an open message file.
Definition: cmpidt.h:703

CMPISelectExpFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:6664

CMPILevel
CMPILevel
An enumeration type that defines logging levels for trace functions.
Definition: cmpidt.h:1219

CMPIIndicationMI
CMPIIndicationMI object.
Definition: cmpift.h:11013

CMPIBrokerExtFT
Function table for MB operating system encapsulation services.
Definition: cmpift.h:2934

CMPIAssociationMIFT::miName
const char * miName
Informal MI-specific name for this MI.
Definition: cmpift.h:9725

CMPIObjectPathFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:5582

CMPIInstanceMIFT
Function table of CMPIInstanceMI object.
Definition: cmpift.h:9027

CMPIBrokerFT::brokerVersion
CMPIVersion brokerVersion
CMPI version supported by this MB for this function table.
Definition: cmpift.h:287

CMPIPredicate::ft
const CMPIPredicateFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:7350

CMPIString::ft
const CMPIStringFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:4581

CMPIInstanceMIFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MI for this function table.
Definition: cmpift.h:9037

CMPIMethodMIFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MI for this function table.
Definition: cmpift.h:10471

CMPIAssociationMIFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MI for this function table.
Definition: cmpift.h:9715

CMPIIndicationMIFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MI for this function table.
Definition: cmpift.h:11041

CMPIArgs
CMPIArgs encapsulated data type object.
Definition: cmpift.h:6240

CMPISelectExp::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:6640

CMPIMethodMI
CMPIMethodMI object.
Definition: cmpift.h:10443

CMPIInstanceMI
CMPIInstanceMI object.
Definition: cmpift.h:9009

CMPIPropertyList::ft
const CMPIPropertyListFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:8696

cmpidt.h
Defines CMPI data types.

CMPIPredOp
CMPIPredOp
An enumeration type that defines predicate operators in parsed queries.
Definition: cmpidt.h:1169

CMPIBroker::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for the MB.
Definition: cmpift.h:219

CMPI_THREAD_TYPE
#define CMPI_THREAD_TYPE
Type for the handle of a thread.
Definition: cmpios.h:56

CMPIContext::ft
const CMPIContextFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:4108

CMPISeverity
CMPISeverity
An enumeration type that defines severity levels for logging functions.
Definition: cmpidt.h:1199

CMPIObjectPathFT
Function table of CMPIObjectPath encapsulated data type object.
Definition: cmpift.h:5572

CMPIIndicationMI::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this MI object.
Definition: cmpift.h:11019

CMPIResultFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:4367

CMPISelectCond::ft
const CMPISelectCondFT * ft
Pointer to the function table for this object.
Definition: cmpift.h:6936

CMPIEnumerationFilter::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:8870

CMPIContextFT::ftVersion
CMPIVersion ftVersion
CMPI version supported by the MB for this function table.
Definition: cmpift.h:4128

CMPIArray
CMPIArray encapsulated data type object.
Definition: cmpift.h:4737

CMPIObjectPath::hdl
const void * hdl
Opaque pointer to MB-specific implementation data for this object.
Definition: cmpift.h:5560