cmpi
|
00001 /* 00002 * 00003 * $Id: cmpift.h,v 1.9 2009/02/28 03:18:20 tyreld Exp $ 00004 * 00005 * (C) Copyright IBM Corp. 2003, 2005, 2006, 2008 00006 * 00007 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE ECLIPSE PUBLIC LICENSE 00008 * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE 00009 * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT. 00010 * 00011 * You can obtain a current copy of the Eclipse Public License from 00012 * http://www.opensource.org/licenses/eclipse-1.0.txt 00013 * 00014 * Author: Adrian Schuur <schuur@de.ibm.com> 00015 * Contributors: Konrad Rzeszutek <darnok@us.ibm.com> 00016 * 00017 * Description: CMPI Function Table Definions 00018 * 00019 */ 00020 00021 /* ------------------------------------------------------------------------- */ 00022 /* */ 00023 /* Copyright (c) 2006 The Open Group */ 00024 /* */ 00025 /* Permission is hereby granted, free of charge, to any person obtaining a */ 00026 /* copy of this software (the "Software"), to deal in the Software without */ 00027 /* restriction, including without limitation the rights to use, copy, */ 00028 /* modify, merge, publish, distribute, sublicense, and/or sell copies of */ 00029 /* the Software, and to permit persons to whom the Software is furnished */ 00030 /* to do so, subject to the following conditions: */ 00031 /* */ 00032 /* The above copyright notice and this permission notice shall be included */ 00033 /* in all copies or substantial portions of the Software. */ 00034 /* */ 00035 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS */ 00036 /* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ 00037 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ 00038 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ 00039 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT */ 00040 /* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR */ 00041 /* THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ 00042 /* */ 00043 /* ------------------------------------------------------------------------- */ 00044 00045 #ifndef _CMPIFT_H_ 00046 # define _CMPIFT_H_ 00047 00048 # include "cmpidt.h" 00049 # include "cmpios.h" 00050 00051 # ifdef __cplusplus 00052 extern "C" 00053 { 00054 # endif 00055 00056 00057 //--------------------------------------------------- 00058 //-- 00059 // _CMPIBrokerEncFT Function Table 00060 //-- 00061 //--------------------------------------------------- 00062 00063 00069 struct _CMPIBrokerEncFT 00070 { 00071 00074 int ftVersion; 00075 00082 CMPIInstance *(*newInstance) 00083 (const CMPIBroker * mb, const CMPIObjectPath * op, CMPIStatus * rc); 00084 00092 CMPIObjectPath *(*newObjectPath) 00093 (const CMPIBroker * mb, const char *ns, const char *cn, 00094 CMPIStatus * rc); 00095 00101 CMPIArgs *(*newArgs) (const CMPIBroker * mb, CMPIStatus * rc); 00102 00109 CMPIString *(*newString) 00110 (const CMPIBroker * mb, const char *data, CMPIStatus * rc); 00111 00119 CMPIArray *(*newArray) 00120 (const CMPIBroker * mb, CMPICount max, CMPIType type, CMPIStatus * rc); 00121 00127 CMPIDateTime *(*newDateTime) (const CMPIBroker * mb, CMPIStatus * rc); 00128 00137 CMPIDateTime *(*newDateTimeFromBinary) 00138 (const CMPIBroker * mb, CMPIUint64 binTime, CMPIBoolean interval, 00139 CMPIStatus * rc); 00140 00147 CMPIDateTime *(*newDateTimeFromChars) 00148 (const CMPIBroker * mb, const char *utcTime, CMPIStatus * rc); 00149 00158 CMPISelectExp *(*newSelectExp) 00159 (const CMPIBroker * mb, const char *query, const char *lang, 00160 CMPIArray ** projection, CMPIStatus * st); 00161 00170 CMPIBoolean (*classPathIsA) 00171 (const CMPIBroker * mb, const CMPIObjectPath * op, const char *type, 00172 CMPIStatus * rc); 00173 00181 CMPIString *(*toString) 00182 (const CMPIBroker * mb, const void *object, CMPIStatus * rc); 00183 00193 CMPIBoolean (*isOfType) 00194 (const CMPIBroker * mb, const void *object, const char *type, 00195 CMPIStatus * rc); 00196 00204 CMPIString *(*getType) 00205 (const CMPIBroker * mb, const void *object, CMPIStatus * rc); 00206 00215 CMPIString *(*getMessage) 00216 (const CMPIBroker * mb, const char *msgId, const char *defMsg, 00217 CMPIStatus * rc, CMPICount count, ...); 00218 00229 CMPIStatus (*logMessage) 00230 (const CMPIBroker *, int severity, const char *id, 00231 const char *text, const CMPIString * string); 00232 00242 CMPIStatus (*trace) 00243 (const CMPIBroker *, int level, const char *component, 00244 const char *text, const CMPIString * string); 00245 00246 # ifdef CMPI_VER_200 00247 00256 CMPIError* (*newCMPIError) 00257 (const CMPIBroker*, const char*, const char*, const char*, 00258 const CMPIErrorSeverity, const CMPIErrorProbableCause,const CMPIrc, 00259 CMPIStatus *rc); 00266 CMPIStatus (*openMessageFile) 00267 (const CMPIBroker* mb, const char *msgFile, 00268 CMPIMsgFileHandle* msgFileHandle); 00269 00275 CMPIStatus (*closeMessageFile) 00276 (const CMPIBroker* mb, const CMPIMsgFileHandle msgFileHandle); 00277 00287 CMPIString* (*getMessage2) 00288 (const CMPIBroker* mb, const char *msgId, 00289 const CMPIMsgFileHandle msgFileHandle, const char *defMsg, 00290 CMPIStatus* rc, CMPICount count, ...); 00291 # endif /* CMPI_VER_200 */ 00292 00293 }; 00294 00295 00296 00297 //--------------------------------------------------- 00298 //-- 00299 // _CMPIBrokerFT Function Table 00300 //-- 00301 //--------------------------------------------------- 00302 00303 00308 struct _CMPIBrokerFT 00309 { 00310 00314 unsigned int brokerCapabilities; 00317 unsigned int brokerVersion; 00320 const char *brokerName; 00321 00330 CMPIContext *(*prepareAttachThread) 00331 (const CMPIBroker * mb, const CMPIContext * ctx); 00332 00339 CMPIStatus (*attachThread) (const CMPIBroker *, const CMPIContext *); 00340 00348 CMPIStatus (*detachThread) 00349 (const CMPIBroker * mb, const CMPIContext * ctx); 00350 00351 // class 0 services 00352 00361 CMPIStatus (*deliverIndication) 00362 (const CMPIBroker * mb, const CMPIContext * ctx, 00363 const char *ns, const CMPIInstance * ind); 00364 // class 1 services 00365 00373 CMPIEnumeration *(*enumerateInstanceNames) 00374 (const CMPIBroker * mb, const CMPIContext * ctx, 00375 const CMPIObjectPath * op, CMPIStatus * rc); 00376 00388 CMPIInstance *(*getInstance) 00389 (const CMPIBroker * mb, const CMPIContext * ctx, 00390 const CMPIObjectPath * op, const char **properties, CMPIStatus * rc); 00391 00392 // class 2 services 00393 00402 CMPIObjectPath *(*createInstance) 00403 (const CMPIBroker * mb, const CMPIContext * ctx, 00404 const CMPIObjectPath * op, const CMPIInstance * inst, CMPIStatus * rc); 00405 00413 CMPIStatus (*modifyInstance) 00414 (const CMPIBroker * mb, const CMPIContext * ctx, 00415 const CMPIObjectPath * op, const CMPIInstance * inst, 00416 const char **properties); 00417 00424 CMPIStatus (*deleteInstance) 00425 (const CMPIBroker * mb, const CMPIContext * ctx, 00426 const CMPIObjectPath * op); 00427 00438 CMPIEnumeration *(*execQuery) 00439 (const CMPIBroker * mb, const CMPIContext * ctx, 00440 const CMPIObjectPath * op, const char *query, const char *lang, 00441 CMPIStatus * rc); 00442 00455 CMPIEnumeration *(*enumerateInstances) 00456 (const CMPIBroker * mb, const CMPIContext * ctx, 00457 const CMPIObjectPath * op, const char **properties, CMPIStatus * rc); 00458 00489 CMPIEnumeration *(*associators) 00490 (const CMPIBroker * mb, const CMPIContext * ctx, 00491 const CMPIObjectPath * op, const char *assocClass, 00492 const char *resultClass, const char *role, const char *resultRole, 00493 const char **properties, CMPIStatus * rc); 00494 00522 CMPIEnumeration *(*associatorNames) 00523 (const CMPIBroker * mb, const CMPIContext * ctx, 00524 const CMPIObjectPath * op, const char *assocClass, 00525 const char *resultClass, const char *role, const char *resultRole, 00526 CMPIStatus * rc); 00527 00549 CMPIEnumeration *(*references) 00550 (const CMPIBroker * mb, const CMPIContext * ctx, 00551 const CMPIObjectPath * op, const char *resultClass, const char *role, 00552 const char **properties, CMPIStatus * rc); 00553 00572 CMPIEnumeration *(*referenceNames) 00573 (const CMPIBroker * mb, const CMPIContext * ctx, 00574 const CMPIObjectPath * op, const char *resultClass, const char *role, 00575 CMPIStatus * rc); 00576 00588 CMPIData (*invokeMethod) 00589 (const CMPIBroker * mb, const CMPIContext * ctx, 00590 const CMPIObjectPath * op, const char *method, 00591 const CMPIArgs * in, CMPIArgs * out, CMPIStatus * rc); 00592 00602 CMPIStatus (*setProperty) 00603 (const CMPIBroker * mb, const CMPIContext * ctx, 00604 const CMPIObjectPath * op, const char *name, const CMPIValue * value, 00605 CMPIType type); 00606 00615 CMPIData (*getProperty) 00616 (const CMPIBroker * mb, const CMPIContext * ctx, 00617 const CMPIObjectPath * op, const char *name, CMPIStatus * rc); 00618 }; 00619 00620 00621 //--------------------------------------------------- 00622 //-- 00623 // _CMPIBrokerExtFT Function Table 00624 //-- 00625 //--------------------------------------------------- 00626 00627 00628 struct timespec; 00629 00635 struct _CMPIBrokerExtFT 00636 { 00639 int ftVersion; 00648 char *(*resolveFileName) (const char *filename); 00649 00650 00657 CMPI_THREAD_TYPE (*newThread) 00658 (CMPI_THREAD_RETURN (CMPI_THREAD_CDECL * start) (void *), void *parm, 00659 int detached); 00660 00666 int (*joinThread) (CMPI_THREAD_TYPE thread, CMPI_THREAD_RETURN * retval); 00667 00672 int (*exitThread) (CMPI_THREAD_RETURN return_code); 00673 00678 int (*cancelThread) (CMPI_THREAD_TYPE thread); 00679 00684 int (*threadSleep) (CMPIUint32 msec); 00685 00691 int (*threadOnce) (int *once, void (*init) (void)); 00692 00693 /* Create a POSIX threading conformant thread key. This key can be used as a key to access the thread local store. 00694 @param key The address for the key to be returned. 00695 @param cleanup Function to be invoked during thread local store cleanup. 00696 @return Completion code as defined by POSIX threading semantics. 00697 */ 00698 int (*createThreadKey) 00699 (CMPI_THREAD_KEY_TYPE * key, void (*cleanup) (void *)); 00700 00705 int (*destroyThreadKey) (CMPI_THREAD_KEY_TYPE key); 00706 00711 void *(*getThreadSpecific) (CMPI_THREAD_KEY_TYPE key); 00712 00718 int (*setThreadSpecific) (CMPI_THREAD_KEY_TYPE key, void *value); 00719 00720 00725 CMPI_MUTEX_TYPE (*newMutex) (int opt); 00726 00730 void (*destroyMutex) (CMPI_MUTEX_TYPE mutex); 00731 00735 void (*lockMutex) (CMPI_MUTEX_TYPE mutex); 00736 00740 void (*unlockMutex) (CMPI_MUTEX_TYPE mutex); 00741 00746 CMPI_COND_TYPE (*newCondition) (int opt); 00747 00751 void (*destroyCondition) (CMPI_COND_TYPE cond); 00752 00759 int (*condWait) (CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex); 00760 00770 int (*timedCondWait) 00771 (CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex, struct timespec * wait); 00772 00777 int (*signalCondition) (CMPI_COND_TYPE cond); 00778 }; 00779 00780 00781 00782 # if defined (CMPI_VER_200) 00783 //--------------------------------------------------- 00784 //-- 00785 // _CMPIBroker Memory Function Table 00786 //-- 00787 //--------------------------------------------------- 00788 00795 struct _CMPIBrokerMemFT 00796 { 00797 00798 const int ftVersion; 00799 00807 CMPIGcStat *(*mark) (const CMPIBroker * mb, CMPIStatus * rc); 00808 00815 CMPIStatus (*release) (const CMPIBroker * mb, const CMPIGcStat * gc); 00816 00823 void *(*cmpiMalloc) (const CMPIBroker * mb, size_t size); 00824 00833 void *(*cmpiCalloc) (const CMPIBroker * mb, size_t, size_t); 00834 00847 void *(*cmpiRealloc) (const CMPIBroker * mb, void *, size_t); 00848 00849 00857 char *(*cmpiStrDup) (const CMPIBroker * mb, const char *); 00858 00866 void (*cmpiFree) (const CMPIBroker * mb, void *); 00867 00876 void (*freeInstance) (const CMPIBroker * mb, CMPIInstance * inst); 00877 00886 void (*freeObjectPath) (const CMPIBroker * mb, CMPIObjectPath * obj); 00887 00896 void (*freeArgs) (const CMPIBroker * mb, CMPIArgs * args); 00897 00906 void (*freeString) (const CMPIBroker * mb, CMPIString * str); 00907 00916 void (*freeArray) (const CMPIBroker * mb, CMPIArray * array); 00917 00926 void (*freeDateTime) (const CMPIBroker * mb, CMPIDateTime * date); 00927 00936 void (*freeSelectExp) (const CMPIBroker * mb, CMPISelectExp * se); 00937 }; 00938 00939 # endif 00940 00941 //--------------------------------------------------- 00942 //-- 00943 // _CMPIBroker Encapsulated object 00944 //-- 00945 //--------------------------------------------------- 00946 00947 00950 struct _CMPIBroker 00951 { 00952 00955 void *hdl; 00956 00959 CMPIBrokerFT *bft; 00960 00963 CMPIBrokerEncFT *eft; 00964 00967 CMPIBrokerExtFT *xft; 00968 00969 # ifdef CMPI_VER_200 00970 00972 CMPIBrokerMemFT *mft; 00973 # endif 00974 00975 }; 00976 00977 00978 00979 //--------------------------------------------------- 00980 //-- 00981 // _CMPIContext Function Table 00982 //-- 00983 //--------------------------------------------------- 00984 00985 00989 struct _CMPIContextFT 00990 { 00991 00994 int ftVersion; 00995 01001 CMPIStatus (*release) (CMPIContext * ctx); 01002 01008 CMPIContext *(*clone) (const CMPIContext * ctx, CMPIStatus * rc); 01009 01010 01017 CMPIData (*getEntry) 01018 (const CMPIContext * ctx, const char *name, CMPIStatus * rc); 01019 01027 CMPIData (*getEntryAt) 01028 (const CMPIContext * ctx, CMPICount index, CMPIString ** name, 01029 CMPIStatus * rc); 01030 01035 CMPICount (*getEntryCount) (const CMPIContext * ctx, CMPIStatus * rc); 01036 01044 CMPIStatus (*addEntry) 01045 (const CMPIContext * ctx, const char *name, const CMPIValue * value, 01046 const CMPIType type); 01047 }; 01048 01049 01050 01051 01052 //--------------------------------------------------- 01053 //-- 01054 // _CMPIContext Encapsulated object 01055 //-- 01056 //--------------------------------------------------- 01057 01058 01061 struct _CMPIContext 01062 { 01063 01066 void *hdl; 01067 01070 CMPIContextFT *ft; 01071 }; 01072 01073 01074 01075 01076 //--------------------------------------------------- 01077 //-- 01078 // _CMPIResult Encapsulated object 01079 //-- 01080 //--------------------------------------------------- 01081 01082 01085 struct _CMPIResult 01086 { 01087 01090 void *hdl; 01091 01094 CMPIResultFT *ft; 01095 }; 01096 01097 01098 //--------------------------------------------------- 01099 //-- 01100 // _CMPIResult Function Table 01101 //-- 01102 //--------------------------------------------------- 01103 01104 01109 struct _CMPIResultFT 01110 { 01111 01114 int ftVersion; 01115 01121 CMPIStatus (*release) (CMPIResult * rslt); 01122 01128 CMPIResult *(*clone) (const CMPIResult * rslt, CMPIStatus * rc); 01129 01136 CMPIStatus (*returnData) 01137 (const CMPIResult * rslt, const CMPIValue * value, const CMPIType type); 01138 01144 CMPIStatus (*returnInstance) 01145 (const CMPIResult * rslt, const CMPIInstance * inst); 01146 01152 CMPIStatus (*returnObjectPath) 01153 (const CMPIResult * rslt, const CMPIObjectPath * ref); 01154 01159 CMPIStatus (*returnDone) (const CMPIResult * rslt); 01160 01161 # ifdef CMPI_VER_200 01162 01167 CMPIStatus (*returnError)(const CMPIResult* rslt, 01168 const CMPIError* er); 01169 # endif 01170 }; 01171 01172 # ifdef CMPI_VER_200 01173 struct _CMPIError { 01174 void *hdl; 01175 CMPIErrorFT *ft; 01176 }; 01177 01178 //--------------------------------------------------- 01179 //-- 01180 // _CMPIErrorFT Function Table 01181 //-- 01182 //--------------------------------------------------- 01183 01184 01188 struct _CMPIErrorFT { 01191 CMPISint32 ftVersion; 01197 CMPIStatus (*release)(CMPIError*); 01203 CMPIError* (*clone)(const CMPIError*, CMPIStatus*); 01209 CMPIErrorType (*getErrorType)(const CMPIError*, CMPIStatus*); 01215 CMPIString* (*getOtherErrorType)(const CMPIError*, CMPIStatus*); 01221 CMPIString* (*getOwningEntity)(const CMPIError*, CMPIStatus*); 01227 CMPIString* (*getMessageID)(const CMPIError*, CMPIStatus*); 01233 CMPIString* (*getMessage)(const CMPIError*, CMPIStatus*); 01239 CMPIErrorSeverity (*getPerceivedSeverity)(const CMPIError*, CMPIStatus*); 01245 CMPIErrorProbableCause (*getProbableCause)(const CMPIError*, CMPIStatus*); 01251 CMPIString* (*getProbableCauseDescription)(const CMPIError*, CMPIStatus*); 01257 CMPIArray* (*getRecommendedActions)(const CMPIError*, CMPIStatus*); 01263 CMPIString* (*getErrorSource)(const CMPIError*, CMPIStatus*); 01269 CMPIErrorSrcFormat (*getErrorSourceFormat)(const CMPIError*, CMPIStatus*); 01275 CMPIString* (*getOtherErrorSourceFormat)(const CMPIError*, CMPIStatus*); 01281 CMPIrc (*getCIMStatusCode)(const CMPIError*, CMPIStatus*); 01287 CMPIString* (*getCIMStatusCodeDescription)(const CMPIError*, CMPIStatus*); 01293 CMPIArray* (*getMessageArguments)(const CMPIError*, CMPIStatus*); 01299 CMPIStatus (*setErrorType)(CMPIError*, const CMPIErrorType); 01305 CMPIStatus (*setOtherErrorType)(CMPIError*, const char *); 01311 CMPIStatus (*setProbableCauseDescription)(CMPIError*, const char *); 01317 CMPIStatus (*setRecommendedActions)(CMPIError*, const CMPIArray*); 01323 CMPIStatus (*setErrorSource)(CMPIError*, const char*); 01329 CMPIStatus (*setErrorSourceFormat)(CMPIError*, const CMPIErrorSrcFormat ); 01335 CMPIStatus (*setOtherErrorSourceFormat)(CMPIError*, const char*); 01341 CMPIStatus (*setCIMStatusCodeDescription)(CMPIError*, const char*); 01348 CMPIStatus (*setMessageArguments)(CMPIError*, CMPIArray*); 01349 }; 01350 # endif /* CMPI_VER_200 */ 01351 01352 01353 //--------------------------------------------------- 01354 //-- 01355 // _CMPIInstance Encapsulated object 01356 //-- 01357 //--------------------------------------------------- 01358 01359 01362 struct _CMPIInstance 01363 { 01364 01367 void *hdl; 01368 01371 CMPIInstanceFT *ft; 01372 }; 01373 01374 01375 01376 //--------------------------------------------------- 01377 //-- 01378 // _CMPIInstance Function Table 01379 //-- 01380 //--------------------------------------------------- 01381 01382 01386 struct _CMPIInstanceFT 01387 { 01388 01391 int ftVersion; 01392 01398 CMPIStatus (*release) (CMPIInstance * inst); 01399 01406 CMPIInstance *(*clone) (const CMPIInstance * inst, CMPIStatus * rc); 01407 01414 CMPIData (*getProperty) 01415 (const CMPIInstance * inst, const char *name, CMPIStatus * rc); 01416 01424 CMPIData (*getPropertyAt) 01425 (const CMPIInstance * inst, CMPICount index, CMPIString ** name, 01426 CMPIStatus * rc); 01432 CMPICount (*getPropertyCount) 01433 (const CMPIInstance * inst, CMPIStatus * rc); 01434 01442 CMPIStatus (*setProperty) 01443 (const CMPIInstance * inst, const char *name, 01444 const CMPIValue * value, CMPIType type); 01445 01452 CMPIObjectPath *(*getObjectPath) 01453 (const CMPIInstance * inst, CMPIStatus * rc); 01454 01463 CMPIStatus (*setPropertyFilter) 01464 (CMPIInstance * inst, const char **propertyList, const char **keys); 01465 01475 CMPIStatus (*setObjectPath) (CMPIInstance * inst, 01476 const CMPIObjectPath * op); 01477 #ifdef CMPI_VER_200 01478 01488 CMPIStatus (*setPropertyWithOrigin)(const CMPIInstance*, const char*, 01489 const CMPIValue*, const CMPIType, const char*); 01490 #endif /* CMPI_VER_200 */ 01491 01492 }; 01493 01494 01495 01496 01497 //--------------------------------------------------- 01498 //-- 01499 // _CMPIObjectPath Encapsulated object 01500 //-- 01501 //--------------------------------------------------- 01502 01503 01506 struct _CMPIObjectPath 01507 { 01508 01511 void *hdl; 01512 01515 CMPIObjectPathFT *ft; 01516 }; 01517 01518 01519 01520 //--------------------------------------------------- 01521 //-- 01522 // _CMPIObjectPath Function Table 01523 //-- 01524 //--------------------------------------------------- 01525 01526 01530 struct _CMPIObjectPathFT 01531 { 01532 01535 int ftVersion; 01536 01542 CMPIStatus (*release) (CMPIObjectPath * op); 01543 01550 CMPIObjectPath *(*clone) (const CMPIObjectPath * op, CMPIStatus * rc); 01551 01557 CMPIStatus (*setNameSpace) (CMPIObjectPath * op, const char *ns); 01558 01564 CMPIString *(*getNameSpace) (const CMPIObjectPath * op, CMPIStatus * rc); 01565 01571 CMPIStatus (*setHostname) (CMPIObjectPath * op, const char *hn); 01572 01578 CMPIString *(*getHostname) (const CMPIObjectPath * op, CMPIStatus * rc); 01579 01585 CMPIStatus (*setClassName) (CMPIObjectPath * op, const char *cn); 01586 01592 CMPIString *(*getClassName) (const CMPIObjectPath * op, CMPIStatus * rc); 01593 01601 CMPIStatus (*addKey) 01602 (CMPIObjectPath * op, const char *name, 01603 const CMPIValue * value, const CMPIType type); 01604 01611 CMPIData (*getKey) 01612 (const CMPIObjectPath * op, const char *name, CMPIStatus * rc); 01613 01621 CMPIData (*getKeyAt) 01622 (const CMPIObjectPath * op, CMPICount index, CMPIString ** name, 01623 CMPIStatus * rc); 01629 CMPICount (*getKeyCount) (const CMPIObjectPath * op, CMPIStatus * rc); 01635 CMPIStatus (*setNameSpaceFromObjectPath) 01636 (CMPIObjectPath * op, const CMPIObjectPath * src); 01637 01643 CMPIStatus (*setHostAndNameSpaceFromObjectPath) 01644 (CMPIObjectPath * op, const CMPIObjectPath * src); 01645 01646 01647 01648 // optional qualifier support 01649 01650 01657 CMPIData (*getClassQualifier) 01658 (const CMPIObjectPath * op, const char *qName, CMPIStatus * rc); 01659 01667 CMPIData (*getPropertyQualifier) 01668 (const CMPIObjectPath * op, 01669 const char *pName, const char *qName, CMPIStatus * rc); 01670 01678 CMPIData (*getMethodQualifier) 01679 (const CMPIObjectPath * op, 01680 const char *methodName, const char *qName, CMPIStatus * rc); 01681 01690 CMPIData (*getParameterQualifier) 01691 (const CMPIObjectPath * op, 01692 const char *mName, 01693 const char *pName, const char *qName, CMPIStatus * rc); 01694 01700 CMPIString *(*toString) (const CMPIObjectPath * op, CMPIStatus * rc); 01701 01702 }; 01703 01704 01705 01706 01707 //--------------------------------------------------- 01708 //-- 01709 // _CMPISelectExp Encapsulated object 01710 //-- 01711 //--------------------------------------------------- 01712 01713 01716 struct _CMPISelectExp 01717 { 01718 01721 void *hdl; 01722 01725 CMPISelectExpFT *ft; 01726 }; 01727 01728 01729 01730 //--------------------------------------------------- 01731 //-- 01732 // _CMPISelectExpFT Function Table 01733 //-- 01734 //--------------------------------------------------- 01735 01736 01740 struct _CMPISelectExpFT 01741 { 01742 01745 int ftVersion; 01746 01752 CMPIStatus (*release) (CMPISelectExp * se); 01753 01760 CMPISelectExp *(*clone) (const CMPISelectExp * se, CMPIStatus * rc); 01761 01768 CMPIBoolean (*evaluate) 01769 (const CMPISelectExp * se, const CMPIInstance * inst, CMPIStatus * rc); 01770 01776 CMPIString *(*getString) (const CMPISelectExp * se, CMPIStatus * rc); 01777 01783 CMPISelectCond *(*getDOC) (const CMPISelectExp * se, CMPIStatus * rc); 01784 01790 CMPISelectCond *(*getCOD) (const CMPISelectExp * se, CMPIStatus * rc); 01791 01799 CMPIBoolean (*evaluateUsingAccessor) 01800 (const CMPISelectExp * se, CMPIAccessor * accessor, void *parm, 01801 CMPIStatus * rc); 01802 }; 01803 01804 01805 01806 //--------------------------------------------------- 01807 //-- 01808 // _CMPISelectCond Encapsulated object 01809 //-- 01810 //--------------------------------------------------- 01811 01812 01815 struct _CMPISelectCond 01816 { 01817 01820 void *hdl; 01821 01824 CMPISelectCondFT *ft; 01825 }; 01826 01827 01828 01829 //--------------------------------------------------- 01830 //-- 01831 // _CMPISelectCondFT Function Table 01832 //-- 01833 //--------------------------------------------------- 01834 01835 01839 struct _CMPISelectCondFT 01840 { 01841 01844 const int ftVersion; 01845 01851 CMPIStatus (*release) (CMPISelectCond * sc); 01852 01859 CMPISelectCond *(*clone) (const CMPISelectCond * sc, CMPIStatus * rc); 01860 01868 CMPICount (*getCountAndType) 01869 (const CMPISelectCond * sc, int* type, CMPIStatus * rc); 01870 01877 CMPISubCond *(*getSubCondAt) 01878 (const CMPISelectCond * sc, CMPICount index, CMPIStatus * rc); 01879 }; 01880 01881 01882 01883 01884 //--------------------------------------------------- 01885 //-- 01886 // _CMPISubCond Encapsulated object 01887 //-- 01888 //--------------------------------------------------- 01889 01890 01893 struct _CMPISubCond 01894 { 01895 01898 void *hdl; 01899 01902 CMPISubCondFT *ft; 01903 }; 01904 01905 01906 01907 //--------------------------------------------------- 01908 //-- 01909 // _CMPISubCondFT Function Table 01910 //-- 01911 //--------------------------------------------------- 01912 01913 01917 struct _CMPISubCondFT 01918 { 01919 01922 int ftVersion; 01923 01929 CMPIStatus (*release) (CMPISubCond * sc); 01930 01937 CMPISubCond *(*clone) (const CMPISubCond * sc, CMPIStatus * rc); 01938 01944 CMPICount (*getCount) (const CMPISubCond * sc, CMPIStatus * rc); 01945 01952 CMPIPredicate *(*getPredicateAt) 01953 (const CMPISubCond * sc, CMPICount index, CMPIStatus * rc); 01954 01961 CMPIPredicate *(*getPredicate) 01962 (const CMPISubCond * sc, const char *name, CMPIStatus * rc); 01963 }; 01964 01965 01966 01967 01968 //--------------------------------------------------- 01969 //-- 01970 // _CMPIPredicate Encapsulated object 01971 //-- 01972 //--------------------------------------------------- 01973 01974 01977 struct _CMPIPredicate 01978 { 01979 01982 void *hdl; 01983 01986 CMPIPredicateFT *ft; 01987 }; 01988 01989 01990 01991 01992 //--------------------------------------------------- 01993 //-- 01994 // _CMPIPredicateFT Function Table 01995 //-- 01996 //--------------------------------------------------- 01997 01998 02002 struct _CMPIPredicateFT 02003 { 02004 02007 int ftVersion; 02008 02014 CMPIStatus (*release) (CMPIPredicate * pr); 02015 02022 CMPIPredicate *(*clone) (const CMPIPredicate * pr, CMPIStatus * rc); 02023 02032 CMPIStatus (*getData) 02033 (const CMPIPredicate * pr, CMPIType * type, 02034 CMPIPredOp * op, CMPIString ** lhs, CMPIString ** rhs); 02035 02048 CMPIBoolean (*evaluateUsingAccessor) 02049 (const CMPIPredicate * pr, CMPIAccessor * accessorFnc, void *parm, 02050 CMPIStatus * rc); 02051 }; 02052 02053 02054 02055 02056 //--------------------------------------------------- 02057 //-- 02058 // _CMPIArgs Encapsulated object 02059 //-- 02060 //--------------------------------------------------- 02061 02062 02065 struct _CMPIArgs 02066 { 02067 02070 void *hdl; 02071 02074 CMPIArgsFT *ft; 02075 }; 02076 02077 02078 02079 //--------------------------------------------------- 02080 //-- 02081 // _CMPIArgsFT Function Table 02082 //-- 02083 //--------------------------------------------------- 02084 02085 02089 struct _CMPIArgsFT 02090 { 02091 02094 int ftVersion; 02095 02101 CMPIStatus (*release) (CMPIArgs * as); 02102 02109 CMPIArgs *(*clone) (const CMPIArgs * as, CMPIStatus * rc); 02110 02118 CMPIStatus (*addArg) 02119 (const CMPIArgs * as, const char *name, const CMPIValue * value, 02120 const CMPIType type); 02121 02128 CMPIData (*getArg) 02129 (const CMPIArgs * as, const char *name, CMPIStatus * rc); 02130 02138 CMPIData (*getArgAt) 02139 (const CMPIArgs * as, CMPICount index, CMPIString ** name, 02140 CMPIStatus * rc); 02141 02147 CMPICount (*getArgCount) (const CMPIArgs * as, CMPIStatus * rc); 02148 }; 02149 02150 02151 02152 02153 //--------------------------------------------------- 02154 //-- 02155 // _CMPIString Encapsulated object 02156 //-- 02157 //--------------------------------------------------- 02158 02159 02162 struct _CMPIString 02163 { 02164 02167 void *hdl; 02168 02171 CMPIStringFT *ft; 02172 }; 02173 02174 02175 02176 //--------------------------------------------------- 02177 //-- 02178 // _CMPIStringFT Function Table 02179 //-- 02180 //--------------------------------------------------- 02181 02182 02186 struct _CMPIStringFT 02187 { 02188 02191 int ftVersion; 02192 02198 CMPIStatus (*release) (CMPIString * st); 02199 02206 CMPIString *(*clone) (const CMPIString * st, CMPIStatus * rc); 02207 02213 const char *(*getCharPtr) (const CMPIString * st, CMPIStatus * rc); 02214 }; 02215 02216 02217 02218 02219 //--------------------------------------------------- 02220 //-- 02221 // _CMPIArray Encapsulated object 02222 //-- 02223 //--------------------------------------------------- 02224 02225 02228 struct _CMPIArray 02229 { 02230 02233 void *hdl; 02234 02237 CMPIArrayFT *ft; 02238 }; 02239 02240 02241 02242 //--------------------------------------------------- 02243 //-- 02244 // _CMPIArrayFT Function Table 02245 //-- 02246 //--------------------------------------------------- 02247 02248 02252 struct _CMPIArrayFT 02253 { 02254 02257 int ftVersion; 02258 02264 CMPIStatus (*release) (CMPIArray * ar); 02265 02272 CMPIArray *(*clone) (const CMPIArray * ar, CMPIStatus * rc); 02273 02279 CMPICount (*getSize) (const CMPIArray * ar, CMPIStatus * rc); 02280 02286 CMPIType (*getSimpleType) (const CMPIArray * ar, CMPIStatus * rc); 02287 02294 CMPIData (*getElementAt) 02295 (const CMPIArray * ar, CMPICount index, CMPIStatus * rc); 02296 02304 CMPIStatus (*setElementAt) 02305 (CMPIArray * ar, CMPICount index, const CMPIValue * value, 02306 CMPIType type); 02307 }; 02308 02309 02310 02311 02312 02313 //--------------------------------------------------- 02314 //-- 02315 // _CMPIEnumeration Encapsulated object 02316 //-- 02317 //--------------------------------------------------- 02318 02319 02322 struct _CMPIEnumeration 02323 { 02324 02327 void *hdl; 02328 02331 CMPIEnumerationFT *ft; 02332 }; 02333 02334 02335 02336 //--------------------------------------------------- 02337 //-- 02338 // _CMPIEnumerationFT Function Table 02339 //-- 02340 //--------------------------------------------------- 02341 02342 02346 struct _CMPIEnumerationFT 02347 { 02348 02351 int ftVersion; 02352 02358 CMPIStatus (*release) (CMPIEnumeration * en); 02359 02366 CMPIEnumeration *(*clone) (const CMPIEnumeration * en, CMPIStatus * rc); 02367 02373 CMPIData (*getNext) (const CMPIEnumeration * en, CMPIStatus * rc); 02374 02380 CMPIBoolean (*hasNext) (const CMPIEnumeration * en, CMPIStatus * rc); 02381 02387 CMPIArray *(*toArray) (const CMPIEnumeration * en, CMPIStatus * rc); 02388 }; 02389 02390 02391 02392 02393 02394 //--------------------------------------------------- 02395 //-- 02396 // _CMPIDateTime Encapsulated object 02397 //-- 02398 //--------------------------------------------------- 02399 02400 02403 struct _CMPIDateTime 02404 { 02405 02408 void *hdl; 02409 02412 CMPIDateTimeFT *ft; 02413 }; 02414 02415 02416 02417 //--------------------------------------------------- 02418 //-- 02419 // _CMPIDateTimeFT Function Table 02420 //-- 02421 //--------------------------------------------------- 02422 02423 02427 struct _CMPIDateTimeFT 02428 { 02429 02432 int ftVersion; 02433 02439 CMPIStatus (*release) (CMPIDateTime * dt); 02440 02447 CMPIDateTime *(*clone) (const CMPIDateTime * dt, CMPIStatus * rc); 02448 02455 CMPIUint64 (*getBinaryFormat) (const CMPIDateTime * dt, 02456 CMPIStatus * rc); 02457 02463 CMPIString *(*getStringFormat) (const CMPIDateTime * dt, CMPIStatus * rc); 02464 02470 CMPIBoolean (*isInterval) (const CMPIDateTime * dt, CMPIStatus * rc); 02471 }; 02472 02473 02474 02475 02476 02477 02478 //--------------------------------------------------- 02479 //-- 02480 // _CMPIInstanceMI Instance Provider object 02481 //-- 02482 //--------------------------------------------------- 02483 02484 02487 typedef struct _CMPIInstanceMIFT CMPIInstanceMIFT; 02488 typedef struct _CMPIInstanceMI 02489 { 02490 02493 void *hdl; 02494 02497 CMPIInstanceMIFT *ft; 02498 } CMPIInstanceMI; 02499 02500 02501 02502 //--------------------------------------------------- 02503 //-- 02504 // _CMPIInstanceMIFT Function Table 02505 //-- 02506 //--------------------------------------------------- 02507 02508 02513 struct _CMPIInstanceMIFT 02514 { 02515 02518 int ftVersion; 02519 02522 int miVersion; 02523 02526 const char *miName; 02527 02546 CMPIStatus (*cleanup) 02547 (CMPIInstanceMI * mi, const CMPIContext * ctx, CMPIBoolean terminating); 02548 02562 CMPIStatus (*enumerateInstanceNames) 02563 (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, 02564 const CMPIObjectPath * op); 02565 02582 CMPIStatus (*enumerateInstances) 02583 (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, 02584 const CMPIObjectPath * op, const char **properties); 02585 02602 CMPIStatus (*getInstance) 02603 (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, 02604 const CMPIObjectPath * op, const char **properties); 02605 02619 CMPIStatus (*createInstance) 02620 (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, 02621 const CMPIObjectPath * op, const CMPIInstance * inst); 02622 02635 CMPIStatus (*modifyInstance) 02636 (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, 02637 const CMPIObjectPath * op, const CMPIInstance * inst, 02638 const char **properties); 02639 02653 CMPIStatus (*deleteInstance) 02654 (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, 02655 const CMPIObjectPath * op); 02656 02674 CMPIStatus (*execQuery) 02675 (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, 02676 const CMPIObjectPath * op, const char *query, const char *lang); 02677 }; 02678 02679 02680 02681 02682 02683 02684 //--------------------------------------------------- 02685 //-- 02686 // _CMPIAssociationMI Association Provider object 02687 //-- 02688 //--------------------------------------------------- 02689 02690 02693 typedef struct _CMPIAssociationMIFT CMPIAssociationMIFT; 02694 typedef struct _CMPIAssociationMI 02695 { 02696 02699 void *hdl; 02700 02703 CMPIAssociationMIFT *ft; 02704 } CMPIAssociationMI; 02705 02706 02707 //--------------------------------------------------- 02708 //-- 02709 // _CMPIAssociationMIFT Function Table 02710 //-- 02711 //--------------------------------------------------- 02712 02713 02718 struct _CMPIAssociationMIFT 02719 { 02720 02723 int ftVersion; 02724 02727 const CMPISint32 miVersion; 02728 02731 const char *miName; 02732 02750 CMPIStatus (*cleanup) 02751 (CMPIAssociationMI * mi, const CMPIContext * ctx, 02752 CMPIBoolean terminating); 02753 02790 CMPIStatus (*associators) 02791 (CMPIAssociationMI * mi, const CMPIContext * ctx, 02792 const CMPIResult * rslt, const CMPIObjectPath * op, 02793 const char *asscClass, const char *resultClass, const char *role, 02794 const char *resultRole, const char **properties); 02795 02829 CMPIStatus (*associatorNames) 02830 (CMPIAssociationMI * mi, const CMPIContext * ctx, 02831 const CMPIResult * rslt, const CMPIObjectPath * op, 02832 const char *assocClass, const char *resultClass, const char *role, 02833 const char *resultRole); 02834 02862 CMPIStatus (*references) 02863 (CMPIAssociationMI * mi, const CMPIContext * ctx, 02864 const CMPIResult * rslt, const CMPIObjectPath * op, 02865 const char *resultClass, const char *role, const char **properties); 02866 02891 CMPIStatus (*referenceNames) 02892 (CMPIAssociationMI * mi, const CMPIContext * ctx, 02893 const CMPIResult * rslt, const CMPIObjectPath * op, 02894 const char *resultClass, const char *role); 02895 }; 02896 02897 02898 02899 02900 02901 02902 //--------------------------------------------------- 02903 //-- 02904 // _CMPIMethodMI Method Provider object 02905 //-- 02906 //--------------------------------------------------- 02907 02908 02911 typedef struct _CMPIMethodMIFT CMPIMethodMIFT; 02912 typedef struct _CMPIMethodMI 02913 { 02914 02917 void *hdl; 02918 02921 CMPIMethodMIFT *ft; 02922 } CMPIMethodMI; 02923 02924 02925 02926 //--------------------------------------------------- 02927 //-- 02928 // _CMPIMethodMIFT Function Table 02929 //-- 02930 //--------------------------------------------------- 02931 02932 02937 struct _CMPIMethodMIFT 02938 { 02939 02942 int ftVersion; 02943 02946 int miVersion; 02947 02950 const char *miName; 02951 02970 CMPIStatus (*cleanup) 02971 (CMPIMethodMI * mi, const CMPIContext * ctx, CMPIBoolean terminating); 02972 02991 CMPIStatus (*invokeMethod) 02992 (CMPIMethodMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, 02993 const CMPIObjectPath * op, const char *method, const CMPIArgs * in, 02994 CMPIArgs * out); 02995 }; 02996 02997 02998 02999 03000 03001 //--------------------------------------------------- 03002 //-- 03003 // _CMPIPropertyMI Property Provider object 03004 //-- 03005 //--------------------------------------------------- 03006 03007 03010 typedef struct _CMPIPropertyMIFT CMPIPropertyMIFT; 03011 typedef struct _CMPIPropertyMI 03012 { 03013 03016 void *hdl; 03017 03020 CMPIPropertyMIFT *ft; 03021 } CMPIPropertyMI; 03022 03023 03024 03025 //--------------------------------------------------- 03026 //-- 03027 // _CMPIPropertyMIFT Function Table 03028 //-- 03029 //--------------------------------------------------- 03030 03031 03036 struct _CMPIPropertyMIFT 03037 { 03038 03041 int ftVersion; 03042 03045 int miVersion; 03046 03049 const char *miName; 03050 03066 CMPIStatus (*cleanup) 03067 (CMPIPropertyMI * mi, const CMPIContext * ctx, CMPIBoolean terminating); 03068 03081 CMPIStatus (*setProperty) 03082 (CMPIPropertyMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, 03083 const CMPIObjectPath * op, const char *name, const CMPIData data); 03084 03102 CMPIStatus (*getProperty) 03103 (CMPIPropertyMI *, const CMPIContext *, const CMPIResult *, 03104 const CMPIObjectPath *, const char *name); 03105 #ifdef CMPI_VER_200 03106 03118 CMPIStatus (*setPropertyWithOrigin)(CMPIPropertyMI*, const CMPIContext*, 03119 const CMPIResult*, CMPIObjectPath * op, 03120 const char *name, const CMPIData data, const char*); 03121 #endif /* CMPI_VER_200 */ 03122 }; 03123 03124 03125 03126 03127 03128 //--------------------------------------------------- 03129 //-- 03130 // _CMPIIndicationMI Indication Provider object 03131 //-- 03132 //--------------------------------------------------- 03133 03134 03137 typedef struct _CMPIIndicationMIFT CMPIIndicationMIFT; 03138 typedef struct _CMPIIndicationMI 03139 { 03140 03143 void *hdl; 03144 03147 CMPIIndicationMIFT *ft; 03148 } CMPIIndicationMI; 03149 03150 03151 03152 //--------------------------------------------------- 03153 //-- 03154 // _CMPIIndicationMIFT Function Table 03155 //-- 03156 //--------------------------------------------------- 03157 03158 03163 struct _CMPIIndicationMIFT 03164 { 03165 03168 int ftVersion; 03169 03172 int miVersion; 03173 03176 const char *miName; 03177 03197 CMPIStatus (*cleanup) 03198 (CMPIIndicationMI * mi, const CMPIContext * ctx, 03199 CMPIBoolean terminating); 03200 03220 CMPIStatus (*authorizeFilter) (CMPIIndicationMI * mi, 03221 const CMPIContext * ctx, 03222 const CMPISelectExp * filter, 03223 const char *className, 03224 const CMPIObjectPath * op, 03225 const char *owner); 03248 CMPIStatus (*mustPoll) (CMPIIndicationMI * mi, const CMPIContext * ctx, 03249 const CMPISelectExp * filter, 03250 const char *className, 03251 const CMPIObjectPath * classPath); 03252 03275 CMPIStatus (*activateFilter) (CMPIIndicationMI * mi, 03276 const CMPIContext * ctx, 03277 const CMPISelectExp * filter, 03278 const char *className, 03279 const CMPIObjectPath * classPath, 03280 CMPIBoolean firstActivation); 03281 03304 CMPIStatus (*deActivateFilter) (CMPIIndicationMI * mi, 03305 const CMPIContext * ctx, 03306 const CMPISelectExp * filter, 03307 const char *className, 03308 const CMPIObjectPath * classPath, 03309 CMPIBoolean lastActiviation); 03310 03327 CMPIStatus (*enableIndications) (CMPIIndicationMI * mi, 03328 const CMPIContext *); 03343 CMPIStatus (*disableIndications) (CMPIIndicationMI * mi, 03344 const CMPIContext *); 03345 03346 }; 03347 03348 # include "cmpimacs.h" 03349 03350 03351 # ifdef __cplusplus 03352 }; 03353 # endif 03354 03355 #endif // _CMPIFT_H_