cmpi
cmpimacs.h
Go to the documentation of this file.
1 /*
2  *
3  * $Id: cmpimacs.h,v 1.11 2009/03/04 17:46:42 tyreld Exp $
4  *
5  * (C) Copyright IBM Corp. 2003, 2005, 2006, 2008
6  *
7  * THIS FILE IS PROVIDED UNDER THE TERMS OF THE ECLIPSE PUBLIC LICENSE
8  * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
9  * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
10  *
11  * You can obtain a current copy of the Eclipse Public License from
12  * http://www.opensource.org/licenses/eclipse-1.0.txt
13  *
14  * Author: Adrian Schuur <schuur@de.ibm.com>
15  * Contributors: Konrad Rzeszutek <darnok@us.ibm.com>
16  *
17  * Description: CMPI Convenience Definions
18  *
19  */
20 
21 /* ------------------------------------------------------------------------- */
22 /* */
23 /* Copyright (c) 2006 The Open Group */
24 /* */
25 /* Permission is hereby granted, free of charge, to any person obtaining a */
26 /* copy of this software (the "Software"), to deal in the Software without */
27 /* restriction, including without limitation the rights to use, copy, */
28 /* modify, merge, publish, distribute, sublicense, and/or sell copies of */
29 /* the Software, and to permit persons to whom the Software is furnished */
30 /* to do so, subject to the following conditions: */
31 /* */
32 /* The above copyright notice and this permission notice shall be included */
33 /* in all copies or substantial portions of the Software. */
34 /* */
35 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS */
36 /* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
37 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
38 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
39 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT */
40 /* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR */
41 /* THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
42 /* */
43 /* ------------------------------------------------------------------------- */
44 
45 #ifndef _CMPIMACS_H_
46 # define _CMPIMACS_H_
47 
48 # ifndef DOC_ONLY
49 # include "cmpidt.h"
50 # include "cmpift.h"
51 # endif
52 
53 # ifdef DOC_ONLY
54 # define CMPI_INLINE
55 # endif
56 
57 # ifdef DOC_ONLY
58 
63 noReturn CMReturn (CMPIrc rc);
64 # else
65 # define CMReturn(rc) \
66  { CMPIStatus stat={(rc),NULL}; \
67  return stat; }
68 # endif
69 
70 # ifdef DOC_ONLY
71 
77 noReturn CMReturnWithString (CMPIrc rc, CMPIString * str);
78 # else
79 # define CMReturnWithString(rc,str) \
80  { CMPIStatus stat={(rc),(str)}; \
81  return stat; }
82 # endif
83 
84 # ifdef DOC_ONLY
85 
92 noReturn CMReturnWithChars (const CMPIBroker * mb, CMPIrc rc, char *msg);
93 # else
94 # define CMReturnWithChars(b,rc,chars) \
95  { CMPIStatus stat={(rc),NULL}; \
96  stat.msg=(b)->eft->newString((b),(chars),NULL); \
97  return stat; }
98 # endif
99 
100 
101 # ifdef CMPI_INLINE
102 
106 inline static void
107 CMSetStatus (CMPIStatus * st, CMPIrc rcp)
108 {
109  if (st)
110  {
111  (st)->rc = (rcp);
112  (st)->msg = NULL;
113  }
114 }
115 # else
116 # define CMSetStatus(st,rcp) \
117  { (st)->rc=(rcp); (st)->msg=NULL; }
118 # endif
119 
120 
121 # ifdef CMPI_INLINE
122 
127 inline static void
128 CMSetStatusWithString (CMPIStatus * st, CMPIrc rcp, const CMPIString * string)
129 {
130  if (st)
131  {
132  (st)->rc = (rcp);
133  (st)->msg = (string);
134  }
135 }
136 # else
137 # define CMSetStatusWithString(st,rcp,string) \
138  { (st)->rc=(rcp); (st)->msg=(string); }
139 # endif
140 
141 
142 # ifdef CMPI_INLINE
143 
149 inline static void
150 CMSetStatusWithChars (const CMPIBroker * mb, CMPIStatus * st, CMPIrc rcp,
151  const char *chars)
152 {
153  if (st && mb)
154  {
155  (st)->rc = (rcp);
156  (st)->msg = (mb)->eft->newString ((mb), (chars), NULL);
157  }
158 }
159 # else
160 # define CMSetStatusWithChars(mb,st,rcp,chars) \
161  { (st)->rc=(rcp); \
162  (st)->msg=(mb)->eft->newString((mb),(chars),NULL); }
163 # endif
164 
165 
166 # ifdef CMPI_INLINE
167 
170 inline static CMPIBoolean
171 CMIsNullObject (const void *obj)
172 {
173  return ((obj) == NULL || *((void **) (obj)) == NULL);
174 }
175 # else
176 # define CMIsNullObject(o) ((o)==NULL || *((void**)(o))==NULL)
177 # endif
178 
179 # ifdef CMPI_INLINE
180 
183 inline static CMPIBoolean
184 CMIsNullValue (const CMPIData val)
185 {
186  return ((val.state) & CMPI_nullValue);
187 }
188 # else
189 # define CMIsNullValue(v) ((v.state) & CMPI_nullValue)
190 # endif
191 
192 # ifdef CMPI_INLINE
193 
196 inline static CMPIBoolean
198 {
199  return ((val.state) & CMPI_keyValue);
200 }
201 # else
202 # define CMIsKeyValue(v) ((v.state) & CMPI_keyValue)
203 # endif
204 
205 # ifdef CMPI_INLINE
206 
209 inline static CMPIBoolean
210 CMIsArray (const CMPIData val)
211 {
212  return ((val.type) & CMPI_ARRAY);
213 }
214 # else
215 # define CMIsArray(v) ((v.type) & CMPI_ARRAY)
216 # endif
217 
218 
219  // Life-cycle macros
220 
221 # define CMClone(o,rc) ((o)->ft->clone((o),(rc)))
222 # define CMRelease(o) ((o)->ft->release((o)))
223 
224  // CMPIBroker factory macros
225 
226 # ifdef CMPI_INLINE
227 
233 inline static CMPIInstance *
234 CMNewInstance (const CMPIBroker * mb, const CMPIObjectPath * op,
235  CMPIStatus * rc)
236 {
237  return ((mb)->eft->newInstance ((mb), (op), (rc)));
238 }
239 # else
240 # define CMNewInstance(b,c,rc) ((b)->eft->newInstance((b),(c),(rc)))
241 # endif
242 
243 # ifdef CMPI_INLINE
244 
251 inline static CMPIObjectPath *
252 CMNewObjectPath (const CMPIBroker * mb, const char *ns, const char *cn,
253  CMPIStatus * rc)
254 {
255  return ((mb)->eft->newObjectPath ((mb), (ns), (cn), (rc)));
256 }
257 # else
258 # define CMNewObjectPath(b,n,c,rc) \
259  ((b)->eft->newObjectPath((b),(n),(c),(rc)))
260 # endif
261 
262 # ifdef CMPI_INLINE
263 
269 inline static CMPIString *
270 CMNewString (const CMPIBroker * mb, const char *data, CMPIStatus * rc)
271 {
272  return ((mb)->eft->newString ((mb), (data), (rc)));
273 }
274 # else
275 # define CMNewString(b,s,rc) ((b)->eft->newString((b),(s),(rc)))
276 # endif
277 
278 # ifdef CMPI_INLINE
279 
284 inline static CMPIArgs *
285 CMNewArgs (const CMPIBroker * mb, CMPIStatus * rc)
286 {
287  return ((mb)->eft->newArgs ((mb), (rc)));
288 }
289 # else
290 # define CMNewArgs(b,rc) ((b)->eft->newArgs((b),(rc)))
291 # endif
292 
293 # ifdef CMPI_INLINE
294 
301 inline static CMPIArray *
302 CMNewArray (const CMPIBroker * mb, CMPICount max, CMPIType type,
303  CMPIStatus * rc)
304 {
305  return ((mb)->eft->newArray ((mb), (max), (type), (rc)));
306 }
307 # else
308 # define CMNewArray(b,c,t,rc) ((b)->eft->newArray((b),(c),(t),(rc)))
309 # endif
310 
311 # ifdef CMPI_INLINE
312 
317 inline static CMPIDateTime *
318 CMNewDateTime (const CMPIBroker * mb, CMPIStatus * rc)
319 {
320  return ((mb)->eft->newDateTime ((mb), (rc)));
321 }
322 # else
323 # define CMNewDateTime(b,rc) ((b)->eft->newDateTime((b),(rc)))
324 # endif
325 
326 # ifdef CMPI_INLINE
327 
336  (const CMPIBroker * mb, CMPIUint64 binTime, CMPIBoolean interval,
337  CMPIStatus * rc)
338 {
339  return ((mb)->eft->
340  newDateTimeFromBinary ((mb), (binTime), (interval), (rc)));
341 }
342 # else
343 # define CMNewDateTimeFromBinary(b,d,i,rc) \
344  ((b)->eft->newDateTimeFromBinary((b),(d),(i),(rc)))
345 # endif
346 
347 # ifdef CMPI_INLINE
348 
355  (const CMPIBroker * mb, const char *utcTime, CMPIStatus * rc)
356 {
357  return ((mb)->eft->newDateTimeFromChars ((mb), (utcTime), (rc)));
358 }
359 # else
360 # define CMNewDateTimeFromChars(b,d,rc) \
361  ((b)->eft->newDateTimeFromChars((b),(d),(rc)))
362 # endif
363 
364 # ifdef CMPI_INLINE
365 
374 inline static CMPISelectExp *CMNewSelectExp
375  (const CMPIBroker * mb, const char *query, const char *lang,
376  CMPIArray ** projection, CMPIStatus * rc)
377 {
378  return ((mb)->eft->
379  newSelectExp ((mb), (query), (lang), (projection), (rc)));
380 }
381 # else
382 # define CMNewSelectExp(b,q,l,p,rc) \
383  ((b)->eft->newSelectExp((b),(q),(l),(p),(rc)))
384 # endif
385 
386 # ifdef CMPI_INLINE
387 
395 inline static CMPIBoolean CMClassPathIsA
396  (const CMPIBroker * mb, const CMPIObjectPath * op, const char *type,
397  CMPIStatus * rc)
398 {
399  return ((mb)->eft->classPathIsA ((mb), (op), (type), (rc)));
400 }
401 # else
402 # define CMClassPathIsA(b,p,pn,rc) \
403  ((b)->eft->classPathIsA((b),(p),(pn),(rc)))
404 # endif
405 
406  // Debugging macros
407 
408 # ifdef CMPI_INLINE
409 
416 inline static CMPIString *CDToString
417  (const CMPIBroker * mb, const void *object, CMPIStatus * rc)
418 {
419  return ((mb)->eft->toString ((mb), (void *) (object), (rc)));
420 }
421 # else
422 # define CDToString(b,o,rc) ((b)->eft->toString((b),(void*)(o),(rc)))
423 # endif
424 
425 # ifdef CMPI_INLINE
426 
435 inline static CMPIBoolean CDIsOfType
436  (const CMPIBroker * mb, const void *object, const char *type,
437  CMPIStatus * rc)
438 {
439  return ((mb)->eft->isOfType ((mb), (void *) (object), (type), (rc)));
440 }
441 # else
442 # define CDIsOfType(b,o,t,rc) \
443  (b)->eft->isOfType((b),(void*)(o),(t),(rc))
444 # endif
445 
446 # ifdef CMPI_INLINE
447 
454 inline static CMPIString *CDGetType
455  (const CMPIBroker * mb, const void *object, CMPIStatus * rc)
456 {
457  return ((mb)->eft->getType ((mb), (object), (rc)));
458 }
459 # else
460 # define CDGetType(b,o,rc) ((b)->eft->getType((b),(void*)(o),(rc)))
461 # endif
462 
463 # ifdef CMPI_VER_85
464 # ifdef CMPI_INLINE
465 
490 inline static CMPIString *CMGetMessage
491  (const CMPIBroker * b, const char *msgId, const char *defMsg,
492  CMPIStatus * rc, unsigned int, ...)
493 # else
494 
495 # define CMFmtSint(v) CMPI_sint32,((long int)v)
496 # define CMFmtUint(v) CMPI_uint32,((unsigned long int)v)
497 # define CMFmtSint64(v) CMPI_sint64,((long long int)v)
498 # define CMFmtUint64(v) CMPI_uint64,((unsigned long long int)v)
499 # define CMFmtReal(v) CMPI_real64,((double)v)
500 # define CMFmtBoolean(v) CMPI_boolean,((int)v)
501 # define CMFmtChars(v) CMPI_chars,((char*)v)
502 # define CMFmtString(v) CMPI_String,((CMPI_String*)v)
503 
504 # define CMFmtArgs0() 0
505 # define CMFmtArgs1(v1) \
506  1,v1
507 # define CMFmtArgs2(v1,v2) \
508  2,v1,v2
509 # define CMFmtArgs3(v1,v2,v3) \
510  3,v1,v2,v3
511 # define CMFmtArgs4(v1,v2,v3,v4) \
512  4,v1,v2,v3,v4
513 # define CMFmtArgs5(v1,v2,v3,v4,v5) \
514  5,v1,v2,v3,v4,v5
515 # define CMFmtArgs6(v1,v2,v3,v4,v5,v6) \
516  6,v1,v2,v3,v4,v5,v6
517 # define CMFmtArgs7(v1,v2,v3,v4,v5,v6,v7) \
518  7,v1,v2,v3,v4,v5,v6,v7
519 # define CMFmtArgs8(v1,v2,v3,v4,v5,v6,v7,v8) \
520  8,v1,v2,v3,v4,v5,v6,v7,v8
521 # define CMFmtArgs9(v1,v2,v3,v4,v5,v6,v7,v8,v9) \
522  9,v1,v2,v3,v4,v5,v6,v7,v8,v9
523 # define CMFmtArgs10(v1,v2,v3,v4,v5,v6,v7,v8,v9,v10) \
524  10,v1,v2,v3,v4,v5,v6,v7,v8,v9,v10
525 
526 # define CMGetMessage(b,id,def,rc,parms) ((b)->eft->getMessage((b),(id),(def),(rc),parms))
527 # endif /* CMPI_INLINE */
528 # endif /* CMPI_VER_85 */
529 
530 
531 # ifdef CMPI_VER_100
532 # ifdef CMPI_INLINE
533 
544 inline static CMPIStatus CMLogMessage
545  (const CMPIBroker * b, int severity, const char *id,
546  const char *text, const CMPIString * string)
547 {
548  return ((b)->eft->logMessage ((b), (severity), (id), (text), (string)));
549 }
550 # else
551 # define CMLogMessage(b,severity,id, text, string) ((b)->eft->logMessage((b),(severity),(id),(text),(string)))
552 # endif
553 # endif /* CMPI_VER_100 */
554 
555 # ifdef CMPI_VER_100
556 # ifdef CMPI_INLINE
557 
568 inline static CMPIStatus CMTraceMessage
569  (const CMPIBroker * b, int level, const char *component,
570  const char *text, const CMPIString * string)
571 {
572  return ((b)->eft->trace ((b), (level), (component), (text), (string)));
573 }
574 # else
575 # define CMTraceMessage(b,level,component, text, string) ((b)->eft->trace((b),(level),(component),(text),(string)))
576 # endif
577 # endif /* CMPI_VER_100 */
578 
579 # ifdef CMPI_VER_200
580 # ifdef CMPI_INLINE
581 
593 inline static CMPIError* CMNewCMPIError
594  (const CMPIBroker* b, const char *owner, const char* msgID, const char* msg,
595  const CMPIErrorSeverity sev, const CMPIErrorProbableCause pc,
596  const CMPIrc cimStatusCode, CMPIStatus* rc)
597 {
598  return ((b)->eft->newCMPIError ((b), (owner), (msgID), (msg), (sev),
599  (pc), (cimStatusCode), (rc)));
600 }
601 # else
602 # define CMNewCMPIError(b,owner,msgID,msg,sev,pc,cimStatusCode,rc) \
603  ((b)->eft->newCMPIError((b),(owner),(msgID),(msg),(sev), \
604  (pc),(cimStatusCode),(rc)))
605 # endif /* CMPI_INLINE */
606 # endif /* CMPI_VER_200 */
607 
608 # ifdef CMPI_VER_200
609 # ifdef CMPI_INLINE
610 
617 inline static CMPIStatus CMOpenMessageFile
618  (const CMPIBroker* b, const char *msgFile, CMPIMsgFileHandle *msgFileHandle)
619 {
620  return ((b)->eft->openMessageFile ((b), (msgFile), (msgFileHandle)));
621 }
622 # else
623 # define CMOpenMessageFile(b,mf,mfh) ((b)->eft->openMessageFile((b),(mf),(mfh)))
624 # endif /* CMPI_INLINE */
625 # endif /* CMPI_VER_200 */
626 
627 # ifdef CMPI_VER_200
628 # ifdef CMPI_INLINE
629 
635  inline static CMPIStatus CMCloseMessageFile
636  (const CMPIBroker* b, const CMPIMsgFileHandle msgFilehandle)
637 {
638  return ((b)->eft->closeMessageFile ((b), (msgFileHandle)));
639 }
640 # else
641 # define CMCloseMessageFile(b,mfh) ((b)->eft->closeMessageFile((b),(mfh)))
642 # endif /* CMPI_INLINE */
643 # endif /* CMPI_VER_200 */
644 
645 # ifdef CMPI_VER_200
646 # ifdef CMPI_INLINE
647 
674 inline static CMPIString* CMGetMessage2
675  (const CMPIBroker* mb, const char *msgId,
676  const CMPIMsgFileHandle msgFilehandle, const char *defMsg,
677  CMPIStatus* rc, unsigned int, ...);
678 # else
679 # define CMGetMessage2(b,id,mfh,def,rc,parms) ((b)->eft->getMessage2((b),(id),(mfh),(def),(rc),parms))
680 # endif /* CMPI_INLINE */
681 # endif /* CMPI_VER_200 */
682 
683 
684  // CMPIInstance macros
685 
686 
687 # ifdef CMPI_INLINE
688 
694 inline static CMPIData CMGetProperty
695  (const CMPIInstance * inst, const char *name, CMPIStatus * rc)
696 {
697  return ((inst)->ft->getProperty ((inst), (name), (rc)));
698 }
699 # else
700 # define CMGetProperty(i,n,rc) ((i)->ft->getProperty((i),(n),(rc)))
701 # endif
702 
703 # ifdef CMPI_INLINE
704 
711 inline static CMPIData CMGetPropertyAt
712  (const CMPIInstance * inst, CMPICount index, CMPIString ** name,
713  CMPIStatus * rc)
714 {
715  return ((inst)->ft->getPropertyAt ((inst), (index), (name), (rc)));
716 }
717 # else
718 # define CMGetPropertyAt(i,num,s,rc) \
719  ((i)->ft->getPropertyAt((i),(num),(s),(rc)))
720 # endif
721 
722 # ifdef CMPI_INLINE
723 
730 inline static CMPIStatus CMSetProperty
731  (const CMPIInstance * inst, const char *name,
732  const CMPIValue * value, CMPIType type)
733 {
734  return ((inst)->ft->setProperty ((inst), (name), (value), (type)));
735 }
736 # else
737 # define CMSetProperty(i,n,v,t) \
738  ((i)->ft->setProperty((i),(n),(CMPIValue*)(v),(t)))
739 # endif
740 
741 # ifdef CMPI_INLINE
742 
747 inline static CMPICount CMGetPropertyCount
748  (const CMPIInstance * inst, CMPIStatus * rc)
749 {
750  return ((inst)->ft->getPropertyCount ((inst), (rc)));
751 }
752 # else
753 # define CMGetPropertyCount(i,rc) ((i)->ft->getPropertyCount((i),(rc)))
754 # endif
755 
756 # ifdef CMPI_INLINE
757 
763 inline static CMPIObjectPath *CMGetObjectPath
764  (const CMPIInstance * inst, CMPIStatus * rc)
765 {
766  return ((inst)->ft->getObjectPath ((inst), (rc)));
767 }
768 # else
769 # define CMGetObjectPath(i,rc) ((i)->ft->getObjectPath((i),(rc)))
770 # endif
771 
772 # ifdef CMPI_VER_100
773 # ifdef CMPI_INLINE
774 
782 inline static CMPIStatus CMSetObjectPath
783  (CMPIInstance * inst, const CMPIObjectPath * obj)
784 {
785  return ((inst)->ft->setObjectPath ((inst), (obj)));
786 }
787 # else
788 # define CMSetObjectPath(i,obj) ((i)->ft->setObjectPath((i),(obj)))
789 # endif
790 # endif /* CMPI_VER_100 */
791 
792 # ifdef CMPI_INLINE
793 
801 inline static CMPIStatus CMSetPropertyFilter
802  (CMPIInstance * inst, const char **propertyList, char **keys)
803 {
804  return ((inst)->ft->setPropertyFilter ((inst), (propertyList), (keys)));
805 }
806 # else
807 # define CMSetPropertyFilter(i,pl,k) ((i)->ft->setPropertyFilter((i),(pl),(k)))
808 # endif
809 
810 # ifdef CMPI_VER_200
811 # ifdef CMPI_INLINE
812 
823  (const CMPIInstance * inst, const char *name,
824  const CMPIValue * value, CMPIType type, const char * origin)
825 {
826  return ((inst)->ft->setPropertyWithOrigin (
827  (inst), (name), (value), (type), (origin)));
828 }
829 # else
830 # define CMSetPropertyWithOrigin(i,n,v,t,o) \
831  ((i)->ft->setPropertyWithOrigin((i),(n),(CMPIValue*)(v),(t),(o)))
832 # endif
833 # endif /* CMPI_VER_200 */
834 
835 
836  // CMPIObjectPath macros
837 
838 
839 # ifdef CMPI_INLINE
840 
845 inline static CMPIStatus
846 CMSetHostname (CMPIObjectPath * op, const char *hn)
847 {
848  return ((op)->ft->setHostname ((op), (hn)));
849 }
850 # else
851 # define CMSetHostname(p,n) ((p)->ft->setHostname((p),(n)))
852 # endif
853 
854 # ifdef CMPI_INLINE
855 
860 inline static CMPIString *CMGetHostname
861  (const CMPIObjectPath * op, CMPIStatus * rc)
862 {
863  return ((op)->ft->getHostname ((op), (rc)));
864 }
865 # else
866 # define CMGetHostname(p,rc) ((p)->ft->getHostname((p),(rc)))
867 # endif
868 
869 # ifdef CMPI_INLINE
870 
875 inline static CMPIStatus
876 CMSetNameSpace (CMPIObjectPath * op, const char *ns)
877 {
878  return ((op)->ft->setNameSpace ((op), (ns)));
879 }
880 # else
881 # define CMSetNameSpace(p,n) ((p)->ft->setNameSpace((p),(n)))
882 # endif
883 
884 # ifdef CMPI_INLINE
885 
890 inline static CMPIString *CMGetNameSpace
891  (const CMPIObjectPath * op, CMPIStatus * rc)
892 {
893  return ((op)->ft->getNameSpace ((op), (rc)));
894 }
895 # else
896 # define CMGetNameSpace(p,rc) ((p)->ft->getNameSpace((p),(rc)))
897 # endif
898 
899 # ifdef CMPI_INLINE
900 
905 inline static CMPIStatus
906 CMSetClassName (CMPIObjectPath * op, const char *cn)
907 {
908  return ((op)->ft->setClassName ((op), (cn)));
909 }
910 # else
911 # define CMSetClassName(p,n) ((p)->ft->setClassName((p),(n)))
912 # endif
913 
914 # ifdef CMPI_INLINE
915 
920 inline static CMPIString *CMGetClassName
921  (const CMPIObjectPath * op, CMPIStatus * rc)
922 {
923  return ((op)->ft->getClassName ((op), (rc)));
924 }
925 # else
926 # define CMGetClassName(p,rc) ((p)->ft->getClassName((p),(rc)))
927 # endif
928 
929 # ifdef CMPI_INLINE
930 
937 inline static CMPIStatus CMAddKey
938  (CMPIObjectPath * op, const char *name,
939  const CMPIValue * value, const CMPIType type)
940 {
941  return ((op)->ft->addKey ((op), (name), (value), (type)));
942 }
943 # else
944 # define CMAddKey(p,n,v,t) \
945  ((p)->ft->addKey((p),(n),(CMPIValue*)(v),(t)))
946 # endif
947 
948 # ifdef CMPI_INLINE
949 
955 inline static CMPIData CMGetKey
956  (const CMPIObjectPath * op, const char *name, CMPIStatus * rc)
957 {
958  return ((op)->ft->getKey ((op), (name), (rc)));
959 }
960 # else
961 # define CMGetKey(p,n,rc) ((p)->ft->getKey((p),(n),(rc)))
962 # endif
963 
964 # ifdef CMPI_INLINE
965 
972 inline static CMPIData CMGetKeyAt
973  (const CMPIObjectPath * op, CMPICount index, CMPIString ** name,
974  CMPIStatus * rc)
975 {
976  return ((op)->ft->getKeyAt ((op), (index), (name), (rc)));
977 }
978 # else
979 # define CMGetKeyAt(p,i,n,rc) ((p)->ft->getKeyAt((p),(i),(n),(rc)))
980 # endif
981 
982 
983 # ifdef CMPI_INLINE
984 
989 inline static CMPICount CMGetKeyCount
990  (const CMPIObjectPath * op, CMPIStatus * rc)
991 {
992  return ((op)->ft->getKeyCount ((op), (rc)));
993 }
994 # else
995 # define CMGetKeyCount(p,rc) ((p)->ft->getKeyCount((p),(rc)))
996 # endif
997 
998 # ifdef CMPI_INLINE
999 
1005  (CMPIObjectPath * op, const CMPIObjectPath * src)
1006 {
1007  return ((op)->ft->setNameSpaceFromObjectPath ((op), (src)));
1008 }
1009 # else
1010 # define CMSetNameSpaceFromObjectPath(p,s) \
1011  ((p)->ft->setNameSpaceFromObjectPath((p),(s)))
1012 # endif
1013 
1014 # ifdef CMPI_INLINE
1015 
1021  (CMPIObjectPath * op, const CMPIObjectPath * src)
1022 {
1023  return ((op)->ft->setHostAndNameSpaceFromObjectPath ((op), (src)));
1024 }
1025 # else
1026 # define CMSetHostAndNameSpaceFromObjectPath(p,s) \
1027  ((p)->ft->setHostAndNameSpaceFromObjectPath((p),(s)))
1028 # endif
1029 
1030 #ifdef CMPI_INLINE
1031 
1037  inline static CMPIData CMGetClassQualifier
1038  (const CMPIObjectPath* op,
1039  const char *qName,
1040  CMPIStatus *rc)
1041  { return ((op)->ft->getClassQualifier((op),(qName),(rc))); }
1042 #else
1043  #define CMGetClassQualifier(op,qName,rc) \
1044  ((op)->ft->getClassQualifier((op),(qName),(rc)))
1045 #endif
1046 
1047 #ifdef CMPI_INLINE
1048 
1055  inline static CMPIData CMGetPropertyQualifier
1056  (const CMPIObjectPath* op,
1057  const char *pName,
1058  const char *qName,
1059  CMPIStatus *rc)
1060  { return ((op)->ft->getPropertyQualifier((op),(pName),(qName),(rc))); }
1061 #else
1062  #define CMGetPropertyQualifier(op,pName,qName,rc) \
1063  ((op)->ft->getPropertyQualifier((op),(pName),(qName),(rc)))
1064 #endif
1065 
1066 #ifdef CMPI_INLINE
1067 
1074  inline static CMPIData CMGetMethodQualifier
1075  (const CMPIObjectPath* op,
1076  const char *methodName,
1077  const char *qName,
1078  CMPIStatus *rc)
1079  { return ((op)->ft->getMethodQualifier((op),(methodName),(qName),(rc))); }
1080 #else
1081  #define CMGetMethodQualifier(op,methodName,qName,rc) \
1082  ((op)->ft->getMethodQualifier((op),(methodName),(qName),(rc)))
1083 #endif
1084 
1085 #ifdef CMPI_INLINE
1086 
1094  inline static CMPIData CMGetParameterQualifier
1095  (const CMPIObjectPath* op,
1096  const char *mName,
1097  const char *pName,
1098  const char *qName,
1099  CMPIStatus *rc)
1100  { return ((op)->ft->getParameterQualifier((op),(mName),(pName),(qName),(rc))); }
1101 #else
1102  #define CMGetParameterQualifier(op,mName,pName,qName,rc) \
1103  ((op)->ft->getParameterQualifier((op),(mName),(pName),(qName),(rc)))
1104 #endif
1105 
1106 # ifdef CMPI_VER_86
1107 # ifdef CMPI_INLINE
1108 
1113 inline static CMPIString *CMObjectPathToString
1114  (const CMPIObjectPath * op, CMPIStatus * rc)
1115 {
1116  return ((op)->ft->toString ((op), (rc)));
1117 }
1118 # else
1119 # define CMObjectPathToString(p,rc) \
1120  ((p)->ft->toString((p),(rc)))
1121 # endif
1122 # endif /* CMPI_VER_86 */
1123 
1124  // CMPIArray macros
1125 
1126 
1127 # ifdef CMPI_INLINE
1128 
1133 inline static CMPICount CMGetArrayCount
1134  (const CMPIArray * ar, CMPIStatus * rc)
1135 {
1136  return ((ar)->ft->getSize ((ar), (rc)));
1137 }
1138 # else
1139 # define CMGetArrayCount(a,rc) ((a)->ft->getSize((a),(rc)))
1140 # endif
1141 
1142 # ifdef CMPI_INLINE
1143 
1148 inline static CMPIType
1149 CMGetArrayType (const CMPIArray * ar, CMPIStatus * rc)
1150 {
1151  return ((ar)->ft->getSimpleType ((ar), (rc)));
1152 }
1153 # else
1154 # define CMGetArrayType(a,rc) ((a)->ft->getSimpleType((a),(rc)))
1155 # endif
1156 
1157 # ifdef CMPI_INLINE
1158 
1164 inline static CMPIData CMGetArrayElementAt
1165  (const CMPIArray * ar, CMPICount index, CMPIStatus * rc)
1166 {
1167  return ((ar)->ft->getElementAt ((ar), (index), (rc)));
1168 }
1169 # else
1170 # define CMGetArrayElementAt(a,n,rc) \
1171  ((a)->ft->getElementAt((a),(n),(rc)))
1172 # endif
1173 
1174 # ifdef CMPI_INLINE
1175 
1182 inline static CMPIStatus CMSetArrayElementAt
1183  (CMPIArray * ar, CMPICount index, const CMPIValue * value, CMPIType type)
1184 {
1185  return ((ar)->ft->setElementAt ((ar), (index), (value), (type)));
1186 }
1187 # else
1188 # define CMSetArrayElementAt(a,n,v,t) \
1189  ((a)->ft->setElementAt((a),(n),(CMPIValue*)(v),(t)))
1190 # endif
1191 
1192 
1193 
1194  // CMPIArgs macros
1195 
1196 
1197 # ifdef CMPI_INLINE
1198 
1205 inline static CMPIStatus CMAddArg
1206  (CMPIArgs * as, char *name, const CMPIValue * value, const CMPIType type)
1207 {
1208  return ((as)->ft->addArg ((as), (name), (CMPIValue*)(value), (type)));
1209 }
1210 # else
1211 # define CMAddArg(a,n,v,t) \
1212  ((a)->ft->addArg((a),(n),(CMPIValue*)(v),(t)))
1213 # endif
1214 
1215 # ifdef CMPI_INLINE
1216 
1222 inline static CMPIData CMGetArg
1223  (const CMPIArgs * as, const char *name, CMPIStatus * rc)
1224 {
1225  return ((as)->ft->getArg ((as), (name), (rc)));
1226 }
1227 # else
1228 # define CMGetArg(a,n,rc) ((a)->ft->getArg((a),(n),(rc)))
1229 # endif
1230 
1231 # ifdef CMPI_INLINE
1232 
1239 inline static CMPIData CMGetArgAt
1240  (const CMPIArgs * as, CMPICount index, CMPIString ** name, CMPIStatus * rc)
1241 {
1242  return ((as)->ft->getArgAt ((as), (index), (name), (rc)));
1243 }
1244 # else
1245 # define CMGetArgAt(a,p,n,rc) ((a)->ft->getArgAt((a),(p),(n),(rc)))
1246 # endif
1247 
1248 # ifdef CMPI_INLINE
1249 
1254 inline static CMPICount CMGetArgCount (const CMPIArgs * as, CMPIStatus * rc)
1255 {
1256  return ((as)->ft->getArgCount ((as), (rc)));
1257 }
1258 # else
1259 # define CMGetArgCount(a,rc) ((a)->ft->getArgCount((a),(rc)))
1260 # endif
1261 
1262 
1263 
1264  // CMPIString Macros
1265 
1266 # define CMGetCharPtr(s) ((char*)s->hdl)
1267 
1268 # ifdef CMPI_INLINE
1269 
1274 inline static char *
1275 CMGetCharsPtr (const CMPIString * st, CMPIStatus * rc)
1276 {
1277  return ((st)->ft->getCharPtr ((st), (rc)));
1278 }
1279 # else
1280 # define CMGetCharsPtr(st,rc) ((st)->ft->getCharPtr((st),(rc)))
1281 # endif
1282 
1283 
1284 
1285  // CMPIDateTime macros
1286 
1287 
1288 # ifdef CMPI_INLINE
1289 
1294 inline static CMPIString *CMGetStringFormat
1295  (const CMPIDateTime * dt, CMPIStatus * rc)
1296 {
1297  return ((dt)->ft->getStringFormat ((dt), (rc)));
1298 }
1299 # else
1300 # define CMGetStringFormat(d,rc) ((d)->ft->getStringFormat((d),(rc)))
1301 # endif
1302 
1303 # ifdef CMPI_INLINE
1304 
1310 inline static CMPIUint64 CMGetBinaryFormat
1311  (const CMPIDateTime * dt, CMPIStatus * rc)
1312 {
1313  return ((dt)->ft->getBinaryFormat ((dt), (rc)));
1314 }
1315 # else
1316 # define CMGetBinaryFormat(d,rc) ((d)->ft->getBinaryFormat((d),(rc)))
1317 # endif
1318 
1319 # ifdef CMPI_INLINE
1320 
1325 inline static CMPIBoolean CMIsInterval
1326  (const CMPIDateTime * dt, CMPIStatus * rc)
1327 {
1328  return ((dt)->ft->isInterval ((dt), (rc)));
1329 }
1330 # else
1331 # define CMIsInterval(d,rc) ((d)->ft->isInterval((d),(rc)))
1332 # endif
1333 
1334 
1335 
1336  // CMPIError macros
1337 
1338 # ifdef CMPI_VER_200
1339 
1340 # ifdef CMPI_INLINE
1341 
1346 inline static CMPIErrorType (*getErrorType)(
1347  const CMPIError* er, CMPIStatus* rc)
1348 {
1349  return ((er)->ft->getErrorType ((er), (rc)));
1350 }
1351 # else
1352 # define CMGetErrorType(e,rc) \
1353  ((e)->ft->getErrorType((e),(rc)))
1354 # endif
1355 
1356 # ifdef CMPI_INLINE
1357 
1362 inline static CMPIString* (*getOtherErrorType)(
1363  const CMPIError* er, CMPIStatus* rc)
1364 {
1365  return ((er)->ft->getOtherErrorType ((er), (rc)));
1366 }
1367 # else
1368 # define CMGetOtherErrorType(e,rc) \
1369  ((e)->ft->getOtherErrorType((e),(rc)))
1370 # endif
1371 
1372 # ifdef CMPI_INLINE
1373 
1378 inline static CMPIString* (*getOwningEntity)(
1379  const CMPIError* er, CMPIStatus* rc)
1380 {
1381  return ((er)->ft->getOwningEntity ((er), (rc)));
1382 }
1383 # else
1384 # define CMGetOwningEntity(e,rc) \
1385  ((e)->ft->getOwningEntity((e),(rc)))
1386 # endif
1387 
1388 # ifdef CMPI_INLINE
1389 
1394 inline static CMPIString* (*getMessageID)(const CMPIError* er, CMPIStatus* rc)
1395 {
1396  return ((er)->ft->getMessageID ((er), (rc)));
1397 }
1398 # else
1399 # define CMGetMessageID(e,rc) \
1400  ((e)->ft->getMessageID((e),(rc)))
1401 # endif
1402 
1403 # ifdef CMPI_INLINE
1404 
1409 inline static CMPIString* (*getMessage)(const CMPIError* er, CMPIStatus* rc)
1410 {
1411  return ((er)->ft->getMessage ((er), (rc)));
1412 }
1413 # else
1414 # define CMGetErrorMessage(e,rc) \
1415  ((e)->ft->getMessage((e),(rc)))
1416 # endif
1417 
1418 # ifdef CMPI_INLINE
1419 
1424 inline static CMPIErrorSeverity (*getPerceivedSeverity)(
1425  const CMPIError* er, CMPIStatus* rc)
1426 {
1427  return ((er)->ft->getPerceivedSeverity ((er), (rc)));
1428 }
1429 # else
1430 # define CMGetPerceivedSeverity(e,rc) \
1431  ((e)->ft->getPerceivedSeverity((e),(rc)))
1432 # endif
1433 
1434 # ifdef CMPI_INLINE
1435 
1440 inline static CMPIErrorProbableCause (*getProbableCause)(
1441  const CMPIError* er, CMPIStatus* rc)
1442 {
1443  return ((er)->ft->getProbableCause ((er), (rc)));
1444 }
1445 # else
1446 # define CMGetProbableCause(e,rc) \
1447  ((e)->ft->getProbableCause((e),(rc)))
1448 # endif
1449 
1450 # ifdef CMPI_INLINE
1451 
1456 inline static CMPIString* (*getProbableCauseDescription)(
1457  const CMPIError* er, CMPIStatus* rc)
1458 {
1459  return ((er)->ft->getProbableCauseDescription ((er), (rc)));
1460 }
1461 # else
1462 # define CMGetProbableCauseDescription(e,rc) \
1463  ((e)->ft->getProbableCauseDescription((e),(rc)))
1464 # endif
1465 
1466 # ifdef CMPI_INLINE
1467 
1472 inline static CMPIArray* (*getRecommendedActions)(
1473  const CMPIError* er, CMPIStatus* rc)
1474 {
1475  return ((er)->ft->getRecommendedActions ((er), (rc)));
1476 }
1477 # else
1478 # define CMGetRecommendedActions(e,rc) \
1479  ((e)->ft->getRecommendedActions((e),(rc)))
1480 # endif
1481 
1482 # ifdef CMPI_INLINE
1483 
1488 inline static CMPIString* (*getErrorSource)(
1489  const CMPIError* er, CMPIStatus* rc)
1490 {
1491  return ((er)->ft->getErrorSource ((er), (rc)));
1492 }
1493 # else
1494 # define CMGetErrorSource(e,rc) \
1495  ((e)->ft->getErrorSource((e),(rc)))
1496 # endif
1497 
1498 # ifdef CMPI_INLINE
1499 
1504 inline static CMPIErrorSrcFormat (*getErrorSourceFormat)(
1505  const CMPIError* er, CMPIStatus* rc)
1506 {
1507  return ((er)->ft->getErrorSourceFormat ((er), (rc)));
1508 }
1509 # else
1510 # define CMGetErrorSourceFormat(e,rc) \
1511  ((e)->ft->getErrorSourceFormat((e),(rc)))
1512 # endif
1513 
1514 # ifdef CMPI_INLINE
1515 
1520 inline static CMPIString* (*getOtherErrorSourceFormat)(
1521  const CMPIError* er, CMPIStatus* rc)
1522 {
1523  return ((er)->ft->getOtherErrorSourceFormat ((er), (rc)));
1524 }
1525 # else
1526 # define CMGetOtherErrorSourceFormat(e,rc) \
1527  ((e)->ft->getOtherErrorSourceFormat((e),(rc)))
1528 # endif
1529 
1530 # ifdef CMPI_INLINE
1531 
1536 inline static CMPIrc (*getCIMStatusCode)(const CMPIError* er, CMPIStatus* rc)
1537 {
1538  return ((er)->ft->getCIMStatusCode ((er), (rc)));
1539 }
1540 # else
1541 # define CMGetCIMStatusCode(e,rc) \
1542  ((e)->ft->getCIMStatusCode((e),(rc)))
1543 # endif
1544 
1545 # ifdef CMPI_INLINE
1546 
1551 inline static CMPIString* (*getCIMStatusCodeDescription)(
1552  const CMPIError* er, CMPIStatus* rc)
1553 {
1554  return ((er)->ft->getCIMStatusCodeDescription ((er), (rc)));
1555 }
1556 # else
1557 # define CMGetCIMStatusCodeDescription(e,rc) \
1558  ((e)->ft->getCIMStatusCodeDescription((e),(rc)))
1559 # endif
1560 
1561 # ifdef CMPI_INLINE
1562 
1567 inline static CMPIArray* (*getMessageArguments)(
1568  const CMPIError* er, CMPIStatus* rc)
1569 {
1570  return ((er)->ft->getMessageArguments ((er), (rc)));
1571 }
1572 # else
1573 # define CMGetMessageArguments(e,rc) \
1574  ((e)->ft->getMessageArguments((e),(rc)))
1575 # endif
1576 
1577 # ifdef CMPI_INLINE
1578 
1583 inline static CMPIStatus (*setErrorType)(
1584  CMPIError* er, const CMPIErrorType et)
1585 {
1586  return ((er)->ft->setErrorType ((er), (et)));
1587 }
1588 # else
1589 # define CMSetErrorType(e,et) \
1590  ((e)->ft->setErrorType((e),(et)))
1591 # endif
1592 
1593 # ifdef CMPI_INLINE
1594 
1599 inline static CMPIStatus (*setOtherErrorType)(CMPIError* er, const char * oet)
1600 {
1601  return ((er)->ft->setOtherErrorType ((er), (oet)));
1602 }
1603 # else
1604 # define CMSetOtherErrorType(e,oet) \
1605  ((e)->ft->setOtherErrorType((e),(oet)))
1606 # endif
1607 
1608 # ifdef CMPI_INLINE
1609 
1614 inline static CMPIStatus (*setProbableCauseDescription)(
1615  CMPIError* er, const char * pcd)
1616 {
1617  return ((er)->ft->setProbableCauseDescription ((er), (pcd)));
1618 }
1619 # else
1620 # define CMSetProbableCauseDescription(e,pcd) \
1621  ((e)->ft->setProbableCauseDescription((e),(pcd)))
1622 # endif
1623 
1624 # ifdef CMPI_INLINE
1625 
1630 inline static CMPIStatus (*setRecommendedActions)(
1631  CMPIError* er, const CMPIArray* ra)
1632 {
1633  return ((er)->ft->setRecommendedActions ((er), (ra)));
1634 }
1635 # else
1636 # define CMSetRecommendedActions(e,ra) \
1637  ((e)->ft->setRecommendedActions((e),(ra)))
1638 # endif
1639 
1640 # ifdef CMPI_INLINE
1641 
1646 inline static CMPIStatus (*setErrorSource)(CMPIError* er, const char* es);
1647 {
1648  return ((er)->ft->setErrorSource ((er), (es)));
1649 }
1650 # else
1651 # define CMSetErrorSource(e,es) \
1652  ((e)->ft->setErrorSource((e),(es)))
1653 # endif
1654 
1655 # ifdef CMPI_INLINE
1656 
1661 inline static CMPIStatus (*setErrorSourceFormat)(
1662  CMPIError* er, const CMPIErrorSrcFormat esf);
1663 {
1664  return ((er)->ft->setErrorSourceFormat ((er), (esf)));
1665 }
1666 # else
1667 # define CMSetErrorSourceFormat(e,esf) \
1668  ((e)->ft->setErrorSourceFormat((e),(esf)))
1669 # endif
1670 
1671 # ifdef CMPI_INLINE
1672 
1677 inline static CMPIStatus (*setOtherErrorSourceFormat)(
1678  CMPIError* er, const char* oesf)
1679 {
1680  return ((er)->ft->setOtherErrorSourceFormat ((er), (oesf)));
1681 }
1682 # else
1683 # define CMSetOtherErrorSourceFormat(e,oesf) \
1684  ((e)->ft->setOtherErrorSourceFormat((e),(oesf)))
1685 # endif
1686 
1687 # ifdef CMPI_INLINE
1688 
1693 inline static CMPIStatus (*setCIMStatusCodeDescription)(
1694  CMPIError* er, const char* cd);
1695 {
1696  return ((er)->ft->setCIMStatusCodeDescription ((er), (cd)));
1697 }
1698 # else
1699 # define CMSetCIMStatusCodeDescription(e,cd) \
1700  ((e)->ft->setCIMStatusCodeDescription((e),(cd)))
1701 # endif
1702 # ifdef CMPI_INLINE
1703 
1709 inline static CMPIStatus (*setMessageArguments)(CMPIError* er, CMPIArray* ma)
1710 {
1711  return ((er)->ft->setMessageArguments ((er), (ma)));
1712 }
1713 # else
1714 # define CMSetMessageArguments(e,ma) \
1715  ((e)->ft->setMessageArguments((e),(ma)))
1716 # endif
1717 
1718 # endif /* CMPI_VER_200 */
1719 
1720 
1721  // CMPIEnumeration Macros
1722 
1723 
1724 # ifdef CMPI_INLINE
1725 
1730 inline static CMPIData
1731 CMGetNext (const CMPIEnumeration * en, CMPIStatus * rc)
1732 {
1733  return ((en)->ft->getNext ((en), (rc)));
1734 }
1735 # else
1736 # define CMGetNext(n,rc) ((n)->ft->getNext((n),(rc)))
1737 # endif
1738 
1739 # ifdef CMPI_INLINE
1740 
1745 inline static CMPIBoolean CMHasNext
1746  (const CMPIEnumeration * en, CMPIStatus * rc)
1747 {
1748  return ((en)->ft->hasNext ((en), (rc)));
1749 }
1750 # else
1751 # define CMHasNext(n,rc) ((n)->ft->hasNext((n),(rc)))
1752 # endif
1753 
1754 # ifdef CMPI_INLINE
1755 
1760 inline static CMPIArray *CMToArray
1761  (const CMPIEnumeration * en, CMPIStatus * rc)
1762 {
1763  return ((en)->ft->toArray ((en), (rc)));
1764 }
1765 # else
1766 # define CMToArray(n,rc) ((n)->ft->toArray((n),(rc)))
1767 # endif
1768 
1769 
1770  // CMPIResult Macros
1771 
1772 
1773 # ifdef CMPI_INLINE
1774 
1780 inline static CMPIStatus CMReturnData
1781  (const CMPIResult * rslt, const CMPIValue * value, const CMPIType type)
1782 {
1783  return ((rslt)->ft->returnData ((rslt), (value), (type)));
1784 }
1785 # else
1786 # define CMReturnData(r,v,t) \
1787  ((r)->ft->returnData((r),(CMPIValue*)(v),(t)))
1788 # endif
1789 
1790 # ifdef CMPI_INLINE
1791 
1796 inline static CMPIStatus CMReturnInstance
1797  (const CMPIResult * rslt, const CMPIInstance * inst)
1798 {
1799  return ((rslt)->ft->returnInstance ((rslt), (inst)));
1800 }
1801 # else
1802 # define CMReturnInstance(r,i) ((r)->ft->returnInstance((r),(i)))
1803 # endif
1804 
1805 # ifdef CMPI_INLINE
1806 
1811 inline static CMPIStatus CMReturnObjectPath
1812  (const CMPIResult * rslt, const CMPIObjectPath * ref)
1813 {
1814  return ((rslt)->ft->returnObjectPath ((rslt), (ref)));
1815 }
1816 # else
1817 # define CMReturnObjectPath(r,o) ((r)->ft->returnObjectPath((r),(o)))
1818 # endif
1819 
1820 # ifdef CMPI_INLINE
1821 
1825 inline static CMPIStatus
1826 CMReturnDone (const CMPIResult * rslt)
1827 {
1828  return ((rslt)->ft->returnDone ((rslt)));
1829 }
1830 # else
1831 # define CMReturnDone(r) ((r)->ft->returnDone((r)))
1832 # endif
1833 
1834 # ifdef CMPI_VER_200
1835 # ifdef CMPI_INLINE
1836 
1841 inline static CMPIStatus CMReturnError
1842  (const CMPIResult* rslt, const CMPIError* er)
1843 {
1844  return ((rslt)->ft->returnError ((rslt), (er)));
1845 }
1846 # else
1847 # define CMReturnError(r,e) \
1848  ((r)->ft->returnError((r),(e)))
1849 # endif
1850 # endif /* CMPI_VER_200 */
1851 
1852 
1853  // CMPIContext Macros
1854 
1855 
1856 # ifdef CMPI_INLINE
1857 
1863 inline static CMPIData CMGetContextEntry
1864  (const CMPIContext * ctx, const char *name, CMPIStatus * rc)
1865 {
1866  return ((ctx)->ft->getEntry ((ctx), (name), (rc)));
1867 }
1868 # else
1869 # define CMGetContextEntry(c,n,rc) \
1870  ((c)->ft->getEntry((c),(n),(rc)))
1871 # endif
1872 
1873 # ifdef CMPI_INLINE
1874 
1881 inline static CMPIData CMGetContextEntryAt
1882  (const CMPIContext * ctx, CMPICount index, CMPIString ** name,
1883  CMPIStatus * rc)
1884 {
1885  return ((ctx)->ft->getEntryAt ((ctx), (index), (name), (rc)));
1886 }
1887 # else
1888 # define CMGetContextEntryAt(c,p,n,rc) \
1889  ((c)->ft->getEntryAt((c),(p),(n),(rc)))
1890 # endif
1891 
1892 # ifdef CMPI_INLINE
1893 
1898 inline static CMPICount CMGetContextEntryCount
1899  (const CMPIContext * ctx, CMPIStatus * rc)
1900 {
1901  return ((ctx)->ft->getEntryCount ((ctx), (rc)));
1902 }
1903 # else
1904 # define CMGetContextEntryCount(c,rc) \
1905  ((c)->ft->getEntryCount((c),(rc)))
1906 # endif
1907 
1908 # ifdef CMPI_INLINE
1909 
1916 inline static CMPIStatus CMAddContextEntry
1917  (const CMPIContext * ctx, const char *name, const CMPIValue * value,
1918  const CMPIType type)
1919 {
1920  return ((ctx)->ft->addEntry ((ctx), (name), (value), (type)));
1921 }
1922 # else
1923 # define CMAddContextEntry(c,n,v,t) \
1924  ((c)->ft->addEntry((c),(n),(CMPIValue*)(v),(t)))
1925 # endif
1926 
1927 
1928 
1929  // CMPISelectExp macros
1930 
1931 
1932 
1933 # ifdef CMPI_INLINE
1934 
1939 inline static CMPIString *CMGetSelExpString
1940  (const CMPISelectExp * se, CMPIStatus * rc)
1941 {
1942  return ((se)->ft->getString ((se), (rc)));
1943 }
1944 # else
1945 # define CMGetSelExpString(s,rc) ((s)->ft->getString((s),(rc)))
1946 # endif
1947 
1948 # ifdef CMPI_INLINE
1949 
1955 inline static CMPIBoolean CMEvaluateSelExp
1956  (const CMPISelectExp * se, const CMPIInstance * inst, CMPIStatus * rc)
1957 {
1958  return ((se)->ft->evaluate ((se), (inst), (rc)));
1959 }
1960 # else
1961 # define CMEvaluateSelExp(s,i,r) ((s)->ft->evaluate((s),(i),(r)))
1962 # endif
1963 
1964 # ifdef CMPI_VER_87
1965 # ifdef CMPI_INLINE
1966 
1974  (const CMPISelectExp * se, CMPIAccessor * accessor, void *parm,
1975  CMPIStatus * rc)
1976 {
1977  return ((se)->ft->evaluateUsingAccessor ((se), (accessor), (parm), (rc)));
1978 }
1979 # else
1980 # define CMEvaluateSelExpUsingAccessor(s,i,p,r) \
1981  ((s)->ft->evaluateUsingAccessor((s),(i),(p),(r)))
1982 # endif
1983 # endif /* CMPI_VER_87 */
1984 
1985 # ifdef CMPI_INLINE
1986 
1991 inline static CMPISelectCond *CMGetDoc
1992  (const CMPISelectExp * se, CMPIStatus * rc)
1993 {
1994  return ((se)->ft->getDOC ((se), (rc)));
1995 }
1996 # else
1997 # define CMGetDoc(s,rc) ((s)->ft->getDOC((s),(rc)))
1998 # endif
1999 
2000 # ifdef CMPI_INLINE
2001 
2006 inline static CMPISelectCond *CMGetCod
2007  (const CMPISelectExp * se, CMPIStatus * rc)
2008 {
2009  return ((se)->ft->getCOD ((se), (rc)));
2010 }
2011 # else
2012 # define CMGetCod(s,rc) ((s)->ft->getCOD((s),(rc)))
2013 # endif
2014 
2015 
2016 
2017  // CMPISelectCond macros
2018 
2019 
2020 
2021 # ifdef CMPI_INLINE
2022 
2029 inline static CMPICount CMGetSubCondCountAndType
2030  (const CMPISelectCond * sc, int * type, CMPIStatus * rc)
2031 {
2032  return ((sc)->ft->getCountAndType ((sc), (type), (rc)));
2033 }
2034 # else
2035 # define CMGetSubCondCountAndType(c,t,rc) \
2036  ((c)->ft->getCountAndType((c),(t),(rc)))
2037 # endif
2038 
2039 # ifdef CMPI_INLINE
2040 
2046 inline static CMPISubCond *CMGetSubCondAt
2047  (const CMPISelectCond * sc, CMPICount index, CMPIStatus * rc)
2048 {
2049  return ((sc)->ft->getSubCondAt ((sc), (index), (rc)));
2050 }
2051 # else
2052 # define CMGetSubCondAt(c,p,rc) ((c)->ft->getSubCondAt((c),(p),(rc)))
2053 # endif
2054 
2055 
2056 
2057  // CMPISubCond macros
2058 
2059 
2060 
2061 # ifdef CMPI_INLINE
2062 
2067 inline static CMPICount CMGetPredicateCount
2068  (const CMPISubCond * sc, CMPIStatus * rc)
2069 {
2070  return ((sc)->ft->getCount ((sc), (rc)));
2071 }
2072 # else
2073 # define CMGetPredicateCount(s,rc) ((s)->ft->getCount((s),(rc)))
2074 # endif
2075 
2076 # ifdef CMPI_INLINE
2077 
2083 inline static CMPIPredicate *CMGetPredicateAt
2084  (const CMPISubCond * sc, CMPICount index, CMPIStatus * rc)
2085 {
2086  return ((sc)->ft->getPredicateAt ((sc), (index), (rc)));
2087 }
2088 # else
2089 # define CMGetPredicateAt(s,p,rc) \
2090  ((s)->ft->getPredicateAt((s),(p),(rc)))
2091 # endif
2092 
2093 # ifdef CMPI_INLINE
2094 
2100 inline static CMPIPredicate *CMGetPredicate
2101  (const CMPISubCond * sc, const char *name, CMPIStatus * rc)
2102 {
2103  return ((sc)->ft->getPredicate ((sc), (name), (rc)));
2104 }
2105 # else
2106 # define CMGetPredicate(s,n,rc) ((s)->ft->getPredicate((s),(n),(rc)))
2107 # endif
2108 
2109 
2110 
2111  // CMPIPredicate macros
2112 
2113 
2114 # ifdef CMPI_INLINE
2115 
2123 inline static CMPIStatus CMGetPredicateData
2124  (const CMPIPredicate * pr, CMPIType * type,
2125  CMPIPredOp * op, CMPIString ** lhs, CMPIString ** rhs)
2126 {
2127  return ((pr)->ft->getData ((pr), (type), (op), (lhs), (rhs)));
2128 }
2129 # else
2130 # define CMGetPredicateData(p,t,o,n,v) \
2131  ((p)->ft->getData((p),(t),(o),(n),(v)))
2132 # endif
2133 
2134 # if defined(CMPI_VER_87) && !defined(CMPI_VER_100)
2135 # ifdef CMPI_INLINE
2136 
2144 inline static int CMEvaluatePredicate
2145  (CMPIPredicate* pr, void* value,
2146  CMPIType type, CMPIStatus* rc)
2147 {
2148  return ((pr)->ft->evaluate((pr),(CMPIValue*)(value),(type),(rc)));
2149 }
2150 # else
2151 # define CMEvaluatePredicate(p,v,t,rc) \
2152  ((p)->ft->evaluate((p),(CMPIValue*)(v),(t),(rc)))
2153 # endif
2154 # endif /* CMPI_VER_87 && !CMPI_VER_100 */
2155 
2156 # ifdef CMPI_VER_100
2157 # ifdef CMPI_INLINE
2158 
2165 inline static int CMEvaluatePredicateUsingAccessor
2166  (const CMPIPredicate * pr, CMPIAccessor * accessor, void *parm,
2167  CMPIStatus * rc)
2168 {
2169  return ((pr)->ft->evaluateUsingAccessor ((pr), (accessor), (parm), (rc)));
2170 }
2171 # else
2172 # define CMEvaluatePredicateUsingAccessor(p,a,parm,rc) \
2173  ((p)->ft->evaluateUsingAccessor((p),(a),(parm),(rc)))
2174 # endif
2175 # endif /* CMPI_VER_100 */
2176 
2177 
2178 
2179  // CMPIBroker Macros
2180 
2181 
2182 
2183 # ifdef CMPI_INLINE
2184 
2187 inline static unsigned long
2188 CBGetBrokerCapabilities (const CMPIBroker * mb)
2189 {
2190  return ((mb)->bft->brokerCapabilities);
2191 }
2192 # else
2193 # define CBGetBrokerCapabilites(b) ((b)->bft->brokerCapabilites)
2194 # endif
2195 
2196 # ifdef CMPI_INLINE
2197 
2199 inline static int
2200 CBBrokerVersion (const CMPIBroker * mb)
2201 {
2202  return ((mb)->bft->brokerVersion);
2203 }
2204 # else
2205 # define CBBrokerVersion(b) ((b)->bft->brokerVersion)
2206 # endif
2207 
2208 # ifdef CMPI_INLINE
2209 
2211 inline static const char *
2212 CBBrokerName (const CMPIBroker * mb)
2213 {
2214  return ((mb)->bft->brokerName);
2215 }
2216 # else
2217 # define CBBrokerName(b) ((b)->bft->brokerName)
2218 # endif
2219 
2220 
2221 # ifdef CMPI_INLINE
2222 
2230 inline static CMPIContext *CBPrepareAttachThread
2231  (const CMPIBroker * mb, const CMPIContext * ctx)
2232 {
2233  return ((mb)->bft->prepareAttachThread ((mb), (ctx)));
2234 }
2235 # else
2236 # define CBPrepareAttachThread(b,c) \
2237  ((b)->bft->prepareAttachThread((b),(c)))
2238 # endif
2239 
2240 # ifdef CMPI_INLINE
2241 
2247 inline static CMPIStatus CBAttachThread
2248  (const CMPIBroker * mb, const CMPIContext * ctx)
2249 {
2250  return ((mb)->bft->attachThread ((mb), (ctx)));
2251 }
2252 # else
2253 # define CBAttachThread(b,c) ((b)->bft->attachThread((b),(c)))
2254 # endif
2255 
2256 # ifdef CMPI_INLINE
2257 
2264 inline static CMPIStatus CBDetachThread
2265  (const CMPIBroker * mb, const CMPIContext * ctx)
2266 {
2267  return ((mb)->bft->detachThread ((mb), (ctx)));
2268 }
2269 # else
2270 # define CBDetachThread(b,c) ((b)->bft->detachThread((b),(c)))
2271 # endif
2272 
2273 
2274 
2275 # ifdef CMPI_INLINE
2276 
2284 inline static CMPIStatus CBDeliverIndication
2285  (const CMPIBroker * mb, const CMPIContext * ctx,
2286  const char *ns, const CMPIInstance * ind)
2287 {
2288  return ((mb)->bft->deliverIndication ((mb), (ctx), (ns), (ind)));
2289 }
2290 # else
2291 # define CBDeliverIndication(b,c,n,i) \
2292  ((b)->bft->deliverIndication((b),(c),(n),(i)))
2293 # endif
2294 
2295 # ifdef CMPI_INLINE
2296 
2303 inline static CMPIEnumeration *CBEnumInstanceNames
2304  (const CMPIBroker * mb, const CMPIContext * ctx,
2305  const CMPIObjectPath * op, CMPIStatus * rc)
2306 {
2307  return ((mb)->bft->enumerateInstanceName ((mb), (ctx), (op), (rc)));
2308 }
2309 # else
2310 # define CBEnumInstanceNames(b,c,p,rc) \
2311  ((b)->bft->enumerateInstanceNames((b),(c),(p),(rc)))
2312 # endif
2313 
2314 # ifdef CMPI_INLINE
2315 
2327 inline static CMPIEnumeration *CBEnumInstances
2328  (const CMPIBroker * mb, const CMPIContext * ctx,
2329  const CMPIObjectPath * op, const char **properties, CMPIStatus * rc)
2330 {
2331  return ((mb)->bft->enumerateInstances ((mb), (ctx), (op), (properties), (rc)));
2332 }
2333 # else
2334 # define CBEnumInstances(b,c,p,pr,rc) \
2335  ((b)->bft->enumerateInstances((b),(c),(p),(pr),(rc)))
2336 # endif
2337 
2338 # ifdef CMPI_INLINE
2339 
2350 inline static CMPIInstance *CBGetInstance
2351  (const CMPIBroker * mb, const CMPIContext * ctx,
2352  const CMPIObjectPath * op, const char **properties, CMPIStatus * rc)
2353 {
2354  return ((mb)->bft->getInstance ((mb), (ctx), (op), (properties), (rc)));
2355 }
2356 # else
2357 # define CBGetInstance(b,c,p,pr,rc) \
2358  ((b)->bft->getInstance((b),(c),(p),(pr),(rc)))
2359 # endif
2360 
2361 # ifdef CMPI_INLINE
2362 
2370 inline static CMPIObjectPath *CBCreateInstance
2371  (const CMPIBroker * mb, const CMPIContext * ctx,
2372  const CMPIObjectPath * op, const CMPIInstance * inst, CMPIStatus * rc)
2373 {
2374  return ((mb)->bft->createInstance ((mb), (ctx), (op), (inst), (rc)));
2375 }
2376 # else
2377 # define CBCreateInstance(b,c,p,i,rc) \
2378  ((b)->bft->createInstance((b),(c),(p),(i),(rc)))
2379 # endif
2380 
2381 # ifdef CMPI_VER_90
2382 # ifdef CMPI_INLINE
2383 
2391 # ifdef CMPI_VER_100
2392 inline static CMPIStatus CBModifyInstance
2393  (const CMPIBroker* mb, const CMPIContext* ctx,
2394  const CMPIObjectPath* op, const CMPIInstance* inst,
2395  const char** properties)
2396 {
2397  return ((mb)->bft->
2398  modifyInstance ((mb), (ctx), (op), (inst), (properties)));
2399 }
2400 # else
2401 inline static CMPIStatus CBSetInstance
2402  (const CMPIBroker* mb, const CMPIContext* ctx,
2403  const CMPIObjectPath* op, const CMPIInstance* inst,
2404  const char** properties)
2405 {
2406  return ((mb)->bft->
2407  setInstance ((mb), (ctx), (op), (inst), (properties)));
2408 }
2409 # endif /* CMPI_VER_100 */
2410 # else
2411 # ifdef CMPI_VER_100
2412 # define CBModifyInstance(b,c,p,i,pr) ((b)->bft->modifyInstance((b),(c),(p),(i),(pr)))
2413 # else
2414 # define CBSetInstance(b,c,p,i,pr) ((b)->bft->setInstance((b),(c),(p),(i),(pr)))
2415 # endif /* CMPI_VER_100 */
2416 # endif
2417 # else /* CMPI_VER_90 */
2418 # ifdef CMPI_INLINE
2419 
2426 inline static CMPIStatus CBSetInstance
2427  (CMPIBroker* mb, CMPIContext* ctx,
2428  CMPIObjectPath* op, CMPIInstance* inst)
2429 {
2430  return ((mb)->bft->
2431  setInstance ((mb), (ctx), (op), (inst), NULL));
2432 }
2433 # else
2434 # define CBSetInstance(b,c,p,i) ((b)->bft->setInstance((b),(c),(p),(i),NULL))
2435 # endif
2436 # endif /* CMPI_VER_90 */
2437 
2438 # ifdef CMPI_INLINE
2439 
2445 inline static CMPIStatus CBDeleteInstance
2446  (const CMPIBroker * mb, const CMPIContext * ctx, const CMPIObjectPath * op)
2447 {
2448  return ((mb)->bft->deleteInstance ((mb), (ctx), (op)));
2449 }
2450 # else
2451 # define CBDeleteInstance(b,c,p) ((b)->bft->deleteInstance((b),(c),(p)))
2452 # endif
2453 
2454 # ifdef CMPI_INLINE
2455 
2465 inline static CMPIEnumeration *CBExecQuery
2466  (const CMPIBroker * mb, const CMPIContext * ctx,
2467  const CMPIObjectPath * op, const char *query, const char *lang,
2468  CMPIStatus * rc)
2469 {
2470  return ((mb)->bft->execQuery ((mb), (ctx), (op), (query), (lang), (rc)));
2471 }
2472 # else
2473 # define CBExecQuery(b,c,p,l,q,rc) \
2474  ((b)->bft->execQuery((b),(c),(p),(l),(q),(rc)))
2475 # endif
2476 
2477 
2478 # ifdef CMPI_INLINE
2479 
2509 inline static CMPIEnumeration *CBAssociators
2510  (const CMPIBroker * mb, const CMPIContext * ctx,
2511  const CMPIObjectPath * op, const char *assocClass, const char *resultClass,
2512  const char *role, const char *resultRole, const char **properties,
2513  CMPIStatus * rc)
2514 {
2515  return ((mb)->bft->
2516  associators ((mb), (ctx), (op), (assocClass), (resultClass), (role),
2517  (resultRole), (properties), (rc)));
2518 }
2519 # else
2520 # define CBAssociators(b,c,p,acl,rcl,r,rr,pr,rc) \
2521  ((b)->bft->associators((b),(c),(p),(acl),(rcl),(r),(rr),(pr),(rc)))
2522 # endif
2523 
2524 # ifdef CMPI_INLINE
2525 
2552 inline static CMPIEnumeration *CBAssociatorNames
2553  (const CMPIBroker * mb, const CMPIContext * ctx,
2554  const CMPIObjectPath * op, const char *assocClass, const char *resultClass,
2555  const char *role, const char *resultRole, CMPIStatus * rc)
2556 {
2557  return ((mb)->bft->associatorNames ((mb), (ctx), (op),
2558  (assocClass), (resultClass), (role),
2559  (resultRole), (rc)));
2560 }
2561 # else
2562 # define CBAssociatorNames(b,c,p,acl,rcl,r,rr,rc) \
2563  ((b)->bft->associatorNames((b),(c),(p),(acl),(rcl),(r),(rr),(rc)))
2564 # endif
2565 
2566 # ifdef CMPI_INLINE
2567 
2588 inline static CMPIEnumeration *CBReferences
2589  (const CMPIBroker * mb, const CMPIContext * ctx,
2590  const CMPIObjectPath * op, const char *resultClass, const char *role,
2591  const char **properties, CMPIStatus * rc)
2592 {
2593  return ((mb)->bft->references ((mb), (ctx), (op),
2594  (resultClass), (role), (properties), (rc)));
2595 }
2596 # else
2597 # define CBReferences(b,c,p,acl,r,pr,rc) \
2598  ((b)->bft->references((b),(c),(p),(acl),(r),(pr),(rc)))
2599 # endif
2600 
2601 # ifdef CMPI_INLINE
2602 
2620 inline static CMPIEnumeration *CBReferenceNames
2621  (const CMPIBroker * mb, const CMPIContext * ctx,
2622  const CMPIObjectPath * op, const char *resultClass, const char *role,
2623  CMPIStatus * rc)
2624 {
2625  return ((mb)->bft->
2626  referenceNames ((mb), (ctx), (op), (resultClass), (role), (rc)));
2627 }
2628 # else
2629 # define CBReferenceNames(b,c,p,acl,r,rc) \
2630  ((b)->bft->referenceNames((b),(c),(p),(acl),(r),(rc)))
2631 # endif
2632 
2633 
2634 # ifdef CMPI_INLINE
2635 
2646 inline static CMPIData CBInvokeMethod
2647  (const CMPIBroker * mb, const CMPIContext * ctx,
2648  const CMPIObjectPath * op, const char *method,
2649  const CMPIArgs * in, CMPIArgs * out, CMPIStatus * rc)
2650 {
2651  return ((mb)->bft->
2652  invokeMethod ((mb), (ctx), (op), (method), (in), (out), (rc)));
2653 }
2654 # else
2655 # define CBInvokeMethod(b,c,p,m,ai,ao,rc) \
2656  ((b)->bft->invokeMethod((b),(c),(p),(m),(ai),(ao),(rc)))
2657 # endif
2658 
2659 # ifdef CMPI_INLINE
2660 
2669 inline static CMPIStatus CBSetProperty
2670  (const CMPIBroker * mb, const CMPIContext * ctx,
2671  const CMPIObjectPath * op, const char *name,
2672  const CMPIValue * value, const CMPIType type)
2673 {
2674  return ((mb)->bft->setProperty ((mb), (ctx), (op), (name),
2675  (CMPIValue *) (value), (type)));
2676 }
2677 # else
2678 # define CBSetProperty(b,c,p,n,v,t) \
2679  ((b)->bft->setProperty((b),(c),(p),(n),(CMPIValue*)(v),(t)))
2680 # endif
2681 
2682 # ifdef CMPI_INLINE
2683 
2691 inline static CMPIData CBGetProperty
2692  (const CMPIBroker * mb, const CMPIContext * ctx,
2693  const CMPIObjectPath * op, const char *name, CMPIStatus * rc)
2694 {
2695  return (mb)->bft->getProperty ((mb), (ctx), (op), (name), (rc));
2696 }
2697 # else
2698 # define CBGetProperty(b,c,p,n,rc) \
2699  (b)->bft->getProperty((b),(c),(p),(n),(rc))
2700 # endif
2701 
2702 
2703 # ifndef DOC_ONLY
2704  // MI factory stubs
2705 
2706  // Used when the MI factory function is not going to call
2707  // a function during initialization.
2708 # define CMNoHook
2709 # endif
2710 
2711 /*
2712  ----------------- C provider factories ---------------------
2713 */
2714 
2715 # ifdef DOC_ONLY
2716 
2735 CMPIInstanceMI *CMInstanceMIStub (chars pfx, chars pn,
2736  CMPIBroker * broker, statement hook);
2737 # else
2738 
2739 # ifdef CMPI_VER_100
2740 # define CMInstanceMIStubChange(pfx) pfx##ModifyInstance
2741 # else
2742 # define CMInstanceMIStubChange(pfx) pfx##SetInstance
2743 # endif /* CMPI_VER_100 */
2744 
2745 # define CMInstanceMIStub(pfx,pn,broker,hook) \
2746  static CMPIInstanceMIFT instMIFT__={ \
2747  CMPICurrentVersion, \
2748  CMPICurrentVersion, \
2749  "instance" #pn, \
2750  pfx##Cleanup, \
2751  pfx##EnumInstanceNames, \
2752  pfx##EnumInstances, \
2753  pfx##GetInstance, \
2754  pfx##CreateInstance, \
2755  CMInstanceMIStubChange(pfx), \
2756  pfx##DeleteInstance, \
2757  pfx##ExecQuery, \
2758  }; \
2759  CMPI_EXTERN_C \
2760  CMPIInstanceMI* pn##_Create_InstanceMI(const CMPIBroker* brkr,const CMPIContext *ctx, CMPIStatus *rc) { \
2761  static CMPIInstanceMI mi={ \
2762  NULL, \
2763  &instMIFT__, \
2764  }; \
2765  broker=brkr; \
2766  hook; \
2767  return &mi; \
2768  }
2769 
2770 # endif
2771 
2772 # ifdef DOC_ONLY
2773 
2793 CMPIAssociationMI *CMAssociationMIStub (chars pfx, chars pn,
2794  CMPIBroker * broker, statement hook);
2795 # else
2796 # define CMAssociationMIStub(pfx,pn,broker,hook) \
2797  static CMPIAssociationMIFT assocMIFT__={ \
2798  CMPICurrentVersion, \
2799  CMPICurrentVersion, \
2800  "association" #pn, \
2801  pfx##AssociationCleanup, \
2802  pfx##Associators, \
2803  pfx##AssociatorNames, \
2804  pfx##References, \
2805  pfx##ReferenceNames, \
2806  }; \
2807  CMPI_EXTERN_C \
2808  CMPIAssociationMI* pn##_Create_AssociationMI(const CMPIBroker* brkr,const CMPIContext *ctx, CMPIStatus *rc) { \
2809  static CMPIAssociationMI mi={ \
2810  NULL, \
2811  &assocMIFT__, \
2812  }; \
2813  broker=brkr; \
2814  hook; \
2815  return &mi; \
2816  }
2817 # endif
2818 
2819 # ifdef DOC_ONLY
2820 
2837 CMPIMethodMI *CMMethodMIStub (chars pfx, chars pn,
2838  CMPIBroker * broker, statement hook);
2839 # else
2840 # define CMMethodMIStub(pfx,pn,broker,hook) \
2841  static CMPIMethodMIFT methMIFT__={ \
2842  CMPICurrentVersion, \
2843  CMPICurrentVersion, \
2844  "method" #pn, \
2845  pfx##MethodCleanup, \
2846  pfx##InvokeMethod, \
2847  }; \
2848  CMPI_EXTERN_C \
2849  CMPIMethodMI* pn##_Create_MethodMI(const CMPIBroker* brkr, const CMPIContext *ctx, CMPIStatus *rc) { \
2850  static CMPIMethodMI mi={ \
2851  NULL, \
2852  &methMIFT__, \
2853  }; \
2854  broker=brkr; \
2855  hook; \
2856  return &mi; \
2857  }
2858 # endif
2859 
2860 # ifdef DOC_ONLY
2861 
2880 CMPIPropertyMI *CMPropertyMIStub (chars pfx, chars pn,
2881  CMPIBroker * broker, statement hook);
2882 # else
2883 # define CMPropertyMIStub(pfx,pn,broker,hook) \
2884  static CMPIPropertyMIFT propMIFT__={ \
2885  CMPICurrentVersion, \
2886  CMPICurrentVersion, \
2887  "property" #pn, \
2888  pfx##PropertyCleanup, \
2889  pfx##SetProperty, \
2890  pfx##GetProperty, \
2891  }; \
2892  CMPI_EXTERN_C \
2893  CMPIPropertyMI* pn##_Create_PropertyMI(const CMPIBroker* brkr,const CMPIContext *ctx, CMPIStatus *rc) { \
2894  static CMPIPropertyMI mi={ \
2895  NULL, \
2896  &propMIFT__, \
2897  }; \
2898  broker=brkr; \
2899  hook; \
2900  return &mi; \
2901  }
2902 # endif
2903 
2904 # ifdef DOC_ONLY
2905 
2923 CMPIIndicationMI *CMIndicationMIStub (chars pfx, chars pn,
2924  CMPIBroker * broker, statement hook);
2925 # else
2926 
2927 # ifdef CMPI_VER_86
2928 # define CMIndicationMIStubExtensions(pfx) pfx##EnableIndications, \
2929  pfx##DisableIndications,
2930 # else
2931 # define CMIndicationMIStubExtensions(pfx)
2932 # endif /* CMPI_VER_86 */
2933 
2934 # define CMIndicationMIStub(pfx,pn,broker,hook) \
2935  static CMPIIndicationMIFT indMIFT__={ \
2936  CMPICurrentVersion, \
2937  CMPICurrentVersion, \
2938  "Indication" #pn, \
2939  pfx##IndicationCleanup, \
2940  pfx##AuthorizeFilter, \
2941  pfx##MustPoll, \
2942  pfx##ActivateFilter, \
2943  pfx##DeActivateFilter, \
2944  CMIndicationMIStubExtensions(pfx) \
2945  }; \
2946  CMPI_EXTERN_C \
2947  CMPIIndicationMI* pn##_Create_IndicationMI(const CMPIBroker* brkr,const CMPIContext *ctx,CMPIStatus *rc) { \
2948  static CMPIIndicationMI mi={ \
2949  NULL, \
2950  &indMIFT__, \
2951  }; \
2952  broker=brkr; \
2953  hook; \
2954  return &mi; \
2955  }
2956 # endif
2957 
2958 /*
2959  ----------------- C++ provider factories ---------------------
2960 */
2961 
2962 # ifdef DOC_ONLY
2963 
2974 CMPIInstanceMI *CMInstanceMIFactory (chars cn, chars pn);
2975 # else
2976 # define CMInstanceMIFactory(cn,pn) \
2977  CMPI_EXTERN_C \
2978  CMPIInstanceMI* pn##_Create_InstanceMI(const CMPIBroker* broker, const CMPIContext *ctxp, CMPIStatus *rc) { \
2979  static CMPIInstanceMIFT instMIFT={ \
2980  CMPICurrentVersion, \
2981  CMPICurrentVersion, \
2982  "instance" #pn, \
2983  (CMPIStatus(*)(CMPIInstanceMI*,const CMPIContext*,CMPIBoolean))CmpiBaseMI::driveBaseCleanup, \
2984  CmpiInstanceMI::driveEnumInstanceNames, \
2985  CmpiInstanceMI::driveEnumInstances, \
2986  CmpiInstanceMI::driveGetInstance, \
2987  CmpiInstanceMI::driveCreateInstance, \
2988  CmpiInstanceMI::driveSetInstance, \
2989  CmpiInstanceMI::driveDeleteInstance, \
2990  CmpiInstanceMI::driveExecQuery, \
2991  }; \
2992  static CMPIInstanceMI mi; \
2993  CmpiContext ctx((CMPIContext*)ctxp); \
2994  mi.ft=&instMIFT; \
2995  CmpiBaseMI *provider=base##pn.getBaseMI(); \
2996  if (provider == 0) {\
2997  provider = new cn(CmpiBroker((CMPIBroker*)broker),ctx); \
2998  provider->setProviderBase(&base##pn); \
2999  provider->initialize(ctx); \
3000  base##pn.setBaseMI(provider); \
3001  } \
3002  mi.hdl=provider; \
3003  base##pn.incUseCount(); \
3004  return &mi; \
3005  }
3006 # endif
3007 
3008 # ifdef DOC_ONLY
3009 
3021 CMPIAssociationMI *CMAssociationMIFactory (chars cn, chars pn);
3022 # else
3023 # define CMAssociationMIFactory(cn,pn) \
3024  CMPI_EXTERN_C \
3025  CMPIAssociationMI* pn##_Create_AssociationMI(const CMPIBroker* broker, const CMPIContext *ctxp, CMPIStatus *rc) { \
3026  static CMPIAssociationMIFT assocMIFT={ \
3027  CMPICurrentVersion, \
3028  CMPICurrentVersion, \
3029  "association" #pn, \
3030  (CMPIStatus(*)(CMPIAssociationMI*,const CMPIContext*,CMPIBoolean))CmpiBaseMI::driveBaseCleanup, \
3031  CmpiAssociationMI::driveAssociators, \
3032  CmpiAssociationMI::driveAssociatorNames, \
3033  CmpiAssociationMI::driveReferences, \
3034  CmpiAssociationMI::driveReferenceNames, \
3035  }; \
3036  static CMPIAssociationMI mi; \
3037  CmpiContext ctx((CMPIContext*)ctxp); \
3038  mi.ft=&assocMIFT; \
3039  CmpiBaseMI *provider=base##pn.getBaseMI(); \
3040  if (provider == 0) {\
3041  provider = new cn(CmpiBroker((CMPIBroker*)broker),ctx); \
3042  provider->setProviderBase(&base##pn); \
3043  provider->initialize(ctx); \
3044  base##pn.setBaseMI(provider); \
3045  } \
3046  mi.hdl=provider; \
3047  base##pn.incUseCount(); \
3048  return &mi; \
3049  }
3050 # endif
3051 
3052 # ifdef DOC_ONLY
3053 
3065 CMPIMethodMI *CMMethodMIFactory (chars cn, chars pn);
3066 # else
3067 # define CMMethodMIFactory(cn,pn) \
3068  CMPI_EXTERN_C \
3069  CMPIMethodMI* pn##_Create_MethodMI(const CMPIBroker* broker, const CMPIContext *ctxp, CMPIStatus *rc) { \
3070  static CMPIMethodMIFT methMIFT={ \
3071  CMPICurrentVersion, \
3072  CMPICurrentVersion, \
3073  "method" #pn, \
3074  (CMPIStatus(*)(CMPIMethodMI*,const CMPIContext*, CMPIBoolean))CmpiBaseMI::driveBaseCleanup, \
3075  CmpiMethodMI::driveInvokeMethod, \
3076  }; \
3077  static CMPIMethodMI mi; \
3078  CmpiContext ctx((CMPIContext*)ctxp); \
3079  mi.ft=&methMIFT; \
3080  CmpiBaseMI *provider=base##pn.getBaseMI(); \
3081  if (provider == 0) {\
3082  provider = new cn(CmpiBroker((CMPIBroker*)broker),ctx); \
3083  provider->setProviderBase(&base##pn); \
3084  provider->initialize(ctx); \
3085  base##pn.setBaseMI(provider); \
3086  } \
3087  mi.hdl=provider; \
3088  base##pn.incUseCount(); \
3089  return &mi; \
3090  }
3091 # endif
3092 
3093 # ifdef DOC_ONLY
3094 
3106 CMPropertyMIFactory (chars cn, chars pn):
3107 # else
3108 # define CMPropertyMIFactory(cn,pn) \
3109  CMPI_EXTERN_C \
3110  CMPIPropertyMI* pn##_Create_PropertyMI(const CMPIBroker* broker, const CMPIContext *ctxp, CMPIStatus *rc) { \
3111  static CMPIPropertyMIFT propMIFT={ \
3112  CMPICurrentVersion, \
3113  CMPICurrentVersion, \
3114  "property" #pn, \
3118  }; \
3119  static CMPIPropertyMI mi; \
3120  CmpiContext ctx((CMPIContext*)ctxp); \
3121  mi.ft=&propMIFT; \
3122  CmpiBaseMI *provider=base##pn.getBaseMI(); \
3123  if (provider == 0) {\
3124  provider = new cn(CmpiBroker((CMPIBroker*)broker),ctx); \
3125  provider->setProviderBase(&base##pn); \
3126  provider->initialize(ctx); \
3127  base##pn.setBaseMI(provider); \
3128  } \
3129  mi.hdl=provider; \
3130  base##pn.incUseCount(); \
3131  return &mi; \
3132  }
3133 # endif
3134 
3135 
3136 # ifdef DOC_ONLY
3137 
3148 CMPIIndicationMI *CMIndicationMIFactory (chars cn, chars pn);
3149 # else
3150 
3151 # ifdef CMPI_VER_86
3152 # define CMIndicationMIFactoryExtensions CmpiIndicationMI::driveEnableIndications, \
3153  CmpiIndicationMI::driveDisableIndications,
3154 # else
3155 # define CMIndicationMIFactoryExtensions
3156 # endif /* CMPI_VER_86 */
3157 
3158 # define CMIndicationMIFactory(cn,pn) \
3159  CMPI_EXTERN_C \
3160  CMPIIndicationMI* pn##_Create_IndicationMI(const CMPIBroker* broker, const CMPIContext *ctxp, CMPIStatus *rc) { \
3161  static CMPIIndicationMIFT indMIFT={ \
3162  CMPICurrentVersion, \
3163  CMPICurrentVersion, \
3164  "indication" #pn, \
3165  (CMPIStatus(*)(CMPIIndicationMI*,const CMPIContext*,CMPIBoolean))CmpiBaseMI::driveBaseCleanup, \
3166  CmpiIndicationMI::driveAuthorizeFilter, \
3167  CmpiIndicationMI::driveMustPoll, \
3168  CmpiIndicationMI::driveActivateFilter, \
3169  CmpiIndicationMI::driveDeActivateFilter, \
3170  CMIndicationMIFactoryExtensions \
3171  }; \
3172  static CMPIIndicationMI mi; \
3173  CmpiContext ctx((CMPIContext*)ctxp); \
3174  mi.ft=&indMIFT; \
3175  CmpiBaseMI *provider=base##pn.getBaseMI(); \
3176  if (provider == 0) {\
3177  provider = new cn(CmpiBroker((CMPIBroker*)broker),ctx); \
3178  provider->setProviderBase(&base##pn); \
3179  provider->initialize(ctx); \
3180  base##pn.setBaseMI(provider); \
3181  } \
3182  mi.hdl=provider; \
3183  base##pn.incUseCount(); \
3184  return &mi; \
3185  }
3186 # endif
3187 
3188 # define CMProviderBase(pn) \
3189  CmpiProviderBase base##pn;
3190 
3191 #endif // _CMPIMACS_H_
#define CMGetBinaryFormat(d, rc)
Definition: cmpimacs.h:1316
enum _CMPIErrorType CMPIErrorType
Definition: cmpift.h:2322
#define CMNewDateTime(b, rc)
Definition: cmpimacs.h:323
#define CBCreateInstance(b, c, p, i, rc)
Definition: cmpimacs.h:2377
Definition: cmpift.h:1893
void * CMPIMsgFileHandle
Definition: cmpidt.h:417
#define CMReturnData(r, v, t)
Definition: cmpimacs.h:1786
#define CDToString(b, o, rc)
Definition: cmpimacs.h:422
#define CMGetMethodQualifier(op, methodName, qName, rc)
Definition: cmpimacs.h:1081
#define CDIsOfType(b, o, t, rc)
Definition: cmpimacs.h:442
#define CMGetKey(p, n, rc)
Definition: cmpimacs.h:961
Definition: cmpidt.h:387
#define CMSetNameSpace(p, n)
Definition: cmpimacs.h:881
enum _CMPIPredOp CMPIPredOp
#define CBSetProperty(b, c, p, n, v, t)
Definition: cmpimacs.h:2678
#define CMGetCod(s, rc)
Definition: cmpimacs.h:2012
Definition: cmpift.h:1506
#define CMMethodMIStub(pfx, pn, broker, hook)
Definition: cmpimacs.h:2840
#define CDGetType(b, o, rc)
Definition: cmpimacs.h:460
#define CMGetDoc(s, rc)
Definition: cmpimacs.h:1997
enum _CMPIErrorProbableCause CMPIErrorProbableCause
#define CBBrokerVersion(b)
Definition: cmpimacs.h:2205
#define CMObjectPathToString(p, rc)
Definition: cmpimacs.h:1119
Definition: CmpiBroker.h:46
CMPIType type
Definition: cmpidt.h:390
CMPIData CMPIAccessor(const char *, void *parm)
Definition: cmpidt.h:399
#define CMIsInterval(d, rc)
Definition: cmpimacs.h:1331
#define CMGetContextEntry(c, n, rc)
Definition: cmpimacs.h:1869
unsigned int CMPICount
Definition: cmpidt.h:138
#define CBEnumInstances(b, c, p, pr, rc)
Definition: cmpimacs.h:2334
Definition: cmpift.h:1173
#define CMReturnError(r, e)
Definition: cmpimacs.h:1847
#define CMCloseMessageFile(b, mfh)
Definition: cmpimacs.h:641
enum _CMPIErrorSrcFormat CMPIErrorSrcFormat
#define CMPropertyMIFactory(cn, pn)
Definition: cmpimacs.h:3108
#define CMGetMessage2(b, id, mfh, def, rc, parms)
Definition: cmpimacs.h:679
Definition: cmpift.h:2488
#define CBDeleteInstance(b, c, p)
Definition: cmpimacs.h:2451
#define CMGetKeyAt(p, i, n, rc)
Definition: cmpimacs.h:979
Definition: cmpift.h:1085
#define CMGetParameterQualifier(op, mName, pName, qName, rc)
Definition: cmpimacs.h:1102
Definition: cmpidt.h:247
#define CMReturnWithChars(b, rc, chars)
Definition: cmpimacs.h:94
#define CMGetMessage(b, id, def, rc, parms)
Definition: cmpimacs.h:526
#define CBEnumInstanceNames(b, c, p, rc)
Definition: cmpimacs.h:2310
Definition: cmpift.h:1815
CMPIValueState state
Definition: cmpidt.h:394
Definition: cmpift.h:1061
Definition: cmpift.h:2403
#define CMGetArrayElementAt(a, n, rc)
Definition: cmpimacs.h:1170
#define CMEvaluateSelExp(s, i, r)
Definition: cmpimacs.h:1961
#define CBBrokerName(b)
Definition: cmpimacs.h:2217
#define CMLogMessage(b, severity, id, text, string)
Definition: cmpimacs.h:551
#define CMSetNameSpaceFromObjectPath(p, s)
Definition: cmpimacs.h:1010
#define CBDetachThread(b, c)
Definition: cmpimacs.h:2270
Definition: cmpift.h:950
#define CMIsKeyValue(v)
Definition: cmpimacs.h:202
#define CMNewObjectPath(b, n, c, rc)
Definition: cmpimacs.h:258
#define CMGetProperty(i, n, rc)
Definition: cmpimacs.h:700
enum _CMPIErrorSeverity CMPIErrorSeverity
#define CMGetSubCondCountAndType(c, t, rc)
Definition: cmpimacs.h:2035
#define CMOpenMessageFile(b, mf, mfh)
Definition: cmpimacs.h:623
#define CMIsNullValue(v)
Definition: cmpimacs.h:189
#define CMGetSubCondAt(c, p, rc)
Definition: cmpimacs.h:2052
#define CMNewDateTimeFromBinary(b, d, i, rc)
Definition: cmpimacs.h:343
#define CMGetKeyCount(p, rc)
Definition: cmpimacs.h:995
#define CMInstanceMIFactory(cn, pn)
Definition: cmpimacs.h:2976
Definition: cmpift.h:1977
#define CMAssociationMIFactory(cn, pn)
Definition: cmpimacs.h:3023
#define CMSetHostAndNameSpaceFromObjectPath(p, s)
Definition: cmpimacs.h:1026
#define CMNewDateTimeFromChars(b, d, rc)
Definition: cmpimacs.h:360
struct _CMPIStatus CMPIStatus
#define CMGetCharsPtr(st, rc)
Definition: cmpimacs.h:1280
#define CMSetClassName(p, n)
Definition: cmpimacs.h:911
#define CMAddContextEntry(c, n, v, t)
Definition: cmpimacs.h:1923
#define CBReferences(b, c, p, acl, r, pr, rc)
Definition: cmpimacs.h:2597
#define CMIndicationMIFactory(cn, pn)
Definition: cmpimacs.h:3158
#define CMSetPropertyWithOrigin(i, n, v, t, o)
Definition: cmpimacs.h:830
#define CBGetInstance(b, c, p, pr, rc)
Definition: cmpimacs.h:2357
#define CMGetPredicate(s, n, rc)
Definition: cmpimacs.h:2106
#define CMGetClassName(p, rc)
Definition: cmpimacs.h:926
#define CMSetStatusWithChars(mb, st, rcp, chars)
Definition: cmpimacs.h:160
#define CMPropertyMIStub(pfx, pn, broker, hook)
Definition: cmpimacs.h:2883
#define CMPI_keyValue
Definition: cmpidt.h:379
#define CMReturn(rc)
Definition: cmpimacs.h:65
#define CMEvaluateSelExpUsingAccessor(s, i, p, r)
Definition: cmpimacs.h:1980
#define CBExecQuery(b, c, p, l, q, rc)
Definition: cmpimacs.h:2473
#define CMSetProperty(i, n, v, t)
Definition: cmpimacs.h:737
#define CMSetStatus(st, rcp)
Definition: cmpimacs.h:116
#define CMHasNext(n, rc)
Definition: cmpimacs.h:1751
#define CMAddKey(p, n, v, t)
Definition: cmpimacs.h:944
#define CBInvokeMethod(b, c, p, m, ai, ao, rc)
Definition: cmpimacs.h:2655
#define CMGetContextEntryAt(c, p, n, rc)
Definition: cmpimacs.h:1888
unsigned char CMPIBoolean
Definition: cmpidt.h:219
#define CMPI_nullValue
Definition: cmpidt.h:378
#define CMGetClassQualifier(op, qName, rc)
Definition: cmpimacs.h:1043
#define CMGetArgCount(a, rc)
Definition: cmpimacs.h:1259
Definition: cmpift.h:1716
static CMPIStatus driveBaseCleanup(void *mi, const CMPIContext *eCtx, CMPIBoolean b)
Definition: CmpiImpl.cpp:62
#define CMNewString(b, s, rc)
Definition: cmpimacs.h:275
#define CMSetHostname(p, n)
Definition: cmpimacs.h:851
#define CMNewArgs(b, rc)
Definition: cmpimacs.h:290
#define CMGetNameSpace(p, rc)
Definition: cmpimacs.h:896
#define CMInstanceMIStub(pfx, pn, broker, hook)
Definition: cmpimacs.h:2745
Definition: cmpift.h:1362
#define CMGetObjectPath(i, rc)
Definition: cmpimacs.h:769
Definition: cmpidt.h:511
#define CMNewInstance(b, c, rc)
Definition: cmpimacs.h:240
#define CMGetSelExpString(s, rc)
Definition: cmpimacs.h:1945
#define CMGetPropertyQualifier(op, pName, qName, rc)
Definition: cmpimacs.h:1062
#define CMReturnObjectPath(r, o)
Definition: cmpimacs.h:1817
#define CMGetPropertyAt(i, num, s, rc)
Definition: cmpimacs.h:718
#define CMGetContextEntryCount(c, rc)
Definition: cmpimacs.h:1904
#define CMGetNext(n, rc)
Definition: cmpimacs.h:1736
#define CBGetProperty(b, c, p, n, rc)
Definition: cmpimacs.h:2698
static CMPIStatus driveGetProperty(CMPIPropertyMI *mi, const CMPIContext *eCtx, const CMPIResult *eRslt, const CMPIObjectPath *eOp, const char *name)
Definition: CmpiImpl.cpp:493
#define CMSetPropertyFilter(i, pl, k)
Definition: cmpimacs.h:807
#define CMReturnInstance(r, i)
Definition: cmpimacs.h:1802
#define CMAddArg(a, n, v, t)
Definition: cmpimacs.h:1211
#define CMIsNullObject(o)
Definition: cmpimacs.h:176
#define CMGetArrayType(a, rc)
Definition: cmpimacs.h:1154
#define CMNewCMPIError(b, owner, msgID, msg, sev, pc, cimStatusCode, rc)
Definition: cmpimacs.h:602
#define CMIsArray(v)
Definition: cmpimacs.h:215
unsigned long long CMPIUint64
Definition: cmpidt.h:225
#define CMToArray(n, rc)
Definition: cmpimacs.h:1766
Definition: cmpift.h:2912
Definition: cmpift.h:3036
#define CMGetArrayCount(a, rc)
Definition: cmpimacs.h:1139
#define CMClassPathIsA(b, p, pn, rc)
Definition: cmpimacs.h:402
Definition: cmpift.h:3138
unsigned short CMPIType
Definition: cmpidt.h:282
#define CMSetArrayElementAt(a, n, v, t)
Definition: cmpimacs.h:1188
Definition: cmpift.h:2162
#define CMPI_EXTERN_C
Definition: cmpios.h:98
#define CBAssociatorNames(b, c, p, acl, rcl, r, rr, rc)
Definition: cmpimacs.h:2562
Definition: cmpift.h:2228
#define CMMethodMIFactory(cn, pn)
Definition: cmpimacs.h:3067
#define CMSetStatusWithString(st, rcp, string)
Definition: cmpimacs.h:137
#define CBReferenceNames(b, c, p, acl, r, rc)
Definition: cmpimacs.h:2629
#define CMGetPredicateData(p, t, o, n, v)
Definition: cmpimacs.h:2130
Definition: cmpift.h:2694
#define CMGetArg(a, n, rc)
Definition: cmpimacs.h:1228
enum _CMPIrc CMPIrc
#define CMNewSelectExp(b, q, l, p, rc)
Definition: cmpimacs.h:382
#define CMGetPredicateCount(s, rc)
Definition: cmpimacs.h:2073
#define CMEvaluatePredicateUsingAccessor(p, a, parm, rc)
Definition: cmpimacs.h:2172
#define CMTraceMessage(b, level, component, text, string)
Definition: cmpimacs.h:575
Definition: cmpift.h:2065
#define CBAttachThread(b, c)
Definition: cmpimacs.h:2253
#define CMGetStringFormat(d, rc)
Definition: cmpimacs.h:1300
#define CMReturnDone(r)
Definition: cmpimacs.h:1831
#define CBModifyInstance(b, c, p, i, pr)
Definition: cmpimacs.h:2412
#define CMNewArray(b, c, t, rc)
Definition: cmpimacs.h:308
#define CMIndicationMIStub(pfx, pn, broker, hook)
Definition: cmpimacs.h:2934
#define CMGetHostname(p, rc)
Definition: cmpimacs.h:866
#define CMGetArgAt(a, p, n, rc)
Definition: cmpimacs.h:1245
#define CMGetPropertyCount(i, rc)
Definition: cmpimacs.h:753
#define CBDeliverIndication(b, c, n, i)
Definition: cmpimacs.h:2291
#define CMSetObjectPath(i, obj)
Definition: cmpimacs.h:788
Definition: cmpift.h:3011
#define CMAssociationMIStub(pfx, pn, broker, hook)
Definition: cmpimacs.h:2796
#define CMPI_ARRAY
Definition: cmpidt.h:319
#define CMGetPredicateAt(s, p, rc)
Definition: cmpimacs.h:2089
#define CMReturnWithString(rc, str)
Definition: cmpimacs.h:79
#define CBAssociators(b, c, p, acl, rcl, r, rr, pr, rc)
Definition: cmpimacs.h:2520
#define CBPrepareAttachThread(b, c)
Definition: cmpimacs.h:2236
static CMPIStatus driveSetProperty(CMPIPropertyMI *mi, const CMPIContext *eCtx, const CMPIResult *eRslt, const CMPIObjectPath *eOp, const char *name, CMPIData data)
Definition: CmpiImpl.cpp:475