cmpimacs.h
1 # 1 "macs.h"
2 # 1 "<built-in>"
3 # 1 "<command-line>"
4 # 1 "/usr/include/stdc-predef.h" 1 3 4
5 
6 # 1 "/usr/include/stdc-predef.h" 3 4
7 /* Copyright (C) 1991-2018 Free Software Foundation, Inc.
8  This file is part of the GNU C Library.
9 
10  The GNU C Library is free software; you can redistribute it and/or
11  modify it under the terms of the GNU Lesser General Public
12  License as published by the Free Software Foundation; either
13  version 2.1 of the License, or (at your option) any later version.
14 
15  The GNU C Library is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  Lesser General Public License for more details.
19 
20  You should have received a copy of the GNU Lesser General Public
21  License along with the GNU C Library; if not, see
22  <http://www.gnu.org/licenses/>. */
23 
24 
25 
26 
27 /* This header is separate from features.h so that the compiler can
28  include it implicitly at the start of every compilation. It must
29  not itself include <features.h> or any other header that includes
30  <features.h> because the implicit include comes before any feature
31  test macros that may be defined in a source file before it first
32  explicitly includes a system header. GCC knows the name of this
33  header in order to preinclude it. */
34 
35 /* glibc's intent is to support the IEC 559 math functionality, real
36  and complex. If the GCC (4.9 and later) predefined macros
37  specifying compiler intent are available, use them to determine
38  whether the overall intent is to support these features; otherwise,
39  presume an older compiler has intent to support these features and
40  define these macros by default. */
41 # 52 "/usr/include/stdc-predef.h" 3 4
42 /* wchar_t uses Unicode 10.0.0. Version 10.0 of the Unicode Standard is
43  synchronized with ISO/IEC 10646:2017, fifth edition, plus
44  the following additions from Amendment 1 to the fifth edition:
45  - 56 emoji characters
46  - 285 hentaigana
47  - 3 additional Zanabazar Square characters */
48 # 1 "<command-line>" 2
49 # 1 "macs.h"
50 
51 # 1 "macs.h"
52 //%LICENSE////////////////////////////////////////////////////////////////
53 //
54 // Licensed to The Open Group (TOG) under one or more contributor license
55 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
56 // this work for additional information regarding copyright ownership.
57 // Each contributor licenses this file to you under the OpenPegasus Open
58 // Source License; you may not use this file except in compliance with the
59 // License.
60 //
61 // Permission is hereby granted, free of charge, to any person obtaining a
62 // copy of this software and associated documentation files (the "Software"),
63 // to deal in the Software without restriction, including without limitation
64 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
65 // and/or sell copies of the Software, and to permit persons to whom the
66 // Software is furnished to do so, subject to the following conditions:
67 //
68 // The above copyright notice and this permission notice shall be included
69 // in all copies or substantial portions of the Software.
70 //
71 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
72 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
73 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
74 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
75 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
76 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
77 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
78 //
80 //
81 //%////////////////////////////////////////////////////////////////////////////
82 # 45 "macs.h"
83 
89  noReturn CMReturn(CMPIrc rc);
90 # 64 "macs.h"
91 
98  noReturn CMReturnWithString(CMPIrc rc, CMPIString * str);
99 # 84 "macs.h"
100 
108  noReturn CMReturnWithChars(const CMPIBroker * mb, CMPIrc rc, char *msg);
109 # 109 "macs.h"
110 
115 inline static void CMSetStatus(CMPIStatus * st, CMPIrc rcp)
116 {
117  if (st)
118  {
119  (st)->rc = (rcp);
120  (st)->msg = NULL;
121  }
122 }
123 # 136 "macs.h"
124 
130 inline static void CMSetStatusWithString(
131  CMPIStatus * st,
132  CMPIrc rcp,
133  const CMPIString * string)
134 {
135  if (st)
136  {
137  (st)->rc = (rcp);
138  (st)->msg = (string);
139  }
140 }
141 # 167 "macs.h"
142 
149 inline static void CMSetStatusWithChars(
150  const CMPIBroker * mb,
151  CMPIStatus * st,
152  CMPIrc rcp,
153  const char *chars)
154 {
155  if (st)
156  {
157  (st)->rc = (rcp);
158  if (mb)
159  {
160  (st)->msg = (mb)->eft->newString ((mb), (chars), NULL);
161  }
162  else
163  {
164  (st)->msg = NULL;
165  }
166  }
167 }
168 # 210 "macs.h"
169 
173 inline static CMPIBoolean CMIsNullObject(const void *obj)
174 {
175  return((obj) == NULL || *((void **) (obj)) == NULL);
176 }
177 
178 
179 
180 
181 
186 inline static CMPIBoolean CMIsNullValue(const CMPIData val)
187 
188 {
189  return((val.state) & CMPI_nullValue);
190 }
191 
192 
193 
194 
195 
200 inline static CMPIBoolean CMIsKeyValue(CMPIData val)
201 {
202  return((val.state) & CMPI_keyValue);
203 }
204 
205 
206 
207 
208 
213 inline static CMPIBoolean CMIsArray(const CMPIData val)
214 {
215  return((val.type) & CMPI_ARRAY);
216 }
217 
218 
219 
220 
221 
222 // Life-cycle macros
223 
224 
225 
226 
227 // CMPIBroker factory macros
228 
229 
237 inline static CMPIInstance *CMNewInstance(
238  const CMPIBroker * mb,
239  const CMPIObjectPath * op,
240  CMPIStatus * rc)
241 {
242  return((mb)->eft->newInstance ((mb), (op), (rc)));
243 }
244 
245 
246 
247 
248 
257 inline static CMPIObjectPath *CMNewObjectPath(
258  const CMPIBroker * mb,
259  const char *ns,
260  const char *cn,
261  CMPIStatus * rc)
262 {
263  return((mb)->eft->newObjectPath ((mb), (ns), (cn), (rc)));
264 }
265 
266 
267 
268 
269 
270 
278 inline static CMPIString *CMNewString(
279  const CMPIBroker * mb,
280  const char *data,
281  CMPIStatus * rc)
282 {
283  return((mb)->eft->newString ((mb), (data), (rc)));
284 }
285 
286 
287 
288 
289 
296 inline static CMPIArgs * CMNewArgs(const CMPIBroker * mb, CMPIStatus * rc)
297 {
298  return((mb)->eft->newArgs ((mb), (rc)));
299 }
300 
301 
302 
303 
304 
313 inline static CMPIArray * CMNewArray(
314  const CMPIBroker * mb,
315  CMPICount max,
316  CMPIType type,
317  CMPIStatus * rc)
318 {
319  return((mb)->eft->newArray((mb), (max), (type), (rc)));
320 }
321 
322 
323 
324 
325 
332 inline static CMPIDateTime *CMNewDateTime(
333  const CMPIBroker * mb,
334  CMPIStatus * rc)
335 {
336  return((mb)->eft->newDateTime ((mb), (rc)));
337 }
338 
339 
340 
341 
342 
353 inline static CMPIDateTime *CMNewDateTimeFromBinary(
354  const CMPIBroker * mb,
355  CMPIUint64 binTime,
356  CMPIBoolean interval,
357  CMPIStatus * rc)
358 {
359  return((mb)->eft->
360  newDateTimeFromBinary((mb), (binTime), (interval), (rc)));
361 }
362 
363 
364 
365 
366 
367 
375 inline static CMPIDateTime *CMNewDateTimeFromChars(
376  const CMPIBroker * mb,
377  const char *utcTime,
378  CMPIStatus * rc)
379 {
380  return((mb)->eft->newDateTimeFromChars ((mb), (utcTime), (rc)));
381 }
382 
383 
384 
385 
386 
387 
398 inline static CMPISelectExp *CMNewSelectExp(
399  const CMPIBroker * mb,
400  const char *query,
401  const char *lang,
402  CMPIArray ** projection,
403  CMPIStatus * rc)
404 {
405  return((mb)->eft->
406  newSelectExp ((mb), (query), (lang), (projection), (rc)));
407 }
408 
409 
410 
411 
412 
413 
423 inline static CMPIBoolean CMClassPathIsA(
424  const CMPIBroker * mb,
425  const CMPIObjectPath * op,
426  const char *type,
427  CMPIStatus * rc)
428 {
429  return((mb)->eft->classPathIsA ((mb), (op), (type), (rc)));
430 }
431 
432 
433 
434 
435 
436 // Debugging macros
437 
438 
447 inline static CMPIString *CDToString(
448  const CMPIBroker * mb,
449  const void *object,
450  CMPIStatus * rc)
451 {
452  return((mb)->eft->toString ((mb), (void *) (object), (rc)));
453 }
454 
455 
456 
457 
458 
469 inline static CMPIBoolean CDIsOfType(
470  const CMPIBroker * mb,
471  const void *object,
472  const char *type,
473  CMPIStatus * rc)
474 {
475  return((mb)->eft->isOfType ((mb), (void *) (object), (type), (rc)));
476 }
477 
478 
479 
480 
481 
482 
491 inline static CMPIString *CDGetType
492  (const CMPIBroker * mb, const void *object, CMPIStatus * rc)
493 {
494  return((mb)->eft->getType ((mb), (object), (rc)));
495 }
496 # 803 "macs.h"
497 // CMPIInstance macros
498 
499 
500 
508 inline static CMPIData CMGetProperty(
509  const CMPIInstance * inst,
510  const char *name,
511  CMPIStatus * rc)
512 {
513  return((inst)->ft->getProperty ((inst), (name), (rc)));
514 }
515 
516 
517 
518 
519 
528 inline static CMPIData CMGetPropertyAt(
529  const CMPIInstance * inst,
530  CMPICount index,
531  CMPIString ** name,
532  CMPIStatus * rc)
533 {
534  return((inst)->ft->getPropertyAt ((inst), (index), (name), (rc)));
535 }
536 
537 
538 
539 
540 
541 
550 inline static CMPIStatus CMSetProperty(
551  const CMPIInstance * inst,
552  const char *name,
553  const CMPIValue * value,
554  CMPIType type)
555 {
556  return((inst)->ft->setProperty ((inst), (name), (value), (type)));
557 }
558 
559 
560 
561 
562 
563 
570 inline static CMPICount CMGetPropertyCount(
571  const CMPIInstance * inst,
572  CMPIStatus * rc)
573 {
574  return((inst)->ft->getPropertyCount ((inst), (rc)));
575 }
576 
577 
578 
579 
580 
588 inline static CMPIObjectPath *CMGetObjectPath(
589  const CMPIInstance * inst,
590  CMPIStatus * rc)
591 {
592  return((inst)->ft->getObjectPath ((inst), (rc)));
593 }
594 # 927 "macs.h"
595 
604 inline static CMPIStatus CMSetPropertyFilter(
605  CMPIInstance * inst,
606  const char **propertyList,
607  char **keys)
608 {
609  return((inst)->ft->setPropertyFilter ((inst), (propertyList), (keys)));
610 }
611 # 982 "macs.h"
612 // CMPIObjectPath macros
613 
614 
615 
622 inline static CMPIStatus CMSetHostname(
623  CMPIObjectPath * op,
624  const char *hn)
625 {
626  return((op)->ft->setHostname ((op), (hn)));
627 }
628 
629 
630 
631 
632 
639 inline static CMPIString *CMGetHostname(
640  const CMPIObjectPath * op,
641  CMPIStatus * rc)
642 {
643  return((op)->ft->getHostname ((op), (rc)));
644 }
645 
646 
647 
648 
649 
656 inline static CMPIStatus CMSetNameSpace(
657  CMPIObjectPath * op,
658  const char *ns)
659 {
660  return((op)->ft->setNameSpace ((op), (ns)));
661 }
662 
663 
664 
665 
666 
673 inline static CMPIString *CMGetNameSpace(
674  const CMPIObjectPath * op,
675  CMPIStatus * rc)
676 {
677  return((op)->ft->getNameSpace ((op), (rc)));
678 }
679 
680 
681 
682 
683 
690 inline static CMPIStatus CMSetClassName(
691  CMPIObjectPath * op,
692  const char *cn)
693 {
694  return((op)->ft->setClassName ((op), (cn)));
695 }
696 
697 
698 
699 
700 
707 inline static CMPIString *CMGetClassName(
708  const CMPIObjectPath * op,
709  CMPIStatus * rc)
710 {
711  return((op)->ft->getClassName ((op), (rc)));
712 }
713 
714 
715 
716 
717 
726 inline static CMPIStatus CMAddKey(
727  CMPIObjectPath * op,
728  const char *name,
729  const CMPIValue * value,
730  const CMPIType type)
731 {
732  return((op)->ft->addKey ((op), (name), (value), (type)));
733 }
734 
735 
736 
737 
738 
739 
747 inline static CMPIData CMGetKey(
748  const CMPIObjectPath * op,
749  const char *name,
750  CMPIStatus * rc)
751 {
752  return((op)->ft->getKey ((op), (name), (rc)));
753 }
754 
755 
756 
757 
758 
767 inline static CMPIData CMGetKeyAt(
768  const CMPIObjectPath * op,
769  CMPICount index,
770  CMPIString ** name,
771  CMPIStatus * rc)
772 {
773  return((op)->ft->getKeyAt ((op), (index), (name), (rc)));
774 }
775 
776 
777 
778 
779 
780 
787 inline static CMPICount CMGetKeyCount(
788  const CMPIObjectPath * op,
789  CMPIStatus * rc)
790 {
791  return((op)->ft->getKeyCount ((op), (rc)));
792 }
793 
794 
795 
796 
797 
804 inline static CMPIStatus CMSetNameSpaceFromObjectPath(
805  CMPIObjectPath * op,
806  const CMPIObjectPath * src)
807 {
808  return((op)->ft->setNameSpaceFromObjectPath ((op), (src)));
809 }
810 
811 
812 
813 
814 
815 
822 inline static CMPIStatus CMSetHostAndNameSpaceFromObjectPath(
823  CMPIObjectPath * op,
824  const CMPIObjectPath * src)
825 {
826  return((op)->ft->setHostAndNameSpaceFromObjectPath ((op), (src)));
827 }
828 
829 
830 
831 
832 
833 
841 inline static CMPIData CMGetClassQualifier(
842  const CMPIObjectPath* op,
843  const char *qName,
844  CMPIStatus *rc)
845 {
846  return((op)->ft->getClassQualifier((op),(qName),(rc)));
847 }
848 
849 
850 
851 
852 
853 
862 inline static CMPIData CMGetPropertyQualifier(
863  const CMPIObjectPath* op,
864  const char *pName,
865  const char *qName,
866  CMPIStatus *rc)
867 {
868  return((op)->ft->getPropertyQualifier((op),(pName),(qName),(rc)));
869 }
870 
871 
872 
873 
874 
875 
884 inline static CMPIData CMGetMethodQualifier(
885  const CMPIObjectPath* op,
886  const char *methodName,
887  const char *qName,
888  CMPIStatus *rc)
889 {
890  return((op)->ft->getMethodQualifier((op),(methodName),(qName),(rc)));
891 }
892 
893 
894 
895 
896 
897 
907 inline static CMPIData CMGetParameterQualifier(
908  const CMPIObjectPath* op,
909  const char *mName,
910  const char *pName,
911  const char *qName,
912  CMPIStatus *rc)
913 {
914  return((op)->ft->getParameterQualifier((op),(mName),(pName),(qName),(rc)));
915 }
916 # 1311 "macs.h"
917 // CMPIArray macros
918 
919 
920 
927 inline static CMPICount CMGetArrayCount(
928  const CMPIArray * ar,
929  CMPIStatus * rc)
930 {
931  return((ar)->ft->getSize ((ar), (rc)));
932 }
933 
934 
935 
936 
937 
944 inline static CMPIType CMGetArrayType(
945  const CMPIArray * ar,
946  CMPIStatus * rc)
947 {
948  return((ar)->ft->getSimpleType ((ar), (rc)));
949 }
950 
951 
952 
953 
954 
962 inline static CMPIData CMGetArrayElementAt(
963  const CMPIArray * ar,
964  CMPICount index,
965  CMPIStatus * rc)
966 {
967  return((ar)->ft->getElementAt ((ar), (index), (rc)));
968 }
969 
970 
971 
972 
973 
974 
983 inline static CMPIStatus CMSetArrayElementAt(
984  CMPIArray * ar,
985  CMPICount index,
986  const CMPIValue * value,
987  CMPIType type)
988 {
989  return((ar)->ft->setElementAt ((ar), (index), (value), (type)));
990 }
991 
992 
993 
994 
995 
996 // CMPIArgs macros
997 
998 
1007 inline static CMPIStatus CMAddArg(
1008  CMPIArgs * as,
1009  char *name,
1010  const CMPIValue * value,
1011  const CMPIType type)
1012 {
1013  return((as)->ft->addArg ((as), (name), (CMPIValue*)(value), (type)));
1014 }
1015 
1016 
1017 
1018 
1019 
1020 
1028 inline static CMPIData CMGetArg(
1029  const CMPIArgs * as,
1030  const char *name,
1031  CMPIStatus * rc)
1032 {
1033  return((as)->ft->getArg ((as), (name), (rc)));
1034 }
1035 
1036 
1037 
1038 
1039 
1048 inline static CMPIData CMGetArgAt(
1049  const CMPIArgs * as,
1050  CMPICount index,
1051  CMPIString ** name,
1052  CMPIStatus * rc)
1053 {
1054  return((as)->ft->getArgAt ((as), (index), (name), (rc)));
1055 }
1056 
1057 
1058 
1059 
1060 
1067 inline static CMPICount CMGetArgCount(const CMPIArgs * as, CMPIStatus * rc)
1068 {
1069  return((as)->ft->getArgCount ((as), (rc)));
1070 }
1071 
1072 
1073 
1074 
1075 
1076 // CMPIString Macros
1077 
1078 // CMGetCharPtr is deprecated. It will be removed in the
1079 // future versions.
1080 
1081 
1082 
1089 inline static char * CMGetCharsPtr(
1090  const CMPIString * st,
1091  CMPIStatus * rc)
1092 {
1093  return((st)->ft->getCharPtr ((st), (rc)));
1094 }
1095 
1096 
1097 
1098 
1099 // CMPIDateTime macros
1100 
1101 
1108 inline static CMPIString *CMGetStringFormat(
1109  const CMPIDateTime * dt,
1110  CMPIStatus * rc)
1111 {
1112  return((dt)->ft->getStringFormat ((dt), (rc)));
1113 }
1114 
1115 
1116 
1117 
1118 
1126 inline static CMPIUint64 CMGetBinaryFormat(
1127  const CMPIDateTime * dt,
1128  CMPIStatus * rc)
1129 {
1130  return((dt)->ft->getBinaryFormat ((dt), (rc)));
1131 }
1132 
1133 
1134 
1135 
1136 
1143 inline static CMPIBoolean CMIsInterval(
1144  const CMPIDateTime * dt,
1145  CMPIStatus * rc)
1146 {
1147  return((dt)->ft->isInterval ((dt), (rc)));
1148 }
1149 
1150 
1151 
1152 
1153 
1154 // CMPIError macros
1155 # 1979 "macs.h"
1156 // CMPIEnumeration Macros
1157 
1158 
1159 
1166 inline static CMPIData CMGetNext(
1167  const CMPIEnumeration * en,
1168  CMPIStatus * rc)
1169 {
1170  return((en)->ft->getNext ((en), (rc)));
1171 }
1172 
1173 
1174 
1175 
1176 
1183 inline static CMPIBoolean CMHasNext(
1184  const CMPIEnumeration * en,
1185  CMPIStatus * rc)
1186 {
1187  return((en)->ft->hasNext ((en), (rc)));
1188 }
1189 
1190 
1191 
1192 
1193 
1200 inline static CMPIArray *CMToArray(
1201  const CMPIEnumeration * en,
1202  CMPIStatus * rc)
1203 {
1204  return((en)->ft->toArray ((en), (rc)));
1205 }
1206 
1207 
1208 
1209 
1210 
1211 // CMPIResult Macros
1212 
1213 
1214 
1222 inline static CMPIStatus CMReturnData(
1223  const CMPIResult * rslt,
1224  const CMPIValue * value,
1225  const CMPIType type)
1226 {
1227  return((rslt)->ft->returnData ((rslt), (value), (type)));
1228 }
1229 
1230 
1231 
1232 
1233 
1234 
1241 inline static CMPIStatus CMReturnInstance(
1242  const CMPIResult * rslt,
1243  const CMPIInstance * inst)
1244 {
1245  return((rslt)->ft->returnInstance ((rslt), (inst)));
1246 }
1247 
1248 
1249 
1250 
1251 
1258 inline static CMPIStatus CMReturnObjectPath(
1259  const CMPIResult * rslt,
1260  const CMPIObjectPath * ref)
1261 {
1262  return((rslt)->ft->returnObjectPath ((rslt), (ref)));
1263 }
1264 
1265 
1266 
1267 
1268 
1274 inline static CMPIStatus CMReturnDone(
1275  const CMPIResult * rslt)
1276 {
1277  return((rslt)->ft->returnDone ((rslt)));
1278 }
1279 # 2127 "macs.h"
1280 // CMPIContext Macros
1281 
1282 
1283 
1291 inline static CMPIData CMGetContextEntry(
1292  const CMPIContext * ctx,
1293  const char *name,
1294  CMPIStatus * rc)
1295 {
1296  return((ctx)->ft->getEntry ((ctx), (name), (rc)));
1297 }
1298 
1299 
1300 
1301 
1302 
1303 
1312 inline static CMPIData CMGetContextEntryAt(
1313  const CMPIContext * ctx,
1314  CMPICount index,
1315  CMPIString ** name,
1316  CMPIStatus * rc)
1317 {
1318  return((ctx)->ft->getEntryAt ((ctx), (index), (name), (rc)));
1319 }
1320 
1321 
1322 
1323 
1324 
1325 
1332 inline static CMPICount CMGetContextEntryCount(
1333  const CMPIContext * ctx,
1334  CMPIStatus * rc)
1335 {
1336  return((ctx)->ft->getEntryCount ((ctx), (rc)));
1337 }
1338 
1339 
1340 
1341 
1342 
1343 
1352 inline static CMPIStatus CMAddContextEntry(
1353  const CMPIContext * ctx,
1354  const char *name,
1355  const CMPIValue * value,
1356  const CMPIType type)
1357 {
1358  return((ctx)->ft->addEntry ((ctx), (name), (value), (type)));
1359 }
1360 
1361 
1362 
1363 
1364 
1365 // CMPISelectExp macros
1366 
1367 
1374 inline static CMPIString *CMGetSelExpString(
1375  const CMPISelectExp * se,
1376  CMPIStatus * rc)
1377 {
1378  return((se)->ft->getString ((se), (rc)));
1379 }
1380 
1381 
1382 
1383 
1384 
1392 inline static CMPIBoolean CMEvaluateSelExp(
1393  const CMPISelectExp * se,
1394  const CMPIInstance * inst,
1395  CMPIStatus * rc)
1396 {
1397  return((se)->ft->evaluate ((se), (inst), (rc)));
1398 }
1399 # 2275 "macs.h"
1400 
1406 inline static CMPISelectCond *CMGetDoc(
1407  const CMPISelectExp * se,
1408  CMPIStatus * rc)
1409 {
1410  return((se)->ft->getDOC ((se), (rc)));
1411 }
1412 
1413 
1414 
1415 
1416 
1423 inline static CMPISelectCond *CMGetCod(
1424  const CMPISelectExp * se,
1425  CMPIStatus * rc)
1426 {
1427  return((se)->ft->getCOD ((se), (rc)));
1428 }
1429 
1430 
1431 
1432 
1433 
1434 // CMPISelectCond macros
1435 
1436 
1437 
1446 inline static CMPICount CMGetSubCondCountAndType(
1447  const CMPISelectCond * sc,
1448  int * type,
1449  CMPIStatus * rc)
1450 {
1451  return((sc)->ft->getCountAndType ((sc), (type), (rc)));
1452 }
1453 
1454 
1455 
1456 
1457 
1458 
1466 inline static CMPISubCond *CMGetSubCondAt(
1467  const CMPISelectCond * sc,
1468  CMPICount index,
1469  CMPIStatus * rc)
1470 {
1471  return((sc)->ft->getSubCondAt ((sc), (index), (rc)));
1472 }
1473 
1474 
1475 
1476 
1477 // CMPISubCond macros
1478 
1479 
1486 inline static CMPICount CMGetPredicateCount(
1487  const CMPISubCond * sc,
1488  CMPIStatus * rc)
1489 {
1490  return((sc)->ft->getCount ((sc), (rc)));
1491 }
1492 
1493 
1494 
1495 
1496 
1504 inline static CMPIPredicate *CMGetPredicateAt(
1505  const CMPISubCond * sc,
1506  CMPICount index,
1507  CMPIStatus * rc)
1508 {
1509  return((sc)->ft->getPredicateAt ((sc), (index), (rc)));
1510 }
1511 
1512 
1513 
1514 
1515 
1516 
1524 inline static CMPIPredicate *CMGetPredicate(
1525  const CMPISubCond * sc,
1526  const char *name,
1527  CMPIStatus * rc)
1528 {
1529  return((sc)->ft->getPredicate ((sc), (name), (rc)));
1530 }
1531 
1532 
1533 
1534 
1535 
1536 // CMPIPredicate macros
1537 
1538 
1539 
1549 inline static CMPIStatus CMGetPredicateData(
1550  const CMPIPredicate * pr,
1551  CMPIType * type,
1552  CMPIPredOp * op,
1553  CMPIString ** lhs,
1554  CMPIString ** rhs)
1555 {
1556  return((pr)->ft->getData ((pr), (type), (op), (lhs), (rhs)));
1557 }
1558 # 2487 "macs.h"
1559 // CMPIBroker Macros
1560 
1561 
1562 
1567 inline static unsigned long CBGetBrokerCapabilities(const CMPIBroker * mb)
1568 {
1569  return((mb)->bft-> brokerCapabilities);
1570 }
1571 
1572 
1573 
1574 
1575 
1579 inline static int CBBrokerVersion(const CMPIBroker * mb)
1580 {
1581  return((mb)->bft->brokerVersion);
1582 }
1583 
1584 
1585 
1586 
1587 
1591 inline static const char *CBBrokerName(const CMPIBroker * mb)
1592 {
1593  return((mb)->bft->brokerName);
1594 }
1595 
1596 
1597 
1598 
1599 
1609 inline static CMPIContext *CBPrepareAttachThread(
1610  const CMPIBroker * mb,
1611  const CMPIContext * ctx)
1612 {
1613  return((mb)->bft->prepareAttachThread ((mb), (ctx)));
1614 }
1615 
1616 
1617 
1618 
1619 
1620 
1628 inline static CMPIStatus CBAttachThread(
1629  const CMPIBroker * mb,
1630  const CMPIContext * ctx)
1631 {
1632  return((mb)->bft->attachThread ((mb), (ctx)));
1633 }
1634 
1635 
1636 
1637 
1638 
1647 inline static CMPIStatus CBDetachThread(
1648  const CMPIBroker * mb,
1649  const CMPIContext * ctx)
1650 {
1651  return((mb)->bft->detachThread ((mb), (ctx)));
1652 }
1653 
1654 
1655 
1656 
1657 
1658 
1668 inline static CMPIStatus CBDeliverIndication(
1669  const CMPIBroker * mb,
1670  const CMPIContext * ctx,
1671  const char *ns,
1672  const CMPIInstance * ind)
1673 {
1674  return((mb)->bft->deliverIndication ((mb), (ctx), (ns), (ind)));
1675 }
1676 
1677 
1678 
1679 
1680 
1681 
1691 inline static CMPIEnumeration *CBEnumInstanceNames(
1692  const CMPIBroker * mb,
1693  const CMPIContext * ctx,
1694  const CMPIObjectPath * op,
1695  CMPIStatus * rc)
1696 {
1697  return((mb)->bft->enumerateInstanceNames ((mb), (ctx), (op), (rc)));
1698 }
1699 
1700 
1701 
1702 
1703 
1704 
1718 inline static CMPIEnumeration *CBEnumInstances(
1719  const CMPIBroker * mb,
1720  const CMPIContext * ctx,
1721  const CMPIObjectPath * op,
1722  const char **properties,
1723  CMPIStatus * rc)
1724 {
1725  return((mb)->bft->enumerateInstances ((mb),(ctx),(op),(properties),(rc)));
1726 }
1727 
1728 
1729 
1730 
1731 
1732 
1745 inline static CMPIInstance *CBGetInstance(
1746  const CMPIBroker * mb,
1747  const CMPIContext * ctx,
1748  const CMPIObjectPath * op,
1749  const char **properties,
1750  CMPIStatus * rc)
1751 {
1752  return((mb)->bft->getInstance ((mb), (ctx), (op), (properties), (rc)));
1753 }
1754 
1755 
1756 
1757 
1758 
1759 
1769 inline static CMPIObjectPath *CBCreateInstance(
1770  const CMPIBroker * mb,
1771  const CMPIContext * ctx,
1772  const CMPIObjectPath * op,
1773  const CMPIInstance * inst,
1774  CMPIStatus * rc)
1775 {
1776  return((mb)->bft->createInstance ((mb), (ctx), (op), (inst), (rc)));
1777 }
1778 # 2758 "macs.h"
1779 
1788 inline static CMPIStatus CBSetInstance(
1789  CMPIBroker* mb,
1790  CMPIContext* ctx,
1791  CMPIObjectPath* op,
1792  CMPIInstance* inst)
1793 {
1794  return((mb)->bft->
1795  setInstance ((mb), (ctx), (op), (inst), NULL));
1796 }
1797 
1798 
1799 
1800 
1801 
1802 
1803 
1811 inline static CMPIStatus CBDeleteInstance(
1812  const CMPIBroker * mb,
1813  const CMPIContext * ctx,
1814  const CMPIObjectPath * op)
1815 {
1816  return((mb)->bft->deleteInstance ((mb), (ctx), (op)));
1817 }
1818 
1819 
1820 
1821 
1822 
1834 inline static CMPIEnumeration *CBExecQuery(
1835  const CMPIBroker * mb,
1836  const CMPIContext * ctx,
1837  const CMPIObjectPath * op,
1838  const char *query,
1839  const char *lang,
1840  CMPIStatus * rc)
1841 {
1842  return((mb)->bft->execQuery ((mb), (ctx), (op), (query), (lang), (rc)));
1843 }
1844 
1845 
1846 
1847 
1848 
1849 
1850 
1883 inline static CMPIEnumeration *CBAssociators(
1884  const CMPIBroker * mb,
1885  const CMPIContext * ctx,
1886  const CMPIObjectPath * op,
1887  const char *assocClass,
1888  const char *resultClass,
1889  const char *role,
1890  const char *resultRole,
1891  const char **properties,
1892  CMPIStatus * rc)
1893 {
1894  return((mb)->bft->
1895  associators ((mb), (ctx), (op), (assocClass), (resultClass), (role),
1896  (resultRole), (properties), (rc)));
1897 }
1898 
1899 
1900 
1901 
1902 
1903 
1933 inline static CMPIEnumeration *CBAssociatorNames(
1934  const CMPIBroker * mb,
1935  const CMPIContext * ctx,
1936  const CMPIObjectPath * op,
1937  const char *assocClass,
1938  const char *resultClass,
1939  const char *role,
1940  const char *resultRole,
1941  CMPIStatus * rc)
1942 {
1943  return((mb)->bft->associatorNames ((mb), (ctx), (op),
1944  (assocClass), (resultClass), (role),
1945  (resultRole), (rc)));
1946 }
1947 
1948 
1949 
1950 
1951 
1952 
1976 inline static CMPIEnumeration *CBReferences(
1977  const CMPIBroker * mb,
1978  const CMPIContext * ctx,
1979  const CMPIObjectPath * op,
1980  const char *resultClass,
1981  const char *role,
1982  const char **properties,
1983  CMPIStatus * rc)
1984 {
1985  return((mb)->bft->references ((mb), (ctx), (op),
1986  (resultClass), (role), (properties), (rc)));
1987 }
1988 
1989 
1990 
1991 
1992 
1993 
2014 inline static CMPIEnumeration *CBReferenceNames(
2015  const CMPIBroker * mb,
2016  const CMPIContext * ctx,
2017  const CMPIObjectPath * op,
2018  const char *resultClass,
2019  const char *role,
2020  CMPIStatus * rc)
2021 {
2022  return((mb)->bft->
2023  referenceNames ((mb), (ctx), (op), (resultClass), (role), (rc)));
2024 }
2025 
2026 
2027 
2028 
2029 
2030 
2031 
2044 inline static CMPIData CBInvokeMethod(
2045  const CMPIBroker * mb,
2046  const CMPIContext * ctx,
2047  const CMPIObjectPath * op,
2048  const char *method,
2049  const CMPIArgs * in,
2050  CMPIArgs * out,
2051  CMPIStatus * rc)
2052 {
2053  return((mb)->bft->
2054  invokeMethod ((mb), (ctx), (op), (method), (in), (out), (rc)));
2055 }
2056 
2057 
2058 
2059 
2060 
2061 
2073 inline static CMPIStatus CBSetProperty(
2074  const CMPIBroker * mb,
2075  const CMPIContext * ctx,
2076  const CMPIObjectPath * op,
2077  const char *name,
2078  const CMPIValue * value,
2079  const CMPIType type)
2080 {
2081  return((mb)->bft->setProperty ((mb), (ctx), (op), (name),
2082  (CMPIValue *) (value), (type)));
2083 }
2084 
2085 
2086 
2087 
2088 
2089 
2100 inline static CMPIData CBGetProperty(
2101  const CMPIBroker * mb,
2102  const CMPIContext * ctx,
2103  const CMPIObjectPath * op,
2104  const char *name,
2105  CMPIStatus * rc)
2106 {
2107  return(mb)->bft->getProperty ((mb), (ctx), (op), (name), (rc));
2108 }
2109 # 3102 "macs.h"
2110 /*
2111  ----------------- C provider factories ---------------------
2112 */
2113 
2114 
2136 CMPIInstanceMI *CMInstanceMIStub(
2137  chars pfx,
2138  chars pn,
2139  CMPIBroker * broker,
2140  statement hook);
2141 # 3172 "macs.h"
2142 
2164 CMPIAssociationMI *CMAssociationMIStub(
2165  chars pfx,
2166  chars pn,
2167  CMPIBroker * broker,
2168  statement hook);
2169 # 3227 "macs.h"
2170 
2189 CMPIMethodMI *CMMethodMIStub(
2190  chars pfx,
2191  chars pn,
2192  CMPIBroker * broker,
2193  statement hook);
2194 # 3276 "macs.h"
2195 
2215 CMPIPropertyMI *CMPropertyMIStub(
2216  chars pfx,
2217  chars pn,
2218  CMPIBroker * broker,
2219  statement hook);
2220 # 3327 "macs.h"
2221 
2242 CMPIIndicationMI *CMIndicationMIStub(
2243  chars pfx,
2244  chars pn,
2245  CMPIBroker * broker,
2246  statement hook);
2247 # 3388 "macs.h"
2248 /*
2249  ----------------- C++ provider factories ---------------------
2250 */
2251 
2252 
2266 CMPIInstanceMI *CMInstanceMIFactory(chars cn, chars pn);
2267 # 3470 "macs.h"
2268 
2281 CMPIAssociationMI *CMAssociationMIFactory(chars cn, chars pn);
2282 # 3544 "macs.h"
2283 
2296 CMPIMethodMI *CMMethodMIFactory(chars cn, chars pn);
2297 # 3615 "macs.h"
2298 
2311 CMPIPropertyMI *CMPropertyMIFactory(chars cn, chars pn);
2312 # 3688 "macs.h"
2313 
2326 CMPIIndicationMI *CMIndicationMIFactory(chars cn, chars pn);
Definition: cmpift.h:2862
Definition: cmpift.h:2376
Definition: cmpidt.h:499
Definition: cmpift.h:1916
CMPIType type
Definition: cmpidt.h:504
Definition: cmpift.h:3046
Definition: cmpift.h:1357
Definition: cmpidt.h:275
Definition: cmpift.h:2288
CMPIValueState state
Definition: cmpidt.h:509
Definition: cmpift.h:1334
Definition: cmpift.h:2951
Definition: cmpift.h:1202
Definition: cmpift.h:2469
Definition: cmpift.h:2175
Definition: cmpift.h:1741
Definition: cmpidt.h:679
Definition: cmpift.h:3551
Definition: cmpift.h:3797
Definition: cmpift.h:2686
Definition: cmpift.h:2757
Definition: cmpift.h:3292
Definition: cmpift.h:2575
Definition: cmpift.h:3664