00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045 #ifndef _CMPIMACS_H_
00046 # define _CMPIMACS_H_
00047
00048 # ifndef DOC_ONLY
00049 # include "cmpidt.h"
00050 # include "cmpift.h"
00051 # endif
00052
00053 # ifdef DOC_ONLY
00054 # define CMPI_INLINE
00055 # endif
00056
00057 # ifdef DOC_ONLY
00058
00063 noReturn CMReturn (CMPIrc rc);
00064 # else
00065 # define CMReturn(rc) \
00066 { CMPIStatus stat={(rc),NULL}; \
00067 return stat; }
00068 # endif
00069
00070 # ifdef DOC_ONLY
00071
00077 noReturn CMReturnWithString (CMPIrc rc, CMPIString * str);
00078 # else
00079 # define CMReturnWithString(rc,str) \
00080 { CMPIStatus stat={(rc),(str)}; \
00081 return stat; }
00082 # endif
00083
00084 # ifdef DOC_ONLY
00085
00092 noReturn CMReturnWithChars (const CMPIBroker * mb, CMPIrc rc, char *msg);
00093 # else
00094 # define CMReturnWithChars(b,rc,chars) \
00095 { CMPIStatus stat={(rc),NULL}; \
00096 stat.msg=(b)->eft->newString((b),(chars),NULL); \
00097 return stat; }
00098 # endif
00099
00100
00101 # ifdef CMPI_INLINE
00102
00106 inline static void
00107 CMSetStatus (CMPIStatus * st, CMPIrc rcp)
00108 {
00109 if (st)
00110 {
00111 (st)->rc = (rcp);
00112 (st)->msg = NULL;
00113 }
00114 }
00115 # else
00116 # define CMSetStatus(st,rcp) \
00117 { (st)->rc=(rcp); (st)->msg=NULL; }
00118 # endif
00119
00120
00121 # ifdef CMPI_INLINE
00122
00127 inline static void
00128 CMSetStatusWithString (CMPIStatus * st, CMPIrc rcp, const CMPIString * string)
00129 {
00130 if (st)
00131 {
00132 (st)->rc = (rcp);
00133 (st)->msg = (string);
00134 }
00135 }
00136 # else
00137 # define CMSetStatusWithString(st,rcp,string) \
00138 { (st)->rc=(rcp); (st)->msg=(string); }
00139 # endif
00140
00141
00142 # ifdef CMPI_INLINE
00143
00149 inline static void
00150 CMSetStatusWithChars (const CMPIBroker * mb, CMPIStatus * st, CMPIrc rcp,
00151 const char *chars)
00152 {
00153 if (st && mb)
00154 {
00155 (st)->rc = (rcp);
00156 (st)->msg = (mb)->eft->newString ((mb), (chars), NULL);
00157 }
00158 }
00159 # else
00160 # define CMSetStatusWithChars(mb,st,rcp,chars) \
00161 { (st)->rc=(rcp); \
00162 (st)->msg=(mb)->eft->newString((mb),(chars),NULL); }
00163 # endif
00164
00165
00166 # ifdef CMPI_INLINE
00167
00170 inline static CMPIBoolean
00171 CMIsNullObject (const void *obj)
00172 {
00173 return ((obj) == NULL || *((void **) (obj)) == NULL);
00174 }
00175 # else
00176 # define CMIsNullObject(o) ((o)==NULL || *((void**)(o))==NULL)
00177 # endif
00178
00179 # ifdef CMPI_INLINE
00180
00183 inline static CMPIBoolean
00184 CMIsNullValue (const CMPIData val)
00185 {
00186 return ((val.state) & CMPI_nullValue);
00187 }
00188 # else
00189 # define CMIsNullValue(v) ((v.state) & CMPI_nullValue)
00190 # endif
00191
00192 # ifdef CMPI_INLINE
00193
00196 inline static CMPIBoolean
00197 CMIsKeyValue (CMPIData val)
00198 {
00199 return ((val.state) & CMPI_keyValue);
00200 }
00201 # else
00202 # define CMIsKeyValue(v) ((v.state) & CMPI_keyValue)
00203 # endif
00204
00205 # ifdef CMPI_INLINE
00206
00209 inline static CMPIBoolean
00210 CMIsArray (const CMPIData val)
00211 {
00212 return ((val.type) & CMPI_ARRAY);
00213 }
00214 # else
00215 # define CMIsArray(v) ((v.type) & CMPI_ARRAY)
00216 # endif
00217
00218
00219
00220
00221 # define CMClone(o,rc) ((o)->ft->clone((o),(rc)))
00222 # define CMRelease(o) ((o)->ft->release((o)))
00223
00224
00225
00226 # ifdef CMPI_INLINE
00227
00233 inline static CMPIInstance *
00234 CMNewInstance (const CMPIBroker * mb, const CMPIObjectPath * op,
00235 CMPIStatus * rc)
00236 {
00237 return ((mb)->eft->newInstance ((mb), (op), (rc)));
00238 }
00239 # else
00240 # define CMNewInstance(b,c,rc) ((b)->eft->newInstance((b),(c),(rc)))
00241 # endif
00242
00243 # ifdef CMPI_INLINE
00244
00251 inline static CMPIObjectPath *
00252 CMNewObjectPath (const CMPIBroker * mb, const char *ns, const char *cn,
00253 CMPIStatus * rc)
00254 {
00255 return ((mb)->eft->newObjectPath ((mb), (ns), (cn), (rc)));
00256 }
00257 # else
00258 # define CMNewObjectPath(b,n,c,rc) \
00259 ((b)->eft->newObjectPath((b),(n),(c),(rc)))
00260 # endif
00261
00262 # ifdef CMPI_INLINE
00263
00269 inline static CMPIString *
00270 CMNewString (const CMPIBroker * mb, const char *data, CMPIStatus * rc)
00271 {
00272 return ((mb)->eft->newString ((mb), (data), (rc)));
00273 }
00274 # else
00275 # define CMNewString(b,s,rc) ((b)->eft->newString((b),(s),(rc)))
00276 # endif
00277
00278 # ifdef CMPI_INLINE
00279
00284 inline static CMPIArgs *
00285 CMNewArgs (const CMPIBroker * mb, CMPIStatus * rc)
00286 {
00287 return ((mb)->eft->newArgs ((mb), (rc)));
00288 }
00289 # else
00290 # define CMNewArgs(b,rc) ((b)->eft->newArgs((b),(rc)))
00291 # endif
00292
00293 # ifdef CMPI_INLINE
00294
00301 inline static CMPIArray *
00302 CMNewArray (const CMPIBroker * mb, CMPICount max, CMPIType type,
00303 CMPIStatus * rc)
00304 {
00305 return ((mb)->eft->newArray ((mb), (max), (type), (rc)));
00306 }
00307 # else
00308 # define CMNewArray(b,c,t,rc) ((b)->eft->newArray((b),(c),(t),(rc)))
00309 # endif
00310
00311 # ifdef CMPI_INLINE
00312
00317 inline static CMPIDateTime *
00318 CMNewDateTime (const CMPIBroker * mb, CMPIStatus * rc)
00319 {
00320 return ((mb)->eft->newDateTime ((mb), (rc)));
00321 }
00322 # else
00323 # define CMNewDateTime(b,rc) ((b)->eft->newDateTime((b),(rc)))
00324 # endif
00325
00326 # ifdef CMPI_INLINE
00327
00335 inline static CMPIDateTime *CMNewDateTimeFromBinary
00336 (const CMPIBroker * mb, CMPIUint64 binTime, CMPIBoolean interval,
00337 CMPIStatus * rc)
00338 {
00339 return ((mb)->eft->
00340 newDateTimeFromBinary ((mb), (binTime), (interval), (rc)));
00341 }
00342 # else
00343 # define CMNewDateTimeFromBinary(b,d,i,rc) \
00344 ((b)->eft->newDateTimeFromBinary((b),(d),(i),(rc)))
00345 # endif
00346
00347 # ifdef CMPI_INLINE
00348
00354 inline static CMPIDateTime *CMNewDateTimeFromChars
00355 (const CMPIBroker * mb, const char *utcTime, CMPIStatus * rc)
00356 {
00357 return ((mb)->eft->newDateTimeFromChars ((mb), (utcTime), (rc)));
00358 }
00359 # else
00360 # define CMNewDateTimeFromChars(b,d,rc) \
00361 ((b)->eft->newDateTimeFromChars((b),(d),(rc)))
00362 # endif
00363
00364 # ifdef CMPI_INLINE
00365
00374 inline static CMPISelectExp *CMNewSelectExp
00375 (const CMPIBroker * mb, const char *query, const char *lang,
00376 CMPIArray ** projection, CMPIStatus * rc)
00377 {
00378 return ((mb)->eft->
00379 newSelectExp ((mb), (query), (lang), (projection), (rc)));
00380 }
00381 # else
00382 # define CMNewSelectExp(b,q,l,p,rc) \
00383 ((b)->eft->newSelectExp((b),(q),(l),(p),(rc)))
00384 # endif
00385
00386 # ifdef CMPI_INLINE
00387
00395 inline static CMPIBoolean CMClassPathIsA
00396 (const CMPIBroker * mb, const CMPIObjectPath * op, const char *type,
00397 CMPIStatus * rc)
00398 {
00399 return ((mb)->eft->classPathIsA ((mb), (op), (type), (rc)));
00400 }
00401 # else
00402 # define CMClassPathIsA(b,p,pn,rc) \
00403 ((b)->eft->classPathIsA((b),(p),(pn),(rc)))
00404 # endif
00405
00406
00407
00408 # ifdef CMPI_INLINE
00409
00416 inline static CMPIString *CDToString
00417 (const CMPIBroker * mb, const void *object, CMPIStatus * rc)
00418 {
00419 return ((mb)->eft->toString ((mb), (void *) (object), (rc)));
00420 }
00421 # else
00422 # define CDToString(b,o,rc) ((b)->eft->toString((b),(void*)(o),(rc)))
00423 # endif
00424
00425 # ifdef CMPI_INLINE
00426
00435 inline static CMPIBoolean CDIsOfType
00436 (const CMPIBroker * mb, const void *object, const char *type,
00437 CMPIStatus * rc)
00438 {
00439 return ((mb)->eft->isOfType ((mb), (void *) (object), (type), (rc)));
00440 }
00441 # else
00442 # define CDIsOfType(b,o,t,rc) \
00443 (b)->eft->isOfType((b),(void*)(o),(t),(rc))
00444 # endif
00445
00446 # ifdef CMPI_INLINE
00447
00454 inline static CMPIString *CDGetType
00455 (const CMPIBroker * mb, const void *object, CMPIStatus * rc)
00456 {
00457 return ((mb)->eft->getType ((mb), (object), (rc)));
00458 }
00459 # else
00460 # define CDGetType(b,o,rc) ((b)->eft->getType((b),(void*)(o),(rc)))
00461 # endif
00462
00463 # ifdef CMPI_VER_85
00464 # ifdef CMPI_INLINE
00465
00490 inline static CMPIString *CMGetMessage
00491 (const CMPIBroker * b, const char *msgId, const char *defMsg,
00492 CMPIStatus * rc, unsigned int, ...)
00493 # else
00494
00495 # define CMFmtSint(v) CMPI_sint32,((long int)v)
00496 # define CMFmtUint(v) CMPI_uint32,((unsigned long int)v)
00497 # define CMFmtSint64(v) CMPI_sint64,((long long int)v)
00498 # define CMFmtUint64(v) CMPI_uint64,((unsigned long long int)v)
00499 # define CMFmtReal(v) CMPI_real64,((double)v)
00500 # define CMFmtBoolean(v) CMPI_boolean,((int)v)
00501 # define CMFmtChars(v) CMPI_chars,((char*)v)
00502 # define CMFmtString(v) CMPI_String,((CMPI_String*)v)
00503
00504 # define CMFmtArgs0() 0
00505 # define CMFmtArgs1(v1) \
00506 1,v1
00507 # define CMFmtArgs2(v1,v2) \
00508 2,v1,v2
00509 # define CMFmtArgs3(v1,v2,v3) \
00510 3,v1,v2,v3
00511 # define CMFmtArgs4(v1,v2,v3,v4) \
00512 4,v1,v2,v3,v4
00513 # define CMFmtArgs5(v1,v2,v3,v4,v5) \
00514 5,v1,v2,v3,v4,v5
00515 # define CMFmtArgs6(v1,v2,v3,v4,v5,v6) \
00516 6,v1,v2,v3,v4,v5,v6
00517 # define CMFmtArgs7(v1,v2,v3,v4,v5,v6,v7) \
00518 7,v1,v2,v3,v4,v5,v6,v7
00519 # define CMFmtArgs8(v1,v2,v3,v4,v5,v6,v7,v8) \
00520 8,v1,v2,v3,v4,v5,v6,v7,v8
00521 # define CMFmtArgs9(v1,v2,v3,v4,v5,v6,v7,v8,v9) \
00522 9,v1,v2,v3,v4,v5,v6,v7,v8,v9
00523 # define CMFmtArgs10(v1,v2,v3,v4,v5,v6,v7,v8,v9,v10) \
00524 10,v1,v2,v3,v4,v5,v6,v7,v8,v9,v10
00525
00526 # define CMGetMessage(b,id,def,rc,parms) ((b)->eft->getMessage((b),(id),(def),(rc),parms))
00527 # endif
00528 # endif
00529
00530
00531 # ifdef CMPI_VER_100
00532 # ifdef CMPI_INLINE
00533
00544 inline static CMPIStatus CMLogMessage
00545 (const CMPIBroker * b, int severity, const char *id,
00546 const char *text, const CMPIString * string)
00547 {
00548 return ((b)->eft->logMessage ((b), (severity), (id), (text), (string)));
00549 }
00550 # else
00551 # define CMLogMessage(b,severity,id, text, string) ((b)->eft->logMessage((b),(severity),(id),(text),(string)))
00552 # endif
00553 # endif
00554
00555 # ifdef CMPI_VER_100
00556 # ifdef CMPI_INLINE
00557
00568 inline static CMPIStatus CMTraceMessage
00569 (const CMPIBroker * b, int level, const char *component,
00570 const char *text, const CMPIString * string)
00571 {
00572 return ((b)->eft->trace ((b), (level), (component), (text), (string)));
00573 }
00574 # else
00575 # define CMTraceMessage(b,level,component, text, string) ((b)->eft->trace((b),(level),(component),(text),(string)))
00576 # endif
00577 # endif
00578
00579 # ifdef CMPI_VER_200
00580 # ifdef CMPI_INLINE
00581
00593 inline static CMPIError* CMNewCMPIError
00594 (const CMPIBroker* b, const char *owner, const char* msgID, const char* msg,
00595 const CMPIErrorSeverity sev, const CMPIErrorProbableCause pc,
00596 const CMPIrc cimStatusCode, CMPIStatus* rc)
00597 {
00598 return ((b)->eft->newCMPIError ((b), (owner), (msgID), (msg), (sev),
00599 (pc), (cimStatusCode), (rc)));
00600 }
00601 # else
00602 # define CMNewCMPIError(b,owner,msgID,msg,sev,pc,cimStatusCode,rc) \
00603 ((b)->eft->newCMPIError((b),(owner),(msgID),(msg),(sev), \
00604 (pc),(cimStatusCode),(rc)))
00605 # endif
00606 # endif
00607
00608 # ifdef CMPI_VER_200
00609 # ifdef CMPI_INLINE
00610
00617 inline static CMPIStatus CMOpenMessageFile
00618 (const CMPIBroker* b, const char *msgFile, CMPIMsgFileHandle *msgFileHandle)
00619 {
00620 return ((b)->eft->openMessageFile ((b), (msgFile), (msgFileHandle)));
00621 }
00622 # else
00623 # define CMOpenMessageFile(b,mf,mfh) ((b)->eft->openMessageFile((b),(mf),(mfh)))
00624 # endif
00625 # endif
00626
00627 # ifdef CMPI_VER_200
00628 # ifdef CMPI_INLINE
00629
00635 inline static CMPIStatus CMCloseMessageFile
00636 (const CMPIBroker* b, const CMPIMsgFileHandle msgFilehandle)
00637 {
00638 return ((b)->eft->closeMessageFile ((b), (msgFileHandle)));
00639 }
00640 # else
00641 # define CMCloseMessageFile(b,mfh) ((b)->eft->closeMessageFile((b),(mfh)))
00642 # endif
00643 # endif
00644
00645 # ifdef CMPI_VER_200
00646 # ifdef CMPI_INLINE
00647
00674 inline static CMPIString* CMGetMessage2
00675 (const CMPIBroker* mb, const char *msgId,
00676 const CMPIMsgFileHandle msgFilehandle, const char *defMsg,
00677 CMPIStatus* rc, unsigned int, ...);
00678 # else
00679 # define CMGetMessage2(b,id,mfh,def,rc,parms) ((b)->eft->getMessage2((b),(id),(mfh),(def),(rc),parms))
00680 # endif
00681 # endif
00682
00683
00684
00685
00686
00687 # ifdef CMPI_INLINE
00688
00694 inline static CMPIData CMGetProperty
00695 (const CMPIInstance * inst, const char *name, CMPIStatus * rc)
00696 {
00697 return ((inst)->ft->getProperty ((inst), (name), (rc)));
00698 }
00699 # else
00700 # define CMGetProperty(i,n,rc) ((i)->ft->getProperty((i),(n),(rc)))
00701 # endif
00702
00703 # ifdef CMPI_INLINE
00704
00711 inline static CMPIData CMGetPropertyAt
00712 (const CMPIInstance * inst, CMPICount index, CMPIString ** name,
00713 CMPIStatus * rc)
00714 {
00715 return ((inst)->ft->getPropertyAt ((inst), (index), (name), (rc)));
00716 }
00717 # else
00718 # define CMGetPropertyAt(i,num,s,rc) \
00719 ((i)->ft->getPropertyAt((i),(num),(s),(rc)))
00720 # endif
00721
00722 # ifdef CMPI_INLINE
00723
00730 inline static CMPIStatus CMSetProperty
00731 (const CMPIInstance * inst, const char *name,
00732 const CMPIValue * value, CMPIType type)
00733 {
00734 return ((inst)->ft->setProperty ((inst), (name), (value), (type)));
00735 }
00736 # else
00737 # define CMSetProperty(i,n,v,t) \
00738 ((i)->ft->setProperty((i),(n),(CMPIValue*)(v),(t)))
00739 # endif
00740
00741 # ifdef CMPI_INLINE
00742
00747 inline static CMPICount CMGetPropertyCount
00748 (const CMPIInstance * inst, CMPIStatus * rc)
00749 {
00750 return ((inst)->ft->getPropertyCount ((inst), (rc)));
00751 }
00752 # else
00753 # define CMGetPropertyCount(i,rc) ((i)->ft->getPropertyCount((i),(rc)))
00754 # endif
00755
00756 # ifdef CMPI_INLINE
00757
00763 inline static CMPIObjectPath *CMGetObjectPath
00764 (const CMPIInstance * inst, CMPIStatus * rc)
00765 {
00766 return ((inst)->ft->getObjectPath ((inst), (rc)));
00767 }
00768 # else
00769 # define CMGetObjectPath(i,rc) ((i)->ft->getObjectPath((i),(rc)))
00770 # endif
00771
00772 # ifdef CMPI_VER_100
00773 # ifdef CMPI_INLINE
00774
00782 inline static CMPIStatus CMSetObjectPath
00783 (CMPIInstance * inst, const CMPIObjectPath * obj)
00784 {
00785 return ((inst)->ft->setObjectPath ((inst), (obj)));
00786 }
00787 # else
00788 # define CMSetObjectPath(i,obj) ((i)->ft->setObjectPath((i),(obj)))
00789 # endif
00790 # endif
00791
00792 # ifdef CMPI_INLINE
00793
00801 inline static CMPIStatus CMSetPropertyFilter
00802 (CMPIInstance * inst, const char **propertyList, char **keys)
00803 {
00804 return ((inst)->ft->setPropertyFilter ((inst), (propertyList), (keys)));
00805 }
00806 # else
00807 # define CMSetPropertyFilter(i,pl,k) ((i)->ft->setPropertyFilter((i),(pl),(k)))
00808 # endif
00809
00810 # ifdef CMPI_VER_200
00811 # ifdef CMPI_INLINE
00812
00822 inline static CMPIStatus CMSetPropertyWithOrigin
00823 (const CMPIInstance * inst, const char *name,
00824 const CMPIValue * value, CMPIType type, const char * origin)
00825 {
00826 return ((inst)->ft->setPropertyWithOrigin (
00827 (inst), (name), (value), (type), (origin)));
00828 }
00829 # else
00830 # define CMSetPropertyWithOrigin(i,n,v,t,o) \
00831 ((i)->ft->setPropertyWithOrigin((i),(n),(CMPIValue*)(v),(t),(o)))
00832 # endif
00833 # endif
00834
00835
00836
00837
00838
00839 # ifdef CMPI_INLINE
00840
00845 inline static CMPIStatus
00846 CMSetHostname (CMPIObjectPath * op, const char *hn)
00847 {
00848 return ((op)->ft->setHostname ((op), (hn)));
00849 }
00850 # else
00851 # define CMSetHostname(p,n) ((p)->ft->setHostname((p),(n)))
00852 # endif
00853
00854 # ifdef CMPI_INLINE
00855
00860 inline static CMPIString *CMGetHostname
00861 (const CMPIObjectPath * op, CMPIStatus * rc)
00862 {
00863 return ((op)->ft->getHostname ((op), (rc)));
00864 }
00865 # else
00866 # define CMGetHostname(p,rc) ((p)->ft->getHostname((p),(rc)))
00867 # endif
00868
00869 # ifdef CMPI_INLINE
00870
00875 inline static CMPIStatus
00876 CMSetNameSpace (CMPIObjectPath * op, const char *ns)
00877 {
00878 return ((op)->ft->setNameSpace ((op), (ns)));
00879 }
00880 # else
00881 # define CMSetNameSpace(p,n) ((p)->ft->setNameSpace((p),(n)))
00882 # endif
00883
00884 # ifdef CMPI_INLINE
00885
00890 inline static CMPIString *CMGetNameSpace
00891 (const CMPIObjectPath * op, CMPIStatus * rc)
00892 {
00893 return ((op)->ft->getNameSpace ((op), (rc)));
00894 }
00895 # else
00896 # define CMGetNameSpace(p,rc) ((p)->ft->getNameSpace((p),(rc)))
00897 # endif
00898
00899 # ifdef CMPI_INLINE
00900
00905 inline static CMPIStatus
00906 CMSetClassName (CMPIObjectPath * op, const char *cn)
00907 {
00908 return ((op)->ft->setClassName ((op), (cn)));
00909 }
00910 # else
00911 # define CMSetClassName(p,n) ((p)->ft->setClassName((p),(n)))
00912 # endif
00913
00914 # ifdef CMPI_INLINE
00915
00920 inline static CMPIString *CMGetClassName
00921 (const CMPIObjectPath * op, CMPIStatus * rc)
00922 {
00923 return ((op)->ft->getClassName ((op), (rc)));
00924 }
00925 # else
00926 # define CMGetClassName(p,rc) ((p)->ft->getClassName((p),(rc)))
00927 # endif
00928
00929 # ifdef CMPI_INLINE
00930
00937 inline static CMPIStatus CMAddKey
00938 (CMPIObjectPath * op, const char *name,
00939 const CMPIValue * value, const CMPIType type)
00940 {
00941 return ((op)->ft->addKey ((op), (name), (value), (type)));
00942 }
00943 # else
00944 # define CMAddKey(p,n,v,t) \
00945 ((p)->ft->addKey((p),(n),(CMPIValue*)(v),(t)))
00946 # endif
00947
00948 # ifdef CMPI_INLINE
00949
00955 inline static CMPIData CMGetKey
00956 (const CMPIObjectPath * op, const char *name, CMPIStatus * rc)
00957 {
00958 return ((op)->ft->getKey ((op), (name), (rc)));
00959 }
00960 # else
00961 # define CMGetKey(p,n,rc) ((p)->ft->getKey((p),(n),(rc)))
00962 # endif
00963
00964 # ifdef CMPI_INLINE
00965
00972 inline static CMPIData CMGetKeyAt
00973 (const CMPIObjectPath * op, CMPICount index, CMPIString ** name,
00974 CMPIStatus * rc)
00975 {
00976 return ((op)->ft->getKeyAt ((op), (index), (name), (rc)));
00977 }
00978 # else
00979 # define CMGetKeyAt(p,i,n,rc) ((p)->ft->getKeyAt((p),(i),(n),(rc)))
00980 # endif
00981
00982
00983 # ifdef CMPI_INLINE
00984
00989 inline static CMPICount CMGetKeyCount
00990 (const CMPIObjectPath * op, CMPIStatus * rc)
00991 {
00992 return ((op)->ft->getKeyCount ((op), (rc)));
00993 }
00994 # else
00995 # define CMGetKeyCount(p,rc) ((p)->ft->getKeyCount((p),(rc)))
00996 # endif
00997
00998 # ifdef CMPI_INLINE
00999
01004 inline static CMPIStatus CMSetNameSpaceFromObjectPath
01005 (CMPIObjectPath * op, const CMPIObjectPath * src)
01006 {
01007 return ((op)->ft->setNameSpaceFromObjectPath ((op), (src)));
01008 }
01009 # else
01010 # define CMSetNameSpaceFromObjectPath(p,s) \
01011 ((p)->ft->setNameSpaceFromObjectPath((p),(s)))
01012 # endif
01013
01014 # ifdef CMPI_INLINE
01015
01020 inline static CMPIStatus CMSetHostAndNameSpaceFromObjectPath
01021 (CMPIObjectPath * op, const CMPIObjectPath * src)
01022 {
01023 return ((op)->ft->setHostAndNameSpaceFromObjectPath ((op), (src)));
01024 }
01025 # else
01026 # define CMSetHostAndNameSpaceFromObjectPath(p,s) \
01027 ((p)->ft->setHostAndNameSpaceFromObjectPath((p),(s)))
01028 # endif
01029
01030 #ifdef CMPI_INLINE
01031
01037 inline static CMPIData CMGetClassQualifier
01038 (const CMPIObjectPath* op,
01039 const char *qName,
01040 CMPIStatus *rc)
01041 { return ((op)->ft->getClassQualifier((op),(qName),(rc))); }
01042 #else
01043 #define CMGetClassQualifier(op,qName,rc) \
01044 ((op)->ft->getClassQualifier((op),(qName),(rc)))
01045 #endif
01046
01047 #ifdef CMPI_INLINE
01048
01055 inline static CMPIData CMGetPropertyQualifier
01056 (const CMPIObjectPath* op,
01057 const char *pName,
01058 const char *qName,
01059 CMPIStatus *rc)
01060 { return ((op)->ft->getPropertyQualifier((op),(pName),(qName),(rc))); }
01061 #else
01062 #define CMGetPropertyQualifier(op,pName,qName,rc) \
01063 ((op)->ft->getPropertyQualifier((op),(pName),(qName),(rc)))
01064 #endif
01065
01066 #ifdef CMPI_INLINE
01067
01074 inline static CMPIData CMGetMethodQualifier
01075 (const CMPIObjectPath* op,
01076 const char *methodName,
01077 const char *qName,
01078 CMPIStatus *rc)
01079 { return ((op)->ft->getMethodQualifier((op),(methodName),(qName),(rc))); }
01080 #else
01081 #define CMGetMethodQualifier(op,methodName,qName,rc) \
01082 ((op)->ft->getMethodQualifier((op),(methodName),(qName),(rc)))
01083 #endif
01084
01085 #ifdef CMPI_INLINE
01086
01094 inline static CMPIData CMGetParameterQualifier
01095 (const CMPIObjectPath* op,
01096 const char *mName,
01097 const char *pName,
01098 const char *qName,
01099 CMPIStatus *rc)
01100 { return ((op)->ft->getParameterQualifier((op),(mName),(pName),(qName),(rc))); }
01101 #else
01102 #define CMGetParameterQualifier(op,mName,pName,qName,rc) \
01103 ((op)->ft->getParameterQualifier((op),(mName),(pName),(qName),(rc)))
01104 #endif
01105
01106 # ifdef CMPI_VER_86
01107 # ifdef CMPI_INLINE
01108
01113 inline static CMPIString *CMObjectPathToString
01114 (const CMPIObjectPath * op, CMPIStatus * rc)
01115 {
01116 return ((op)->ft->toString ((op), (rc)));
01117 }
01118 # else
01119 # define CMObjectPathToString(p,rc) \
01120 ((p)->ft->toString((p),(rc)))
01121 # endif
01122 # endif
01123
01124
01125
01126
01127 # ifdef CMPI_INLINE
01128
01133 inline static CMPICount CMGetArrayCount
01134 (const CMPIArray * ar, CMPIStatus * rc)
01135 {
01136 return ((ar)->ft->getSize ((ar), (rc)));
01137 }
01138 # else
01139 # define CMGetArrayCount(a,rc) ((a)->ft->getSize((a),(rc)))
01140 # endif
01141
01142 # ifdef CMPI_INLINE
01143
01148 inline static CMPIType
01149 CMGetArrayType (const CMPIArray * ar, CMPIStatus * rc)
01150 {
01151 return ((ar)->ft->getSimpleType ((ar), (rc)));
01152 }
01153 # else
01154 # define CMGetArrayType(a,rc) ((a)->ft->getSimpleType((a),(rc)))
01155 # endif
01156
01157 # ifdef CMPI_INLINE
01158
01164 inline static CMPIData CMGetArrayElementAt
01165 (const CMPIArray * ar, CMPICount index, CMPIStatus * rc)
01166 {
01167 return ((ar)->ft->getElementAt ((ar), (index), (rc)));
01168 }
01169 # else
01170 # define CMGetArrayElementAt(a,n,rc) \
01171 ((a)->ft->getElementAt((a),(n),(rc)))
01172 # endif
01173
01174 # ifdef CMPI_INLINE
01175
01182 inline static CMPIStatus CMSetArrayElementAt
01183 (CMPIArray * ar, CMPICount index, const CMPIValue * value, CMPIType type)
01184 {
01185 return ((ar)->ft->setElementAt ((ar), (index), (value), (type)));
01186 }
01187 # else
01188 # define CMSetArrayElementAt(a,n,v,t) \
01189 ((a)->ft->setElementAt((a),(n),(CMPIValue*)(v),(t)))
01190 # endif
01191
01192
01193
01194
01195
01196
01197 # ifdef CMPI_INLINE
01198
01205 inline static CMPIStatus CMAddArg
01206 (CMPIArgs * as, char *name, const CMPIValue * value, const CMPIType type)
01207 {
01208 return ((as)->ft->addArg ((as), (name), (CMPIValue*)(value), (type)));
01209 }
01210 # else
01211 # define CMAddArg(a,n,v,t) \
01212 ((a)->ft->addArg((a),(n),(CMPIValue*)(v),(t)))
01213 # endif
01214
01215 # ifdef CMPI_INLINE
01216
01222 inline static CMPIData CMGetArg
01223 (const CMPIArgs * as, const char *name, CMPIStatus * rc)
01224 {
01225 return ((as)->ft->getArg ((as), (name), (rc)));
01226 }
01227 # else
01228 # define CMGetArg(a,n,rc) ((a)->ft->getArg((a),(n),(rc)))
01229 # endif
01230
01231 # ifdef CMPI_INLINE
01232
01239 inline static CMPIData CMGetArgAt
01240 (const CMPIArgs * as, CMPICount index, CMPIString ** name, CMPIStatus * rc)
01241 {
01242 return ((as)->ft->getArgAt ((as), (index), (name), (rc)));
01243 }
01244 # else
01245 # define CMGetArgAt(a,p,n,rc) ((a)->ft->getArgAt((a),(p),(n),(rc)))
01246 # endif
01247
01248 # ifdef CMPI_INLINE
01249
01254 inline static CMPICount CMGetArgCount (const CMPIArgs * as, CMPIStatus * rc)
01255 {
01256 return ((as)->ft->getArgCount ((as), (rc)));
01257 }
01258 # else
01259 # define CMGetArgCount(a,rc) ((a)->ft->getArgCount((a),(rc)))
01260 # endif
01261
01262
01263
01264
01265
01266 # define CMGetCharPtr(s) ((char*)s->hdl)
01267
01268 # ifdef CMPI_INLINE
01269
01274 inline static char *
01275 CMGetCharsPtr (const CMPIString * st, CMPIStatus * rc)
01276 {
01277 return ((st)->ft->getCharPtr ((st), (rc)));
01278 }
01279 # else
01280 # define CMGetCharsPtr(st,rc) ((st)->ft->getCharPtr((st),(rc)))
01281 # endif
01282
01283
01284
01285
01286
01287
01288 # ifdef CMPI_INLINE
01289
01294 inline static CMPIString *CMGetStringFormat
01295 (const CMPIDateTime * dt, CMPIStatus * rc)
01296 {
01297 return ((dt)->ft->getStringFormat ((dt), (rc)));
01298 }
01299 # else
01300 # define CMGetStringFormat(d,rc) ((d)->ft->getStringFormat((d),(rc)))
01301 # endif
01302
01303 # ifdef CMPI_INLINE
01304
01310 inline static CMPIUint64 CMGetBinaryFormat
01311 (const CMPIDateTime * dt, CMPIStatus * rc)
01312 {
01313 return ((dt)->ft->getBinaryFormat ((dt), (rc)));
01314 }
01315 # else
01316 # define CMGetBinaryFormat(d,rc) ((d)->ft->getBinaryFormat((d),(rc)))
01317 # endif
01318
01319 # ifdef CMPI_INLINE
01320
01325 inline static CMPIBoolean CMIsInterval
01326 (const CMPIDateTime * dt, CMPIStatus * rc)
01327 {
01328 return ((dt)->ft->isInterval ((dt), (rc)));
01329 }
01330 # else
01331 # define CMIsInterval(d,rc) ((d)->ft->isInterval((d),(rc)))
01332 # endif
01333
01334
01335
01336
01337
01338 # ifdef CMPI_VER_200
01339
01340 # ifdef CMPI_INLINE
01341
01346 inline static CMPIErrorType (*getErrorType)(
01347 const CMPIError* er, CMPIStatus* rc)
01348 {
01349 return ((er)->ft->getErrorType ((er), (rc)));
01350 }
01351 # else
01352 # define CMGetErrorType(e,rc) \
01353 ((e)->ft->getErrorType((e),(rc)))
01354 # endif
01355
01356 # ifdef CMPI_INLINE
01357
01362 inline static CMPIString* (*getOtherErrorType)(
01363 const CMPIError* er, CMPIStatus* rc)
01364 {
01365 return ((er)->ft->getOtherErrorType ((er), (rc)));
01366 }
01367 # else
01368 # define CMGetOtherErrorType(e,rc) \
01369 ((e)->ft->getOtherErrorType((e),(rc)))
01370 # endif
01371
01372 # ifdef CMPI_INLINE
01373
01378 inline static CMPIString* (*getOwningEntity)(
01379 const CMPIError* er, CMPIStatus* rc)
01380 {
01381 return ((er)->ft->getOwningEntity ((er), (rc)));
01382 }
01383 # else
01384 # define CMGetOwningEntity(e,rc) \
01385 ((e)->ft->getOwningEntity((e),(rc)))
01386 # endif
01387
01388 # ifdef CMPI_INLINE
01389
01394 inline static CMPIString* (*getMessageID)(const CMPIError* er, CMPIStatus* rc)
01395 {
01396 return ((er)->ft->getMessageID ((er), (rc)));
01397 }
01398 # else
01399 # define CMGetMessageID(e,rc) \
01400 ((e)->ft->getMessageID((e),(rc)))
01401 # endif
01402
01403 # ifdef CMPI_INLINE
01404
01409 inline static CMPIString* (*getMessage)(const CMPIError* er, CMPIStatus* rc)
01410 {
01411 return ((er)->ft->getMessage ((er), (rc)));
01412 }
01413 # else
01414 # define CMGetErrorMessage(e,rc) \
01415 ((e)->ft->getMessage((e),(rc)))
01416 # endif
01417
01418 # ifdef CMPI_INLINE
01419
01424 inline static CMPIErrorSeverity (*getPerceivedSeverity)(
01425 const CMPIError* er, CMPIStatus* rc)
01426 {
01427 return ((er)->ft->getPerceivedSeverity ((er), (rc)));
01428 }
01429 # else
01430 # define CMGetPerceivedSeverity(e,rc) \
01431 ((e)->ft->getPerceivedSeverity((e),(rc)))
01432 # endif
01433
01434 # ifdef CMPI_INLINE
01435
01440 inline static CMPIErrorProbableCause (*getProbableCause)(
01441 const CMPIError* er, CMPIStatus* rc)
01442 {
01443 return ((er)->ft->getProbableCause ((er), (rc)));
01444 }
01445 # else
01446 # define CMGetProbableCause(e,rc) \
01447 ((e)->ft->getProbableCause((e),(rc)))
01448 # endif
01449
01450 # ifdef CMPI_INLINE
01451
01456 inline static CMPIString* (*getProbableCauseDescription)(
01457 const CMPIError* er, CMPIStatus* rc)
01458 {
01459 return ((er)->ft->getProbableCauseDescription ((er), (rc)));
01460 }
01461 # else
01462 # define CMGetProbableCauseDescription(e,rc) \
01463 ((e)->ft->getProbableCauseDescription((e),(rc)))
01464 # endif
01465
01466 # ifdef CMPI_INLINE
01467
01472 inline static CMPIArray* (*getRecommendedActions)(
01473 const CMPIError* er, CMPIStatus* rc)
01474 {
01475 return ((er)->ft->getRecommendedActions ((er), (rc)));
01476 }
01477 # else
01478 # define CMGetRecommendedActions(e,rc) \
01479 ((e)->ft->getRecommendedActions((e),(rc)))
01480 # endif
01481
01482 # ifdef CMPI_INLINE
01483
01488 inline static CMPIString* (*getErrorSource)(
01489 const CMPIError* er, CMPIStatus* rc)
01490 {
01491 return ((er)->ft->getErrorSource ((er), (rc)));
01492 }
01493 # else
01494 # define CMGetErrorSource(e,rc) \
01495 ((e)->ft->getErrorSource((e),(rc)))
01496 # endif
01497
01498 # ifdef CMPI_INLINE
01499
01504 inline static CMPIErrorSrcFormat (*getErrorSourceFormat)(
01505 const CMPIError* er, CMPIStatus* rc)
01506 {
01507 return ((er)->ft->getErrorSourceFormat ((er), (rc)));
01508 }
01509 # else
01510 # define CMGetErrorSourceFormat(e,rc) \
01511 ((e)->ft->getErrorSourceFormat((e),(rc)))
01512 # endif
01513
01514 # ifdef CMPI_INLINE
01515
01520 inline static CMPIString* (*getOtherErrorSourceFormat)(
01521 const CMPIError* er, CMPIStatus* rc)
01522 {
01523 return ((er)->ft->getOtherErrorSourceFormat ((er), (rc)));
01524 }
01525 # else
01526 # define CMGetOtherErrorSourceFormat(e,rc) \
01527 ((e)->ft->getOtherErrorSourceFormat((e),(rc)))
01528 # endif
01529
01530 # ifdef CMPI_INLINE
01531
01536 inline static CMPIrc (*getCIMStatusCode)(const CMPIError* er, CMPIStatus* rc)
01537 {
01538 return ((er)->ft->getCIMStatusCode ((er), (rc)));
01539 }
01540 # else
01541 # define CMGetCIMStatusCode(e,rc) \
01542 ((e)->ft->getCIMStatusCode((e),(rc)))
01543 # endif
01544
01545 # ifdef CMPI_INLINE
01546
01551 inline static CMPIString* (*getCIMStatusCodeDescription)(
01552 const CMPIError* er, CMPIStatus* rc)
01553 {
01554 return ((er)->ft->getCIMStatusCodeDescription ((er), (rc)));
01555 }
01556 # else
01557 # define CMGetCIMStatusCodeDescription(e,rc) \
01558 ((e)->ft->getCIMStatusCodeDescription((e),(rc)))
01559 # endif
01560
01561 # ifdef CMPI_INLINE
01562
01567 inline static CMPIArray* (*getMessageArguments)(
01568 const CMPIError* er, CMPIStatus* rc)
01569 {
01570 return ((er)->ft->getMessageArguments ((er), (rc)));
01571 }
01572 # else
01573 # define CMGetMessageArguments(e,rc) \
01574 ((e)->ft->getMessageArguments((e),(rc)))
01575 # endif
01576
01577 # ifdef CMPI_INLINE
01578
01583 inline static CMPIStatus (*setErrorType)(
01584 CMPIError* er, const CMPIErrorType et)
01585 {
01586 return ((er)->ft->setErrorType ((er), (et)));
01587 }
01588 # else
01589 # define CMSetErrorType(e,et) \
01590 ((e)->ft->setErrorType((e),(et)))
01591 # endif
01592
01593 # ifdef CMPI_INLINE
01594
01599 inline static CMPIStatus (*setOtherErrorType)(CMPIError* er, const char * oet)
01600 {
01601 return ((er)->ft->setOtherErrorType ((er), (oet)));
01602 }
01603 # else
01604 # define CMSetOtherErrorType(e,oet) \
01605 ((e)->ft->setOtherErrorType((e),(oet)))
01606 # endif
01607
01608 # ifdef CMPI_INLINE
01609
01614 inline static CMPIStatus (*setProbableCauseDescription)(
01615 CMPIError* er, const char * pcd)
01616 {
01617 return ((er)->ft->setProbableCauseDescription ((er), (pcd)));
01618 }
01619 # else
01620 # define CMSetProbableCauseDescription(e,pcd) \
01621 ((e)->ft->setProbableCauseDescription((e),(pcd)))
01622 # endif
01623
01624 # ifdef CMPI_INLINE
01625
01630 inline static CMPIStatus (*setRecommendedActions)(
01631 CMPIError* er, const CMPIArray* ra)
01632 {
01633 return ((er)->ft->setRecommendedActions ((er), (ra)));
01634 }
01635 # else
01636 # define CMSetRecommendedActions(e,ra) \
01637 ((e)->ft->setRecommendedActions((e),(ra)))
01638 # endif
01639
01640 # ifdef CMPI_INLINE
01641
01646 inline static CMPIStatus (*setErrorSource)(CMPIError* er, const char* es);
01647 {
01648 return ((er)->ft->setErrorSource ((er), (es)));
01649 }
01650 # else
01651 # define CMSetErrorSource(e,es) \
01652 ((e)->ft->setErrorSource((e),(es)))
01653 # endif
01654
01655 # ifdef CMPI_INLINE
01656
01661 inline static CMPIStatus (*setErrorSourceFormat)(
01662 CMPIError* er, const CMPIErrorSrcFormat esf);
01663 {
01664 return ((er)->ft->setErrorSourceFormat ((er), (esf)));
01665 }
01666 # else
01667 # define CMSetErrorSourceFormat(e,esf) \
01668 ((e)->ft->setErrorSourceFormat((e),(esf)))
01669 # endif
01670
01671 # ifdef CMPI_INLINE
01672
01677 inline static CMPIStatus (*setOtherErrorSourceFormat)(
01678 CMPIError* er, const char* oesf)
01679 {
01680 return ((er)->ft->setOtherErrorSourceFormat ((er), (oesf)));
01681 }
01682 # else
01683 # define CMSetOtherErrorSourceFormat(e,oesf) \
01684 ((e)->ft->setOtherErrorSourceFormat((e),(oesf)))
01685 # endif
01686
01687 # ifdef CMPI_INLINE
01688
01693 inline static CMPIStatus (*setCIMStatusCodeDescription)(
01694 CMPIError* er, const char* cd);
01695 {
01696 return ((er)->ft->setCIMStatusCodeDescription ((er), (cd)));
01697 }
01698 # else
01699 # define CMSetCIMStatusCodeDescription(e,cd) \
01700 ((e)->ft->setCIMStatusCodeDescription((e),(cd)))
01701 # endif
01702 # ifdef CMPI_INLINE
01703
01709 inline static CMPIStatus (*setMessageArguments)(CMPIError* er, CMPIArray* ma)
01710 {
01711 return ((er)->ft->setMessageArguments ((er), (ma)));
01712 }
01713 # else
01714 # define CMSetMessageArguments(e,ma) \
01715 ((e)->ft->setMessageArguments((e),(ma)))
01716 # endif
01717
01718 # endif
01719
01720
01721
01722
01723
01724 # ifdef CMPI_INLINE
01725
01730 inline static CMPIData
01731 CMGetNext (const CMPIEnumeration * en, CMPIStatus * rc)
01732 {
01733 return ((en)->ft->getNext ((en), (rc)));
01734 }
01735 # else
01736 # define CMGetNext(n,rc) ((n)->ft->getNext((n),(rc)))
01737 # endif
01738
01739 # ifdef CMPI_INLINE
01740
01745 inline static CMPIBoolean CMHasNext
01746 (const CMPIEnumeration * en, CMPIStatus * rc)
01747 {
01748 return ((en)->ft->hasNext ((en), (rc)));
01749 }
01750 # else
01751 # define CMHasNext(n,rc) ((n)->ft->hasNext((n),(rc)))
01752 # endif
01753
01754 # ifdef CMPI_INLINE
01755
01760 inline static CMPIArray *CMToArray
01761 (const CMPIEnumeration * en, CMPIStatus * rc)
01762 {
01763 return ((en)->ft->toArray ((en), (rc)));
01764 }
01765 # else
01766 # define CMToArray(n,rc) ((n)->ft->toArray((n),(rc)))
01767 # endif
01768
01769
01770
01771
01772
01773 # ifdef CMPI_INLINE
01774
01780 inline static CMPIStatus CMReturnData
01781 (const CMPIResult * rslt, const CMPIValue * value, const CMPIType type)
01782 {
01783 return ((rslt)->ft->returnData ((rslt), (value), (type)));
01784 }
01785 # else
01786 # define CMReturnData(r,v,t) \
01787 ((r)->ft->returnData((r),(CMPIValue*)(v),(t)))
01788 # endif
01789
01790 # ifdef CMPI_INLINE
01791
01796 inline static CMPIStatus CMReturnInstance
01797 (const CMPIResult * rslt, const CMPIInstance * inst)
01798 {
01799 return ((rslt)->ft->returnInstance ((rslt), (inst)));
01800 }
01801 # else
01802 # define CMReturnInstance(r,i) ((r)->ft->returnInstance((r),(i)))
01803 # endif
01804
01805 # ifdef CMPI_INLINE
01806
01811 inline static CMPIStatus CMReturnObjectPath
01812 (const CMPIResult * rslt, const CMPIObjectPath * ref)
01813 {
01814 return ((rslt)->ft->returnObjectPath ((rslt), (ref)));
01815 }
01816 # else
01817 # define CMReturnObjectPath(r,o) ((r)->ft->returnObjectPath((r),(o)))
01818 # endif
01819
01820 # ifdef CMPI_INLINE
01821
01825 inline static CMPIStatus
01826 CMReturnDone (const CMPIResult * rslt)
01827 {
01828 return ((rslt)->ft->returnDone ((rslt)));
01829 }
01830 # else
01831 # define CMReturnDone(r) ((r)->ft->returnDone((r)))
01832 # endif
01833
01834 # ifdef CMPI_VER_200
01835 # ifdef CMPI_INLINE
01836
01841 inline static CMPIStatus CMReturnError
01842 (const CMPIResult* rslt, const CMPIError* er)
01843 {
01844 return ((rslt)->ft->returnError ((rslt), (er)));
01845 }
01846 # else
01847 # define CMReturnError(r,e) \
01848 ((r)->ft->returnError((r),(e)))
01849 # endif
01850 # endif
01851
01852
01853
01854
01855
01856 # ifdef CMPI_INLINE
01857
01863 inline static CMPIData CMGetContextEntry
01864 (const CMPIContext * ctx, const char *name, CMPIStatus * rc)
01865 {
01866 return ((ctx)->ft->getEntry ((ctx), (name), (rc)));
01867 }
01868 # else
01869 # define CMGetContextEntry(c,n,rc) \
01870 ((c)->ft->getEntry((c),(n),(rc)))
01871 # endif
01872
01873 # ifdef CMPI_INLINE
01874
01881 inline static CMPIData CMGetContextEntryAt
01882 (const CMPIContext * ctx, CMPICount index, CMPIString ** name,
01883 CMPIStatus * rc)
01884 {
01885 return ((ctx)->ft->getEntryAt ((ctx), (index), (name), (rc)));
01886 }
01887 # else
01888 # define CMGetContextEntryAt(c,p,n,rc) \
01889 ((c)->ft->getEntryAt((c),(p),(n),(rc)))
01890 # endif
01891
01892 # ifdef CMPI_INLINE
01893
01898 inline static CMPICount CMGetContextEntryCount
01899 (const CMPIContext * ctx, CMPIStatus * rc)
01900 {
01901 return ((ctx)->ft->getEntryCount ((ctx), (rc)));
01902 }
01903 # else
01904 # define CMGetContextEntryCount(c,rc) \
01905 ((c)->ft->getEntryCount((c),(rc)))
01906 # endif
01907
01908 # ifdef CMPI_INLINE
01909
01916 inline static CMPIStatus CMAddContextEntry
01917 (const CMPIContext * ctx, const char *name, const CMPIValue * value,
01918 const CMPIType type)
01919 {
01920 return ((ctx)->ft->addEntry ((ctx), (name), (value), (type)));
01921 }
01922 # else
01923 # define CMAddContextEntry(c,n,v,t) \
01924 ((c)->ft->addEntry((c),(n),(CMPIValue*)(v),(t)))
01925 # endif
01926
01927
01928
01929
01930
01931
01932
01933 # ifdef CMPI_INLINE
01934
01939 inline static CMPIString *CMGetSelExpString
01940 (const CMPISelectExp * se, CMPIStatus * rc)
01941 {
01942 return ((se)->ft->getString ((se), (rc)));
01943 }
01944 # else
01945 # define CMGetSelExpString(s,rc) ((s)->ft->getString((s),(rc)))
01946 # endif
01947
01948 # ifdef CMPI_INLINE
01949
01955 inline static CMPIBoolean CMEvaluateSelExp
01956 (const CMPISelectExp * se, const CMPIInstance * inst, CMPIStatus * rc)
01957 {
01958 return ((se)->ft->evaluate ((se), (inst), (rc)));
01959 }
01960 # else
01961 # define CMEvaluateSelExp(s,i,r) ((s)->ft->evaluate((s),(i),(r)))
01962 # endif
01963
01964 # ifdef CMPI_VER_87
01965 # ifdef CMPI_INLINE
01966
01973 inline static CMPIBoolean CMEvaluateSelExpUsingAccessor
01974 (const CMPISelectExp * se, CMPIAccessor * accessor, void *parm,
01975 CMPIStatus * rc)
01976 {
01977 return ((se)->ft->evaluateUsingAccessor ((se), (accessor), (parm), (rc)));
01978 }
01979 # else
01980 # define CMEvaluateSelExpUsingAccessor(s,i,p,r) \
01981 ((s)->ft->evaluateUsingAccessor((s),(i),(p),(r)))
01982 # endif
01983 # endif
01984
01985 # ifdef CMPI_INLINE
01986
01991 inline static CMPISelectCond *CMGetDoc
01992 (const CMPISelectExp * se, CMPIStatus * rc)
01993 {
01994 return ((se)->ft->getDOC ((se), (rc)));
01995 }
01996 # else
01997 # define CMGetDoc(s,rc) ((s)->ft->getDOC((s),(rc)))
01998 # endif
01999
02000 # ifdef CMPI_INLINE
02001
02006 inline static CMPISelectCond *CMGetCod
02007 (const CMPISelectExp * se, CMPIStatus * rc)
02008 {
02009 return ((se)->ft->getCOD ((se), (rc)));
02010 }
02011 # else
02012 # define CMGetCod(s,rc) ((s)->ft->getCOD((s),(rc)))
02013 # endif
02014
02015
02016
02017
02018
02019
02020
02021 # ifdef CMPI_INLINE
02022
02029 inline static CMPICount CMGetSubCondCountAndType
02030 (const CMPISelectCond * sc, int * type, CMPIStatus * rc)
02031 {
02032 return ((sc)->ft->getCountAndType ((sc), (type), (rc)));
02033 }
02034 # else
02035 # define CMGetSubCondCountAndType(c,t,rc) \
02036 ((c)->ft->getCountAndType((c),(t),(rc)))
02037 # endif
02038
02039 # ifdef CMPI_INLINE
02040
02046 inline static CMPISubCond *CMGetSubCondAt
02047 (const CMPISelectCond * sc, CMPICount index, CMPIStatus * rc)
02048 {
02049 return ((sc)->ft->getSubCondAt ((sc), (index), (rc)));
02050 }
02051 # else
02052 # define CMGetSubCondAt(c,p,rc) ((c)->ft->getSubCondAt((c),(p),(rc)))
02053 # endif
02054
02055
02056
02057
02058
02059
02060
02061 # ifdef CMPI_INLINE
02062
02067 inline static CMPICount CMGetPredicateCount
02068 (const CMPISubCond * sc, CMPIStatus * rc)
02069 {
02070 return ((sc)->ft->getCount ((sc), (rc)));
02071 }
02072 # else
02073 # define CMGetPredicateCount(s,rc) ((s)->ft->getCount((s),(rc)))
02074 # endif
02075
02076 # ifdef CMPI_INLINE
02077
02083 inline static CMPIPredicate *CMGetPredicateAt
02084 (const CMPISubCond * sc, CMPICount index, CMPIStatus * rc)
02085 {
02086 return ((sc)->ft->getPredicateAt ((sc), (index), (rc)));
02087 }
02088 # else
02089 # define CMGetPredicateAt(s,p,rc) \
02090 ((s)->ft->getPredicateAt((s),(p),(rc)))
02091 # endif
02092
02093 # ifdef CMPI_INLINE
02094
02100 inline static CMPIPredicate *CMGetPredicate
02101 (const CMPISubCond * sc, const char *name, CMPIStatus * rc)
02102 {
02103 return ((sc)->ft->getPredicate ((sc), (name), (rc)));
02104 }
02105 # else
02106 # define CMGetPredicate(s,n,rc) ((s)->ft->getPredicate((s),(n),(rc)))
02107 # endif
02108
02109
02110
02111
02112
02113
02114 # ifdef CMPI_INLINE
02115
02123 inline static CMPIStatus CMGetPredicateData
02124 (const CMPIPredicate * pr, CMPIType * type,
02125 CMPIPredOp * op, CMPIString ** lhs, CMPIString ** rhs)
02126 {
02127 return ((pr)->ft->getData ((pr), (type), (op), (lhs), (rhs)));
02128 }
02129 # else
02130 # define CMGetPredicateData(p,t,o,n,v) \
02131 ((p)->ft->getData((p),(t),(o),(n),(v)))
02132 # endif
02133
02134 # if defined(CMPI_VER_87) && !defined(CMPI_VER_100)
02135 # ifdef CMPI_INLINE
02136
02144 inline static int CMEvaluatePredicate
02145 (CMPIPredicate* pr, void* value,
02146 CMPIType type, CMPIStatus* rc)
02147 {
02148 return ((pr)->ft->evaluate((pr),(CMPIValue*)(value),(type),(rc)));
02149 }
02150 # else
02151 # define CMEvaluatePredicate(p,v,t,rc) \
02152 ((p)->ft->evaluate((p),(CMPIValue*)(v),(t),(rc)))
02153 # endif
02154 # endif
02155
02156 # ifdef CMPI_VER_100
02157 # ifdef CMPI_INLINE
02158
02165 inline static int CMEvaluatePredicateUsingAccessor
02166 (const CMPIPredicate * pr, CMPIAccessor * accessor, void *parm,
02167 CMPIStatus * rc)
02168 {
02169 return ((pr)->ft->evaluateUsingAccessor ((pr), (accessor), (parm), (rc)));
02170 }
02171 # else
02172 # define CMEvaluatePredicateUsingAccessor(p,a,parm,rc) \
02173 ((p)->ft->evaluateUsingAccessor((p),(a),(parm),(rc)))
02174 # endif
02175 # endif
02176
02177
02178
02179
02180
02181
02182
02183 # ifdef CMPI_INLINE
02184
02187 inline static unsigned long
02188 CBGetBrokerCapabilities (const CMPIBroker * mb)
02189 {
02190 return ((mb)->bft->brokerCapabilities);
02191 }
02192 # else
02193 # define CBGetBrokerCapabilites(b) ((b)->bft->brokerCapabilites)
02194 # endif
02195
02196 # ifdef CMPI_INLINE
02197
02199 inline static int
02200 CBBrokerVersion (const CMPIBroker * mb)
02201 {
02202 return ((mb)->bft->brokerVersion);
02203 }
02204 # else
02205 # define CBBrokerVersion(b) ((b)->bft->brokerVersion)
02206 # endif
02207
02208 # ifdef CMPI_INLINE
02209
02211 inline static const char *
02212 CBBrokerName (const CMPIBroker * mb)
02213 {
02214 return ((mb)->bft->brokerName);
02215 }
02216 # else
02217 # define CBBrokerName(b) ((b)->bft->brokerName)
02218 # endif
02219
02220
02221 # ifdef CMPI_INLINE
02222
02230 inline static CMPIContext *CBPrepareAttachThread
02231 (const CMPIBroker * mb, const CMPIContext * ctx)
02232 {
02233 return ((mb)->bft->prepareAttachThread ((mb), (ctx)));
02234 }
02235 # else
02236 # define CBPrepareAttachThread(b,c) \
02237 ((b)->bft->prepareAttachThread((b),(c)))
02238 # endif
02239
02240 # ifdef CMPI_INLINE
02241
02247 inline static CMPIStatus CBAttachThread
02248 (const CMPIBroker * mb, const CMPIContext * ctx)
02249 {
02250 return ((mb)->bft->attachThread ((mb), (ctx)));
02251 }
02252 # else
02253 # define CBAttachThread(b,c) ((b)->bft->attachThread((b),(c)))
02254 # endif
02255
02256 # ifdef CMPI_INLINE
02257
02264 inline static CMPIStatus CBDetachThread
02265 (const CMPIBroker * mb, const CMPIContext * ctx)
02266 {
02267 return ((mb)->bft->detachThread ((mb), (ctx)));
02268 }
02269 # else
02270 # define CBDetachThread(b,c) ((b)->bft->detachThread((b),(c)))
02271 # endif
02272
02273
02274
02275 # ifdef CMPI_INLINE
02276
02284 inline static CMPIStatus CBDeliverIndication
02285 (const CMPIBroker * mb, const CMPIContext * ctx,
02286 const char *ns, const CMPIInstance * ind)
02287 {
02288 return ((mb)->bft->deliverIndication ((mb), (ctx), (ns), (ind)));
02289 }
02290 # else
02291 # define CBDeliverIndication(b,c,n,i) \
02292 ((b)->bft->deliverIndication((b),(c),(n),(i)))
02293 # endif
02294
02295 # ifdef CMPI_INLINE
02296
02303 inline static CMPIEnumeration *CBEnumInstanceNames
02304 (const CMPIBroker * mb, const CMPIContext * ctx,
02305 const CMPIObjectPath * op, CMPIStatus * rc)
02306 {
02307 return ((mb)->bft->enumerateInstanceName ((mb), (ctx), (op), (rc)));
02308 }
02309 # else
02310 # define CBEnumInstanceNames(b,c,p,rc) \
02311 ((b)->bft->enumerateInstanceNames((b),(c),(p),(rc)))
02312 # endif
02313
02314 # ifdef CMPI_INLINE
02315
02327 inline static CMPIEnumeration *CBEnumInstances
02328 (const CMPIBroker * mb, const CMPIContext * ctx,
02329 const CMPIObjectPath * op, const char **properties, CMPIStatus * rc)
02330 {
02331 return ((mb)->bft->enumerateInstances ((mb), (ctx), (op), (properties), (rc)));
02332 }
02333 # else
02334 # define CBEnumInstances(b,c,p,pr,rc) \
02335 ((b)->bft->enumerateInstances((b),(c),(p),(pr),(rc)))
02336 # endif
02337
02338 # ifdef CMPI_INLINE
02339
02350 inline static CMPIInstance *CBGetInstance
02351 (const CMPIBroker * mb, const CMPIContext * ctx,
02352 const CMPIObjectPath * op, const char **properties, CMPIStatus * rc)
02353 {
02354 return ((mb)->bft->getInstance ((mb), (ctx), (op), (properties), (rc)));
02355 }
02356 # else
02357 # define CBGetInstance(b,c,p,pr,rc) \
02358 ((b)->bft->getInstance((b),(c),(p),(pr),(rc)))
02359 # endif
02360
02361 # ifdef CMPI_INLINE
02362
02370 inline static CMPIObjectPath *CBCreateInstance
02371 (const CMPIBroker * mb, const CMPIContext * ctx,
02372 const CMPIObjectPath * op, const CMPIInstance * inst, CMPIStatus * rc)
02373 {
02374 return ((mb)->bft->createInstance ((mb), (ctx), (op), (inst), (rc)));
02375 }
02376 # else
02377 # define CBCreateInstance(b,c,p,i,rc) \
02378 ((b)->bft->createInstance((b),(c),(p),(i),(rc)))
02379 # endif
02380
02381 # ifdef CMPI_VER_90
02382 # ifdef CMPI_INLINE
02383
02391 # ifdef CMPI_VER_100
02392 inline static CMPIStatus CBModifyInstance
02393 (const CMPIBroker* mb, const CMPIContext* ctx,
02394 const CMPIObjectPath* op, const CMPIInstance* inst,
02395 const char** properties)
02396 {
02397 return ((mb)->bft->
02398 modifyInstance ((mb), (ctx), (op), (inst), (properties)));
02399 }
02400 # else
02401 inline static CMPIStatus CBSetInstance
02402 (const CMPIBroker* mb, const CMPIContext* ctx,
02403 const CMPIObjectPath* op, const CMPIInstance* inst,
02404 const char** properties)
02405 {
02406 return ((mb)->bft->
02407 setInstance ((mb), (ctx), (op), (inst), (properties)));
02408 }
02409 # endif
02410 # else
02411 # ifdef CMPI_VER_100
02412 # define CBModifyInstance(b,c,p,i,pr) ((b)->bft->modifyInstance((b),(c),(p),(i),(pr)))
02413 # else
02414 # define CBSetInstance(b,c,p,i,pr) ((b)->bft->setInstance((b),(c),(p),(i),(pr)))
02415 # endif
02416 # endif
02417 # else
02418 # ifdef CMPI_INLINE
02419
02426 inline static CMPIStatus CBSetInstance
02427 (CMPIBroker* mb, CMPIContext* ctx,
02428 CMPIObjectPath* op, CMPIInstance* inst)
02429 {
02430 return ((mb)->bft->
02431 setInstance ((mb), (ctx), (op), (inst), NULL));
02432 }
02433 # else
02434 # define CBSetInstance(b,c,p,i) ((b)->bft->setInstance((b),(c),(p),(i),NULL))
02435 # endif
02436 # endif
02437
02438 # ifdef CMPI_INLINE
02439
02445 inline static CMPIStatus CBDeleteInstance
02446 (const CMPIBroker * mb, const CMPIContext * ctx, const CMPIObjectPath * op)
02447 {
02448 return ((mb)->bft->deleteInstance ((mb), (ctx), (op)));
02449 }
02450 # else
02451 # define CBDeleteInstance(b,c,p) ((b)->bft->deleteInstance((b),(c),(p)))
02452 # endif
02453
02454 # ifdef CMPI_INLINE
02455
02465 inline static CMPIEnumeration *CBExecQuery
02466 (const CMPIBroker * mb, const CMPIContext * ctx,
02467 const CMPIObjectPath * op, const char *query, const char *lang,
02468 CMPIStatus * rc)
02469 {
02470 return ((mb)->bft->execQuery ((mb), (ctx), (op), (query), (lang), (rc)));
02471 }
02472 # else
02473 # define CBExecQuery(b,c,p,l,q,rc) \
02474 ((b)->bft->execQuery((b),(c),(p),(l),(q),(rc)))
02475 # endif
02476
02477
02478 # ifdef CMPI_INLINE
02479
02509 inline static CMPIEnumeration *CBAssociators
02510 (const CMPIBroker * mb, const CMPIContext * ctx,
02511 const CMPIObjectPath * op, const char *assocClass, const char *resultClass,
02512 const char *role, const char *resultRole, const char **properties,
02513 CMPIStatus * rc)
02514 {
02515 return ((mb)->bft->
02516 associators ((mb), (ctx), (op), (assocClass), (resultClass), (role),
02517 (resultRole), (properties), (rc)));
02518 }
02519 # else
02520 # define CBAssociators(b,c,p,acl,rcl,r,rr,pr,rc) \
02521 ((b)->bft->associators((b),(c),(p),(acl),(rcl),(r),(rr),(pr),(rc)))
02522 # endif
02523
02524 # ifdef CMPI_INLINE
02525
02552 inline static CMPIEnumeration *CBAssociatorNames
02553 (const CMPIBroker * mb, const CMPIContext * ctx,
02554 const CMPIObjectPath * op, const char *assocClass, const char *resultClass,
02555 const char *role, const char *resultRole, CMPIStatus * rc)
02556 {
02557 return ((mb)->bft->associatorNames ((mb), (ctx), (op),
02558 (assocClass), (resultClass), (role),
02559 (resultRole), (rc)));
02560 }
02561 # else
02562 # define CBAssociatorNames(b,c,p,acl,rcl,r,rr,rc) \
02563 ((b)->bft->associatorNames((b),(c),(p),(acl),(rcl),(r),(rr),(rc)))
02564 # endif
02565
02566 # ifdef CMPI_INLINE
02567
02588 inline static CMPIEnumeration *CBReferences
02589 (const CMPIBroker * mb, const CMPIContext * ctx,
02590 const CMPIObjectPath * op, const char *resultClass, const char *role,
02591 const char **properties, CMPIStatus * rc)
02592 {
02593 return ((mb)->bft->references ((mb), (ctx), (op),
02594 (resultClass), (role), (properties), (rc)));
02595 }
02596 # else
02597 # define CBReferences(b,c,p,acl,r,pr,rc) \
02598 ((b)->bft->references((b),(c),(p),(acl),(r),(pr),(rc)))
02599 # endif
02600
02601 # ifdef CMPI_INLINE
02602
02620 inline static CMPIEnumeration *CBReferenceNames
02621 (const CMPIBroker * mb, const CMPIContext * ctx,
02622 const CMPIObjectPath * op, const char *resultClass, const char *role,
02623 CMPIStatus * rc)
02624 {
02625 return ((mb)->bft->
02626 referenceNames ((mb), (ctx), (op), (resultClass), (role), (rc)));
02627 }
02628 # else
02629 # define CBReferenceNames(b,c,p,acl,r,rc) \
02630 ((b)->bft->referenceNames((b),(c),(p),(acl),(r),(rc)))
02631 # endif
02632
02633
02634 # ifdef CMPI_INLINE
02635
02646 inline static CMPIData CBInvokeMethod
02647 (const CMPIBroker * mb, const CMPIContext * ctx,
02648 const CMPIObjectPath * op, const char *method,
02649 const CMPIArgs * in, CMPIArgs * out, CMPIStatus * rc)
02650 {
02651 return ((mb)->bft->
02652 invokeMethod ((mb), (ctx), (op), (method), (in), (out), (rc)));
02653 }
02654 # else
02655 # define CBInvokeMethod(b,c,p,m,ai,ao,rc) \
02656 ((b)->bft->invokeMethod((b),(c),(p),(m),(ai),(ao),(rc)))
02657 # endif
02658
02659 # ifdef CMPI_INLINE
02660
02669 inline static CMPIStatus CBSetProperty
02670 (const CMPIBroker * mb, const CMPIContext * ctx,
02671 const CMPIObjectPath * op, const char *name,
02672 const CMPIValue * value, const CMPIType type)
02673 {
02674 return ((mb)->bft->setProperty ((mb), (ctx), (op), (name),
02675 (CMPIValue *) (value), (type)));
02676 }
02677 # else
02678 # define CBSetProperty(b,c,p,n,v,t) \
02679 ((b)->bft->setProperty((b),(c),(p),(n),(CMPIValue*)(v),(t)))
02680 # endif
02681
02682 # ifdef CMPI_INLINE
02683
02691 inline static CMPIData CBGetProperty
02692 (const CMPIBroker * mb, const CMPIContext * ctx,
02693 const CMPIObjectPath * op, const char *name, CMPIStatus * rc)
02694 {
02695 return (mb)->bft->getProperty ((mb), (ctx), (op), (name), (rc));
02696 }
02697 # else
02698 # define CBGetProperty(b,c,p,n,rc) \
02699 (b)->bft->getProperty((b),(c),(p),(n),(rc))
02700 # endif
02701
02702
02703 # ifndef DOC_ONLY
02704
02705
02706
02707
02708 # define CMNoHook
02709 # endif
02710
02711
02712
02713
02714
02715 # ifdef DOC_ONLY
02716
02735 CMPIInstanceMI *CMInstanceMIStub (chars pfx, chars pn,
02736 CMPIBroker * broker, statement hook);
02737 # else
02738
02739 # ifdef CMPI_VER_100
02740 # define CMInstanceMIStubChange(pfx) pfx##ModifyInstance
02741 # else
02742 # define CMInstanceMIStubChange(pfx) pfx##SetInstance
02743 # endif
02744
02745 # define CMInstanceMIStub(pfx,pn,broker,hook) \
02746 static CMPIInstanceMIFT instMIFT__={ \
02747 CMPICurrentVersion, \
02748 CMPICurrentVersion, \
02749 "instance" #pn, \
02750 pfx##Cleanup, \
02751 pfx##EnumInstanceNames, \
02752 pfx##EnumInstances, \
02753 pfx##GetInstance, \
02754 pfx##CreateInstance, \
02755 CMInstanceMIStubChange(pfx), \
02756 pfx##DeleteInstance, \
02757 pfx##ExecQuery, \
02758 }; \
02759 CMPI_EXTERN_C \
02760 CMPIInstanceMI* pn##_Create_InstanceMI(const CMPIBroker* brkr,const CMPIContext *ctx, CMPIStatus *rc) { \
02761 static CMPIInstanceMI mi={ \
02762 NULL, \
02763 &instMIFT__, \
02764 }; \
02765 broker=brkr; \
02766 hook; \
02767 return &mi; \
02768 }
02769
02770 # endif
02771
02772 # ifdef DOC_ONLY
02773
02793 CMPIAssociationMI *CMAssociationMIStub (chars pfx, chars pn,
02794 CMPIBroker * broker, statement hook);
02795 # else
02796 # define CMAssociationMIStub(pfx,pn,broker,hook) \
02797 static CMPIAssociationMIFT assocMIFT__={ \
02798 CMPICurrentVersion, \
02799 CMPICurrentVersion, \
02800 "association" #pn, \
02801 pfx##AssociationCleanup, \
02802 pfx##Associators, \
02803 pfx##AssociatorNames, \
02804 pfx##References, \
02805 pfx##ReferenceNames, \
02806 }; \
02807 CMPI_EXTERN_C \
02808 CMPIAssociationMI* pn##_Create_AssociationMI(const CMPIBroker* brkr,const CMPIContext *ctx, CMPIStatus *rc) { \
02809 static CMPIAssociationMI mi={ \
02810 NULL, \
02811 &assocMIFT__, \
02812 }; \
02813 broker=brkr; \
02814 hook; \
02815 return &mi; \
02816 }
02817 # endif
02818
02819 # ifdef DOC_ONLY
02820
02837 CMPIMethodMI *CMMethodMIStub (chars pfx, chars pn,
02838 CMPIBroker * broker, statement hook);
02839 # else
02840 # define CMMethodMIStub(pfx,pn,broker,hook) \
02841 static CMPIMethodMIFT methMIFT__={ \
02842 CMPICurrentVersion, \
02843 CMPICurrentVersion, \
02844 "method" #pn, \
02845 pfx##MethodCleanup, \
02846 pfx##InvokeMethod, \
02847 }; \
02848 CMPI_EXTERN_C \
02849 CMPIMethodMI* pn##_Create_MethodMI(const CMPIBroker* brkr, const CMPIContext *ctx, CMPIStatus *rc) { \
02850 static CMPIMethodMI mi={ \
02851 NULL, \
02852 &methMIFT__, \
02853 }; \
02854 broker=brkr; \
02855 hook; \
02856 return &mi; \
02857 }
02858 # endif
02859
02860 # ifdef DOC_ONLY
02861
02880 CMPIPropertyMI *CMPropertyMIStub (chars pfx, chars pn,
02881 CMPIBroker * broker, statement hook);
02882 # else
02883 # define CMPropertyMIStub(pfx,pn,broker,hook) \
02884 static CMPIPropertyMIFT propMIFT__={ \
02885 CMPICurrentVersion, \
02886 CMPICurrentVersion, \
02887 "property" #pn, \
02888 pfx##PropertyCleanup, \
02889 pfx##SetProperty, \
02890 pfx##GetProperty, \
02891 }; \
02892 CMPI_EXTERN_C \
02893 CMPIPropertyMI* pn##_Create_PropertyMI(const CMPIBroker* brkr,const CMPIContext *ctx, CMPIStatus *rc) { \
02894 static CMPIPropertyMI mi={ \
02895 NULL, \
02896 &propMIFT__, \
02897 }; \
02898 broker=brkr; \
02899 hook; \
02900 return &mi; \
02901 }
02902 # endif
02903
02904 # ifdef DOC_ONLY
02905
02923 CMPIIndicationMI *CMIndicationMIStub (chars pfx, chars pn,
02924 CMPIBroker * broker, statement hook);
02925 # else
02926
02927 # ifdef CMPI_VER_86
02928 # define CMIndicationMIStubExtensions(pfx) pfx##EnableIndications, \
02929 pfx##DisableIndications,
02930 # else
02931 # define CMIndicationMIStubExtensions(pfx)
02932 # endif
02933
02934 # define CMIndicationMIStub(pfx,pn,broker,hook) \
02935 static CMPIIndicationMIFT indMIFT__={ \
02936 CMPICurrentVersion, \
02937 CMPICurrentVersion, \
02938 "Indication" #pn, \
02939 pfx##IndicationCleanup, \
02940 pfx##AuthorizeFilter, \
02941 pfx##MustPoll, \
02942 pfx##ActivateFilter, \
02943 pfx##DeActivateFilter, \
02944 CMIndicationMIStubExtensions(pfx) \
02945 }; \
02946 CMPI_EXTERN_C \
02947 CMPIIndicationMI* pn##_Create_IndicationMI(const CMPIBroker* brkr,const CMPIContext *ctx,CMPIStatus *rc) { \
02948 static CMPIIndicationMI mi={ \
02949 NULL, \
02950 &indMIFT__, \
02951 }; \
02952 broker=brkr; \
02953 hook; \
02954 return &mi; \
02955 }
02956 # endif
02957
02958
02959
02960
02961
02962 # ifdef DOC_ONLY
02963
02974 CMPIInstanceMI *CMInstanceMIFactory (chars cn, chars pn);
02975 # else
02976 # define CMInstanceMIFactory(cn,pn) \
02977 CMPI_EXTERN_C \
02978 CMPIInstanceMI* pn##_Create_InstanceMI(const CMPIBroker* broker, const CMPIContext *ctxp, CMPIStatus *rc) { \
02979 static CMPIInstanceMIFT instMIFT={ \
02980 CMPICurrentVersion, \
02981 CMPICurrentVersion, \
02982 "instance" #pn, \
02983 (CMPIStatus(*)(CMPIInstanceMI*,const CMPIContext*,CMPIBoolean))CmpiBaseMI::driveBaseCleanup, \
02984 CmpiInstanceMI::driveEnumInstanceNames, \
02985 CmpiInstanceMI::driveEnumInstances, \
02986 CmpiInstanceMI::driveGetInstance, \
02987 CmpiInstanceMI::driveCreateInstance, \
02988 CmpiInstanceMI::driveSetInstance, \
02989 CmpiInstanceMI::driveDeleteInstance, \
02990 CmpiInstanceMI::driveExecQuery, \
02991 }; \
02992 static CMPIInstanceMI mi; \
02993 CmpiContext ctx((CMPIContext*)ctxp); \
02994 mi.ft=&instMIFT; \
02995 CmpiBaseMI *provider=base##pn.getBaseMI(); \
02996 if (provider == 0) {\
02997 provider = new cn(CmpiBroker((CMPIBroker*)broker),ctx); \
02998 provider->setProviderBase(&base##pn); \
02999 provider->initialize(ctx); \
03000 base##pn.setBaseMI(provider); \
03001 } \
03002 mi.hdl=provider; \
03003 base##pn.incUseCount(); \
03004 return &mi; \
03005 }
03006 # endif
03007
03008 # ifdef DOC_ONLY
03009
03021 CMPIAssociationMI *CMAssociationMIFactory (chars cn, chars pn);
03022 # else
03023 # define CMAssociationMIFactory(cn,pn) \
03024 CMPI_EXTERN_C \
03025 CMPIAssociationMI* pn##_Create_AssociationMI(const CMPIBroker* broker, const CMPIContext *ctxp, CMPIStatus *rc) { \
03026 static CMPIAssociationMIFT assocMIFT={ \
03027 CMPICurrentVersion, \
03028 CMPICurrentVersion, \
03029 "association" #pn, \
03030 (CMPIStatus(*)(CMPIAssociationMI*,const CMPIContext*,CMPIBoolean))CmpiBaseMI::driveBaseCleanup, \
03031 CmpiAssociationMI::driveAssociators, \
03032 CmpiAssociationMI::driveAssociatorNames, \
03033 CmpiAssociationMI::driveReferences, \
03034 CmpiAssociationMI::driveReferenceNames, \
03035 }; \
03036 static CMPIAssociationMI mi; \
03037 CmpiContext ctx((CMPIContext*)ctxp); \
03038 mi.ft=&assocMIFT; \
03039 CmpiBaseMI *provider=base##pn.getBaseMI(); \
03040 if (provider == 0) {\
03041 provider = new cn(CmpiBroker((CMPIBroker*)broker),ctx); \
03042 provider->setProviderBase(&base##pn); \
03043 provider->initialize(ctx); \
03044 base##pn.setBaseMI(provider); \
03045 } \
03046 mi.hdl=provider; \
03047 base##pn.incUseCount(); \
03048 return &mi; \
03049 }
03050 # endif
03051
03052 # ifdef DOC_ONLY
03053
03065 CMPIMethodMI *CMMethodMIFactory (chars cn, chars pn);
03066 # else
03067 # define CMMethodMIFactory(cn,pn) \
03068 CMPI_EXTERN_C \
03069 CMPIMethodMI* pn##_Create_MethodMI(const CMPIBroker* broker, const CMPIContext *ctxp, CMPIStatus *rc) { \
03070 static CMPIMethodMIFT methMIFT={ \
03071 CMPICurrentVersion, \
03072 CMPICurrentVersion, \
03073 "method" #pn, \
03074 (CMPIStatus(*)(CMPIMethodMI*,const CMPIContext*, CMPIBoolean))CmpiBaseMI::driveBaseCleanup, \
03075 CmpiMethodMI::driveInvokeMethod, \
03076 }; \
03077 static CMPIMethodMI mi; \
03078 CmpiContext ctx((CMPIContext*)ctxp); \
03079 mi.ft=&methMIFT; \
03080 CmpiBaseMI *provider=base##pn.getBaseMI(); \
03081 if (provider == 0) {\
03082 provider = new cn(CmpiBroker((CMPIBroker*)broker),ctx); \
03083 provider->setProviderBase(&base##pn); \
03084 provider->initialize(ctx); \
03085 base##pn.setBaseMI(provider); \
03086 } \
03087 mi.hdl=provider; \
03088 base##pn.incUseCount(); \
03089 return &mi; \
03090 }
03091 # endif
03092
03093 # ifdef DOC_ONLY
03094
03105 CMPIPropertyMI *
03106 CMPropertyMIFactory (chars cn, chars pn):
03107 # else
03108 # define CMPropertyMIFactory(cn,pn) \
03109 CMPI_EXTERN_C \
03110 CMPIPropertyMI* pn##_Create_PropertyMI(const CMPIBroker* broker, const CMPIContext *ctxp, CMPIStatus *rc) { \
03111 static CMPIPropertyMIFT propMIFT={ \
03112 CMPICurrentVersion, \
03113 CMPICurrentVersion, \
03114 "property" #pn, \
03115 (CMPIStatus(*)(CMPIPropertyMI*,const CMPIContext*,CMPIBoolean))CmpiBaseMI::driveBaseCleanup, \
03116 CmpiPropertyMI::driveSetProperty, \
03117 CmpiPropertyMI::driveGetProperty, \
03118 }; \
03119 static CMPIPropertyMI mi; \
03120 CmpiContext ctx((CMPIContext*)ctxp); \
03121 mi.ft=&propMIFT; \
03122 CmpiBaseMI *provider=base##pn.getBaseMI(); \
03123 if (provider == 0) {\
03124 provider = new cn(CmpiBroker((CMPIBroker*)broker),ctx); \
03125 provider->setProviderBase(&base##pn); \
03126 provider->initialize(ctx); \
03127 base##pn.setBaseMI(provider); \
03128 } \
03129 mi.hdl=provider; \
03130 base##pn.incUseCount(); \
03131 return &mi; \
03132 }
03133 # endif
03134
03135
03136 # ifdef DOC_ONLY
03137
03148 CMPIIndicationMI *CMIndicationMIFactory (chars cn, chars pn);
03149 # else
03150
03151 # ifdef CMPI_VER_86
03152 # define CMIndicationMIFactoryExtensions CmpiIndicationMI::driveEnableIndications, \
03153 CmpiIndicationMI::driveDisableIndications,
03154 # else
03155 # define CMIndicationMIFactoryExtensions
03156 # endif
03157
03158 # define CMIndicationMIFactory(cn,pn) \
03159 CMPI_EXTERN_C \
03160 CMPIIndicationMI* pn##_Create_IndicationMI(const CMPIBroker* broker, const CMPIContext *ctxp, CMPIStatus *rc) { \
03161 static CMPIIndicationMIFT indMIFT={ \
03162 CMPICurrentVersion, \
03163 CMPICurrentVersion, \
03164 "indication" #pn, \
03165 (CMPIStatus(*)(CMPIIndicationMI*,const CMPIContext*,CMPIBoolean))CmpiBaseMI::driveBaseCleanup, \
03166 CmpiIndicationMI::driveAuthorizeFilter, \
03167 CmpiIndicationMI::driveMustPoll, \
03168 CmpiIndicationMI::driveActivateFilter, \
03169 CmpiIndicationMI::driveDeActivateFilter, \
03170 CMIndicationMIFactoryExtensions \
03171 }; \
03172 static CMPIIndicationMI mi; \
03173 CmpiContext ctx((CMPIContext*)ctxp); \
03174 mi.ft=&indMIFT; \
03175 CmpiBaseMI *provider=base##pn.getBaseMI(); \
03176 if (provider == 0) {\
03177 provider = new cn(CmpiBroker((CMPIBroker*)broker),ctx); \
03178 provider->setProviderBase(&base##pn); \
03179 provider->initialize(ctx); \
03180 base##pn.setBaseMI(provider); \
03181 } \
03182 mi.hdl=provider; \
03183 base##pn.incUseCount(); \
03184 return &mi; \
03185 }
03186 # endif
03187
03188 # define CMProviderBase(pn) \
03189 CmpiProviderBase base##pn;
03190
03191 #endif // _CMPIMACS_H_