cmpi

cmpi/cmpift.h

Go to the documentation of this file.
00001 /*
00002  *
00003  * $Id: cmpift.h,v 1.9 2009/02/28 03:18:20 tyreld Exp $
00004  *
00005  * (C) Copyright IBM Corp. 2003, 2005, 2006, 2008
00006  *
00007  * THIS FILE IS PROVIDED UNDER THE TERMS OF THE ECLIPSE PUBLIC LICENSE
00008  * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
00009  * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
00010  *
00011  * You can obtain a current copy of the Eclipse Public License from
00012  * http://www.opensource.org/licenses/eclipse-1.0.txt
00013  *
00014  * Author:        Adrian Schuur <schuur@de.ibm.com>
00015  * Contributors:  Konrad Rzeszutek <darnok@us.ibm.com>
00016  *
00017  * Description: CMPI Function Table Definions
00018  *
00019  */
00020 
00021 /* ------------------------------------------------------------------------- */
00022 /*                                                                           */
00023 /* Copyright (c) 2006 The Open Group                                         */
00024 /*                                                                           */
00025 /* Permission is hereby granted, free of charge, to any person obtaining a   */
00026 /* copy of this software (the "Software"), to deal in the Software without   */
00027 /* restriction, including without limitation the rights to use, copy,        */
00028 /* modify, merge, publish, distribute, sublicense, and/or sell copies of     */
00029 /* the Software, and to permit persons to whom the Software is furnished     */
00030 /* to do so, subject to the following conditions:                            */
00031 /*                                                                           */
00032 /* The above copyright notice and this permission notice shall be included   */
00033 /* in all copies or substantial portions of the Software.                    */
00034 /*                                                                           */
00035 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS   */
00036 /* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF                */
00037 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.    */
00038 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY      */
00039 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT */
00040 /* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR  */
00041 /* THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                */
00042 /*                                                                           */
00043 /* ------------------------------------------------------------------------- */
00044 
00045 #ifndef _CMPIFT_H_
00046 #   define _CMPIFT_H_
00047 
00048 #   include "cmpidt.h"
00049 #   include "cmpios.h"
00050 
00051 #   ifdef __cplusplus
00052 extern "C"
00053 {
00054 #   endif
00055 
00056 
00057   //---------------------------------------------------
00058   //--
00059   //   _CMPIBrokerEncFT Function Table
00060   //--
00061   //---------------------------------------------------
00062 
00063 
00069   struct _CMPIBrokerEncFT
00070   {
00071 
00074     int ftVersion;
00075 
00082     CMPIInstance *(*newInstance)
00083       (const CMPIBroker * mb, const CMPIObjectPath * op, CMPIStatus * rc);
00084 
00092     CMPIObjectPath *(*newObjectPath)
00093       (const CMPIBroker * mb, const char *ns, const char *cn,
00094        CMPIStatus * rc);
00095 
00101     CMPIArgs *(*newArgs) (const CMPIBroker * mb, CMPIStatus * rc);
00102 
00109     CMPIString *(*newString)
00110       (const CMPIBroker * mb, const char *data, CMPIStatus * rc);
00111 
00119     CMPIArray *(*newArray)
00120       (const CMPIBroker * mb, CMPICount max, CMPIType type, CMPIStatus * rc);
00121 
00127     CMPIDateTime *(*newDateTime) (const CMPIBroker * mb, CMPIStatus * rc);
00128 
00137     CMPIDateTime *(*newDateTimeFromBinary)
00138       (const CMPIBroker * mb, CMPIUint64 binTime, CMPIBoolean interval,
00139        CMPIStatus * rc);
00140 
00147     CMPIDateTime *(*newDateTimeFromChars)
00148       (const CMPIBroker * mb, const char *utcTime, CMPIStatus * rc);
00149 
00158     CMPISelectExp *(*newSelectExp)
00159       (const CMPIBroker * mb, const char *query, const char *lang,
00160        CMPIArray ** projection, CMPIStatus * st);
00161 
00170       CMPIBoolean (*classPathIsA)
00171       (const CMPIBroker * mb, const CMPIObjectPath * op, const char *type,
00172        CMPIStatus * rc);
00173 
00181     CMPIString *(*toString)
00182       (const CMPIBroker * mb, const void *object, CMPIStatus * rc);
00183 
00193       CMPIBoolean (*isOfType)
00194       (const CMPIBroker * mb, const void *object, const char *type,
00195        CMPIStatus * rc);
00196 
00204     CMPIString *(*getType)
00205       (const CMPIBroker * mb, const void *object, CMPIStatus * rc);
00206 
00215     CMPIString *(*getMessage)
00216       (const CMPIBroker * mb, const char *msgId, const char *defMsg,
00217        CMPIStatus * rc, CMPICount count, ...);
00218 
00229       CMPIStatus (*logMessage)
00230       (const CMPIBroker *, int severity, const char *id,
00231        const char *text, const CMPIString * string);
00232 
00242       CMPIStatus (*trace)
00243       (const CMPIBroker *, int level, const char *component,
00244        const char *text, const CMPIString * string);
00245 
00246 #       ifdef CMPI_VER_200
00247 
00256           CMPIError* (*newCMPIError)
00257           (const CMPIBroker*, const char*, const char*, const char*,
00258            const CMPIErrorSeverity, const CMPIErrorProbableCause,const CMPIrc,
00259            CMPIStatus *rc);
00266      CMPIStatus (*openMessageFile)
00267       (const CMPIBroker* mb, const char *msgFile,
00268        CMPIMsgFileHandle* msgFileHandle);
00269 
00275      CMPIStatus (*closeMessageFile)
00276       (const CMPIBroker* mb, const CMPIMsgFileHandle msgFileHandle);
00277 
00287      CMPIString* (*getMessage2)
00288       (const CMPIBroker* mb, const char *msgId,
00289        const CMPIMsgFileHandle msgFileHandle, const char *defMsg,
00290        CMPIStatus* rc, CMPICount count, ...);
00291 #       endif /* CMPI_VER_200 */
00292 
00293   };
00294 
00295 
00296 
00297   //---------------------------------------------------
00298   //--
00299   //   _CMPIBrokerFT Function Table
00300   //--
00301   //---------------------------------------------------
00302 
00303 
00308   struct _CMPIBrokerFT
00309   {
00310 
00314     unsigned int brokerCapabilities;
00317     unsigned int brokerVersion;
00320     const char *brokerName;
00321 
00330     CMPIContext *(*prepareAttachThread)
00331       (const CMPIBroker * mb, const CMPIContext * ctx);
00332 
00339       CMPIStatus (*attachThread) (const CMPIBroker *, const CMPIContext *);
00340 
00348       CMPIStatus (*detachThread)
00349       (const CMPIBroker * mb, const CMPIContext * ctx);
00350 
00351     // class 0 services
00352 
00361       CMPIStatus (*deliverIndication)
00362       (const CMPIBroker * mb, const CMPIContext * ctx,
00363        const char *ns, const CMPIInstance * ind);
00364     // class 1 services
00365 
00373     CMPIEnumeration *(*enumerateInstanceNames)
00374       (const CMPIBroker * mb, const CMPIContext * ctx,
00375        const CMPIObjectPath * op, CMPIStatus * rc);
00376 
00388     CMPIInstance *(*getInstance)
00389       (const CMPIBroker * mb, const CMPIContext * ctx,
00390        const CMPIObjectPath * op, const char **properties, CMPIStatus * rc);
00391 
00392     // class 2 services
00393 
00402     CMPIObjectPath *(*createInstance)
00403       (const CMPIBroker * mb, const CMPIContext * ctx,
00404        const CMPIObjectPath * op, const CMPIInstance * inst, CMPIStatus * rc);
00405 
00413       CMPIStatus (*modifyInstance)
00414       (const CMPIBroker * mb, const CMPIContext * ctx,
00415        const CMPIObjectPath * op, const CMPIInstance * inst,
00416        const char **properties);
00417 
00424       CMPIStatus (*deleteInstance)
00425       (const CMPIBroker * mb, const CMPIContext * ctx,
00426        const CMPIObjectPath * op);
00427 
00438     CMPIEnumeration *(*execQuery)
00439       (const CMPIBroker * mb, const CMPIContext * ctx,
00440        const CMPIObjectPath * op, const char *query, const char *lang,
00441        CMPIStatus * rc);
00442 
00455     CMPIEnumeration *(*enumerateInstances)
00456       (const CMPIBroker * mb, const CMPIContext * ctx,
00457        const CMPIObjectPath * op, const char **properties, CMPIStatus * rc);
00458 
00489     CMPIEnumeration *(*associators)
00490       (const CMPIBroker * mb, const CMPIContext * ctx,
00491        const CMPIObjectPath * op, const char *assocClass,
00492        const char *resultClass, const char *role, const char *resultRole,
00493        const char **properties, CMPIStatus * rc);
00494 
00522     CMPIEnumeration *(*associatorNames)
00523       (const CMPIBroker * mb, const CMPIContext * ctx,
00524        const CMPIObjectPath * op, const char *assocClass,
00525        const char *resultClass, const char *role, const char *resultRole,
00526        CMPIStatus * rc);
00527 
00549     CMPIEnumeration *(*references)
00550       (const CMPIBroker * mb, const CMPIContext * ctx,
00551        const CMPIObjectPath * op, const char *resultClass, const char *role,
00552        const char **properties, CMPIStatus * rc);
00553 
00572     CMPIEnumeration *(*referenceNames)
00573       (const CMPIBroker * mb, const CMPIContext * ctx,
00574        const CMPIObjectPath * op, const char *resultClass, const char *role,
00575        CMPIStatus * rc);
00576 
00588       CMPIData (*invokeMethod)
00589       (const CMPIBroker * mb, const CMPIContext * ctx,
00590        const CMPIObjectPath * op, const char *method,
00591        const CMPIArgs * in, CMPIArgs * out, CMPIStatus * rc);
00592 
00602       CMPIStatus (*setProperty)
00603       (const CMPIBroker * mb, const CMPIContext * ctx,
00604        const CMPIObjectPath * op, const char *name, const CMPIValue * value,
00605        CMPIType type);
00606 
00615       CMPIData (*getProperty)
00616       (const CMPIBroker * mb, const CMPIContext * ctx,
00617        const CMPIObjectPath * op, const char *name, CMPIStatus * rc);
00618   };
00619 
00620 
00621   //---------------------------------------------------
00622   //--
00623   //   _CMPIBrokerExtFT Function Table
00624   //--
00625   //---------------------------------------------------
00626 
00627 
00628   struct timespec;
00629 
00635   struct _CMPIBrokerExtFT
00636   {
00639     int ftVersion;
00648     char *(*resolveFileName) (const char *filename);
00649 
00650 
00657       CMPI_THREAD_TYPE (*newThread)
00658       (CMPI_THREAD_RETURN (CMPI_THREAD_CDECL * start) (void *), void *parm,
00659        int detached);
00660 
00666     int (*joinThread) (CMPI_THREAD_TYPE thread, CMPI_THREAD_RETURN * retval);
00667 
00672     int (*exitThread) (CMPI_THREAD_RETURN return_code);
00673 
00678     int (*cancelThread) (CMPI_THREAD_TYPE thread);
00679 
00684     int (*threadSleep) (CMPIUint32 msec);
00685 
00691     int (*threadOnce) (int *once, void (*init) (void));
00692 
00693     /* Create a POSIX threading conformant thread key. This key can be used as a key to access the thread local store.
00694        @param key The address for the key to be returned.
00695        @param cleanup Function to be invoked during thread local store cleanup.
00696        @return Completion code as defined by POSIX threading semantics.
00697      */
00698     int (*createThreadKey)
00699       (CMPI_THREAD_KEY_TYPE * key, void (*cleanup) (void *));
00700 
00705     int (*destroyThreadKey) (CMPI_THREAD_KEY_TYPE key);
00706 
00711     void *(*getThreadSpecific) (CMPI_THREAD_KEY_TYPE key);
00712 
00718     int (*setThreadSpecific) (CMPI_THREAD_KEY_TYPE key, void *value);
00719 
00720 
00725       CMPI_MUTEX_TYPE (*newMutex) (int opt);
00726 
00730     void (*destroyMutex) (CMPI_MUTEX_TYPE mutex);
00731 
00735     void (*lockMutex) (CMPI_MUTEX_TYPE mutex);
00736 
00740     void (*unlockMutex) (CMPI_MUTEX_TYPE mutex);
00741 
00746       CMPI_COND_TYPE (*newCondition) (int opt);
00747 
00751     void (*destroyCondition) (CMPI_COND_TYPE cond);
00752 
00759     int (*condWait) (CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex);
00760 
00770     int (*timedCondWait)
00771       (CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex, struct timespec * wait);
00772 
00777     int (*signalCondition) (CMPI_COND_TYPE cond);
00778   };
00779 
00780 
00781 
00782 #   if defined (CMPI_VER_200)
00783   //---------------------------------------------------
00784   //--
00785   //   _CMPIBroker Memory Function Table
00786   //--
00787   //---------------------------------------------------
00788 
00795   struct _CMPIBrokerMemFT
00796   {
00797 
00798     const int ftVersion;
00799 
00807     CMPIGcStat *(*mark) (const CMPIBroker * mb, CMPIStatus * rc);
00808 
00815       CMPIStatus (*release) (const CMPIBroker * mb, const CMPIGcStat * gc);
00816 
00823     void *(*cmpiMalloc) (const CMPIBroker * mb, size_t size);
00824 
00833     void *(*cmpiCalloc) (const CMPIBroker * mb, size_t, size_t);
00834 
00847     void *(*cmpiRealloc) (const CMPIBroker * mb, void *, size_t);
00848 
00849 
00857     char *(*cmpiStrDup) (const CMPIBroker * mb, const char *);
00858 
00866     void (*cmpiFree) (const CMPIBroker * mb, void *);
00867 
00876     void (*freeInstance) (const CMPIBroker * mb, CMPIInstance * inst);
00877 
00886     void (*freeObjectPath) (const CMPIBroker * mb, CMPIObjectPath * obj);
00887 
00896     void (*freeArgs) (const CMPIBroker * mb, CMPIArgs * args);
00897 
00906     void (*freeString) (const CMPIBroker * mb, CMPIString * str);
00907 
00916     void (*freeArray) (const CMPIBroker * mb, CMPIArray * array);
00917 
00926     void (*freeDateTime) (const CMPIBroker * mb, CMPIDateTime * date);
00927 
00936     void (*freeSelectExp) (const CMPIBroker * mb, CMPISelectExp * se);
00937   };
00938 
00939 #   endif
00940 
00941   //---------------------------------------------------
00942   //--
00943   //   _CMPIBroker Encapsulated object
00944   //--
00945   //---------------------------------------------------
00946 
00947 
00950   struct _CMPIBroker
00951   {
00952 
00955     void *hdl;
00956 
00959     CMPIBrokerFT *bft;
00960 
00963     CMPIBrokerEncFT *eft;
00964 
00967     CMPIBrokerExtFT *xft;
00968 
00969 #   ifdef CMPI_VER_200
00970 
00972     CMPIBrokerMemFT *mft;
00973 #   endif
00974 
00975   };
00976 
00977 
00978 
00979   //---------------------------------------------------
00980   //--
00981   //   _CMPIContext Function Table
00982   //--
00983   //---------------------------------------------------
00984 
00985 
00989   struct _CMPIContextFT
00990   {
00991 
00994     int ftVersion;
00995 
01001       CMPIStatus (*release) (CMPIContext * ctx);
01002 
01008     CMPIContext *(*clone) (const CMPIContext * ctx, CMPIStatus * rc);
01009 
01010 
01017       CMPIData (*getEntry)
01018       (const CMPIContext * ctx, const char *name, CMPIStatus * rc);
01019 
01027       CMPIData (*getEntryAt)
01028       (const CMPIContext * ctx, CMPICount index, CMPIString ** name,
01029        CMPIStatus * rc);
01030 
01035       CMPICount (*getEntryCount) (const CMPIContext * ctx, CMPIStatus * rc);
01036 
01044       CMPIStatus (*addEntry)
01045       (const CMPIContext * ctx, const char *name, const CMPIValue * value,
01046        const CMPIType type);
01047   };
01048 
01049 
01050 
01051 
01052   //---------------------------------------------------
01053   //--
01054   //   _CMPIContext Encapsulated object
01055   //--
01056   //---------------------------------------------------
01057 
01058 
01061   struct _CMPIContext
01062   {
01063 
01066     void *hdl;
01067 
01070     CMPIContextFT *ft;
01071   };
01072 
01073 
01074 
01075 
01076   //---------------------------------------------------
01077   //--
01078   //   _CMPIResult Encapsulated object
01079   //--
01080   //---------------------------------------------------
01081 
01082 
01085   struct _CMPIResult
01086   {
01087 
01090     void *hdl;
01091 
01094     CMPIResultFT *ft;
01095   };
01096 
01097 
01098   //---------------------------------------------------
01099   //--
01100   //   _CMPIResult Function Table
01101   //--
01102   //---------------------------------------------------
01103 
01104 
01109   struct _CMPIResultFT
01110   {
01111 
01114     int ftVersion;
01115 
01121       CMPIStatus (*release) (CMPIResult * rslt);
01122 
01128     CMPIResult *(*clone) (const CMPIResult * rslt, CMPIStatus * rc);
01129 
01136       CMPIStatus (*returnData)
01137       (const CMPIResult * rslt, const CMPIValue * value, const CMPIType type);
01138 
01144       CMPIStatus (*returnInstance)
01145       (const CMPIResult * rslt, const CMPIInstance * inst);
01146 
01152       CMPIStatus (*returnObjectPath)
01153       (const CMPIResult * rslt, const CMPIObjectPath * ref);
01154 
01159       CMPIStatus (*returnDone) (const CMPIResult * rslt);
01160 
01161 #       ifdef CMPI_VER_200
01162 
01167         CMPIStatus (*returnError)(const CMPIResult* rslt,
01168                 const CMPIError* er);
01169 #       endif
01170   };
01171 
01172 #       ifdef CMPI_VER_200
01173         struct _CMPIError {
01174                 void *hdl;
01175                 CMPIErrorFT *ft;
01176         };
01177 
01178   //---------------------------------------------------
01179   //--
01180   //   _CMPIErrorFT Function Table
01181   //--
01182   //---------------------------------------------------
01183 
01184 
01188 struct _CMPIErrorFT {
01191     CMPISint32 ftVersion;
01197     CMPIStatus (*release)(CMPIError*);
01203     CMPIError* (*clone)(const CMPIError*, CMPIStatus*);
01209     CMPIErrorType (*getErrorType)(const CMPIError*, CMPIStatus*);
01215     CMPIString* (*getOtherErrorType)(const CMPIError*, CMPIStatus*);
01221     CMPIString* (*getOwningEntity)(const CMPIError*, CMPIStatus*);
01227     CMPIString* (*getMessageID)(const CMPIError*, CMPIStatus*);
01233     CMPIString* (*getMessage)(const CMPIError*, CMPIStatus*);
01239     CMPIErrorSeverity (*getPerceivedSeverity)(const CMPIError*, CMPIStatus*);
01245     CMPIErrorProbableCause (*getProbableCause)(const CMPIError*, CMPIStatus*);
01251     CMPIString* (*getProbableCauseDescription)(const CMPIError*, CMPIStatus*);
01257     CMPIArray* (*getRecommendedActions)(const CMPIError*, CMPIStatus*);
01263     CMPIString* (*getErrorSource)(const CMPIError*, CMPIStatus*);
01269     CMPIErrorSrcFormat (*getErrorSourceFormat)(const CMPIError*, CMPIStatus*);
01275     CMPIString* (*getOtherErrorSourceFormat)(const CMPIError*, CMPIStatus*);
01281     CMPIrc (*getCIMStatusCode)(const CMPIError*, CMPIStatus*);
01287     CMPIString* (*getCIMStatusCodeDescription)(const CMPIError*, CMPIStatus*);
01293         CMPIArray* (*getMessageArguments)(const CMPIError*, CMPIStatus*);
01299     CMPIStatus (*setErrorType)(CMPIError*, const CMPIErrorType);
01305     CMPIStatus (*setOtherErrorType)(CMPIError*, const char *);
01311     CMPIStatus (*setProbableCauseDescription)(CMPIError*, const char *);
01317     CMPIStatus (*setRecommendedActions)(CMPIError*, const CMPIArray*);
01323     CMPIStatus (*setErrorSource)(CMPIError*, const char*);
01329     CMPIStatus (*setErrorSourceFormat)(CMPIError*, const CMPIErrorSrcFormat );
01335     CMPIStatus (*setOtherErrorSourceFormat)(CMPIError*, const char*);
01341     CMPIStatus (*setCIMStatusCodeDescription)(CMPIError*, const char*);
01348         CMPIStatus (*setMessageArguments)(CMPIError*, CMPIArray*);
01349 };
01350 #       endif /* CMPI_VER_200 */
01351 
01352 
01353   //---------------------------------------------------
01354   //--
01355   //   _CMPIInstance Encapsulated object
01356   //--
01357   //---------------------------------------------------
01358 
01359 
01362   struct _CMPIInstance
01363   {
01364 
01367     void *hdl;
01368 
01371     CMPIInstanceFT *ft;
01372   };
01373 
01374 
01375 
01376   //---------------------------------------------------
01377   //--
01378   //   _CMPIInstance Function Table
01379   //--
01380   //---------------------------------------------------
01381 
01382 
01386   struct _CMPIInstanceFT
01387   {
01388 
01391     int ftVersion;
01392 
01398       CMPIStatus (*release) (CMPIInstance * inst);
01399 
01406     CMPIInstance *(*clone) (const CMPIInstance * inst, CMPIStatus * rc);
01407 
01414       CMPIData (*getProperty)
01415       (const CMPIInstance * inst, const char *name, CMPIStatus * rc);
01416 
01424       CMPIData (*getPropertyAt)
01425       (const CMPIInstance * inst, CMPICount index, CMPIString ** name,
01426        CMPIStatus * rc);
01432       CMPICount (*getPropertyCount)
01433       (const CMPIInstance * inst, CMPIStatus * rc);
01434 
01442       CMPIStatus (*setProperty)
01443       (const CMPIInstance * inst, const char *name,
01444        const CMPIValue * value, CMPIType type);
01445 
01452     CMPIObjectPath *(*getObjectPath)
01453       (const CMPIInstance * inst, CMPIStatus * rc);
01454 
01463       CMPIStatus (*setPropertyFilter)
01464       (CMPIInstance * inst, const char **propertyList, const char **keys);
01465 
01475       CMPIStatus (*setObjectPath) (CMPIInstance * inst,
01476                                    const CMPIObjectPath * op);
01477 #ifdef CMPI_VER_200
01478 
01488           CMPIStatus (*setPropertyWithOrigin)(const CMPIInstance*, const char*,
01489                     const CMPIValue*, const CMPIType, const char*);
01490 #endif /* CMPI_VER_200 */
01491 
01492   };
01493 
01494 
01495 
01496 
01497   //---------------------------------------------------
01498   //--
01499   //   _CMPIObjectPath Encapsulated object
01500   //--
01501   //---------------------------------------------------
01502 
01503 
01506   struct _CMPIObjectPath
01507   {
01508 
01511     void *hdl;
01512 
01515     CMPIObjectPathFT *ft;
01516   };
01517 
01518 
01519 
01520   //---------------------------------------------------
01521   //--
01522   //   _CMPIObjectPath Function Table
01523   //--
01524   //---------------------------------------------------
01525 
01526 
01530   struct _CMPIObjectPathFT
01531   {
01532 
01535     int ftVersion;
01536 
01542       CMPIStatus (*release) (CMPIObjectPath * op);
01543 
01550     CMPIObjectPath *(*clone) (const CMPIObjectPath * op, CMPIStatus * rc);
01551 
01557       CMPIStatus (*setNameSpace) (CMPIObjectPath * op, const char *ns);
01558 
01564     CMPIString *(*getNameSpace) (const CMPIObjectPath * op, CMPIStatus * rc);
01565 
01571       CMPIStatus (*setHostname) (CMPIObjectPath * op, const char *hn);
01572 
01578     CMPIString *(*getHostname) (const CMPIObjectPath * op, CMPIStatus * rc);
01579 
01585       CMPIStatus (*setClassName) (CMPIObjectPath * op, const char *cn);
01586 
01592     CMPIString *(*getClassName) (const CMPIObjectPath * op, CMPIStatus * rc);
01593 
01601       CMPIStatus (*addKey)
01602       (CMPIObjectPath * op, const char *name,
01603        const CMPIValue * value, const CMPIType type);
01604 
01611       CMPIData (*getKey)
01612       (const CMPIObjectPath * op, const char *name, CMPIStatus * rc);
01613 
01621       CMPIData (*getKeyAt)
01622       (const CMPIObjectPath * op, CMPICount index, CMPIString ** name,
01623        CMPIStatus * rc);
01629       CMPICount (*getKeyCount) (const CMPIObjectPath * op, CMPIStatus * rc);
01635       CMPIStatus (*setNameSpaceFromObjectPath)
01636       (CMPIObjectPath * op, const CMPIObjectPath * src);
01637 
01643       CMPIStatus (*setHostAndNameSpaceFromObjectPath)
01644       (CMPIObjectPath * op, const CMPIObjectPath * src);
01645 
01646 
01647 
01648     // optional qualifier support
01649 
01650 
01657       CMPIData (*getClassQualifier)
01658       (const CMPIObjectPath * op, const char *qName, CMPIStatus * rc);
01659 
01667       CMPIData (*getPropertyQualifier)
01668       (const CMPIObjectPath * op,
01669        const char *pName, const char *qName, CMPIStatus * rc);
01670 
01678       CMPIData (*getMethodQualifier)
01679       (const CMPIObjectPath * op,
01680        const char *methodName, const char *qName, CMPIStatus * rc);
01681 
01690       CMPIData (*getParameterQualifier)
01691       (const CMPIObjectPath * op,
01692        const char *mName,
01693        const char *pName, const char *qName, CMPIStatus * rc);
01694 
01700     CMPIString *(*toString) (const CMPIObjectPath * op, CMPIStatus * rc);
01701 
01702   };
01703 
01704 
01705 
01706 
01707   //---------------------------------------------------
01708   //--
01709   //   _CMPISelectExp Encapsulated object
01710   //--
01711   //---------------------------------------------------
01712 
01713 
01716   struct _CMPISelectExp
01717   {
01718 
01721     void *hdl;
01722 
01725     CMPISelectExpFT *ft;
01726   };
01727 
01728 
01729 
01730   //---------------------------------------------------
01731   //--
01732   //   _CMPISelectExpFT Function Table
01733   //--
01734   //---------------------------------------------------
01735 
01736 
01740   struct _CMPISelectExpFT
01741   {
01742 
01745     int ftVersion;
01746 
01752       CMPIStatus (*release) (CMPISelectExp * se);
01753 
01760     CMPISelectExp *(*clone) (const CMPISelectExp * se, CMPIStatus * rc);
01761 
01768       CMPIBoolean (*evaluate)
01769       (const CMPISelectExp * se, const CMPIInstance * inst, CMPIStatus * rc);
01770 
01776     CMPIString *(*getString) (const CMPISelectExp * se, CMPIStatus * rc);
01777 
01783     CMPISelectCond *(*getDOC) (const CMPISelectExp * se, CMPIStatus * rc);
01784 
01790     CMPISelectCond *(*getCOD) (const CMPISelectExp * se, CMPIStatus * rc);
01791 
01799       CMPIBoolean (*evaluateUsingAccessor)
01800       (const CMPISelectExp * se, CMPIAccessor * accessor, void *parm,
01801        CMPIStatus * rc);
01802   };
01803 
01804 
01805 
01806   //---------------------------------------------------
01807   //--
01808   //   _CMPISelectCond Encapsulated object
01809   //--
01810   //---------------------------------------------------
01811 
01812 
01815   struct _CMPISelectCond
01816   {
01817 
01820     void *hdl;
01821 
01824     CMPISelectCondFT *ft;
01825   };
01826 
01827 
01828 
01829   //---------------------------------------------------
01830   //--
01831   //   _CMPISelectCondFT Function Table
01832   //--
01833   //---------------------------------------------------
01834 
01835 
01839   struct _CMPISelectCondFT
01840   {
01841 
01844     const int ftVersion;
01845 
01851       CMPIStatus (*release) (CMPISelectCond * sc);
01852 
01859     CMPISelectCond *(*clone) (const CMPISelectCond * sc, CMPIStatus * rc);
01860 
01868       CMPICount (*getCountAndType)
01869       (const CMPISelectCond * sc, int* type, CMPIStatus * rc);
01870 
01877     CMPISubCond *(*getSubCondAt)
01878       (const CMPISelectCond * sc, CMPICount index, CMPIStatus * rc);
01879   };
01880 
01881 
01882 
01883 
01884   //---------------------------------------------------
01885   //--
01886   //   _CMPISubCond Encapsulated object
01887   //--
01888   //---------------------------------------------------
01889 
01890 
01893   struct _CMPISubCond
01894   {
01895 
01898     void *hdl;
01899 
01902     CMPISubCondFT *ft;
01903   };
01904 
01905 
01906 
01907   //---------------------------------------------------
01908   //--
01909   //   _CMPISubCondFT Function Table
01910   //--
01911   //---------------------------------------------------
01912 
01913 
01917   struct _CMPISubCondFT
01918   {
01919 
01922     int ftVersion;
01923 
01929       CMPIStatus (*release) (CMPISubCond * sc);
01930 
01937     CMPISubCond *(*clone) (const CMPISubCond * sc, CMPIStatus * rc);
01938 
01944       CMPICount (*getCount) (const CMPISubCond * sc, CMPIStatus * rc);
01945 
01952     CMPIPredicate *(*getPredicateAt)
01953       (const CMPISubCond * sc, CMPICount index, CMPIStatus * rc);
01954 
01961     CMPIPredicate *(*getPredicate)
01962       (const CMPISubCond * sc, const char *name, CMPIStatus * rc);
01963   };
01964 
01965 
01966 
01967 
01968   //---------------------------------------------------
01969   //--
01970   //   _CMPIPredicate Encapsulated object
01971   //--
01972   //---------------------------------------------------
01973 
01974 
01977   struct _CMPIPredicate
01978   {
01979 
01982     void *hdl;
01983 
01986     CMPIPredicateFT *ft;
01987   };
01988 
01989 
01990 
01991 
01992   //---------------------------------------------------
01993   //--
01994   //   _CMPIPredicateFT Function Table
01995   //--
01996   //---------------------------------------------------
01997 
01998 
02002   struct _CMPIPredicateFT
02003   {
02004 
02007     int ftVersion;
02008 
02014       CMPIStatus (*release) (CMPIPredicate * pr);
02015 
02022     CMPIPredicate *(*clone) (const CMPIPredicate * pr, CMPIStatus * rc);
02023 
02032       CMPIStatus (*getData)
02033       (const CMPIPredicate * pr, CMPIType * type,
02034        CMPIPredOp * op, CMPIString ** lhs, CMPIString ** rhs);
02035 
02048       CMPIBoolean (*evaluateUsingAccessor)
02049       (const CMPIPredicate * pr, CMPIAccessor * accessorFnc, void *parm,
02050        CMPIStatus * rc);
02051   };
02052 
02053 
02054 
02055 
02056   //---------------------------------------------------
02057   //--
02058   //   _CMPIArgs Encapsulated object
02059   //--
02060   //---------------------------------------------------
02061 
02062 
02065   struct _CMPIArgs
02066   {
02067 
02070     void *hdl;
02071 
02074     CMPIArgsFT *ft;
02075   };
02076 
02077 
02078 
02079   //---------------------------------------------------
02080   //--
02081   //   _CMPIArgsFT Function Table
02082   //--
02083   //---------------------------------------------------
02084 
02085 
02089   struct _CMPIArgsFT
02090   {
02091 
02094     int ftVersion;
02095 
02101       CMPIStatus (*release) (CMPIArgs * as);
02102 
02109     CMPIArgs *(*clone) (const CMPIArgs * as, CMPIStatus * rc);
02110 
02118       CMPIStatus (*addArg)
02119       (const CMPIArgs * as, const char *name, const CMPIValue * value,
02120        const CMPIType type);
02121 
02128       CMPIData (*getArg)
02129       (const CMPIArgs * as, const char *name, CMPIStatus * rc);
02130 
02138       CMPIData (*getArgAt)
02139       (const CMPIArgs * as, CMPICount index, CMPIString ** name,
02140        CMPIStatus * rc);
02141 
02147       CMPICount (*getArgCount) (const CMPIArgs * as, CMPIStatus * rc);
02148   };
02149 
02150 
02151 
02152 
02153   //---------------------------------------------------
02154   //--
02155   //   _CMPIString Encapsulated object
02156   //--
02157   //---------------------------------------------------
02158 
02159 
02162   struct _CMPIString
02163   {
02164 
02167     void *hdl;
02168 
02171     CMPIStringFT *ft;
02172   };
02173 
02174 
02175 
02176   //---------------------------------------------------
02177   //--
02178   //   _CMPIStringFT Function Table
02179   //--
02180   //---------------------------------------------------
02181 
02182 
02186   struct _CMPIStringFT
02187   {
02188 
02191     int ftVersion;
02192 
02198       CMPIStatus (*release) (CMPIString * st);
02199 
02206     CMPIString *(*clone) (const CMPIString * st, CMPIStatus * rc);
02207 
02213     const char *(*getCharPtr) (const CMPIString * st, CMPIStatus * rc);
02214   };
02215 
02216 
02217 
02218 
02219   //---------------------------------------------------
02220   //--
02221   //   _CMPIArray Encapsulated object
02222   //--
02223   //---------------------------------------------------
02224 
02225 
02228   struct _CMPIArray
02229   {
02230 
02233     void *hdl;
02234 
02237     CMPIArrayFT *ft;
02238   };
02239 
02240 
02241 
02242   //---------------------------------------------------
02243   //--
02244   //   _CMPIArrayFT Function Table
02245   //--
02246   //---------------------------------------------------
02247 
02248 
02252   struct _CMPIArrayFT
02253   {
02254 
02257     int ftVersion;
02258 
02264       CMPIStatus (*release) (CMPIArray * ar);
02265 
02272     CMPIArray *(*clone) (const CMPIArray * ar, CMPIStatus * rc);
02273 
02279       CMPICount (*getSize) (const CMPIArray * ar, CMPIStatus * rc);
02280 
02286       CMPIType (*getSimpleType) (const CMPIArray * ar, CMPIStatus * rc);
02287 
02294       CMPIData (*getElementAt)
02295       (const CMPIArray * ar, CMPICount index, CMPIStatus * rc);
02296 
02304       CMPIStatus (*setElementAt)
02305       (CMPIArray * ar, CMPICount index, const CMPIValue * value,
02306        CMPIType type);
02307   };
02308 
02309 
02310 
02311 
02312 
02313   //---------------------------------------------------
02314   //--
02315   //   _CMPIEnumeration Encapsulated object
02316   //--
02317   //---------------------------------------------------
02318 
02319 
02322   struct _CMPIEnumeration
02323   {
02324 
02327     void *hdl;
02328 
02331     CMPIEnumerationFT *ft;
02332   };
02333 
02334 
02335 
02336   //---------------------------------------------------
02337   //--
02338   //   _CMPIEnumerationFT Function Table
02339   //--
02340   //---------------------------------------------------
02341 
02342 
02346   struct _CMPIEnumerationFT
02347   {
02348 
02351     int ftVersion;
02352 
02358       CMPIStatus (*release) (CMPIEnumeration * en);
02359 
02366     CMPIEnumeration *(*clone) (const CMPIEnumeration * en, CMPIStatus * rc);
02367 
02373       CMPIData (*getNext) (const CMPIEnumeration * en, CMPIStatus * rc);
02374 
02380       CMPIBoolean (*hasNext) (const CMPIEnumeration * en, CMPIStatus * rc);
02381 
02387     CMPIArray *(*toArray) (const CMPIEnumeration * en, CMPIStatus * rc);
02388   };
02389 
02390 
02391 
02392 
02393 
02394   //---------------------------------------------------
02395   //--
02396   //   _CMPIDateTime Encapsulated object
02397   //--
02398   //---------------------------------------------------
02399 
02400 
02403   struct _CMPIDateTime
02404   {
02405 
02408     void *hdl;
02409 
02412     CMPIDateTimeFT *ft;
02413   };
02414 
02415 
02416 
02417   //---------------------------------------------------
02418   //--
02419   //   _CMPIDateTimeFT Function Table
02420   //--
02421   //---------------------------------------------------
02422 
02423 
02427   struct _CMPIDateTimeFT
02428   {
02429 
02432     int ftVersion;
02433 
02439       CMPIStatus (*release) (CMPIDateTime * dt);
02440 
02447     CMPIDateTime *(*clone) (const CMPIDateTime * dt, CMPIStatus * rc);
02448 
02455       CMPIUint64 (*getBinaryFormat) (const CMPIDateTime * dt,
02456                                      CMPIStatus * rc);
02457 
02463     CMPIString *(*getStringFormat) (const CMPIDateTime * dt, CMPIStatus * rc);
02464 
02470       CMPIBoolean (*isInterval) (const CMPIDateTime * dt, CMPIStatus * rc);
02471   };
02472 
02473 
02474 
02475 
02476 
02477 
02478   //---------------------------------------------------
02479   //--
02480   //   _CMPIInstanceMI Instance Provider object
02481   //--
02482   //---------------------------------------------------
02483 
02484 
02487   typedef struct _CMPIInstanceMIFT CMPIInstanceMIFT;
02488   typedef struct _CMPIInstanceMI
02489   {
02490 
02493     void *hdl;
02494 
02497     CMPIInstanceMIFT *ft;
02498   } CMPIInstanceMI;
02499 
02500 
02501 
02502   //---------------------------------------------------
02503   //--
02504   //   _CMPIInstanceMIFT Function Table
02505   //--
02506   //---------------------------------------------------
02507 
02508 
02513   struct _CMPIInstanceMIFT
02514   {
02515 
02518     int ftVersion;
02519 
02522     int miVersion;
02523 
02526     const char *miName;
02527 
02546       CMPIStatus (*cleanup)
02547       (CMPIInstanceMI * mi, const CMPIContext * ctx, CMPIBoolean terminating);
02548 
02562       CMPIStatus (*enumerateInstanceNames)
02563       (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt,
02564        const CMPIObjectPath * op);
02565 
02582       CMPIStatus (*enumerateInstances)
02583       (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt,
02584        const CMPIObjectPath * op, const char **properties);
02585 
02602       CMPIStatus (*getInstance)
02603       (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt,
02604        const CMPIObjectPath * op, const char **properties);
02605 
02619       CMPIStatus (*createInstance)
02620       (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt,
02621        const CMPIObjectPath * op, const CMPIInstance * inst);
02622 
02635       CMPIStatus (*modifyInstance)
02636       (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt,
02637        const CMPIObjectPath * op, const CMPIInstance * inst,
02638        const char **properties);
02639 
02653       CMPIStatus (*deleteInstance)
02654       (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt,
02655        const CMPIObjectPath * op);
02656 
02674       CMPIStatus (*execQuery)
02675       (CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt,
02676        const CMPIObjectPath * op, const char *query, const char *lang);
02677   };
02678 
02679 
02680 
02681 
02682 
02683 
02684   //---------------------------------------------------
02685   //--
02686   //   _CMPIAssociationMI Association Provider object
02687   //--
02688   //---------------------------------------------------
02689 
02690 
02693   typedef struct _CMPIAssociationMIFT CMPIAssociationMIFT;
02694   typedef struct _CMPIAssociationMI
02695   {
02696 
02699     void *hdl;
02700 
02703     CMPIAssociationMIFT *ft;
02704   } CMPIAssociationMI;
02705 
02706 
02707   //---------------------------------------------------
02708   //--
02709   //   _CMPIAssociationMIFT Function Table
02710   //--
02711   //---------------------------------------------------
02712 
02713 
02718   struct _CMPIAssociationMIFT
02719   {
02720 
02723     int ftVersion;
02724 
02727     const CMPISint32 miVersion;
02728 
02731     const char *miName;
02732 
02750       CMPIStatus (*cleanup)
02751       (CMPIAssociationMI * mi, const CMPIContext * ctx,
02752        CMPIBoolean terminating);
02753 
02790       CMPIStatus (*associators)
02791       (CMPIAssociationMI * mi, const CMPIContext * ctx,
02792        const CMPIResult * rslt, const CMPIObjectPath * op,
02793        const char *asscClass, const char *resultClass, const char *role,
02794        const char *resultRole, const char **properties);
02795 
02829       CMPIStatus (*associatorNames)
02830       (CMPIAssociationMI * mi, const CMPIContext * ctx,
02831        const CMPIResult * rslt, const CMPIObjectPath * op,
02832        const char *assocClass, const char *resultClass, const char *role,
02833        const char *resultRole);
02834 
02862       CMPIStatus (*references)
02863       (CMPIAssociationMI * mi, const CMPIContext * ctx,
02864        const CMPIResult * rslt, const CMPIObjectPath * op,
02865        const char *resultClass, const char *role, const char **properties);
02866 
02891       CMPIStatus (*referenceNames)
02892       (CMPIAssociationMI * mi, const CMPIContext * ctx,
02893        const CMPIResult * rslt, const CMPIObjectPath * op,
02894        const char *resultClass, const char *role);
02895   };
02896 
02897 
02898 
02899 
02900 
02901 
02902   //---------------------------------------------------
02903   //--
02904   //   _CMPIMethodMI Method Provider object
02905   //--
02906   //---------------------------------------------------
02907 
02908 
02911   typedef struct _CMPIMethodMIFT CMPIMethodMIFT;
02912   typedef struct _CMPIMethodMI
02913   {
02914 
02917     void *hdl;
02918 
02921     CMPIMethodMIFT *ft;
02922   } CMPIMethodMI;
02923 
02924 
02925 
02926   //---------------------------------------------------
02927   //--
02928   //   _CMPIMethodMIFT Function Table
02929   //--
02930   //---------------------------------------------------
02931 
02932 
02937   struct _CMPIMethodMIFT
02938   {
02939 
02942     int ftVersion;
02943 
02946     int miVersion;
02947 
02950     const char *miName;
02951 
02970       CMPIStatus (*cleanup)
02971       (CMPIMethodMI * mi, const CMPIContext * ctx, CMPIBoolean terminating);
02972 
02991       CMPIStatus (*invokeMethod)
02992       (CMPIMethodMI * mi, const CMPIContext * ctx, const CMPIResult * rslt,
02993        const CMPIObjectPath * op, const char *method, const CMPIArgs * in,
02994        CMPIArgs * out);
02995   };
02996 
02997 
02998 
02999 
03000 
03001   //---------------------------------------------------
03002   //--
03003   //   _CMPIPropertyMI Property Provider object
03004   //--
03005   //---------------------------------------------------
03006 
03007 
03010   typedef struct _CMPIPropertyMIFT CMPIPropertyMIFT;
03011   typedef struct _CMPIPropertyMI
03012   {
03013 
03016     void *hdl;
03017 
03020     CMPIPropertyMIFT *ft;
03021   } CMPIPropertyMI;
03022 
03023 
03024 
03025   //---------------------------------------------------
03026   //--
03027   //   _CMPIPropertyMIFT Function Table
03028   //--
03029   //---------------------------------------------------
03030 
03031 
03036   struct _CMPIPropertyMIFT
03037   {
03038 
03041     int ftVersion;
03042 
03045     int miVersion;
03046 
03049     const char *miName;
03050 
03066       CMPIStatus (*cleanup)
03067       (CMPIPropertyMI * mi, const CMPIContext * ctx, CMPIBoolean terminating);
03068 
03081       CMPIStatus (*setProperty)
03082       (CMPIPropertyMI * mi, const CMPIContext * ctx, const CMPIResult * rslt,
03083        const CMPIObjectPath * op, const char *name, const CMPIData data);
03084 
03102       CMPIStatus (*getProperty)
03103       (CMPIPropertyMI *, const CMPIContext *, const CMPIResult *,
03104        const CMPIObjectPath *, const char *name);
03105 #ifdef CMPI_VER_200
03106 
03118           CMPIStatus (*setPropertyWithOrigin)(CMPIPropertyMI*, const CMPIContext*,
03119                   const CMPIResult*, CMPIObjectPath * op,
03120           const char *name, const CMPIData data, const char*);
03121 #endif /* CMPI_VER_200 */
03122   };
03123 
03124 
03125 
03126 
03127 
03128   //---------------------------------------------------
03129   //--
03130   //   _CMPIIndicationMI Indication Provider object
03131   //--
03132   //---------------------------------------------------
03133 
03134 
03137   typedef struct _CMPIIndicationMIFT CMPIIndicationMIFT;
03138   typedef struct _CMPIIndicationMI
03139   {
03140 
03143     void *hdl;
03144 
03147     CMPIIndicationMIFT *ft;
03148   } CMPIIndicationMI;
03149 
03150 
03151 
03152   //---------------------------------------------------
03153   //--
03154   //   _CMPIIndicationMIFT Function Table
03155   //--
03156   //---------------------------------------------------
03157 
03158 
03163   struct _CMPIIndicationMIFT
03164   {
03165 
03168     int ftVersion;
03169 
03172     int miVersion;
03173 
03176     const char *miName;
03177 
03197       CMPIStatus (*cleanup)
03198       (CMPIIndicationMI * mi, const CMPIContext * ctx,
03199        CMPIBoolean terminating);
03200 
03220       CMPIStatus (*authorizeFilter) (CMPIIndicationMI * mi,
03221                                      const CMPIContext * ctx,
03222                                      const CMPISelectExp * filter,
03223                                      const char *className,
03224                                      const CMPIObjectPath * op,
03225                                      const char *owner);
03248       CMPIStatus (*mustPoll) (CMPIIndicationMI * mi, const CMPIContext * ctx,
03249                               const CMPISelectExp * filter,
03250                               const char *className,
03251                               const CMPIObjectPath * classPath);
03252 
03275       CMPIStatus (*activateFilter) (CMPIIndicationMI * mi,
03276                                     const CMPIContext * ctx,
03277                                     const CMPISelectExp * filter,
03278                                     const char *className,
03279                                     const CMPIObjectPath * classPath,
03280                                     CMPIBoolean firstActivation);
03281 
03304       CMPIStatus (*deActivateFilter) (CMPIIndicationMI * mi,
03305                                       const CMPIContext * ctx,
03306                                       const CMPISelectExp * filter,
03307                                       const char *className,
03308                                       const CMPIObjectPath * classPath,
03309                                       CMPIBoolean lastActiviation);
03310 
03327       CMPIStatus (*enableIndications) (CMPIIndicationMI * mi,
03328                                        const CMPIContext *);
03343       CMPIStatus (*disableIndications) (CMPIIndicationMI * mi,
03344                                         const CMPIContext *);
03345 
03346   };
03347 
03348 #   include "cmpimacs.h"
03349 
03350 
03351 #   ifdef __cplusplus
03352 };
03353 #   endif
03354 
03355 #endif // _CMPIFT_H_