cmpi/cmpimacs.h

Go to the documentation of this file.
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_

Generated on Sat Feb 26 13:04:34 2022 for cmpi by  doxygen 1.4.6