cmpift.h
1 //%LICENSE////////////////////////////////////////////////////////////////
2 //
3 // Licensed to The Open Group (TOG) under one or more contributor license
4 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
5 // this work for additional information regarding copyright ownership.
6 // Each contributor licenses this file to you under the OpenPegasus Open
7 // Source License; you may not use this file except in compliance with the
8 // License.
9 //
10 // Permission is hereby granted, free of charge, to any person obtaining a
11 // copy of this software and associated documentation files (the "Software"),
12 // to deal in the Software without restriction, including without limitation
13 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 // and/or sell copies of the Software, and to permit persons to whom the
15 // Software is furnished to do so, subject to the following conditions:
16 //
17 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
19 //
20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
24 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
29 //
30 //%////////////////////////////////////////////////////////////////////////////
31 
32 #ifndef _CMPIFT_H_
33 #define _CMPIFT_H_
34 
35 #include "cmpidt.h"
36 #include "cmpios.h"
37 
38 #ifdef __cplusplus
39 extern "C"
40 {
41 #endif
42 
43 
44  //---------------------------------------------------
45  //--
46  // _CMPIBrokerEncFT Function Table
47  //--
48  //---------------------------------------------------
49 
50 
58  {
62  int ftVersion;
63 
71  CMPIInstance *(*newInstance)(
72  const CMPIBroker * mb,
73  const CMPIObjectPath * op,
74  CMPIStatus * rc);
75 
84  CMPIObjectPath *(*newObjectPath)(
85  const CMPIBroker * mb,
86  const char *ns,
87  const char *cn,
88  CMPIStatus * rc);
89 
96  CMPIArgs *(*newArgs)(const CMPIBroker * mb, CMPIStatus * rc);
97 
105  CMPIString *(*newString)(
106  const CMPIBroker * mb,
107  const char *data,
108  CMPIStatus * rc);
109 
118  CMPIArray *(*newArray)(
119  const CMPIBroker * mb,
120  CMPICount max,
121  CMPIType type,
122  CMPIStatus * rc);
123 
130  CMPIDateTime *(*newDateTime)(
131  const CMPIBroker * mb,
132  CMPIStatus * rc);
133 
144  CMPIDateTime *(*newDateTimeFromBinary)(
145  const CMPIBroker * mb,
146  CMPIUint64 binTime,
147  CMPIBoolean interval,
148  CMPIStatus * rc);
149 
157  CMPIDateTime *(*newDateTimeFromChars)(
158  const CMPIBroker * mb,
159  const char *utcTime,
160  CMPIStatus * rc);
161 
172  CMPISelectExp *(*newSelectExp)(
173  const CMPIBroker * mb,
174  const char *query,
175  const char *lang,
176  CMPIArray ** projection,
177  CMPIStatus * st);
178 
188  CMPIBoolean (*classPathIsA)(
189  const CMPIBroker * mb,
190  const CMPIObjectPath * op,
191  const char *type,
192  CMPIStatus * rc);
193 
202  CMPIString *(*toString)(
203  const CMPIBroker * mb,
204  const void *object,
205  CMPIStatus * rc);
206 
217  CMPIBoolean (*isOfType)(
218  const CMPIBroker * mb,
219  const void *object,
220  const char *type,
221  CMPIStatus * rc);
222 
231  CMPIString *(*getType)(
232  const CMPIBroker * mb,
233  const void *object,
234  CMPIStatus * rc);
235 
245 #ifdef CMPI_VER_85
246  CMPIString *(*getMessage)(
247  const CMPIBroker * mb,
248  const char *msgId,
249  const char *defMsg,
250  CMPIStatus * rc,
251  CMPICount count, ...);
252 #endif // CMPI_VER_85
253 
266 #ifdef CMPI_VER_100
268  const CMPIBroker *,
269  CMPISeverity severity,
270  const char *id,
271  const char *text,
272  const CMPIString * string);
273 
288  const CMPIBroker *,
289  CMPILevel level,
290  const char *component,
291  const char *text,
292  const CMPIString * string);
293 #else // pre-1.0 versions supported getKeyList()
294  CMPIArray *(*getKeyList)(
295  CMPIBroker *mb,
296  CMPIContext *ctx,
297  CMPIObjectPath *op,
298  CMPIStatus *rc);
299 #endif /* CMPI_VER_100 */
300 
301 #ifdef CMPI_VER_200
302 
313  CMPIError* (*newCMPIError)(
314  const CMPIBroker*,
315  const char*,
316  const char*,
317  const char*,
318  const CMPIErrorSeverity,
319  const CMPIErrorProbableCause,
320  const CMPIrc,
321  CMPIStatus *rc);
322 
332  const CMPIBroker* mb,
333  const char *msgFile,
334  CMPIMsgFileHandle* msgFileHandle);
335 
343  const CMPIBroker* mb,
344  const CMPIMsgFileHandle msgFileHandle);
345 
356  CMPIString* (*getMessage2)(
357  const CMPIBroker* mb,
358  const char *msgId,
359  const CMPIMsgFileHandle msgFileHandle,
360  const char *defMsg,
361  CMPIStatus* rc,
362  CMPICount count,...);
363 
364 #endif /* CMPI_VER_200 */
365 
366  };
367 
368 
369 
370  //---------------------------------------------------
371  //--
372  // _CMPIBrokerFT Function Table
373  //--
374  //---------------------------------------------------
375 
376 
383  {
384 
389  unsigned int brokerCapabilities;
393  unsigned int brokerVersion;
397  const char *brokerName;
398 
408  CMPIContext *(*prepareAttachThread)(
409  const CMPIBroker * mb,
410  const CMPIContext * ctx);
411 
420  const CMPIBroker *,
421  const CMPIContext *);
422 
432  const CMPIBroker * mb,
433  const CMPIContext * ctx);
434 
435  // class 0 services
436 
447  const CMPIBroker * mb,
448  const CMPIContext * ctx,
449  const char *ns,
450  const CMPIInstance * ind);
451 
452  // class 1 services.
453 
463  CMPIEnumeration *(*enumerateInstanceNames)(
464  const CMPIBroker * mb,
465  const CMPIContext * ctx,
466  const CMPIObjectPath * op,
467  CMPIStatus * rc);
468 
482  CMPIInstance *(*getInstance)(
483  const CMPIBroker * mb,
484  const CMPIContext * ctx,
485  const CMPIObjectPath * op,
486  const char **properties,
487  CMPIStatus * rc);
488 
489  // class 2 services.
490 
501  CMPIObjectPath *(*createInstance)(
502  const CMPIBroker * mb,
503  const CMPIContext * ctx,
504  const CMPIObjectPath * op,
505  const CMPIInstance * inst,
506  CMPIStatus * rc);
507 
519  const CMPIBroker * mb,
520  const CMPIContext * ctx,
521  const CMPIObjectPath * op,
522  const CMPIInstance * inst,
523  const char **properties);
524 
534  const CMPIBroker * mb,
535  const CMPIContext * ctx,
536  const CMPIObjectPath * op);
537 
549  CMPIEnumeration *(*execQuery)(
550  const CMPIBroker * mb,
551  const CMPIContext * ctx,
552  const CMPIObjectPath * op,
553  const char *query,
554  const char *lang,
555  CMPIStatus * rc);
556 
570  CMPIEnumeration *(*enumerateInstances)(
571  const CMPIBroker * mb,
572  const CMPIContext * ctx,
573  const CMPIObjectPath * op,
574  const char **properties,
575  CMPIStatus * rc);
576 
613  CMPIEnumeration *(*associators)(
614  const CMPIBroker * mb,
615  const CMPIContext * ctx,
616  const CMPIObjectPath * op,
617  const char *assocClass,
618  const char *resultClass,
619  const char *role,
620  const char *resultRole,
621  const char **properties,
622  CMPIStatus * rc);
623 
656  CMPIEnumeration *(*associatorNames)(
657  const CMPIBroker * mb,
658  const CMPIContext * ctx,
659  const CMPIObjectPath * op,
660  const char *assocClass,
661  const char *resultClass,
662  const char *role,
663  const char *resultRole,
664  CMPIStatus * rc);
665 
689  CMPIEnumeration *(*references)(
690  const CMPIBroker * mb,
691  const CMPIContext * ctx,
692  const CMPIObjectPath * op,
693  const char *resultClass,
694  const char *role,
695  const char **properties,
696  CMPIStatus * rc);
697 
718  CMPIEnumeration *(*referenceNames)(
719  const CMPIBroker * mb,
720  const CMPIContext * ctx,
721  const CMPIObjectPath * op,
722  const char *resultClass,
723  const char *role,
724  CMPIStatus * rc);
725 
740  const CMPIBroker * mb,
741  const CMPIContext * ctx,
742  const CMPIObjectPath * op,
743  const char *method,
744  const CMPIArgs * in,
745  CMPIArgs * out,
746  CMPIStatus * rc);
747 
761  const CMPIBroker * mb,
762  const CMPIContext * ctx,
763  const CMPIObjectPath * op,
764  const char *name,
765  const CMPIValue * value,
766  CMPIType type);
767 
780  const CMPIBroker * mb,
781  const CMPIContext * ctx,
782  const CMPIObjectPath * op,
783  const char *name,
784  CMPIStatus * rc);
785  };
786 
787 
788  //---------------------------------------------------
789  //--
790  // _CMPIBrokerExtFT Function Table
791  //--
792  //---------------------------------------------------
793 
794 #ifdef CMPI_VER_90
795 
796  struct timespec;
797 
805  {
820  char *(*resolveFileName) (const char *filename);
821 
822 
831  CMPI_THREAD_TYPE (*newThread)(
832  CMPI_THREAD_RETURN (CMPI_THREAD_CDECL * start) (void *),
833  void *parm,
834  int detached);
835 
844  int (*joinThread)(
845  CMPI_THREAD_TYPE thread,
846  CMPI_THREAD_RETURN * retval);
847 
855  int (*exitThread) (CMPI_THREAD_RETURN return_code);
856 
863  int (*cancelThread) (CMPI_THREAD_TYPE thread);
864 
872  int (*threadSleep) (CMPIUint32 msec);
873 
882  int (*threadOnce) (int *once, void (*init) (void));
883 
893  CMPI_THREAD_KEY_TYPE * key,
894  void (*cleanup) (void *));
895 
901  int (*destroyThreadKey) (CMPI_THREAD_KEY_TYPE key);
902 
908  void *(*getThreadSpecific) (CMPI_THREAD_KEY_TYPE key);
909 
916  int (*setThreadSpecific) (CMPI_THREAD_KEY_TYPE key, void *value);
917 
918 
925  CMPI_MUTEX_TYPE (*newMutex) (int opt);
926 
931  void (*destroyMutex) (CMPI_MUTEX_TYPE mutex);
932 
938  void (*lockMutex) (CMPI_MUTEX_TYPE mutex);
939 
944  void (*unlockMutex) (CMPI_MUTEX_TYPE mutex);
945 
952  CMPI_COND_TYPE (*newCondition) (int opt);
953 
958  void (*destroyCondition) (CMPI_COND_TYPE cond);
959 
969  int (*condWait) (CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex);
970 
985  CMPI_COND_TYPE cond,
986  CMPI_MUTEX_TYPE mutex,
987  struct timespec * wait);
988 
995  int (*signalCondition) (CMPI_COND_TYPE cond);
996  };
997 
998 #endif /* CMPI_VER_90 */
999 
1000 #ifdef CMPI_VER_200
1001  //---------------------------------------------------
1002  //--
1003  // _CMPIBroker Memory Function Table
1004  //--
1005  //---------------------------------------------------
1006 
1015  {
1016 
1021 
1031  CMPIGcStat *(*mark) (const CMPIBroker * mb, CMPIStatus * rc);
1032 
1041  const CMPIBroker * mb,
1042  const CMPIGcStat * gc);
1043 
1051  void *(*cmpiMalloc) (const CMPIBroker * mb, size_t size);
1052 
1062  void *(*cmpiCalloc) (const CMPIBroker * mb, size_t, size_t);
1063 
1077  void *(*cmpiRealloc) (const CMPIBroker * mb, void *, size_t);
1078 
1079 
1088  char *(*cmpiStrDup) (const CMPIBroker * mb, const char *);
1089 
1098  void (*cmpiFree) (const CMPIBroker * mb, void *);
1099 
1109  void (*freeInstance) (const CMPIBroker * mb, CMPIInstance * inst);
1110 
1121  const CMPIBroker * mb,
1122  CMPIObjectPath * obj);
1123 
1133  void (*freeArgs)(
1134  const CMPIBroker * mb,
1135  CMPIArgs * args);
1136 
1146  void (*freeString)(
1147  const CMPIBroker * mb,
1148  CMPIString * str);
1149 
1159  void (*freeArray)(
1160  const CMPIBroker * mb,
1161  CMPIArray * array);
1162 
1172  void (*freeDateTime)(
1173  const CMPIBroker * mb,
1174  CMPIDateTime * date);
1175 
1185  void (*freeSelectExp)(
1186  const CMPIBroker * mb,
1187  CMPISelectExp * se);
1188  };
1189 
1190 #endif /* CMPI_VER_200 */
1191 
1192  //---------------------------------------------------
1193  //--
1194  // _CMPIBroker Encapsulated object
1195  //--
1196  //---------------------------------------------------
1197 
1198 
1203  {
1204 
1208  void *hdl;
1209 
1214 
1219 
1223 #ifdef CMPI_VER_90
1225 #endif
1226 
1227 #ifdef CMPI_VER_200
1228 
1232 #endif
1233 
1234  };
1235 
1236 
1237  //---------------------------------------------------
1238  //--
1239  // _CMPIContext Function Table
1240  //--
1241  //---------------------------------------------------
1242 
1243 
1249  {
1250 
1255 
1263 
1270  CMPIContext *(*clone) (const CMPIContext * ctx, CMPIStatus * rc);
1271 
1272 
1281  const CMPIContext * ctx,
1282  const char *name,
1283  CMPIStatus * rc);
1284 
1295  const CMPIContext * ctx,
1296  CMPICount index,
1297  CMPIString ** name,
1298  CMPIStatus * rc);
1299 
1305  CMPICount (*getEntryCount)(
1306  const CMPIContext * ctx,
1307  CMPIStatus * rc);
1308 
1318  const CMPIContext * ctx,
1319  const char *name,
1320  const CMPIValue * value,
1321  const CMPIType type);
1322  };
1323 
1324 
1325  //---------------------------------------------------
1326  //--
1327  // _CMPIContext Encapsulated object
1328  //--
1329  //---------------------------------------------------
1330 
1335  {
1336 
1340  void *hdl;
1341 
1346  };
1347 
1348  //---------------------------------------------------
1349  //--
1350  // _CMPIResult Encapsulated object
1351  //--
1352  //---------------------------------------------------
1353 
1358  {
1359 
1363  void *hdl;
1364 
1369  };
1370 
1371  //---------------------------------------------------
1372  //--
1373  // _CMPIResult Function Table
1374  //--
1375  //---------------------------------------------------
1376 
1383  {
1384 
1389 
1397 
1404  CMPIResult *(*clone) (const CMPIResult * rslt, CMPIStatus * rc);
1405 
1414  const CMPIResult * rslt,
1415  const CMPIValue * value,
1416  const CMPIType type);
1417 
1425  const CMPIResult * rslt,
1426  const CMPIInstance * inst);
1427 
1435  const CMPIResult * rslt,
1436  const CMPIObjectPath * ref);
1437 
1444 
1445 #ifdef CMPI_VER_200
1446 
1453  const CMPIResult* rslt,
1454  const CMPIError* er);
1455 #endif
1456  };
1457 
1458 #ifdef CMPI_VER_200
1459 
1462  struct _CMPIError
1463  {
1467  void *hdl;
1468 
1473  };
1474 
1475  //---------------------------------------------------
1476  //--
1477  // _CMPIErrorFT Function Table
1478  //--
1479  //---------------------------------------------------
1480 
1481 
1487  {
1491  CMPISint32 ftVersion;
1492 
1500 
1507  CMPIError* (*clone)(const CMPIError*, CMPIStatus*);
1508 
1515  CMPIErrorType (*getErrorType)(const CMPIError*, CMPIStatus*);
1516 
1523  CMPIString* (*getOtherErrorType)(const CMPIError*, CMPIStatus*);
1524 
1531  CMPIString* (*getOwningEntity)(const CMPIError*, CMPIStatus*);
1532 
1539  CMPIString* (*getMessageID)(const CMPIError*, CMPIStatus*);
1540 
1547  CMPIString* (*getMessage)(const CMPIError*, CMPIStatus*);
1548 
1555  CMPIErrorSeverity (*getPerceivedSeverity)(
1556  const CMPIError*,
1557  CMPIStatus*);
1558 
1565  CMPIErrorProbableCause (*getProbableCause)(
1566  const CMPIError*,
1567  CMPIStatus*);
1568 
1575  CMPIString* (*getProbableCauseDescription)(
1576  const CMPIError*,
1577  CMPIStatus*);
1578 
1585  CMPIArray* (*getRecommendedActions)(
1586  const CMPIError*,
1587  CMPIStatus*);
1588 
1595  CMPIString* (*getErrorSource)(const CMPIError*, CMPIStatus*);
1596 
1603  CMPIErrorSrcFormat (*getErrorSourceFormat)(
1604  const CMPIError*,
1605  CMPIStatus*);
1606 
1614  CMPIString* (*getOtherErrorSourceFormat)(
1615  const CMPIError*,
1616  CMPIStatus*);
1617 
1625 
1632  CMPIString* (*getCIMStatusCodeDescription)(
1633  const CMPIError*,
1634  CMPIStatus*);
1635 
1642  CMPIArray* (*getMessageArguments)(
1643  const CMPIError*,
1644  CMPIStatus*);
1645 
1652  CMPIStatus (*setErrorType)(CMPIError*, const CMPIErrorType);
1653 
1662 
1670  CMPIError*,
1671  const char *);
1672 
1681 
1690 
1698  CMPIError*,
1699  const CMPIErrorSrcFormat );
1700 
1708 
1716  CMPIError*,
1717  const char*);
1718 
1727  };
1728 #endif /* CMPI_VER_200 */
1729 
1730 
1731  //---------------------------------------------------
1732  //--
1733  // _CMPIInstance Encapsulated object
1734  //--
1735  //---------------------------------------------------
1736 
1737 
1742  {
1743 
1747  void *hdl;
1748 
1753  };
1754 
1755 
1756  //---------------------------------------------------
1757  //--
1758  // _CMPIInstance Function Table
1759  //--
1760  //---------------------------------------------------
1761 
1767  {
1768 
1773 
1782 
1790  CMPIInstance *(*clone)(const CMPIInstance * inst, CMPIStatus * rc);
1791 
1800  const CMPIInstance * inst,
1801  const char *name,
1802  CMPIStatus * rc);
1803 
1813  const CMPIInstance * inst,
1814  CMPICount index,
1815  CMPIString ** name,
1816  CMPIStatus * rc);
1817 
1824  CMPICount (*getPropertyCount)(
1825  const CMPIInstance * inst,
1826  CMPIStatus * rc);
1827 
1837  const CMPIInstance * inst,
1838  const char *name,
1839  const CMPIValue * value,
1840  CMPIType type);
1841 
1849  CMPIObjectPath *(*getObjectPath)(
1850  const CMPIInstance * inst,
1851  CMPIStatus * rc);
1852 
1864  CMPIInstance * inst,
1865  const char **propertyList,
1866  const char **keys);
1867 
1868 #ifdef CMPI_VER_100
1869 
1880  CMPIInstance * inst,
1881  const CMPIObjectPath * op);
1882 #endif /* CMPI_VER_100 */
1883 
1884 #ifdef CMPI_VER_200
1885 
1897  const CMPIInstance*,
1898  const char*,
1899  const CMPIValue*,
1900  const CMPIType,
1901  const char*);
1902 #endif /* CMPI_VER_200 */
1903 
1904  };
1905 
1906 
1907  //---------------------------------------------------
1908  //--
1909  // _CMPIObjectPath Encapsulated object
1910  //--
1911  //---------------------------------------------------
1912 
1917  {
1918 
1922  void *hdl;
1923 
1928  };
1929 
1930 
1931  //---------------------------------------------------
1932  //--
1933  // _CMPIObjectPath Function Table
1934  //--
1935  //---------------------------------------------------
1936 
1942  {
1943 
1948 
1956 
1964  CMPIObjectPath *(*clone)(
1965  const CMPIObjectPath * op,
1966  CMPIStatus * rc);
1967 
1975  CMPIObjectPath * op,
1976  const char *ns);
1977 
1984  CMPIString *(*getNameSpace)(
1985  const CMPIObjectPath * op,
1986  CMPIStatus * rc);
1987 
1994  CMPIStatus (*setHostname) (CMPIObjectPath * op, const char *hn);
1995 
2002  CMPIString *(*getHostname)(
2003  const CMPIObjectPath * op,
2004  CMPIStatus * rc);
2005 
2013  CMPIObjectPath * op,
2014  const char *cn);
2015 
2022  CMPIString *(*getClassName)(
2023  const CMPIObjectPath * op,
2024  CMPIStatus * rc);
2025 
2035  CMPIObjectPath * op,
2036  const char *name,
2037  const CMPIValue * value,
2038  const CMPIType type);
2039 
2048  const CMPIObjectPath * op,
2049  const char *name,
2050  CMPIStatus * rc);
2051 
2061  const CMPIObjectPath * op,
2062  CMPICount index,
2063  CMPIString ** name,
2064  CMPIStatus * rc);
2065 
2072  CMPICount (*getKeyCount)(const CMPIObjectPath * op, CMPIStatus * rc);
2073 
2081  CMPIObjectPath * op,
2082  const CMPIObjectPath * src);
2083 
2092  CMPIObjectPath * op,
2093  const CMPIObjectPath * src);
2094 
2095  // optional qualifier support
2096 
2105  const CMPIObjectPath * op,
2106  const char *qName,
2107  CMPIStatus * rc);
2108 
2118  const CMPIObjectPath * op,
2119  const char *pName,
2120  const char *qName,
2121  CMPIStatus * rc);
2122 
2132  const CMPIObjectPath * op,
2133  const char *methodName,
2134  const char *qName,
2135  CMPIStatus * rc);
2136 
2147  const CMPIObjectPath * op,
2148  const char *mName,
2149  const char *pName,
2150  const char *qName,
2151  CMPIStatus * rc);
2152 
2153 #ifdef CMPI_VER_86
2154 
2160  CMPIString *(*toString)(const CMPIObjectPath * op, CMPIStatus * rc);
2161 # endif /* CMPI_VER_86 */
2162 
2163  };
2164 
2165 
2166  //---------------------------------------------------
2167  //--
2168  // _CMPISelectExp Encapsulated object
2169  //--
2170  //---------------------------------------------------
2171 
2176  {
2177 
2181  void *hdl;
2182 
2187  };
2188 
2189 
2190  //---------------------------------------------------
2191  //--
2192  // _CMPISelectExpFT Function Table
2193  //--
2194  //---------------------------------------------------
2195 
2201  {
2202 
2207 
2215 
2223  CMPISelectExp *(*clone)(const CMPISelectExp * se, CMPIStatus * rc);
2224 
2232  CMPIBoolean (*evaluate)(
2233  const CMPISelectExp * se,
2234  const CMPIInstance * inst,
2235  CMPIStatus * rc);
2236 
2243  CMPIString *(*getString)(const CMPISelectExp * se, CMPIStatus * rc);
2244 
2251  CMPISelectCond *(*getDOC)(const CMPISelectExp * se, CMPIStatus * rc);
2252 
2259  CMPISelectCond *(*getCOD)(const CMPISelectExp * se, CMPIStatus * rc);
2260 
2270 #ifdef CMPI_VER_87
2271  CMPIBoolean (*evaluateUsingAccessor)(
2272  const CMPISelectExp * se,
2273  CMPIAccessor * accessor,
2274  void *parm,
2275  CMPIStatus * rc);
2276 #endif /* CMPI_VER_87 */
2277  };
2278 
2279  //---------------------------------------------------
2280  //--
2281  // _CMPISelectCond Encapsulated object
2282  //--
2283  //---------------------------------------------------
2284 
2289  {
2290 
2294  void *hdl;
2295 
2300  };
2301 
2302 
2303  //---------------------------------------------------
2304  //--
2305  // _CMPISelectCondFT Function Table
2306  //--
2307  //---------------------------------------------------
2308 
2309 
2315  {
2316 
2321 
2329 
2337  CMPISelectCond *(*clone)(const CMPISelectCond * sc, CMPIStatus * rc);
2338 
2348  CMPICount (*getCountAndType)(
2349  const CMPISelectCond * sc,
2350  int* type,
2351  CMPIStatus * rc);
2352 
2360  CMPISubCond *(*getSubCondAt)(
2361  const CMPISelectCond * sc,
2362  CMPICount index,
2363  CMPIStatus * rc);
2364  };
2365 
2366 
2367  //---------------------------------------------------
2368  //--
2369  // _CMPISubCond Encapsulated object
2370  //--
2371  //---------------------------------------------------
2372 
2377  {
2378 
2382  void *hdl;
2383 
2388  };
2389 
2390  //---------------------------------------------------
2391  //--
2392  // _CMPISubCondFT Function Table
2393  //--
2394  //---------------------------------------------------
2395 
2401  {
2402 
2407 
2415 
2423  CMPISubCond *(*clone) (const CMPISubCond * sc, CMPIStatus * rc);
2424 
2431  CMPICount (*getCount) (const CMPISubCond * sc, CMPIStatus * rc);
2432 
2440  CMPIPredicate *(*getPredicateAt)(
2441  const CMPISubCond * sc,
2442  CMPICount index,
2443  CMPIStatus * rc);
2444 
2452  CMPIPredicate *(*getPredicate)(
2453  const CMPISubCond * sc,
2454  const char *name,
2455  CMPIStatus * rc);
2456  };
2457 
2458 
2459  //---------------------------------------------------
2460  //--
2461  // _CMPIPredicate Encapsulated object
2462  //--
2463  //---------------------------------------------------
2464 
2465 
2470  {
2471 
2475  void *hdl;
2476 
2481  };
2482 
2483 
2484  //---------------------------------------------------
2485  //--
2486  // _CMPIPredicateFT Function Table
2487  //--
2488  //---------------------------------------------------
2489 
2495  {
2496 
2501 
2509 
2517  CMPIPredicate *(*clone)(const CMPIPredicate * pr, CMPIStatus * rc);
2518 
2529  const CMPIPredicate * pr,
2530  CMPIType * type,
2531  CMPIPredOp * op,
2532  CMPIString ** lhs,
2533  CMPIString ** rhs);
2534 
2535 #if defined(CMPI_VER_87) && !defined(CMPI_VER_100)
2536 // Deprecated in the CMPI spec.
2537  int (*evaluate)
2538  (CMPIPredicate* pr, CMPIValue* value,
2539  CMPIType type, CMPIStatus* rc);
2540 #endif
2541 
2557 #ifdef CMPI_VER_100
2558  CMPIBoolean (*evaluateUsingAccessor)
2559  (const CMPIPredicate * pr, CMPIAccessor * accessorFnc, void *parm,
2560  CMPIStatus * rc);
2561 #endif /* CMPI_VER_100 */
2562 
2563  };
2564 
2565 
2566  //---------------------------------------------------
2567  //--
2568  // _CMPIArgs Encapsulated object
2569  //--
2570  //---------------------------------------------------
2571 
2575  struct _CMPIArgs
2576  {
2577 
2581  void *hdl;
2582 
2587  };
2588 
2589 
2590  //---------------------------------------------------
2591  //--
2592  // _CMPIArgsFT Function Table
2593  //--
2594  //---------------------------------------------------
2595 
2596 
2602  {
2603 
2608 
2616 
2624  CMPIArgs *(*clone) (const CMPIArgs * as, CMPIStatus * rc);
2625 
2635  const CMPIArgs * as,
2636  const char *name,
2637  const CMPIValue * value,
2638  const CMPIType type);
2639 
2648  const CMPIArgs * as,
2649  const char *name,
2650  CMPIStatus * rc);
2651 
2661  const CMPIArgs * as,
2662  CMPICount index,
2663  CMPIString ** name,
2664  CMPIStatus * rc);
2665 
2672  CMPICount (*getArgCount) (const CMPIArgs * as, CMPIStatus * rc);
2673  };
2674 
2675 
2676  //---------------------------------------------------
2677  //--
2678  // _CMPIString Encapsulated object
2679  //--
2680  //---------------------------------------------------
2681 
2682 
2687  {
2688 
2692  void *hdl;
2693 
2698  };
2699 
2700 
2701  //---------------------------------------------------
2702  //--
2703  // _CMPIStringFT Function Table
2704  //--
2705  //---------------------------------------------------
2706 
2707 
2713  {
2714 
2719 
2727 
2735  CMPIString *(*clone)(const CMPIString * st, CMPIStatus * rc);
2736 
2743  const char *(*getCharPtr)(const CMPIString * st, CMPIStatus * rc);
2744  };
2745 
2746 
2747  //---------------------------------------------------
2748  //--
2749  // _CMPIArray Encapsulated object
2750  //--
2751  //---------------------------------------------------
2752 
2753 
2757  struct _CMPIArray
2758  {
2759 
2763  void *hdl;
2764 
2769  };
2770 
2771 
2772  //---------------------------------------------------
2773  //--
2774  // _CMPIArrayFT Function Table
2775  //--
2776  //---------------------------------------------------
2777 
2778 
2784  {
2785 
2790 
2798 
2806  CMPIArray *(*clone)(const CMPIArray * ar, CMPIStatus * rc);
2807 
2814  CMPICount (*getSize)(const CMPIArray * ar, CMPIStatus * rc);
2815 
2822  CMPIType (*getSimpleType)(const CMPIArray * ar, CMPIStatus * rc);
2823 
2832  const CMPIArray * ar,
2833  CMPICount index,
2834  CMPIStatus * rc);
2835 
2845  CMPIArray * ar,
2846  CMPICount index,
2847  const CMPIValue * value,
2848  CMPIType type);
2849  };
2850 
2851 
2852  //---------------------------------------------------
2853  //--
2854  // _CMPIEnumeration Encapsulated object
2855  //--
2856  //---------------------------------------------------
2857 
2858 
2863  {
2864 
2868  void *hdl;
2869 
2874  };
2875 
2876 
2877  //---------------------------------------------------
2878  //--
2879  // _CMPIEnumerationFT Function Table
2880  //--
2881  //---------------------------------------------------
2882 
2883 
2889  {
2890 
2895 
2903 
2911  CMPIEnumeration *(*clone)(
2912  const CMPIEnumeration * en,
2913  CMPIStatus * rc);
2914 
2922 
2929  CMPIBoolean (*hasNext)(const CMPIEnumeration * en, CMPIStatus * rc);
2930 
2937  CMPIArray *(*toArray)(const CMPIEnumeration * en, CMPIStatus * rc);
2938  };
2939 
2940 
2941  //---------------------------------------------------
2942  //--
2943  // _CMPIDateTime Encapsulated object
2944  //--
2945  //---------------------------------------------------
2946 
2947 
2952  {
2953 
2957  void *hdl;
2958 
2963  };
2964 
2965 
2966  //---------------------------------------------------
2967  //--
2968  // _CMPIDateTimeFT Function Table
2969  //--
2970  //---------------------------------------------------
2971 
2972 
2978  {
2979 
2984 
2992 
3000  CMPIDateTime *(*clone) (const CMPIDateTime * dt, CMPIStatus * rc);
3001 
3009  CMPIUint64 (*getBinaryFormat)(
3010  const CMPIDateTime * dt,
3011  CMPIStatus * rc);
3012 
3019  CMPIString *(*getStringFormat)(
3020  const CMPIDateTime * dt,
3021  CMPIStatus * rc);
3022 
3029  CMPIBoolean (*isInterval)(
3030  const CMPIDateTime * dt,
3031  CMPIStatus * rc);
3032  };
3033 
3034 
3035  //---------------------------------------------------
3036  //--
3037  // _CMPIInstanceMI Instance Provider object
3038  //--
3039  //---------------------------------------------------
3040 
3041 
3042  typedef struct _CMPIInstanceMIFT CMPIInstanceMIFT;
3046  typedef struct _CMPIInstanceMI
3047  {
3048 
3052  void *hdl;
3053 
3058  } CMPIInstanceMI;
3059 
3060 
3061  //---------------------------------------------------
3062  //--
3063  // _CMPIInstanceMIFT Function Table
3064  //--
3065  //---------------------------------------------------
3066 
3067 
3074  {
3075 
3080 
3085 
3089  const char *miName;
3090 
3113  CMPIInstanceMI * mi,
3114  const CMPIContext * ctx,
3115  CMPIBoolean terminating);
3116 
3132  CMPIInstanceMI * mi,
3133  const CMPIContext * ctx,
3134  const CMPIResult * rslt,
3135  const CMPIObjectPath * op);
3136 
3155  CMPIInstanceMI * mi,
3156  const CMPIContext * ctx,
3157  const CMPIResult * rslt,
3158  const CMPIObjectPath * op,
3159  const char **properties);
3160 
3180  CMPIInstanceMI * mi,
3181  const CMPIContext * ctx,
3182  const CMPIResult * rslt,
3183  const CMPIObjectPath * op,
3184  const char **properties);
3185 
3202  CMPIInstanceMI * mi,
3203  const CMPIContext * ctx,
3204  const CMPIResult * rslt,
3205  const CMPIObjectPath * op,
3206  const CMPIInstance * inst);
3207 
3224  CMPIInstanceMI * mi,
3225  const CMPIContext * ctx,
3226  const CMPIResult * rslt,
3227  const CMPIObjectPath * op,
3228  const CMPIInstance * inst,
3229  const char **properties);
3230 
3247  CMPIInstanceMI * mi,
3248  const CMPIContext * ctx,
3249  const CMPIResult * rslt,
3250  const CMPIObjectPath * op);
3251 
3272  CMPIInstanceMI * mi,
3273  const CMPIContext * ctx,
3274  const CMPIResult * rslt,
3275  const CMPIObjectPath * op,
3276  const char *query,
3277  const char *lang);
3278  };
3279 
3280 
3281  //---------------------------------------------------
3282  //--
3283  // _CMPIAssociationMI Association Provider object
3284  //--
3285  //---------------------------------------------------
3286 
3287 
3292  typedef struct _CMPIAssociationMI
3293  {
3294 
3298  void *hdl;
3299 
3305 
3306 
3307  //---------------------------------------------------
3308  //--
3309  // _CMPIAssociationMIFT Function Table
3310  //--
3311  //---------------------------------------------------
3312 
3313 
3320  {
3321 
3326 
3331 
3335  const char *miName;
3336 
3358  CMPIAssociationMI * mi,
3359  const CMPIContext * ctx,
3360  CMPIBoolean terminating);
3361 
3406  CMPIAssociationMI * mi,
3407  const CMPIContext * ctx,
3408  const CMPIResult * rslt,
3409  const CMPIObjectPath * op,
3410  const char *asscClass,
3411  const char *resultClass,
3412  const char *role,
3413  const char *resultRole,
3414  const char **properties);
3415 
3456  CMPIAssociationMI * mi,
3457  const CMPIContext * ctx,
3458  const CMPIResult * rslt,
3459  const CMPIObjectPath * op,
3460  const char *assocClass,
3461  const char *resultClass,
3462  const char *role,
3463  const char *resultRole);
3464 
3496  CMPIAssociationMI * mi,
3497  const CMPIContext * ctx,
3498  const CMPIResult * rslt,
3499  const CMPIObjectPath * op,
3500  const char *resultClass,
3501  const char *role,
3502  const char **properties);
3503 
3532  CMPIAssociationMI * mi,
3533  const CMPIContext * ctx,
3534  const CMPIResult * rslt,
3535  const CMPIObjectPath * op,
3536  const char *resultClass,
3537  const char *role);
3538  };
3539 
3540 
3541  //---------------------------------------------------
3542  //--
3543  // _CMPIMethodMI Method Provider object
3544  //--
3545  //---------------------------------------------------
3546 
3547  typedef struct _CMPIMethodMIFT CMPIMethodMIFT;
3551  typedef struct _CMPIMethodMI
3552  {
3553 
3557  void *hdl;
3558 
3563  } CMPIMethodMI;
3564 
3565 
3566  //---------------------------------------------------
3567  //--
3568  // _CMPIMethodMIFT Function Table
3569  //--
3570  //---------------------------------------------------
3571 
3572 
3579  {
3580 
3585 
3590 
3594  const char *miName;
3595 
3617  CMPIMethodMI * mi,
3618  const CMPIContext * ctx,
3619  CMPIBoolean terminating);
3620 
3643  CMPIMethodMI * mi,
3644  const CMPIContext * ctx,
3645  const CMPIResult * rslt,
3646  const CMPIObjectPath * op,
3647  const char *method,
3648  const CMPIArgs * in,
3649  CMPIArgs * out);
3650  };
3651 
3652 
3653  //---------------------------------------------------
3654  //--
3655  // _CMPIPropertyMI Property Provider object
3656  //--
3657  //---------------------------------------------------
3658 
3659 
3660  typedef struct _CMPIPropertyMIFT CMPIPropertyMIFT;
3664  typedef struct _CMPIPropertyMI
3665  {
3666 
3670  void *hdl;
3671 
3676  } CMPIPropertyMI;
3677 
3678 
3679 
3680  //---------------------------------------------------
3681  //--
3682  // _CMPIPropertyMIFT Function Table
3683  //--
3684  //---------------------------------------------------
3685 
3686 
3693  {
3694 
3699 
3704 
3708  const char *miName;
3709 
3727  CMPIPropertyMI * mi,
3728  const CMPIContext * ctx,
3729  CMPIBoolean terminating);
3730 
3749  CMPIPropertyMI * mi,
3750  const CMPIContext * ctx,
3751  const CMPIResult * rslt,
3752  const CMPIObjectPath * op,
3753  const char *name,
3754  const CMPIData data);
3755 
3778  CMPIPropertyMI *,
3779  const CMPIContext *,
3780  const CMPIResult *,
3781  const CMPIObjectPath *,
3782  const char *name);
3783  };
3784 
3785 
3786  //---------------------------------------------------
3787  //--
3788  // _CMPIIndicationMI Indication Provider object
3789  //--
3790  //---------------------------------------------------
3791 
3792 
3793  typedef struct _CMPIIndicationMIFT CMPIIndicationMIFT;
3797  typedef struct _CMPIIndicationMI
3798  {
3799 
3803  void *hdl;
3804 
3809  } CMPIIndicationMI;
3810 
3811 
3812  //---------------------------------------------------
3813  //--
3814  // _CMPIIndicationMIFT Function Table
3815  //--
3816  //---------------------------------------------------
3817 
3818 
3825  {
3826 
3831 
3836 
3840  const char *miName;
3841 
3864  CMPIIndicationMI * mi,
3865  const CMPIContext * ctx,
3866  CMPIBoolean terminating);
3867 
3891  CMPIIndicationMI * mi,
3892  const CMPIContext * ctx,
3893  const CMPISelectExp * filter,
3894  const char *className,
3895  const CMPIObjectPath * op,
3896  const char *owner);
3897 
3926  CMPIIndicationMI * mi,
3927  const CMPIContext * ctx,
3928  const CMPISelectExp * filter,
3929  const char *className,
3930  const CMPIObjectPath * classPath);
3931 
3960  CMPIIndicationMI * mi,
3961  const CMPIContext * ctx,
3962  const CMPISelectExp * filter,
3963  const char *className,
3964  const CMPIObjectPath * classPath,
3965  CMPIBoolean firstActivation);
3966 
3994  CMPIIndicationMI * mi,
3995  const CMPIContext * ctx,
3996  const CMPISelectExp * filter,
3997  const char *className,
3998  const CMPIObjectPath * classPath,
3999  CMPIBoolean lastActiviation);
4000 
4026  CMPIIndicationMI * mi,
4027  const CMPIContext *);
4028 
4054  CMPIIndicationMI * mi,
4055  const CMPIContext *);
4056 
4057  };
4058 
4059 #include "cmpimacs.h"
4060 
4061 
4062 #ifdef __cplusplus
4063 };
4064 #endif
4065 
4066 #endif // _CMPIFT_H_
Definition: cmpift.h:2862
unsigned int brokerVersion
Definition: cmpift.h:393
Definition: cmpift.h:2376
CMPIData(* getProperty)(const CMPIInstance *inst, const char *name, CMPIStatus *rc)
Definition: cmpift.h:1799
Definition: cmpift.h:2400
CMPIStatus(* setProperty)(const CMPIInstance *inst, const char *name, const CMPIValue *value, CMPIType type)
Definition: cmpift.h:1836
int(* cancelThread)(CMPI_THREAD_TYPE thread)
Definition: cmpift.h:863
CMPIStatus(* deliverIndication)(const CMPIBroker *mb, const CMPIContext *ctx, const char *ns, const CMPIInstance *ind)
Definition: cmpift.h:446
int ftVersion
Definition: cmpift.h:1020
CMPIInstanceMIFT * ft
Definition: cmpift.h:3057
CMPIStatus(* cleanup)(CMPIInstanceMI *mi, const CMPIContext *ctx, CMPIBoolean terminating)
Definition: cmpift.h:3112
CMPIStatus(* addArg)(const CMPIArgs *as, const char *name, const CMPIValue *value, const CMPIType type)
Definition: cmpift.h:2634
CMPIStatus(* disableIndications)(CMPIIndicationMI *mi, const CMPIContext *)
Definition: cmpift.h:4053
CMPIStatus(* openMessageFile)(const CMPIBroker *mb, const char *msgFile, CMPIMsgFileHandle *msgFileHandle)
Definition: cmpift.h:331
CMPIErrorSrcFormat(* getErrorSourceFormat)(const CMPIError *, CMPIStatus *)
Definition: cmpift.h:1603
CMPIStatus(* returnObjectPath)(const CMPIResult *rslt, const CMPIObjectPath *ref)
Definition: cmpift.h:1434
CMPIStatus(* setPropertyFilter)(CMPIInstance *inst, const char **propertyList, const char **keys)
Definition: cmpift.h:1863
int ftVersion
Definition: cmpift.h:62
CMPIStatus(* createInstance)(CMPIInstanceMI *mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath *op, const CMPIInstance *inst)
Definition: cmpift.h:3201
Definition: cmpidt.h:499
CMPIStatus(* release)(CMPISubCond *sc)
Definition: cmpift.h:2414
CMPIStatus(* setErrorType)(CMPIError *, const CMPIErrorType)
Definition: cmpift.h:1652
int ftVersion
Definition: cmpift.h:2320
int(* setThreadSpecific)(CMPI_THREAD_KEY_TYPE key, void *value)
Definition: cmpift.h:916
CMPICount(* getEntryCount)(const CMPIContext *ctx, CMPIStatus *rc)
Definition: cmpift.h:1305
void * hdl
Definition: cmpift.h:3557
CMPIResultFT * ft
Definition: cmpift.h:1368
Definition: cmpift.h:1916
int ftVersion
Definition: cmpift.h:2406
Definition: cmpift.h:2888
CMPIStatus(* returnInstance)(const CMPIResult *rslt, const CMPIInstance *inst)
Definition: cmpift.h:1424
const char * miName
Definition: cmpift.h:3708
CMPIEnumerationFT * ft
Definition: cmpift.h:2873
CMPIData(* getArg)(const CMPIArgs *as, const char *name, CMPIStatus *rc)
Definition: cmpift.h:2647
CMPIStatus(* associators)(CMPIAssociationMI *mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath *op, const char *asscClass, const char *resultClass, const char *role, const char *resultRole, const char **properties)
Definition: cmpift.h:3405
CMPIStatus(* trace)(const CMPIBroker *, CMPILevel level, const char *component, const char *text, const CMPIString *string)
Definition: cmpift.h:287
Definition: cmpift.h:1462
CMPICount(* getKeyCount)(const CMPIObjectPath *op, CMPIStatus *rc)
Definition: cmpift.h:2072
int ftVersion
Definition: cmpift.h:2718
const char * brokerName
Definition: cmpift.h:397
int miVersion
Definition: cmpift.h:3330
CMPIStatus(* setCIMStatusCodeDescription)(CMPIError *, const char *)
Definition: cmpift.h:1715
CMPIBoolean(* isInterval)(const CMPIDateTime *dt, CMPIStatus *rc)
Definition: cmpift.h:3029
int(* exitThread)(CMPI_THREAD_RETURN return_code)
Definition: cmpift.h:855
Definition: cmpift.h:3046
CMPIErrorSeverity(* getPerceivedSeverity)(const CMPIError *, CMPIStatus *)
Definition: cmpift.h:1555
int ftVersion
Definition: cmpift.h:2500
CMPIStatus(* closeMessageFile)(const CMPIBroker *mb, const CMPIMsgFileHandle msgFileHandle)
Definition: cmpift.h:342
CMPIStatus(* enableIndications)(CMPIIndicationMI *mi, const CMPIContext *)
Definition: cmpift.h:4025
Definition: cmpift.h:1941
CMPIStatus(* setPropertyWithOrigin)(const CMPIInstance *, const char *, const CMPIValue *, const CMPIType, const char *)
Definition: cmpift.h:1896
Definition: cmpift.h:1357
CMPIErrorFT * ft
Definition: cmpift.h:1472
CMPICount(* getArgCount)(const CMPIArgs *as, CMPIStatus *rc)
Definition: cmpift.h:2672
Definition: cmpidt.h:275
int(* condWait)(CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex)
Definition: cmpift.h:969
CMPIStatus(* deleteInstance)(const CMPIBroker *mb, const CMPIContext *ctx, const CMPIObjectPath *op)
Definition: cmpift.h:533
int miVersion
Definition: cmpift.h:3589
Definition: cmpift.h:1014
CMPIStatus(* release)(CMPISelectCond *sc)
Definition: cmpift.h:2328
void * hdl
Definition: cmpift.h:2181
Definition: cmpift.h:2288
void * hdl
Definition: cmpift.h:1340
CMPIObjectPathFT * ft
Definition: cmpift.h:1927
CMPIStatus(* references)(CMPIAssociationMI *mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath *op, const char *resultClass, const char *role, const char **properties)
Definition: cmpift.h:3495
CMPIStatus(* deleteInstance)(CMPIInstanceMI *mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath *op)
Definition: cmpift.h:3246
Definition: cmpift.h:1334
Definition: cmpift.h:2951
CMPIStatus(* addKey)(CMPIObjectPath *op, const char *name, const CMPIValue *value, const CMPIType type)
Definition: cmpift.h:2034
CMPI_COND_TYPE(* newCondition)(int opt)
Definition: cmpift.h:952
unsigned int brokerCapabilities
Definition: cmpift.h:389
int(* destroyThreadKey)(CMPI_THREAD_KEY_TYPE key)
Definition: cmpift.h:901
CMPIStatus(* setErrorSource)(CMPIError *, const char *)
Definition: cmpift.h:1689
int ftVersion
Definition: cmpift.h:2789
CMPISelectExpFT * ft
Definition: cmpift.h:2186
Definition: cmpift.h:1202
CMPIBoolean(* evaluate)(const CMPISelectExp *se, const CMPIInstance *inst, CMPIStatus *rc)
Definition: cmpift.h:2232
CMPIStatus(* getProperty)(CMPIPropertyMI *, const CMPIContext *, const CMPIResult *, const CMPIObjectPath *, const char *name)
Definition: cmpift.h:3777
CMPIData(* getKeyAt)(const CMPIObjectPath *op, CMPICount index, CMPIString **name, CMPIStatus *rc)
Definition: cmpift.h:2060
void * hdl
Definition: cmpift.h:1208
CMPIStatus(* getData)(const CMPIPredicate *pr, CMPIType *type, CMPIPredOp *op, CMPIString **lhs, CMPIString **rhs)
Definition: cmpift.h:2528
int miVersion
Definition: cmpift.h:3703
CMPIStatus(* release)(CMPIString *st)
Definition: cmpift.h:2726
CMPIPredicateFT * ft
Definition: cmpift.h:2480
CMPIAssociationMIFT * ft
Definition: cmpift.h:3303
CMPIData(* getMethodQualifier)(const CMPIObjectPath *op, const char *methodName, const char *qName, CMPIStatus *rc)
Definition: cmpift.h:2131
Definition: cmpift.h:1766
void(* freeArgs)(const CMPIBroker *mb, CMPIArgs *args)
Definition: cmpift.h:1133
int ftVersion
Definition: cmpift.h:3079
CMPIBrokerMemFT * mft
Definition: cmpift.h:1231
CMPIStatus(* setClassName)(CMPIObjectPath *op, const char *cn)
Definition: cmpift.h:2012
void * hdl
Definition: cmpift.h:1467
Definition: cmpift.h:2469
int ftVersion
Definition: cmpift.h:1772
void * hdl
Definition: cmpift.h:2475
CMPIData(* getNext)(const CMPIEnumeration *en, CMPIStatus *rc)
Definition: cmpift.h:2921
CMPIStatus(* release)(CMPIResult *rslt)
Definition: cmpift.h:1396
Definition: cmpift.h:3578
CMPIStatus(* activateFilter)(CMPIIndicationMI *mi, const CMPIContext *ctx, const CMPISelectExp *filter, const char *className, const CMPIObjectPath *classPath, CMPIBoolean firstActivation)
Definition: cmpift.h:3959
int miVersion
Definition: cmpift.h:3084
void * hdl
Definition: cmpift.h:2581
CMPIStatus(* associatorNames)(CMPIAssociationMI *mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath *op, const char *assocClass, const char *resultClass, const char *role, const char *resultRole)
Definition: cmpift.h:3455
void * hdl
Definition: cmpift.h:2382
CMPIArrayFT * ft
Definition: cmpift.h:2768
CMPIStatus(* cleanup)(CMPIPropertyMI *mi, const CMPIContext *ctx, CMPIBoolean terminating)
Definition: cmpift.h:3726
int ftVersion
Definition: cmpift.h:2206
CMPIIndicationMIFT * ft
Definition: cmpift.h:3808
const char * miName
Definition: cmpift.h:3594
int ftVersion
Definition: cmpift.h:3698
CMPIStatus(* addEntry)(const CMPIContext *ctx, const char *name, const CMPIValue *value, const CMPIType type)
Definition: cmpift.h:1317
CMPIStatus(* setProperty)(CMPIPropertyMI *mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath *op, const char *name, const CMPIData data)
Definition: cmpift.h:3748
CMPIStatus(* release)(CMPIEnumeration *en)
Definition: cmpift.h:2902
void * hdl
Definition: cmpift.h:1363
CMPIStatus(* release)(CMPIInstance *inst)
Definition: cmpift.h:1781
CMPIBoolean(* evaluateUsingAccessor)(const CMPIPredicate *pr, CMPIAccessor *accessorFnc, void *parm, CMPIStatus *rc)
Definition: cmpift.h:2559
Definition: cmpift.h:57
CMPIStatus(* deActivateFilter)(CMPIIndicationMI *mi, const CMPIContext *ctx, const CMPISelectExp *filter, const char *className, const CMPIObjectPath *classPath, CMPIBoolean lastActiviation)
Definition: cmpift.h:3993
CMPIInstanceFT * ft
Definition: cmpift.h:1752
CMPISelectCondFT * ft
Definition: cmpift.h:2299
Definition: cmpift.h:2783
void * hdl
Definition: cmpift.h:2763
CMPIStatus(* setHostAndNameSpaceFromObjectPath)(CMPIObjectPath *op, const CMPIObjectPath *src)
Definition: cmpift.h:2091
CMPIStatus(* referenceNames)(CMPIAssociationMI *mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath *op, const char *resultClass, const char *role)
Definition: cmpift.h:3531
CMPIBrokerExtFT * xft
Definition: cmpift.h:1224
CMPIStatus(* release)(CMPIObjectPath *op)
Definition: cmpift.h:1955
CMPIStatus(* cleanup)(CMPIMethodMI *mi, const CMPIContext *ctx, CMPIBoolean terminating)
Definition: cmpift.h:3616
CMPIBoolean(* evaluateUsingAccessor)(const CMPISelectExp *se, CMPIAccessor *accessor, void *parm, CMPIStatus *rc)
Definition: cmpift.h:2271
CMPIStatus(* setErrorSourceFormat)(CMPIError *, const CMPIErrorSrcFormat)
Definition: cmpift.h:1697
int miVersion
Definition: cmpift.h:3835
CMPIStatus(* release)(CMPIArray *ar)
Definition: cmpift.h:2797
void * hdl
Definition: cmpift.h:1747
void * hdl
Definition: cmpift.h:1922
CMPIBoolean(* classPathIsA)(const CMPIBroker *mb, const CMPIObjectPath *op, const char *type, CMPIStatus *rc)
Definition: cmpift.h:188
Definition: cmpift.h:3319
int(* signalCondition)(CMPI_COND_TYPE cond)
Definition: cmpift.h:995
Definition: cmpift.h:2314
CMPIData(* getEntry)(const CMPIContext *ctx, const char *name, CMPIStatus *rc)
Definition: cmpift.h:1280
void(* unlockMutex)(CMPI_MUTEX_TYPE mutex)
Definition: cmpift.h:944
CMPIStringFT * ft
Definition: cmpift.h:2697
CMPIData(* getParameterQualifier)(const CMPIObjectPath *op, const char *mName, const char *pName, const char *qName, CMPIStatus *rc)
Definition: cmpift.h:2146
Definition: cmpift.h:2175
const char * miName
Definition: cmpift.h:3089
void(* freeSelectExp)(const CMPIBroker *mb, CMPISelectExp *se)
Definition: cmpift.h:1185
CMPIData(* getArgAt)(const CMPIArgs *as, CMPICount index, CMPIString **name, CMPIStatus *rc)
Definition: cmpift.h:2660
CMPIStatus(* release)(CMPIPredicate *pr)
Definition: cmpift.h:2508
CMPIStatus(* setRecommendedActions)(CMPIError *, const CMPIArray *)
Definition: cmpift.h:1680
CMPIStatus(* setProperty)(const CMPIBroker *mb, const CMPIContext *ctx, const CMPIObjectPath *op, const char *name, const CMPIValue *value, CMPIType type)
Definition: cmpift.h:760
int ftVersion
Definition: cmpift.h:3325
int(* threadSleep)(CMPIUint32 msec)
Definition: cmpift.h:872
CMPICount(* getCountAndType)(const CMPISelectCond *sc, int *type, CMPIStatus *rc)
Definition: cmpift.h:2348
CMPIStatus(* invokeMethod)(CMPIMethodMI *mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath *op, const char *method, const CMPIArgs *in, CMPIArgs *out)
Definition: cmpift.h:3642
CMPIData(* getPropertyQualifier)(const CMPIObjectPath *op, const char *pName, const char *qName, CMPIStatus *rc)
Definition: cmpift.h:2117
void(* destroyMutex)(CMPI_MUTEX_TYPE mutex)
Definition: cmpift.h:931
CMPIData(* getProperty)(const CMPIBroker *mb, const CMPIContext *ctx, const CMPIObjectPath *op, const char *name, CMPIStatus *rc)
Definition: cmpift.h:779
Definition: cmpift.h:1741
CMPIStatus(* mustPoll)(CMPIIndicationMI *mi, const CMPIContext *ctx, const CMPISelectExp *filter, const char *className, const CMPIObjectPath *classPath)
Definition: cmpift.h:3925
CMPIStatus(* logMessage)(const CMPIBroker *, CMPISeverity severity, const char *id, const char *text, const CMPIString *string)
Definition: cmpift.h:267
CMPICount(* getSize)(const CMPIArray *ar, CMPIStatus *rc)
Definition: cmpift.h:2814
Definition: cmpift.h:2977
Definition: cmpift.h:3824
CMPI_THREAD_TYPE(* newThread)(CMPI_THREAD_RETURN(CMPI_THREAD_CDECL *start)(void *), void *parm, int detached)
Definition: cmpift.h:831
CMPIPropertyMIFT * ft
Definition: cmpift.h:3675
Definition: cmpift.h:2200
Definition: cmpidt.h:679
CMPIStatus(* setOtherErrorSourceFormat)(CMPIError *, const char *)
Definition: cmpift.h:1707
void(* cmpiFree)(const CMPIBroker *mb, void *)
Definition: cmpift.h:1098
int ftVersion
Definition: cmpift.h:1388
void * hdl
Definition: cmpift.h:3052
CMPIDateTimeFT * ft
Definition: cmpift.h:2962
CMPIData(* getEntryAt)(const CMPIContext *ctx, CMPICount index, CMPIString **name, CMPIStatus *rc)
Definition: cmpift.h:1294
const char * miName
Definition: cmpift.h:3335
CMPIStatus(* execQuery)(CMPIInstanceMI *mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath *op, const char *query, const char *lang)
Definition: cmpift.h:3271
CMPIStatus(* setNameSpaceFromObjectPath)(CMPIObjectPath *op, const CMPIObjectPath *src)
Definition: cmpift.h:2080
Definition: cmpift.h:1382
CMPIStatus(* detachThread)(const CMPIBroker *mb, const CMPIContext *ctx)
Definition: cmpift.h:431
Definition: cmpift.h:3551
Definition: cmpift.h:3692
void * hdl
Definition: cmpift.h:2957
int ftVersion
Definition: cmpift.h:2607
CMPIStatus(* attachThread)(const CMPIBroker *, const CMPIContext *)
Definition: cmpift.h:419
Definition: cmpift.h:2712
Definition: cmpift.h:3797
void * hdl
Definition: cmpift.h:3803
int(* joinThread)(CMPI_THREAD_TYPE thread, CMPI_THREAD_RETURN *retval)
Definition: cmpift.h:844
Definition: cmpift.h:1248
Definition: cmpift.h:2601
void(* freeDateTime)(const CMPIBroker *mb, CMPIDateTime *date)
Definition: cmpift.h:1172
CMPIrc(* getCIMStatusCode)(const CMPIError *, CMPIStatus *)
Definition: cmpift.h:1624
int ftVersion
Definition: cmpift.h:2894
CMPIErrorType(* getErrorType)(const CMPIError *, CMPIStatus *)
Definition: cmpift.h:1515
CMPIStatus(* release)(CMPIContext *ctx)
Definition: cmpift.h:1262
CMPIUint64(* getBinaryFormat)(const CMPIDateTime *dt, CMPIStatus *rc)
Definition: cmpift.h:3009
Definition: cmpift.h:3073
void * hdl
Definition: cmpift.h:2692
CMPIStatus(* cleanup)(CMPIIndicationMI *mi, const CMPIContext *ctx, CMPIBoolean terminating)
Definition: cmpift.h:3863
CMPIStatus(* returnError)(const CMPIResult *rslt, const CMPIError *er)
Definition: cmpift.h:1452
Definition: cmpift.h:2686
CMPIData(* getClassQualifier)(const CMPIObjectPath *op, const char *qName, CMPIStatus *rc)
Definition: cmpift.h:2104
CMPIStatus(* returnData)(const CMPIResult *rslt, const CMPIValue *value, const CMPIType type)
Definition: cmpift.h:1413
CMPIStatus(* enumerateInstanceNames)(CMPIInstanceMI *mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath *op)
Definition: cmpift.h:3131
int ftVersion
Definition: cmpift.h:809
void(* freeInstance)(const CMPIBroker *mb, CMPIInstance *inst)
Definition: cmpift.h:1109
void(* freeArray)(const CMPIBroker *mb, CMPIArray *array)
Definition: cmpift.h:1159
Definition: cmpift.h:2757
int(* createThreadKey)(CMPI_THREAD_KEY_TYPE *key, void(*cleanup)(void *))
Definition: cmpift.h:892
int ftVersion
Definition: cmpift.h:3830
Definition: cmpift.h:2494
void(* destroyCondition)(CMPI_COND_TYPE cond)
Definition: cmpift.h:958
CMPIContextFT * ft
Definition: cmpift.h:1345
Definition: cmpift.h:3292
void(* lockMutex)(CMPI_MUTEX_TYPE mutex)
Definition: cmpift.h:938
void * hdl
Definition: cmpift.h:2868
CMPIStatus(* release)(const CMPIBroker *mb, const CMPIGcStat *gc)
Definition: cmpift.h:1040
Definition: cmpift.h:804
CMPIData(* getPropertyAt)(const CMPIInstance *inst, CMPICount index, CMPIString **name, CMPIStatus *rc)
Definition: cmpift.h:1812
int(* timedCondWait)(CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex, struct timespec *wait)
Definition: cmpift.h:984
Definition: cmpift.h:1486
int ftVersion
Definition: cmpift.h:3584
CMPIStatus(* authorizeFilter)(CMPIIndicationMI *mi, const CMPIContext *ctx, const CMPISelectExp *filter, const char *className, const CMPIObjectPath *op, const char *owner)
Definition: cmpift.h:3890
CMPIData(* getKey)(const CMPIObjectPath *op, const char *name, CMPIStatus *rc)
Definition: cmpift.h:2047
CMPIType(* getSimpleType)(const CMPIArray *ar, CMPIStatus *rc)
Definition: cmpift.h:2822
void * hdl
Definition: cmpift.h:2294
CMPIStatus(* setHostname)(CMPIObjectPath *op, const char *hn)
Definition: cmpift.h:1994
int(* threadOnce)(int *once, void(*init)(void))
Definition: cmpift.h:882
CMPIStatus(* setMessageArguments)(CMPIError *, CMPIArray *)
Definition: cmpift.h:1726
CMPIStatus(* getInstance)(CMPIInstanceMI *mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath *op, const char **properties)
Definition: cmpift.h:3179
CMPIStatus(* setProbableCauseDescription)(CMPIError *, const char *)
Definition: cmpift.h:1669
CMPIBoolean(* hasNext)(const CMPIEnumeration *en, CMPIStatus *rc)
Definition: cmpift.h:2929
void(* freeObjectPath)(const CMPIBroker *mb, CMPIObjectPath *obj)
Definition: cmpift.h:1120
CMPIStatus(* returnDone)(const CMPIResult *rslt)
Definition: cmpift.h:1443
Definition: cmpift.h:2575
CMPIErrorProbableCause(* getProbableCause)(const CMPIError *, CMPIStatus *)
Definition: cmpift.h:1565
void * hdl
Definition: cmpift.h:3298
const char * miName
Definition: cmpift.h:3840
CMPIStatus(* setOtherErrorType)(CMPIError *, const char *)
Definition: cmpift.h:1661
CMPIStatus(* modifyInstance)(const CMPIBroker *mb, const CMPIContext *ctx, const CMPIObjectPath *op, const CMPIInstance *inst, const char **properties)
Definition: cmpift.h:518
CMPIStatus(* setObjectPath)(CMPIInstance *inst, const CMPIObjectPath *op)
Definition: cmpift.h:1879
CMPIStatus(* release)(CMPIError *)
Definition: cmpift.h:1499
CMPIArgsFT * ft
Definition: cmpift.h:2586
CMPIStatus(* release)(CMPIArgs *as)
Definition: cmpift.h:2615
int ftVersion
Definition: cmpift.h:1947
CMPISubCondFT * ft
Definition: cmpift.h:2387
CMPICount(* getPropertyCount)(const CMPIInstance *inst, CMPIStatus *rc)
Definition: cmpift.h:1824
void * hdl
Definition: cmpift.h:3670
CMPIStatus(* modifyInstance)(CMPIInstanceMI *mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath *op, const CMPIInstance *inst, const char **properties)
Definition: cmpift.h:3223
CMPIStatus(* enumerateInstances)(CMPIInstanceMI *mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath *op, const char **properties)
Definition: cmpift.h:3154
CMPIStatus(* setElementAt)(CMPIArray *ar, CMPICount index, const CMPIValue *value, CMPIType type)
Definition: cmpift.h:2844
CMPIStatus(* cleanup)(CMPIAssociationMI *mi, const CMPIContext *ctx, CMPIBoolean terminating)
Definition: cmpift.h:3357
CMPIBrokerFT * bft
Definition: cmpift.h:1213
CMPIData(* getElementAt)(const CMPIArray *ar, CMPICount index, CMPIStatus *rc)
Definition: cmpift.h:2831
CMPI_MUTEX_TYPE(* newMutex)(int opt)
Definition: cmpift.h:925
int ftVersion
Definition: cmpift.h:1254
Definition: cmpift.h:3664
int ftVersion
Definition: cmpift.h:2983
void(* freeString)(const CMPIBroker *mb, CMPIString *str)
Definition: cmpift.h:1146
CMPIBoolean(* isOfType)(const CMPIBroker *mb, const void *object, const char *type, CMPIStatus *rc)
Definition: cmpift.h:217
Definition: cmpift.h:382
CMPICount(* getCount)(const CMPISubCond *sc, CMPIStatus *rc)
Definition: cmpift.h:2431
CMPIMethodMIFT * ft
Definition: cmpift.h:3562
CMPIStatus(* release)(CMPISelectExp *se)
Definition: cmpift.h:2214
CMPIBrokerEncFT * eft
Definition: cmpift.h:1218
CMPIStatus(* setNameSpace)(CMPIObjectPath *op, const char *ns)
Definition: cmpift.h:1974
CMPIStatus(* release)(CMPIDateTime *dt)
Definition: cmpift.h:2991
CMPISint32 ftVersion
Definition: cmpift.h:1491
CMPIData(* invokeMethod)(const CMPIBroker *mb, const CMPIContext *ctx, const CMPIObjectPath *op, const char *method, const CMPIArgs *in, CMPIArgs *out, CMPIStatus *rc)
Definition: cmpift.h:739