cmpi
|
00001 /* 00002 * 00003 * $Id: cmpimacs.h,v 1.11 2009/03/04 17:46:42 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 Convenience 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 _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 // Life-cycle macros 00220 00221 # define CMClone(o,rc) ((o)->ft->clone((o),(rc))) 00222 # define CMRelease(o) ((o)->ft->release((o))) 00223 00224 // CMPIBroker factory macros 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 // Debugging macros 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 /* CMPI_INLINE */ 00528 # endif /* CMPI_VER_85 */ 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 /* CMPI_VER_100 */ 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 /* CMPI_VER_100 */ 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 /* CMPI_INLINE */ 00606 # endif /* CMPI_VER_200 */ 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 /* CMPI_INLINE */ 00625 # endif /* CMPI_VER_200 */ 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 /* CMPI_INLINE */ 00643 # endif /* CMPI_VER_200 */ 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 /* CMPI_INLINE */ 00681 # endif /* CMPI_VER_200 */ 00682 00683 00684 // CMPIInstance macros 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 /* CMPI_VER_100 */ 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 /* CMPI_VER_200 */ 00834 00835 00836 // CMPIObjectPath macros 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 /* CMPI_VER_86 */ 01123 01124 // CMPIArray macros 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 // CMPIArgs macros 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 // CMPIString Macros 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 // CMPIDateTime macros 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 // CMPIError macros 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 /* CMPI_VER_200 */ 01719 01720 01721 // CMPIEnumeration Macros 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 // CMPIResult Macros 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 /* CMPI_VER_200 */ 01851 01852 01853 // CMPIContext Macros 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 // CMPISelectExp macros 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 /* CMPI_VER_87 */ 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 // CMPISelectCond macros 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 // CMPISubCond macros 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 // CMPIPredicate macros 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 /* CMPI_VER_87 && !CMPI_VER_100 */ 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 /* CMPI_VER_100 */ 02176 02177 02178 02179 // CMPIBroker Macros 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 /* CMPI_VER_100 */ 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 /* CMPI_VER_100 */ 02416 # endif 02417 # else /* CMPI_VER_90 */ 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 /* CMPI_VER_90 */ 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 // MI factory stubs 02705 02706 // Used when the MI factory function is not going to call 02707 // a function during initialization. 02708 # define CMNoHook 02709 # endif 02710 02711 /* 02712 ----------------- C provider factories --------------------- 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 /* CMPI_VER_100 */ 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 /* CMPI_VER_86 */ 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 ----------------- C++ provider factories --------------------- 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 /* CMPI_VER_86 */ 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_