/var/tmp/tog-pegasus-2.9.0-8m.mo8/pegasus/src/Pegasus/Provider/CMPI/cmpift.h
00001 //%LICENSE////////////////////////////////////////////////////////////////
00002 //
00003 // Licensed to The Open Group (TOG) under one or more contributor license
00004 // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
00005 // this work for additional information regarding copyright ownership.
00006 // Each contributor licenses this file to you under the OpenPegasus Open
00007 // Source License; you may not use this file except in compliance with the
00008 // License.
00009 //
00010 // Permission is hereby granted, free of charge, to any person obtaining a
00011 // copy of this software and associated documentation files (the "Software"),
00012 // to deal in the Software without restriction, including without limitation
00013 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
00014 // and/or sell copies of the Software, and to permit persons to whom the
00015 // Software is furnished to do so, subject to the following conditions:
00016 //
00017 // The above copyright notice and this permission notice shall be included
00018 // in all copies or substantial portions of the Software.
00019 //
00020 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
00021 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00022 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
00023 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
00024 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
00025 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
00026 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00027 //
00029 //
00030 //%////////////////////////////////////////////////////////////////////////////
00031 
00032 #ifndef _CMPIFT_H_
00033 #define _CMPIFT_H_
00034 
00035 #include "cmpidt.h"
00036 #include "cmpios.h"
00037 
00038 #ifdef __cplusplus
00039 extern "C"
00040 {
00041 #endif
00042 
00043 
00044     //---------------------------------------------------
00045     //--
00046     //   _CMPIBrokerEncFT Function Table
00047     //--
00048     //---------------------------------------------------
00049 
00050 
00057     struct _CMPIBrokerEncFT
00058     {
00062         int ftVersion;
00063 
00071         CMPIInstance *(*newInstance)(
00072             const CMPIBroker * mb,
00073             const CMPIObjectPath * op,
00074             CMPIStatus * rc);
00075 
00084         CMPIObjectPath *(*newObjectPath)(
00085             const CMPIBroker * mb,
00086             const char *ns,
00087             const char *cn,
00088             CMPIStatus * rc);
00089 
00096         CMPIArgs *(*newArgs)(const CMPIBroker * mb, CMPIStatus * rc);
00097 
00105         CMPIString *(*newString)(
00106             const CMPIBroker * mb,
00107             const char *data,
00108             CMPIStatus * rc);
00109 
00118         CMPIArray *(*newArray)(
00119             const CMPIBroker * mb,
00120             CMPICount max,
00121             CMPIType type,
00122             CMPIStatus * rc);
00123 
00130         CMPIDateTime *(*newDateTime)(
00131             const CMPIBroker * mb,
00132             CMPIStatus * rc);
00133 
00144         CMPIDateTime *(*newDateTimeFromBinary)(
00145             const CMPIBroker * mb,
00146             CMPIUint64 binTime,
00147             CMPIBoolean interval,
00148             CMPIStatus * rc);
00149 
00157         CMPIDateTime *(*newDateTimeFromChars)(
00158             const CMPIBroker * mb,
00159             const char *utcTime,
00160             CMPIStatus * rc);
00161 
00172         CMPISelectExp *(*newSelectExp)(
00173             const CMPIBroker * mb,
00174             const char *query,
00175             const char *lang,
00176             CMPIArray ** projection,
00177             CMPIStatus * st);
00178 
00188         CMPIBoolean (*classPathIsA)(
00189             const CMPIBroker * mb,
00190             const CMPIObjectPath * op,
00191             const char *type,
00192             CMPIStatus * rc);
00193 
00202         CMPIString *(*toString)(
00203             const CMPIBroker * mb,
00204             const void *object,
00205             CMPIStatus * rc);
00206 
00217         CMPIBoolean (*isOfType)(
00218             const CMPIBroker * mb,
00219             const void *object,
00220             const char *type,
00221             CMPIStatus * rc);
00222 
00231         CMPIString *(*getType)(
00232             const CMPIBroker * mb,
00233             const void *object,
00234             CMPIStatus * rc);
00235 
00245 #ifdef CMPI_VER_85
00246         CMPIString *(*getMessage)(
00247             const CMPIBroker * mb,
00248             const char *msgId,
00249             const char *defMsg,
00250             CMPIStatus * rc,
00251             CMPICount count, ...);
00252 #endif // CMPI_VER_85
00253 
00266 #ifdef CMPI_VER_100
00267         CMPIStatus (*logMessage)(
00268             const CMPIBroker *,
00269             CMPISeverity severity,
00270             const char *id,
00271             const char *text,
00272             const CMPIString * string);
00273 
00287         CMPIStatus (*trace)(
00288             const CMPIBroker *,
00289             CMPILevel level,
00290             const char *component,
00291             const char *text,
00292             const CMPIString * string);
00293 #else // pre-1.0 versions supported getKeyList()
00294         CMPIArray *(*getKeyList)(
00295             CMPIBroker *mb,
00296             CMPIContext *ctx,
00297             CMPIObjectPath *op,
00298             CMPIStatus *rc);
00299 #endif /* CMPI_VER_100 */
00300 
00301 #ifdef CMPI_VER_200
00302 
00313         CMPIError* (*newCMPIError)(
00314             const CMPIBroker*,
00315             const char*,
00316             const char*,
00317             const char*,
00318             const CMPIErrorSeverity,
00319             const CMPIErrorProbableCause,
00320             const CMPIrc,
00321             CMPIStatus *rc);
00322 
00331         CMPIStatus (*openMessageFile)(
00332             const CMPIBroker* mb,
00333             const char *msgFile,
00334             CMPIMsgFileHandle* msgFileHandle);
00335 
00342         CMPIStatus (*closeMessageFile)(
00343             const CMPIBroker* mb,
00344             const CMPIMsgFileHandle msgFileHandle);
00345 
00356         CMPIString* (*getMessage2)(
00357             const CMPIBroker* mb,
00358             const char *msgId,
00359             const CMPIMsgFileHandle msgFileHandle,
00360             const char *defMsg,
00361             CMPIStatus* rc,
00362             CMPICount count,...);
00363 
00364 #endif /* CMPI_VER_200 */
00365 
00366     };
00367 
00368 
00369 
00370     //---------------------------------------------------
00371     //--
00372     //   _CMPIBrokerFT Function Table
00373     //--
00374     //---------------------------------------------------
00375 
00376 
00382     struct _CMPIBrokerFT
00383     {
00384 
00389         unsigned int brokerCapabilities;
00393         unsigned int brokerVersion;
00397         const char *brokerName;
00398 
00408         CMPIContext *(*prepareAttachThread)(
00409             const CMPIBroker * mb,
00410             const CMPIContext * ctx);
00411 
00419         CMPIStatus (*attachThread)(
00420             const CMPIBroker *,
00421             const CMPIContext *);
00422 
00431         CMPIStatus (*detachThread)(
00432             const CMPIBroker * mb,
00433             const CMPIContext * ctx);
00434 
00435         // class 0 services
00436 
00446         CMPIStatus (*deliverIndication)(
00447             const CMPIBroker * mb,
00448             const CMPIContext * ctx,
00449             const char *ns,
00450             const CMPIInstance * ind);
00451 
00452         // class 1 services.
00453 
00463         CMPIEnumeration *(*enumerateInstanceNames)(
00464             const CMPIBroker * mb,
00465             const CMPIContext * ctx,
00466             const CMPIObjectPath * op,
00467             CMPIStatus * rc);
00468 
00482         CMPIInstance *(*getInstance)(
00483             const CMPIBroker * mb,
00484             const CMPIContext * ctx,
00485             const CMPIObjectPath * op,
00486             const char **properties,
00487             CMPIStatus * rc);
00488 
00489         // class 2 services.
00490 
00501         CMPIObjectPath *(*createInstance)(
00502             const CMPIBroker * mb,
00503             const CMPIContext * ctx,
00504             const CMPIObjectPath * op,
00505             const CMPIInstance * inst,
00506             CMPIStatus * rc);
00507 
00518         CMPIStatus (*modifyInstance)(
00519             const CMPIBroker * mb,
00520             const CMPIContext * ctx,
00521             const CMPIObjectPath * op,
00522             const CMPIInstance * inst,
00523             const char **properties);
00524 
00533         CMPIStatus (*deleteInstance)(
00534             const CMPIBroker * mb,
00535             const CMPIContext * ctx,
00536             const CMPIObjectPath * op);
00537 
00549         CMPIEnumeration *(*execQuery)(
00550             const CMPIBroker * mb,
00551             const CMPIContext * ctx,
00552             const CMPIObjectPath * op,
00553             const char *query,
00554             const char *lang,
00555             CMPIStatus * rc);
00556 
00570         CMPIEnumeration *(*enumerateInstances)(
00571             const CMPIBroker * mb,
00572             const CMPIContext * ctx,
00573             const CMPIObjectPath * op,
00574             const char **properties,
00575             CMPIStatus * rc);
00576 
00613         CMPIEnumeration *(*associators)(
00614             const CMPIBroker * mb,
00615             const CMPIContext * ctx,
00616             const CMPIObjectPath * op,
00617             const char *assocClass,
00618             const char *resultClass,
00619             const char *role,
00620             const char *resultRole,
00621             const char **properties,
00622             CMPIStatus * rc);
00623 
00656         CMPIEnumeration *(*associatorNames)(
00657             const CMPIBroker * mb,
00658             const CMPIContext * ctx,
00659             const CMPIObjectPath * op,
00660             const char *assocClass,
00661             const char *resultClass,
00662             const char *role,
00663             const char *resultRole,
00664             CMPIStatus * rc);
00665 
00689         CMPIEnumeration *(*references)(
00690             const CMPIBroker * mb,
00691             const CMPIContext * ctx,
00692             const CMPIObjectPath * op,
00693             const char *resultClass,
00694             const char *role,
00695             const char **properties,
00696             CMPIStatus * rc);
00697 
00718         CMPIEnumeration *(*referenceNames)(
00719             const CMPIBroker * mb,
00720             const CMPIContext * ctx,
00721             const CMPIObjectPath * op,
00722             const char *resultClass,
00723             const char *role,
00724             CMPIStatus * rc);
00725 
00739         CMPIData (*invokeMethod)(
00740             const CMPIBroker * mb,
00741             const CMPIContext * ctx,
00742             const CMPIObjectPath * op,
00743             const char *method,
00744             const CMPIArgs * in,
00745             CMPIArgs * out,
00746             CMPIStatus * rc);
00747 
00760         CMPIStatus (*setProperty)(
00761             const CMPIBroker * mb,
00762             const CMPIContext * ctx,
00763             const CMPIObjectPath * op,
00764             const char *name,
00765             const CMPIValue * value,
00766             CMPIType type);
00767 
00779         CMPIData (*getProperty)(
00780             const CMPIBroker * mb,
00781             const CMPIContext * ctx,
00782             const CMPIObjectPath * op,
00783             const char *name,
00784             CMPIStatus * rc);
00785     };
00786 
00787 
00788     //---------------------------------------------------
00789     //--
00790     //   _CMPIBrokerExtFT Function Table
00791     //--
00792     //---------------------------------------------------
00793 
00794 #ifdef CMPI_VER_90
00795 
00796     struct timespec;
00797 
00804     struct _CMPIBrokerExtFT
00805     {
00809         int ftVersion;
00820         char *(*resolveFileName) (const char *filename);
00821 
00822 
00831         CMPI_THREAD_TYPE (*newThread)(
00832             CMPI_THREAD_RETURN (CMPI_THREAD_CDECL * start) (void *),
00833             void *parm,
00834             int detached);
00835 
00844         int (*joinThread)(
00845             CMPI_THREAD_TYPE thread,
00846             CMPI_THREAD_RETURN * retval);
00847 
00855         int (*exitThread) (CMPI_THREAD_RETURN return_code);
00856 
00863         int (*cancelThread) (CMPI_THREAD_TYPE thread);
00864 
00872         int (*threadSleep) (CMPIUint32 msec);
00873 
00882         int (*threadOnce) (int *once, void (*init) (void));
00883 
00892         int (*createThreadKey)(
00893             CMPI_THREAD_KEY_TYPE * key,
00894             void (*cleanup) (void *));
00895 
00901         int (*destroyThreadKey) (CMPI_THREAD_KEY_TYPE key);
00902 
00908         void *(*getThreadSpecific) (CMPI_THREAD_KEY_TYPE key);
00909 
00916         int (*setThreadSpecific) (CMPI_THREAD_KEY_TYPE key, void *value);
00917 
00918 
00925         CMPI_MUTEX_TYPE (*newMutex) (int opt);
00926 
00931         void (*destroyMutex) (CMPI_MUTEX_TYPE mutex);
00932 
00938         void (*lockMutex) (CMPI_MUTEX_TYPE mutex);
00939 
00944         void (*unlockMutex) (CMPI_MUTEX_TYPE mutex);
00945 
00952         CMPI_COND_TYPE (*newCondition) (int opt);
00953 
00958         void (*destroyCondition) (CMPI_COND_TYPE cond);
00959 
00969         int (*condWait) (CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex);
00970 
00984         int (*timedCondWait)(
00985             CMPI_COND_TYPE cond,
00986             CMPI_MUTEX_TYPE mutex,
00987             struct timespec * wait);
00988 
00995         int (*signalCondition) (CMPI_COND_TYPE cond);
00996     };
00997 
00998 #endif /* CMPI_VER_90 */
00999 
01000 #ifdef CMPI_VER_200
01001     //---------------------------------------------------
01002     //--
01003     //   _CMPIBroker Memory Function Table
01004     //--
01005     //---------------------------------------------------
01006 
01014     struct _CMPIBrokerMemFT
01015     {
01016 
01020         int ftVersion;
01021 
01031         CMPIGcStat *(*mark) (const CMPIBroker * mb, CMPIStatus * rc);
01032 
01040         CMPIStatus (*release)(
01041             const CMPIBroker * mb,
01042             const CMPIGcStat * gc);
01043 
01051         void *(*cmpiMalloc) (const CMPIBroker * mb, size_t size);
01052 
01062         void *(*cmpiCalloc) (const CMPIBroker * mb, size_t, size_t);
01063 
01077         void *(*cmpiRealloc) (const CMPIBroker * mb, void *, size_t);
01078 
01079 
01088         char *(*cmpiStrDup) (const CMPIBroker * mb, const char *);
01089 
01098         void (*cmpiFree) (const CMPIBroker * mb, void *);
01099 
01109         void (*freeInstance) (const CMPIBroker * mb, CMPIInstance * inst);
01110 
01120         void (*freeObjectPath)(
01121             const CMPIBroker * mb,
01122             CMPIObjectPath * obj);
01123 
01133         void (*freeArgs)(
01134             const CMPIBroker * mb,
01135             CMPIArgs * args);
01136 
01146         void (*freeString)(
01147             const CMPIBroker * mb,
01148             CMPIString * str);
01149 
01159         void (*freeArray)(
01160             const CMPIBroker * mb,
01161             CMPIArray * array);
01162 
01172         void (*freeDateTime)(
01173             const CMPIBroker * mb,
01174             CMPIDateTime * date);
01175 
01185         void (*freeSelectExp)(
01186             const CMPIBroker * mb,
01187             CMPISelectExp * se);
01188     };
01189 
01190 #endif /* CMPI_VER_200 */
01191 
01192     //---------------------------------------------------
01193     //--
01194     //   _CMPIBroker Encapsulated object
01195     //--
01196     //---------------------------------------------------
01197 
01198 
01202     struct _CMPIBroker
01203     {
01204 
01208         void *hdl;
01209 
01213         CMPIBrokerFT *bft;
01214 
01218         CMPIBrokerEncFT *eft;
01219 
01223 #ifdef CMPI_VER_90
01224         CMPIBrokerExtFT *xft;
01225 #endif
01226 
01227 #ifdef CMPI_VER_200
01228 
01231         CMPIBrokerMemFT *mft;
01232 #endif
01233 
01234     };
01235 
01236 
01237     //---------------------------------------------------
01238     //--
01239     //   _CMPIContext Function Table
01240     //--
01241     //---------------------------------------------------
01242 
01243 
01248     struct _CMPIContextFT
01249     {
01250 
01254         int ftVersion;
01255 
01262         CMPIStatus (*release) (CMPIContext * ctx);
01263 
01270         CMPIContext *(*clone) (const CMPIContext * ctx, CMPIStatus * rc);
01271 
01272 
01280         CMPIData (*getEntry)(
01281             const CMPIContext * ctx,
01282             const char *name,
01283             CMPIStatus * rc);
01284 
01294         CMPIData (*getEntryAt)(
01295             const CMPIContext * ctx,
01296             CMPICount index,
01297             CMPIString ** name,
01298             CMPIStatus * rc);
01299 
01305         CMPICount (*getEntryCount)(
01306             const CMPIContext * ctx,
01307             CMPIStatus * rc);
01308 
01317         CMPIStatus (*addEntry)(
01318             const CMPIContext * ctx,
01319             const char *name,
01320             const CMPIValue * value,
01321             const CMPIType type);
01322     };
01323 
01324 
01325     //---------------------------------------------------
01326     //--
01327     //   _CMPIContext Encapsulated object
01328     //--
01329     //---------------------------------------------------
01330 
01334     struct _CMPIContext
01335     {
01336 
01340         void *hdl;
01341 
01345         CMPIContextFT *ft;
01346     };
01347 
01348     //---------------------------------------------------
01349     //--
01350     //   _CMPIResult Encapsulated object
01351     //--
01352     //---------------------------------------------------
01353 
01357     struct _CMPIResult
01358     {
01359 
01363         void *hdl;
01364 
01368         CMPIResultFT *ft;
01369     };
01370 
01371     //---------------------------------------------------
01372     //--
01373     //   _CMPIResult Function Table
01374     //--
01375     //---------------------------------------------------
01376 
01382     struct _CMPIResultFT
01383     {
01384 
01388         int ftVersion;
01389 
01396         CMPIStatus (*release) (CMPIResult * rslt);
01397 
01404         CMPIResult *(*clone) (const CMPIResult * rslt, CMPIStatus * rc);
01405 
01413         CMPIStatus (*returnData)(
01414             const CMPIResult * rslt,
01415             const CMPIValue * value,
01416             const CMPIType type);
01417 
01424         CMPIStatus (*returnInstance)(
01425             const CMPIResult * rslt,
01426             const CMPIInstance * inst);
01427 
01434         CMPIStatus (*returnObjectPath)(
01435             const CMPIResult * rslt,
01436             const CMPIObjectPath * ref);
01437 
01443         CMPIStatus (*returnDone)(const CMPIResult * rslt);
01444 
01445 #ifdef CMPI_VER_200
01446 
01452         CMPIStatus (*returnError)(
01453             const CMPIResult* rslt,
01454             const CMPIError* er);
01455 #endif
01456     };
01457 
01458 #ifdef CMPI_VER_200
01459 
01462     struct _CMPIError
01463     {
01467         void *hdl;
01468 
01472         CMPIErrorFT *ft;
01473     };
01474 
01475     //---------------------------------------------------
01476     //--
01477     //   _CMPIErrorFT Function Table
01478     //--
01479     //---------------------------------------------------
01480 
01481 
01486     struct _CMPIErrorFT
01487     {
01491         CMPISint32 ftVersion;
01492 
01499         CMPIStatus (*release)(CMPIError*);
01500 
01507         CMPIError* (*clone)(const CMPIError*, CMPIStatus*);
01508 
01515         CMPIErrorType (*getErrorType)(const CMPIError*, CMPIStatus*);
01516 
01523         CMPIString* (*getOtherErrorType)(const CMPIError*, CMPIStatus*);
01524 
01531         CMPIString* (*getOwningEntity)(const CMPIError*, CMPIStatus*);
01532 
01539         CMPIString* (*getMessageID)(const CMPIError*, CMPIStatus*);
01540 
01547         CMPIString* (*getMessage)(const CMPIError*, CMPIStatus*);
01548 
01555         CMPIErrorSeverity (*getPerceivedSeverity)(
01556             const CMPIError*,
01557             CMPIStatus*);
01558 
01565         CMPIErrorProbableCause (*getProbableCause)(
01566             const CMPIError*,
01567             CMPIStatus*);
01568 
01575         CMPIString* (*getProbableCauseDescription)(
01576             const CMPIError*,
01577             CMPIStatus*);
01578 
01585         CMPIArray* (*getRecommendedActions)(
01586             const CMPIError*,
01587             CMPIStatus*);
01588 
01595         CMPIString* (*getErrorSource)(const CMPIError*, CMPIStatus*);
01596 
01603         CMPIErrorSrcFormat (*getErrorSourceFormat)(
01604             const CMPIError*,
01605             CMPIStatus*);
01606 
01614         CMPIString* (*getOtherErrorSourceFormat)(
01615             const CMPIError*,
01616             CMPIStatus*);
01617 
01624         CMPIrc (*getCIMStatusCode)(const CMPIError*, CMPIStatus*);
01625 
01632         CMPIString* (*getCIMStatusCodeDescription)(
01633             const CMPIError*,
01634             CMPIStatus*);
01635 
01642         CMPIArray* (*getMessageArguments)(
01643             const CMPIError*,
01644             CMPIStatus*);
01645 
01652         CMPIStatus (*setErrorType)(CMPIError*, const CMPIErrorType);
01653 
01661         CMPIStatus (*setOtherErrorType)(CMPIError*, const char *);
01662 
01669         CMPIStatus (*setProbableCauseDescription)(
01670             CMPIError*,
01671             const char *);
01672 
01680         CMPIStatus (*setRecommendedActions)(CMPIError*, const CMPIArray*);
01681 
01689         CMPIStatus (*setErrorSource)(CMPIError*, const char*);
01690 
01697         CMPIStatus (*setErrorSourceFormat)(
01698             CMPIError*,
01699             const CMPIErrorSrcFormat );
01700 
01707         CMPIStatus (*setOtherErrorSourceFormat)(CMPIError*, const char*);
01708 
01715         CMPIStatus (*setCIMStatusCodeDescription)(
01716             CMPIError*,
01717             const char*);
01718 
01726         CMPIStatus (*setMessageArguments)(CMPIError*, CMPIArray*);
01727     };
01728 #endif /* CMPI_VER_200 */
01729 
01730 
01731     //---------------------------------------------------
01732     //--
01733     //   _CMPIInstance Encapsulated object
01734     //--
01735     //---------------------------------------------------
01736 
01737 
01741     struct _CMPIInstance
01742     {
01743 
01747         void *hdl;
01748 
01752         CMPIInstanceFT *ft;
01753     };
01754 
01755 
01756     //---------------------------------------------------
01757     //--
01758     //   _CMPIInstance Function Table
01759     //--
01760     //---------------------------------------------------
01761 
01766     struct _CMPIInstanceFT
01767     {
01768 
01772         int ftVersion;
01773 
01781         CMPIStatus (*release) (CMPIInstance * inst);
01782 
01790         CMPIInstance *(*clone)(const CMPIInstance * inst, CMPIStatus * rc);
01791 
01799         CMPIData (*getProperty)(
01800             const CMPIInstance * inst,
01801             const char *name,
01802             CMPIStatus * rc);
01803 
01812         CMPIData (*getPropertyAt)(
01813             const CMPIInstance * inst,
01814             CMPICount index,
01815             CMPIString ** name,
01816             CMPIStatus * rc);
01817 
01824         CMPICount (*getPropertyCount)(
01825             const CMPIInstance * inst,
01826             CMPIStatus * rc);
01827 
01836         CMPIStatus (*setProperty)(
01837             const CMPIInstance * inst,
01838             const char *name,
01839             const CMPIValue * value,
01840             CMPIType type);
01841 
01849         CMPIObjectPath *(*getObjectPath)(
01850             const CMPIInstance * inst,
01851             CMPIStatus * rc);
01852 
01863         CMPIStatus (*setPropertyFilter)(
01864             CMPIInstance * inst,
01865             const char **propertyList,
01866             const char **keys);
01867 
01868 #ifdef CMPI_VER_100
01869 
01879         CMPIStatus (*setObjectPath)(
01880             CMPIInstance * inst,
01881             const CMPIObjectPath * op);
01882 #endif /* CMPI_VER_100 */
01883 
01884 #ifdef CMPI_VER_200
01885 
01896         CMPIStatus (*setPropertyWithOrigin)(
01897             const CMPIInstance*,
01898             const char*,
01899             const CMPIValue*,
01900             const CMPIType,
01901             const char*);
01902 #endif /* CMPI_VER_200 */
01903 
01904     };
01905 
01906 
01907     //---------------------------------------------------
01908     //--
01909     //   _CMPIObjectPath Encapsulated object
01910     //--
01911     //---------------------------------------------------
01912 
01916     struct _CMPIObjectPath
01917     {
01918 
01922         void *hdl;
01923 
01927         CMPIObjectPathFT *ft;
01928     };
01929 
01930 
01931     //---------------------------------------------------
01932     //--
01933     //   _CMPIObjectPath Function Table
01934     //--
01935     //---------------------------------------------------
01936 
01941     struct _CMPIObjectPathFT
01942     {
01943 
01947         int ftVersion;
01948 
01955         CMPIStatus (*release) (CMPIObjectPath * op);
01956 
01964         CMPIObjectPath *(*clone)(
01965             const CMPIObjectPath * op,
01966             CMPIStatus * rc);
01967 
01974         CMPIStatus (*setNameSpace)(
01975             CMPIObjectPath * op,
01976             const char *ns);
01977 
01984         CMPIString *(*getNameSpace)(
01985             const CMPIObjectPath * op,
01986             CMPIStatus * rc);
01987 
01994         CMPIStatus (*setHostname) (CMPIObjectPath * op, const char *hn);
01995 
02002         CMPIString *(*getHostname)(
02003             const CMPIObjectPath * op,
02004             CMPIStatus * rc);
02005 
02012         CMPIStatus (*setClassName)(
02013             CMPIObjectPath * op,
02014             const char *cn);
02015 
02022         CMPIString *(*getClassName)(
02023             const CMPIObjectPath * op,
02024             CMPIStatus * rc);
02025 
02034         CMPIStatus (*addKey)(
02035             CMPIObjectPath * op,
02036             const char *name,
02037             const CMPIValue * value,
02038             const CMPIType type);
02039 
02047         CMPIData (*getKey)(
02048             const CMPIObjectPath * op,
02049             const char *name,
02050             CMPIStatus * rc);
02051 
02060         CMPIData (*getKeyAt)(
02061             const CMPIObjectPath * op,
02062             CMPICount index,
02063             CMPIString ** name,
02064             CMPIStatus * rc);
02065 
02072         CMPICount (*getKeyCount)(const CMPIObjectPath * op, CMPIStatus * rc);
02073 
02080         CMPIStatus (*setNameSpaceFromObjectPath)(
02081             CMPIObjectPath * op,
02082             const CMPIObjectPath * src);
02083 
02091         CMPIStatus (*setHostAndNameSpaceFromObjectPath)(
02092             CMPIObjectPath * op,
02093             const CMPIObjectPath * src);
02094 
02095         // optional qualifier support
02096 
02104         CMPIData (*getClassQualifier)(
02105             const CMPIObjectPath * op,
02106             const char *qName,
02107             CMPIStatus * rc);
02108 
02117         CMPIData (*getPropertyQualifier)(
02118             const CMPIObjectPath * op,
02119             const char *pName,
02120             const char *qName,
02121             CMPIStatus * rc);
02122 
02131         CMPIData (*getMethodQualifier)(
02132             const CMPIObjectPath * op,
02133             const char *methodName,
02134             const char *qName,
02135             CMPIStatus * rc);
02136 
02146         CMPIData (*getParameterQualifier)(
02147             const CMPIObjectPath * op,
02148             const char *mName,
02149             const char *pName,
02150             const char *qName,
02151             CMPIStatus * rc);
02152 
02153 #ifdef CMPI_VER_86
02154 
02160         CMPIString *(*toString)(const CMPIObjectPath * op, CMPIStatus * rc);
02161 #   endif /* CMPI_VER_86 */
02162 
02163     };
02164 
02165 
02166     //---------------------------------------------------
02167     //--
02168     //   _CMPISelectExp Encapsulated object
02169     //--
02170     //---------------------------------------------------
02171 
02175     struct _CMPISelectExp
02176     {
02177 
02181         void *hdl;
02182 
02186         CMPISelectExpFT *ft;
02187     };
02188 
02189 
02190     //---------------------------------------------------
02191     //--
02192     //   _CMPISelectExpFT Function Table
02193     //--
02194     //---------------------------------------------------
02195 
02200     struct _CMPISelectExpFT
02201     {
02202 
02206         int ftVersion;
02207 
02214         CMPIStatus (*release) (CMPISelectExp * se);
02215 
02223         CMPISelectExp *(*clone)(const CMPISelectExp * se, CMPIStatus * rc);
02224 
02232         CMPIBoolean (*evaluate)(
02233             const CMPISelectExp * se,
02234             const CMPIInstance * inst,
02235             CMPIStatus * rc);
02236 
02243         CMPIString *(*getString)(const CMPISelectExp * se, CMPIStatus * rc);
02244 
02251         CMPISelectCond *(*getDOC)(const CMPISelectExp * se, CMPIStatus * rc);
02252 
02259         CMPISelectCond *(*getCOD)(const CMPISelectExp * se, CMPIStatus * rc);
02260 
02270 #ifdef CMPI_VER_87
02271         CMPIBoolean (*evaluateUsingAccessor)(
02272             const CMPISelectExp * se,
02273             CMPIAccessor * accessor,
02274             void *parm,
02275             CMPIStatus * rc);
02276 #endif /* CMPI_VER_87 */
02277     };
02278 
02279     //---------------------------------------------------
02280     //--
02281     //   _CMPISelectCond Encapsulated object
02282     //--
02283     //---------------------------------------------------
02284 
02288     struct _CMPISelectCond
02289     {
02290 
02294         void *hdl;
02295 
02299         CMPISelectCondFT *ft;
02300     };
02301 
02302 
02303     //---------------------------------------------------
02304     //--
02305     //   _CMPISelectCondFT Function Table
02306     //--
02307     //---------------------------------------------------
02308 
02309 
02314     struct _CMPISelectCondFT
02315     {
02316 
02320         int ftVersion;
02321 
02328         CMPIStatus (*release) (CMPISelectCond * sc);
02329 
02337         CMPISelectCond *(*clone)(const CMPISelectCond * sc, CMPIStatus * rc);
02338 
02348         CMPICount (*getCountAndType)(
02349             const CMPISelectCond * sc,
02350             int* type,
02351             CMPIStatus * rc);
02352 
02360         CMPISubCond *(*getSubCondAt)(
02361             const CMPISelectCond * sc,
02362             CMPICount index,
02363             CMPIStatus * rc);
02364     };
02365 
02366 
02367     //---------------------------------------------------
02368     //--
02369     //   _CMPISubCond Encapsulated object
02370     //--
02371     //---------------------------------------------------
02372 
02376     struct _CMPISubCond
02377     {
02378 
02382         void *hdl;
02383 
02387         CMPISubCondFT *ft;
02388     };
02389 
02390     //---------------------------------------------------
02391     //--
02392     //   _CMPISubCondFT Function Table
02393     //--
02394     //---------------------------------------------------
02395 
02400     struct _CMPISubCondFT
02401     {
02402 
02406         int ftVersion;
02407 
02414         CMPIStatus (*release) (CMPISubCond * sc);
02415 
02423         CMPISubCond *(*clone) (const CMPISubCond * sc, CMPIStatus * rc);
02424 
02431         CMPICount (*getCount) (const CMPISubCond * sc, CMPIStatus * rc);
02432 
02440         CMPIPredicate *(*getPredicateAt)(
02441             const CMPISubCond * sc,
02442             CMPICount index,
02443             CMPIStatus * rc);
02444 
02452         CMPIPredicate *(*getPredicate)(
02453             const CMPISubCond * sc,
02454             const char *name,
02455             CMPIStatus * rc);
02456     };
02457 
02458 
02459     //---------------------------------------------------
02460     //--
02461     //   _CMPIPredicate Encapsulated object
02462     //--
02463     //---------------------------------------------------
02464 
02465 
02469     struct _CMPIPredicate
02470     {
02471 
02475         void *hdl;
02476 
02480         CMPIPredicateFT *ft;
02481     };
02482 
02483 
02484     //---------------------------------------------------
02485     //--
02486     //   _CMPIPredicateFT Function Table
02487     //--
02488     //---------------------------------------------------
02489 
02494     struct _CMPIPredicateFT
02495     {
02496 
02500         int ftVersion;
02501 
02508         CMPIStatus (*release) (CMPIPredicate * pr);
02509 
02517         CMPIPredicate *(*clone)(const CMPIPredicate * pr, CMPIStatus * rc);
02518 
02528         CMPIStatus (*getData)(
02529             const CMPIPredicate * pr,
02530             CMPIType * type,
02531             CMPIPredOp * op,
02532             CMPIString ** lhs,
02533             CMPIString ** rhs);
02534 
02535 #if defined(CMPI_VER_87) && !defined(CMPI_VER_100)
02536 //   Deprecated in the CMPI spec.
02537         int (*evaluate)
02538         (CMPIPredicate* pr, CMPIValue* value,
02539             CMPIType type, CMPIStatus* rc);
02540 #endif
02541 
02557 #ifdef CMPI_VER_100
02558         CMPIBoolean (*evaluateUsingAccessor)
02559         (const CMPIPredicate * pr, CMPIAccessor * accessorFnc, void *parm,
02560             CMPIStatus * rc);
02561 #endif /* CMPI_VER_100 */
02562 
02563     };
02564 
02565 
02566     //---------------------------------------------------
02567     //--
02568     //   _CMPIArgs Encapsulated object
02569     //--
02570     //---------------------------------------------------
02571 
02575     struct _CMPIArgs
02576     {
02577 
02581         void *hdl;
02582 
02586         CMPIArgsFT *ft;
02587     };
02588 
02589 
02590     //---------------------------------------------------
02591     //--
02592     //   _CMPIArgsFT Function Table
02593     //--
02594     //---------------------------------------------------
02595 
02596 
02601     struct _CMPIArgsFT
02602     {
02603 
02607         int ftVersion;
02608 
02615         CMPIStatus (*release) (CMPIArgs * as);
02616 
02624         CMPIArgs *(*clone) (const CMPIArgs * as, CMPIStatus * rc);
02625 
02634         CMPIStatus (*addArg)(
02635             const CMPIArgs * as,
02636             const char *name,
02637             const CMPIValue * value,
02638             const CMPIType type);
02639 
02647         CMPIData (*getArg)(
02648             const CMPIArgs * as,
02649             const char *name,
02650             CMPIStatus * rc);
02651 
02660         CMPIData (*getArgAt)(
02661             const CMPIArgs * as,
02662             CMPICount index,
02663             CMPIString ** name,
02664             CMPIStatus * rc);
02665 
02672         CMPICount (*getArgCount) (const CMPIArgs * as, CMPIStatus * rc);
02673     };
02674 
02675 
02676     //---------------------------------------------------
02677     //--
02678     //   _CMPIString Encapsulated object
02679     //--
02680     //---------------------------------------------------
02681 
02682 
02686     struct _CMPIString
02687     {
02688 
02692         void *hdl;
02693 
02697         CMPIStringFT *ft;
02698     };
02699 
02700 
02701     //---------------------------------------------------
02702     //--
02703     //   _CMPIStringFT Function Table
02704     //--
02705     //---------------------------------------------------
02706 
02707 
02712     struct _CMPIStringFT
02713     {
02714 
02718         int ftVersion;
02719 
02726         CMPIStatus (*release)(CMPIString * st);
02727 
02735         CMPIString *(*clone)(const CMPIString * st, CMPIStatus * rc);
02736 
02743         const char *(*getCharPtr)(const CMPIString * st, CMPIStatus * rc);
02744     };
02745 
02746 
02747     //---------------------------------------------------
02748     //--
02749     //   _CMPIArray Encapsulated object
02750     //--
02751     //---------------------------------------------------
02752 
02753 
02757     struct _CMPIArray
02758     {
02759 
02763         void *hdl;
02764 
02768         CMPIArrayFT *ft;
02769     };
02770 
02771 
02772     //---------------------------------------------------
02773     //--
02774     //   _CMPIArrayFT Function Table
02775     //--
02776     //---------------------------------------------------
02777 
02778 
02783     struct _CMPIArrayFT
02784     {
02785 
02789         int ftVersion;
02790 
02797         CMPIStatus (*release) (CMPIArray * ar);
02798 
02806         CMPIArray *(*clone)(const CMPIArray * ar, CMPIStatus * rc);
02807 
02814         CMPICount (*getSize)(const CMPIArray * ar, CMPIStatus * rc);
02815 
02822         CMPIType (*getSimpleType)(const CMPIArray * ar, CMPIStatus * rc);
02823 
02831         CMPIData (*getElementAt)(
02832             const CMPIArray * ar,
02833             CMPICount index,
02834             CMPIStatus * rc);
02835 
02844         CMPIStatus (*setElementAt)(
02845             CMPIArray * ar,
02846             CMPICount index,
02847             const CMPIValue * value,
02848             CMPIType type);
02849     };
02850 
02851 
02852     //---------------------------------------------------
02853     //--
02854     //   _CMPIEnumeration Encapsulated object
02855     //--
02856     //---------------------------------------------------
02857 
02858 
02862     struct _CMPIEnumeration
02863     {
02864 
02868         void *hdl;
02869 
02873         CMPIEnumerationFT *ft;
02874     };
02875 
02876 
02877     //---------------------------------------------------
02878     //--
02879     //   _CMPIEnumerationFT Function Table
02880     //--
02881     //---------------------------------------------------
02882 
02883 
02888     struct _CMPIEnumerationFT
02889     {
02890 
02894         int ftVersion;
02895 
02902         CMPIStatus (*release) (CMPIEnumeration * en);
02903 
02911         CMPIEnumeration *(*clone)(
02912             const CMPIEnumeration * en,
02913             CMPIStatus * rc);
02914 
02921         CMPIData (*getNext)(const CMPIEnumeration * en, CMPIStatus * rc);
02922 
02929         CMPIBoolean (*hasNext)(const CMPIEnumeration * en, CMPIStatus * rc);
02930 
02937         CMPIArray *(*toArray)(const CMPIEnumeration * en, CMPIStatus * rc);
02938     };
02939 
02940 
02941     //---------------------------------------------------
02942     //--
02943     //   _CMPIDateTime Encapsulated object
02944     //--
02945     //---------------------------------------------------
02946 
02947 
02951     struct _CMPIDateTime
02952     {
02953 
02957         void *hdl;
02958 
02962         CMPIDateTimeFT *ft;
02963     };
02964 
02965 
02966     //---------------------------------------------------
02967     //--
02968     //   _CMPIDateTimeFT Function Table
02969     //--
02970     //---------------------------------------------------
02971 
02972 
02977     struct _CMPIDateTimeFT
02978     {
02979 
02983         int ftVersion;
02984 
02991         CMPIStatus (*release) (CMPIDateTime * dt);
02992 
03000         CMPIDateTime *(*clone) (const CMPIDateTime * dt, CMPIStatus * rc);
03001 
03009         CMPIUint64 (*getBinaryFormat)(
03010             const CMPIDateTime * dt,
03011             CMPIStatus * rc);
03012 
03019         CMPIString *(*getStringFormat)(
03020             const CMPIDateTime * dt,
03021             CMPIStatus * rc);
03022 
03029         CMPIBoolean (*isInterval)(
03030             const CMPIDateTime * dt,
03031             CMPIStatus * rc);
03032     };
03033 
03034 
03035     //---------------------------------------------------
03036     //--
03037     //   _CMPIInstanceMI Instance Provider object
03038     //--
03039     //---------------------------------------------------
03040 
03041 
03042     typedef struct _CMPIInstanceMIFT CMPIInstanceMIFT;
03046     typedef struct _CMPIInstanceMI
03047     {
03048 
03052         void *hdl;
03053 
03057         CMPIInstanceMIFT *ft;
03058     } CMPIInstanceMI;
03059 
03060 
03061     //---------------------------------------------------
03062     //--
03063     //   _CMPIInstanceMIFT Function Table
03064     //--
03065     //---------------------------------------------------
03066 
03067 
03073     struct _CMPIInstanceMIFT
03074     {
03075 
03079         int ftVersion;
03080 
03084         int miVersion;
03085 
03089         const char *miName;
03090 
03112         CMPIStatus (*cleanup)(
03113             CMPIInstanceMI * mi,
03114             const CMPIContext * ctx,
03115             CMPIBoolean terminating);
03116 
03131         CMPIStatus (*enumerateInstanceNames)(
03132             CMPIInstanceMI * mi,
03133             const CMPIContext * ctx,
03134             const CMPIResult * rslt,
03135             const CMPIObjectPath * op);
03136 
03154         CMPIStatus (*enumerateInstances)(
03155             CMPIInstanceMI * mi,
03156             const CMPIContext * ctx,
03157             const CMPIResult * rslt,
03158             const CMPIObjectPath * op,
03159             const char **properties);
03160 
03179         CMPIStatus (*getInstance)(
03180             CMPIInstanceMI * mi,
03181             const CMPIContext * ctx,
03182             const CMPIResult * rslt,
03183             const CMPIObjectPath * op,
03184             const char **properties);
03185 
03201         CMPIStatus (*createInstance)(
03202             CMPIInstanceMI * mi,
03203             const CMPIContext * ctx,
03204             const CMPIResult * rslt,
03205             const CMPIObjectPath * op,
03206             const CMPIInstance * inst);
03207 
03223         CMPIStatus (*modifyInstance)(
03224             CMPIInstanceMI * mi,
03225             const CMPIContext * ctx,
03226             const CMPIResult * rslt,
03227             const CMPIObjectPath * op,
03228             const CMPIInstance * inst,
03229             const char **properties);
03230 
03246         CMPIStatus (*deleteInstance)(
03247             CMPIInstanceMI * mi,
03248             const CMPIContext * ctx,
03249             const CMPIResult * rslt,
03250             const CMPIObjectPath * op);
03251 
03271         CMPIStatus (*execQuery)(
03272             CMPIInstanceMI * mi,
03273             const CMPIContext * ctx,
03274             const CMPIResult * rslt,
03275             const CMPIObjectPath * op,
03276             const char *query,
03277             const char *lang);
03278     };
03279 
03280 
03281     //---------------------------------------------------
03282     //--
03283     //   _CMPIAssociationMI Association Provider object
03284     //--
03285     //---------------------------------------------------
03286 
03287 
03288     typedef struct _CMPIAssociationMIFT CMPIAssociationMIFT;
03292     typedef struct _CMPIAssociationMI
03293     {
03294 
03298         void *hdl;
03299 
03303         CMPIAssociationMIFT *ft;
03304     } CMPIAssociationMI;
03305 
03306 
03307     //---------------------------------------------------
03308     //--
03309     //   _CMPIAssociationMIFT Function Table
03310     //--
03311     //---------------------------------------------------
03312 
03313 
03319     struct _CMPIAssociationMIFT
03320     {
03321 
03325         int ftVersion;
03326 
03330         int miVersion;
03331 
03335         const char *miName;
03336 
03357         CMPIStatus (*cleanup)(
03358             CMPIAssociationMI * mi,
03359             const CMPIContext * ctx,
03360             CMPIBoolean terminating);
03361 
03405         CMPIStatus (*associators)(
03406             CMPIAssociationMI * mi,
03407             const CMPIContext * ctx,
03408             const CMPIResult * rslt,
03409             const CMPIObjectPath * op,
03410             const char *asscClass,
03411             const char *resultClass,
03412             const char *role,
03413             const char *resultRole,
03414             const char **properties);
03415 
03455         CMPIStatus (*associatorNames)(
03456             CMPIAssociationMI * mi,
03457             const CMPIContext * ctx,
03458             const CMPIResult * rslt,
03459             const CMPIObjectPath * op,
03460             const char *assocClass,
03461             const char *resultClass,
03462             const char *role,
03463             const char *resultRole);
03464 
03495         CMPIStatus (*references)(
03496             CMPIAssociationMI * mi,
03497             const CMPIContext * ctx,
03498             const CMPIResult * rslt,
03499             const CMPIObjectPath * op,
03500             const char *resultClass,
03501             const char *role,
03502             const char **properties);
03503 
03531         CMPIStatus (*referenceNames)(
03532             CMPIAssociationMI * mi,
03533             const CMPIContext * ctx,
03534             const CMPIResult * rslt,
03535             const CMPIObjectPath * op,
03536             const char *resultClass,
03537             const char *role);
03538     };
03539 
03540 
03541     //---------------------------------------------------
03542     //--
03543     //   _CMPIMethodMI Method Provider object
03544     //--
03545     //---------------------------------------------------
03546 
03547     typedef struct _CMPIMethodMIFT CMPIMethodMIFT;
03551     typedef struct _CMPIMethodMI
03552     {
03553 
03557         void *hdl;
03558 
03562         CMPIMethodMIFT *ft;
03563     } CMPIMethodMI;
03564 
03565 
03566     //---------------------------------------------------
03567     //--
03568     //   _CMPIMethodMIFT Function Table
03569     //--
03570     //---------------------------------------------------
03571 
03572 
03578     struct _CMPIMethodMIFT
03579     {
03580 
03584         int ftVersion;
03585 
03589         int miVersion;
03590 
03594         const char *miName;
03595 
03616         CMPIStatus (*cleanup)(
03617             CMPIMethodMI * mi,
03618             const CMPIContext * ctx,
03619             CMPIBoolean terminating);
03620 
03642         CMPIStatus (*invokeMethod)(
03643             CMPIMethodMI * mi,
03644             const CMPIContext * ctx,
03645             const CMPIResult * rslt,
03646             const CMPIObjectPath * op,
03647             const char *method,
03648             const CMPIArgs * in,
03649             CMPIArgs * out);
03650     };
03651 
03652 
03653     //---------------------------------------------------
03654     //--
03655     //   _CMPIPropertyMI Property Provider object
03656     //--
03657     //---------------------------------------------------
03658 
03659 
03660     typedef struct _CMPIPropertyMIFT CMPIPropertyMIFT;
03664     typedef struct _CMPIPropertyMI
03665     {
03666 
03670         void *hdl;
03671 
03675         CMPIPropertyMIFT *ft;
03676     } CMPIPropertyMI;
03677 
03678 
03679 
03680     //---------------------------------------------------
03681     //--
03682     //   _CMPIPropertyMIFT Function Table
03683     //--
03684     //---------------------------------------------------
03685 
03686 
03692     struct _CMPIPropertyMIFT
03693     {
03694 
03698         int ftVersion;
03699 
03703         int miVersion;
03704 
03708         const char *miName;
03709 
03726         CMPIStatus (*cleanup)(
03727             CMPIPropertyMI * mi,
03728             const CMPIContext * ctx,
03729             CMPIBoolean terminating);
03730 
03748         CMPIStatus (*setProperty)(
03749             CMPIPropertyMI * mi,
03750             const CMPIContext * ctx,
03751             const CMPIResult * rslt,
03752             const CMPIObjectPath * op,
03753             const char *name,
03754             const CMPIData data);
03755 
03777         CMPIStatus (*getProperty)(
03778             CMPIPropertyMI *,
03779             const CMPIContext *,
03780             const CMPIResult *,
03781             const CMPIObjectPath *,
03782             const char *name);
03783     };
03784 
03785 
03786     //---------------------------------------------------
03787     //--
03788     //   _CMPIIndicationMI Indication Provider object
03789     //--
03790     //---------------------------------------------------
03791 
03792 
03793     typedef struct _CMPIIndicationMIFT CMPIIndicationMIFT;
03797     typedef struct _CMPIIndicationMI
03798     {
03799 
03803         void *hdl;
03804 
03808         CMPIIndicationMIFT *ft;
03809     } CMPIIndicationMI;
03810 
03811 
03812     //---------------------------------------------------
03813     //--
03814     //   _CMPIIndicationMIFT Function Table
03815     //--
03816     //---------------------------------------------------
03817 
03818 
03824     struct _CMPIIndicationMIFT
03825     {
03826 
03830         int ftVersion;
03831 
03835         int miVersion;
03836 
03840         const char *miName;
03841 
03863         CMPIStatus (*cleanup)(
03864             CMPIIndicationMI * mi,
03865             const CMPIContext * ctx,
03866             CMPIBoolean terminating);
03867 
03890         CMPIStatus (*authorizeFilter)(
03891             CMPIIndicationMI * mi,
03892             const CMPIContext * ctx,
03893             const CMPISelectExp * filter,
03894             const char *className,
03895             const CMPIObjectPath * op,
03896             const char *owner);
03897 
03925         CMPIStatus (*mustPoll)(
03926             CMPIIndicationMI * mi,
03927             const CMPIContext * ctx,
03928             const CMPISelectExp * filter,
03929             const char *className,
03930             const CMPIObjectPath * classPath);
03931 
03959         CMPIStatus (*activateFilter)(
03960             CMPIIndicationMI * mi,
03961             const CMPIContext * ctx,
03962             const CMPISelectExp * filter,
03963             const char *className,
03964             const CMPIObjectPath * classPath,
03965             CMPIBoolean firstActivation);
03966 
03993         CMPIStatus (*deActivateFilter)(
03994             CMPIIndicationMI * mi,
03995             const CMPIContext * ctx,
03996             const CMPISelectExp * filter,
03997             const char *className,
03998             const CMPIObjectPath * classPath,
03999             CMPIBoolean lastActiviation);
04000 
04025         CMPIStatus (*enableIndications)(
04026             CMPIIndicationMI * mi,
04027             const CMPIContext *);
04028 
04053         CMPIStatus (*disableIndications)(
04054             CMPIIndicationMI * mi,
04055             const CMPIContext *);
04056 
04057     };
04058 
04059 #include "cmpimacs.h"
04060 
04061 
04062 #ifdef __cplusplus
04063 };
04064 #endif
04065 
04066 #endif // _CMPIFT_H_