cmpift.h

Go to the documentation of this file.
00001 
00002 /*
00003  *
00004  * cmpift.h
00005  *
00006  * (C) Copyright IBM Corp. 2003
00007  *
00008  * THIS FILE IS PROVIDED UNDER THE TERMS OF THE COMMON PUBLIC LICENSE
00009  * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
00010  * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
00011  *
00012  * You can obtain a current copy of the Common Public License from
00013  * http://oss.software.ibm.com/developerworks/opensource/license-cpl.html
00014  *
00015  * Author:        Adrian Schuur <schuur@de.ibm.com>
00016  * Contributors:
00017  *
00018  * Description: CMPI Encapsulated types Function Tables
00019  *
00020  */
00021 
00022 #ifndef _CMPIFT_H_
00023 #define _CMPIFT_H_
00024 #include "OW_config.h"
00025 
00026 #include <cmpidt.h>
00027 
00028 #ifdef __cplusplus
00029 extern "C" {
00030 #endif
00031 
00032 
00033 
00034    /*
00035    //---------------------------------------------------
00036    //--
00037    // _CMPIBrokerEncFT Function Table
00038    //--
00039    //---------------------------------------------------
00040    */
00041 
00042 
00048    struct _CMPIBrokerEncFT {
00049 
00052      int ftVersion;
00053 
00060      CMPIInstance* (*newInstance)
00061                  (const CMPIBroker* mb,
00062               const CMPIObjectPath* op, CMPIStatus* rc);
00063 
00071      CMPIObjectPath* (*newObjectPath)
00072                  (const CMPIBroker* mb, 
00073               const char* ns, const char* cn, CMPIStatus* rc);
00074 
00080      CMPIArgs* (*newArgs)
00081                  (const CMPIBroker* mb, CMPIStatus* rc);
00082 
00089      CMPIString* (*newString)
00090                  (const CMPIBroker* mb, const char* data, CMPIStatus* rc);
00091 
00099      CMPIArray* (*newArray)
00100                  (const CMPIBroker* mb, CMPICount max, CMPIType type, CMPIStatus* rc);
00101 
00107      CMPIDateTime* (*newDateTime)
00108                  (const CMPIBroker* mb, CMPIStatus* rc);
00109 
00118      CMPIDateTime* (*newDateTimeFromBinary)
00119                  (const CMPIBroker* mb, CMPIUint64 binTime, CMPIBoolean interval,
00120         CMPIStatus* rc);
00121 
00128      CMPIDateTime* (*newDateTimeFromChars)
00129                  (const CMPIBroker* mb, const char* utcTime, CMPIStatus* rc);
00130 
00139      CMPISelectExp* (*newSelectExp)
00140                  (const CMPIBroker* mb, const char* query, const char* lang,
00141                   CMPIArray** projection, CMPIStatus* st);
00142 
00151      CMPIBoolean (*classPathIsA)
00152                  (const CMPIBroker* mb, const CMPIObjectPath* op, 
00153               const char* type, CMPIStatus* rc);
00154 
00162      CMPIString* (*toString)
00163                  (const CMPIBroker* mb, const void* object, CMPIStatus* rc);
00164 
00174      CMPIBoolean (*isOfType)
00175                  (const CMPIBroker* mb, const void* object, const char* type, CMPIStatus* rc);
00176 
00184      CMPIString* (*getType)
00185                  (const CMPIBroker* mb, const void* object, CMPIStatus* rc);
00186 
00195      #if defined(CMPI_VER_85)
00196      CMPIString* (*getMessage)
00197                  (const CMPIBroker* mb, const char *msgId, const char *defMsg, CMPIStatus* rc, unsigned int count, ...);
00198      #endif /* CMPI_VER_85 */
00199 
00200     #if defined(CMPI_VER_90)
00201     CMPIStatus (*logMessage)
00202       (const CMPIBroker*,int,const char*,const char*,
00203        const CMPIString*);
00204     CMPIStatus (*trace)
00205       (const CMPIBroker*,int,const char*,const char*,
00206        const CMPIString*);
00207     #endif /* CMPI_VER_90 */ 
00208    };
00209 
00210 
00211 
00212    /*
00213    //---------------------------------------------------
00214    //--
00215    // _CMPIBrokerFT Function Table
00216    //--
00217    //---------------------------------------------------
00218    */
00219 
00220 
00225    struct _CMPIBrokerFT {
00226 
00230      unsigned long brokerClassification;
00233      int brokerVersion;
00236      char *brokerName;
00237 
00246      CMPIContext* (*prepareAttachThread)
00247                 (const CMPIBroker* mb, const CMPIContext* ctx);
00248 
00255      CMPIStatus (*attachThread)
00256                 (const CMPIBroker*,const CMPIContext*);
00257 
00265      CMPIStatus (*detachThread)
00266                 (const CMPIBroker* mb, const CMPIContext* ctx);
00267 
00268      /* class 0 services */
00269 
00278      CMPIStatus (*deliverIndication)
00279                 (const CMPIBroker* mb, const CMPIContext* ctx,
00280                  const char* ns, const CMPIInstance* ind);
00281      /* class 1 services */
00282 
00290      CMPIEnumeration* (*enumInstanceNames)
00291                 (const CMPIBroker* mb, const CMPIContext* ctx,
00292                  const CMPIObjectPath* op, CMPIStatus* rc);
00293 
00305      CMPIInstance* (*getInstance)
00306                 (const CMPIBroker* mb, const CMPIContext* ctx,
00307                  const CMPIObjectPath* op, const char** properties, CMPIStatus* rc);
00308 
00309      /* class 2 services */
00310 
00319      CMPIObjectPath* (*createInstance)
00320                 (const CMPIBroker* mb, const CMPIContext* ctx,
00321                  const CMPIObjectPath* op, const CMPIInstance* inst, CMPIStatus* rc);
00322 
00330      CMPIStatus (*modifyInstance)
00331                 (const CMPIBroker* mb, const CMPIContext* ctx,
00332                  const CMPIObjectPath* op,  const CMPIInstance* inst, const char ** properties);
00333 
00340      CMPIStatus (*deleteInstance)
00341                 (const CMPIBroker* mb, const CMPIContext* ctx,
00342                  const CMPIObjectPath* op);
00343 
00354      CMPIEnumeration* (*execQuery)
00355                 (const CMPIBroker* mb, const CMPIContext* ctx,
00356                  const CMPIObjectPath* op, const char* query, const char* lang, CMPIStatus* rc);
00357 
00370      CMPIEnumeration* (*enumInstances)
00371                 (const CMPIBroker* mb, const CMPIContext* ctx,
00372                  const CMPIObjectPath* op, const char** properties, CMPIStatus* rc);
00373 
00404      CMPIEnumeration* (*associators)
00405                 (const CMPIBroker* mb,const CMPIContext* ctx,
00406                  const CMPIObjectPath* op, const char* assocClass, const char* resultClass,
00407        const char* role, const char* resultRole, const char** properties, CMPIStatus* rc);
00408 
00436      CMPIEnumeration* (*associatorNames)
00437                 (const CMPIBroker* mb, const CMPIContext* ctx,
00438                  const CMPIObjectPath* op, const char* assocClass, const char* resultClass,
00439        const char* role, const char* resultRole, CMPIStatus* rc);
00440 
00462      CMPIEnumeration* (*references)
00463                 (const CMPIBroker* mb, const CMPIContext* ctx,
00464                  const CMPIObjectPath* op, const char* resultClass ,const char* role ,
00465        const char** properties, CMPIStatus* rc);
00466 
00485      CMPIEnumeration* (*referenceNames)
00486                 (const CMPIBroker* mb, const CMPIContext* ctx,
00487                  const CMPIObjectPath* op, const char* resultClass, const char* role,
00488                  CMPIStatus* rc);
00489 
00501      CMPIData (*invokeMethod)
00502                 (const CMPIBroker* mb, const CMPIContext* ctx,
00503                  const CMPIObjectPath* op,const char* method,
00504        const CMPIArgs* in, CMPIArgs* out, CMPIStatus* rc);
00505 
00515      CMPIStatus (*setProperty)
00516                 (const CMPIBroker* mb, const CMPIContext* ctx,
00517                  const CMPIObjectPath* op, const char* name , const CMPIValue* value,
00518                  CMPIType type);
00519 
00528      CMPIData (*getProperty)
00529                 (const CMPIBroker* mb, const CMPIContext* ctx,
00530                  const CMPIObjectPath*,const char*,CMPIStatus*);
00531    };
00532 
00533 
00534 
00535    /*
00536    //---------------------------------------------------
00537    //--
00538    // _CMPIBroker Encapsulated object
00539    //--
00540    //---------------------------------------------------
00541    */
00542 
00543 
00546    struct _CMPIBroker {
00547 
00550      void *hdl;
00551 
00554      CMPIBrokerFT *bft;
00555 
00558      CMPIBrokerEncFT *eft;
00559 
00562 #if defined(CMPI_VER_90)
00563      CMPIBrokerExtFT *xft;
00564 #endif
00565    };
00566 
00567 
00568 
00569     //---------------------------------------------------
00570    //--
00571    // _CMPIBrokerExtFT Function Table
00572    //--
00573    //---------------------------------------------------
00574 
00575 #if defined(CMPI_VER_90)
00576 
00577 #include "cmpios.h"
00578 
00579    struct timespec;
00580 
00586    struct _CMPIBrokerExtFT {
00589      int ftVersion;
00590 
00591      char *(*resolveFileName)
00592          (const char *filename);
00593 
00594 
00595 
00596      CMPI_THREAD_TYPE (*newThread)
00597         (CMPI_THREAD_RETURN (CMPI_THREAD_CDECL *start)(void *), void *parm, int detached);
00598 
00599      int (*joinThread)
00600         (CMPI_THREAD_TYPE thread, CMPI_THREAD_RETURN *retval );
00601 
00602      int (*exitThread)
00603         (CMPI_THREAD_RETURN return_code);
00604 
00605      int (*cancelThread)
00606         (CMPI_THREAD_TYPE thread);
00607 
00608      int (*threadSleep)
00609         (CMPIUint32 msec);
00610 
00611      int (*threadOnce)
00612         (int *once, void (*init)(void));
00613 
00614 
00615      int (*createThreadKey)
00616         (CMPI_THREAD_KEY_TYPE *key, void (*cleanup)(void*));
00617 
00618      int (*destroyThreadKey)
00619         (CMPI_THREAD_KEY_TYPE key);
00620 
00621      void *(*getThreadSpecific)
00622         (CMPI_THREAD_KEY_TYPE key);
00623 
00624      int (*setThreadSpecific)
00625         (CMPI_THREAD_KEY_TYPE key, void * value);
00626 
00627 
00628 
00629      CMPI_MUTEX_TYPE (*newMutex)
00630         (int opt);
00631 
00632      void (*destroyMutex)
00633         (CMPI_MUTEX_TYPE);
00634 
00635      void (*lockMutex)
00636         (CMPI_MUTEX_TYPE);
00637 
00638      void (*unlockMutex)
00639         (CMPI_MUTEX_TYPE);
00640 
00641 
00642 
00643      CMPI_COND_TYPE (*newCondition)
00644         (int opt);
00645 
00646      void (*destroyCondition)
00647         (CMPI_COND_TYPE);
00648 
00649      int (*condWait)
00650         (CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex);
00651 
00652      int (*timedCondWait)
00653         (CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex, struct timespec *wait);
00654 
00655      int (*signalCondition)
00656         (CMPI_COND_TYPE cond);
00657   };
00658 
00659 #endif
00660 
00661 
00662    /*
00663    //---------------------------------------------------
00664    //--
00665    // _CMPIContext Function Table
00666    //--
00667    //---------------------------------------------------
00668    */
00669 
00670 
00674   struct _CMPIContextFT {
00675 
00678      int ftVersion;
00679 
00685      CMPIStatus (*release)
00686               (CMPIContext* ctx);
00687 
00693      CMPIContext* (*clone)
00694               (const CMPIContext* ctx, CMPIStatus* rc);
00695 
00702      CMPIData (*getEntry)
00703               (const CMPIContext* ctx, const char* name, CMPIStatus* rc);
00704 
00712      CMPIData (*getEntryAt)
00713               (const CMPIContext* ctx, unsigned int index, CMPIString** name,
00714           CMPIStatus* rc);
00715 
00720      unsigned int (*getEntryCount)
00721               (const CMPIContext* ctx, CMPIStatus* rc);
00722 
00730      CMPIStatus (*addEntry)
00731               (const CMPIContext* ctx, const char* name, const CMPIValue* value, const CMPIType type);
00732   };
00733 
00734 
00735 
00736 
00737   /*
00738    //---------------------------------------------------
00739    //--
00740    // _CMPIContextr Encapsulated object
00741    //--
00742    //---------------------------------------------------
00743    */
00744 
00745 
00748   struct _CMPIContext {
00749 
00752      /* spec says this should be const, but pegasus isn't */ 
00753     void *hdl;
00754 
00757    /* spec says this should be const, but pegasus isn't */ 
00758     CMPIContextFT *ft;
00759   };
00760 
00761 
00762 
00763 
00764   /*
00765    //---------------------------------------------------
00766    //--
00767    // _CMPIResult Encapsulated object
00768    //--
00769    //---------------------------------------------------
00770    */
00771 
00772 
00775   struct _CMPIResult {
00776 
00779      /* spec says this should be const, but pegasus isn't */ 
00780      void *hdl;
00781 
00784     /* spec says this should be const, but pegasus isn't */ 
00785      CMPIResultFT *ft;
00786   };
00787 
00788 
00789   /*
00790    //---------------------------------------------------
00791    //--
00792    // _CMPIResult Function Table
00793    //--
00794    //---------------------------------------------------
00795    */
00796 
00797 
00802   struct _CMPIResultFT {
00803 
00806      int ftVersion;
00807 
00813      CMPIStatus (*release)
00814               (CMPIResult* rslt);
00815 
00821      CMPIResult* (*clone)
00822               (const CMPIResult* rslt,CMPIStatus* rc);
00823 
00830      CMPIStatus (*returnData)
00831               (const CMPIResult* rslt,const CMPIValue* value,const CMPIType type);
00832 
00838      CMPIStatus (*returnInstance)
00839               (const CMPIResult* rslt,const CMPIInstance* inst);
00840 
00846      CMPIStatus (*returnObjectPath)
00847               (const CMPIResult* rslt, const CMPIObjectPath* ref);
00848 
00853      CMPIStatus (*returnDone)
00854               (const CMPIResult* rslt);
00855   };
00856 
00857 
00858 
00859 
00860   /*
00861    //---------------------------------------------------
00862    //--
00863    // _CMPIInstance Encapsulated object
00864    //--
00865    //---------------------------------------------------
00866    */
00867 
00868 
00871    struct _CMPIInstance {
00872 
00875       /* Spec says this should be const, but it isn't in pegasus */
00876      void *hdl;
00877 
00880     /* Spec says this should be const, but it isn't in pegasus */
00881      CMPIInstanceFT* ft;
00882    };
00883 
00884 
00885 
00886   /*
00887    //---------------------------------------------------
00888    //--
00889    // _CMPIInstance Function Table
00890    //--
00891    //---------------------------------------------------
00892    */
00893 
00894 
00898    struct _CMPIInstanceFT {
00899 
00902      int ftVersion;
00903 
00909      CMPIStatus (*release)
00910               (CMPIInstance* inst);
00911 
00918      CMPIInstance* (*clone)
00919               (const CMPIInstance* inst, CMPIStatus* rc);
00920 
00927      CMPIData (*getProperty)
00928               (const CMPIInstance* inst, const char* name, CMPIStatus* rc);
00929 
00937      CMPIData (*getPropertyAt)
00938               (const CMPIInstance* inst, unsigned int index, CMPIString** name,
00939           CMPIStatus* rc);
00940 
00946      unsigned int (*getPropertyCount)
00947               (const CMPIInstance* inst, CMPIStatus* rc);
00948 
00956      CMPIStatus (*setProperty)
00957               (const CMPIInstance* inst, const char* name,
00958                const CMPIValue* value, CMPIType type);
00959 
00966      CMPIObjectPath* (*getObjectPath)
00967               (const CMPIInstance* inst, CMPIStatus* rc);
00968 
00978      CMPIStatus (*setPropertyFilter)
00979               (CMPIInstance* inst, const char **propertyList, const char **keys);
00980 
00981 #ifdef CMPI_VER_100
00982      CMPIStatus (*setObjectPath)
00983          (CMPIInstance*, const CMPIObjectPath*);
00984 #endif
00985    };
00986 
00987 
00988 
00989 
00990   /*
00991    //---------------------------------------------------
00992    //--
00993    // _CMPIObjectPath Encapsulated object
00994    //--
00995    //---------------------------------------------------
00996    */
00997 
00998 
01001    struct _CMPIObjectPath {
01002 
01005       /* Spec says this should be const, but it isn't in pegasus */
01006      void *hdl;
01007 
01010     /* Spec says this should be const, but it isn't in pegasus */
01011      CMPIObjectPathFT* ft;
01012    };
01013 
01014 
01015 
01016   /*
01017    //---------------------------------------------------
01018    //--
01019    // _CMPIObjectPath Function Table
01020    //--
01021    //---------------------------------------------------
01022    */
01023 
01024 
01028    struct _CMPIObjectPathFT {
01029 
01032      int ftVersion;
01033 
01039      CMPIStatus (*release)
01040               (CMPIObjectPath* op);
01041 
01048      CMPIObjectPath* (*clone)
01049               (const CMPIObjectPath* op,CMPIStatus* rc);
01050 
01056      CMPIStatus (*setNameSpace)
01057               (CMPIObjectPath* op,const char* ns);
01058 
01064      CMPIString* (*getNameSpace)
01065               (const CMPIObjectPath* op, CMPIStatus* rc);
01066 
01072      CMPIStatus (*setHostname)
01073               (CMPIObjectPath* op, const char* hn);
01074 
01080      CMPIString* (*getHostname)
01081               (const CMPIObjectPath* op,CMPIStatus* rc);
01082 
01088      CMPIStatus (*setClassName)
01089               (CMPIObjectPath* op, const char* cn);
01090 
01096      CMPIString* (*getClassName)
01097               (const CMPIObjectPath* op,CMPIStatus* rc);
01098 
01106      CMPIStatus (*addKey)
01107               (CMPIObjectPath* op,const char* name,
01108                const CMPIValue* value, const CMPIType type);
01109 
01116      CMPIData (*getKey)
01117               (const CMPIObjectPath* op, const char* name, CMPIStatus* rc);
01118 
01126      CMPIData (*getKeyAt)
01127               (const CMPIObjectPath* op,unsigned int index, CMPIString** name,
01128           CMPIStatus* rc);
01129 
01135      unsigned int (*getKeyCount)
01136               (const CMPIObjectPath* op, CMPIStatus* rc);
01137 
01143      CMPIStatus (*setNameSpaceFromObjectPath)
01144               (CMPIObjectPath* op, const CMPIObjectPath* src);
01145 
01151      CMPIStatus (*setHostAndNameSpaceFromObjectPath)
01152               (CMPIObjectPath* op,
01153                const CMPIObjectPath* src);
01154 
01155 
01156 
01157      /* optional qualifier support */
01158 
01159 
01166      CMPIData (*getClassQualifier)
01167               (const CMPIObjectPath* op,
01168                const char *qName,
01169                CMPIStatus *rc);
01170 
01178      CMPIData (*getPropertyQualifier)
01179               (const CMPIObjectPath* op,
01180                const char *pName,
01181                const char *qName,
01182                CMPIStatus *rc);
01183 
01191      CMPIData (*getMethodQualifier)
01192               (const CMPIObjectPath* op,
01193                const char *methodName,
01194                const char *qName,
01195                CMPIStatus *rc);
01196 
01205      CMPIData (*getParameterQualifier)
01206               (const CMPIObjectPath* op,
01207                const char *mName,
01208                const char *pName,
01209                const char *qName,
01210                CMPIStatus *rc);
01211 
01212 #if defined(CMPI_VER_86)
01213 
01218      CMPIString *(*toString)
01219               (const CMPIObjectPath* op, CMPIStatus *rc);
01220 #endif
01221    };
01222 
01223 
01224 
01225 
01226   /*
01227    //---------------------------------------------------
01228    //--
01229    // _CMPISelectExp Encapsulated object
01230    //--
01231    //---------------------------------------------------
01232    */
01233 
01234 
01237    struct _CMPISelectExp {
01238 
01241       /* Spec says this should be const, but it isn't in pegasus */
01242      void *hdl;
01243 
01246     /* Spec says this should be const, but it isn't in pegasus */
01247      CMPISelectExpFT* ft;
01248    };
01249 
01250 
01251 
01252   /*
01253    //---------------------------------------------------
01254    //--
01255    // _CMPISelectExpFT Function Table
01256    //--
01257    //---------------------------------------------------
01258    */
01259 
01260 
01264    struct _CMPISelectExpFT {
01265 
01268      int ftVersion;
01269 
01275      CMPIStatus (*release)
01276               (CMPISelectExp* se);
01277 
01284      CMPISelectExp* (*clone)
01285               (const CMPISelectExp* se, CMPIStatus* rc);
01286 
01293      CMPIBoolean (*evaluate)
01294               (const CMPISelectExp* se, const CMPIInstance* inst, CMPIStatus* rc);
01295 
01301      CMPIString* (*getString)
01302               (const CMPISelectExp* se, CMPIStatus* rc);
01303 
01309      CMPISelectCond* (*getDOC)
01310               (const CMPISelectExp* se, CMPIStatus* rc);
01311 
01317      CMPISelectCond* (*getCOD)
01318               (const CMPISelectExp* se, CMPIStatus* rc);
01319 
01327 #if defined(CMPI_VER_87)
01328      CMPIBoolean (*evaluateUsingAccessor)
01329               (const CMPISelectExp* se,  CMPIAccessor *accessor, void *parm, CMPIStatus* rc);
01330 #endif
01331    };
01332 
01333 
01334 
01335 
01336   /*
01337    //---------------------------------------------------
01338    //--
01339    // _CMPISelectCond Encapsulated object
01340    //--
01341    //---------------------------------------------------
01342    */
01343 
01344 
01347    struct _CMPISelectCond {
01348 
01351      void *hdl;
01352 
01355      CMPISelectCondFT* ft;
01356    };
01357 
01358 
01359 
01360   /*
01361    //---------------------------------------------------
01362    //--
01363    // _CMPISelectCondFT Function Table
01364    //--
01365    //---------------------------------------------------
01366    */
01367 
01368 
01372    struct _CMPISelectCondFT {
01373 
01376      int ftVersion;
01377 
01383      CMPIStatus (*release)
01384              (CMPISelectCond* sc);
01385 
01392      CMPISelectCond* (*clone)
01393               (const CMPISelectCond* sc, CMPIStatus* rc);
01394 
01402      CMPICount (*getCountAndType)
01403               (const CMPISelectCond* sc, int* type, CMPIStatus* rc);
01404 
01411      CMPISubCond* (*getSubCondAt)
01412               (const CMPISelectCond* sc, unsigned int index, CMPIStatus* rc);
01413    };
01414 
01415 
01416 
01417 
01418   /*
01419    //---------------------------------------------------
01420    //--
01421    // _CMPISubCond Encapsulated object
01422    //--
01423    //---------------------------------------------------
01424    */
01425 
01426 
01429    struct _CMPISubCond {
01430 
01433      void *hdl;
01434 
01437      CMPISubCondFT* ft;
01438    };
01439 
01440 
01441 
01442   /*
01443    //---------------------------------------------------
01444    //--
01445    // _CMPISubCondFT Function Table
01446    //--
01447    //---------------------------------------------------
01448    */
01449 
01450 
01454    struct _CMPISubCondFT {
01455 
01458      int ftVersion;
01459 
01465      CMPIStatus (*release)
01466              (CMPISubCond* sc);
01467 
01474      CMPISubCond* (*clone)
01475               (const CMPISubCond* sc,CMPIStatus* rc);
01476 
01482      CMPICount (*getCount)
01483               (const CMPISubCond* sc, CMPIStatus* rc);
01484 
01491      CMPIPredicate* (*getPredicateAt)
01492               (const CMPISubCond* sc, unsigned int index, CMPIStatus* rc);
01493 
01500      CMPIPredicate* (*getPredicate)
01501               (const CMPISubCond* sc, const char* name, CMPIStatus* rc);
01502    };
01503 
01504 
01505 
01506 
01507   /*
01508    //---------------------------------------------------
01509    //--
01510    // _CMPIPredicate Encapsulated object
01511    //--
01512    //---------------------------------------------------
01513    */
01514 
01515 
01518   struct _CMPIPredicate {
01519 
01522      void *hdl;
01523 
01526      CMPIPredicateFT* ft;
01527    };
01528 
01529 
01530 
01531 
01532   /*
01533    //---------------------------------------------------
01534    //--
01535    // _CMPIPredicateFT Function Table
01536    //--
01537    //---------------------------------------------------
01538    */
01539 
01540 
01544    struct _CMPIPredicateFT {
01545 
01548      int ftVersion;
01549 
01555      CMPIStatus (*release)
01556              (CMPIPredicate* pr);
01557 
01564      CMPIPredicate* (*clone)
01565               (const CMPIPredicate* pr, CMPIStatus* rc);
01566 
01575      CMPIStatus (*getData)
01576               (const CMPIPredicate* pr, CMPIType* type,
01577                CMPIPredOp* op, CMPIString** lhs, CMPIString** rhs);
01578 
01587 #if defined(CMPI_VER_87) && !defined(CMPI_VER_100)
01588 // Deprecated in the CMPI spec.
01589      int (*evaluate)
01590         (CMPIPredicate* pr, CMPIValue* value,
01591                CMPIType type, CMPIStatus* rc);
01592 #endif
01593 
01594 #if defined(CMPI_VER_100)
01595      CMPIBoolean (*evaluateUsingAccessor)
01596        (const CMPIPredicate*,  CMPIAccessor *, void *, CMPIStatus *rc);
01597 #endif
01598    };
01599 
01600 
01601 
01602 
01603   /*
01604    //---------------------------------------------------
01605    //--
01606    // _CMPIArgs Encapsulated object
01607    //--
01608    //---------------------------------------------------
01609    */
01610 
01611 
01614    struct _CMPIArgs {
01615 
01618      void *hdl;
01619 
01622      CMPIArgsFT* ft;
01623    };
01624 
01625 
01626 
01627   /*
01628    //---------------------------------------------------
01629    //--
01630    // _CMPIArgsFT Function Table
01631    //--
01632    //---------------------------------------------------
01633    */
01634 
01635 
01639    struct _CMPIArgsFT{
01640 
01643      int ftVersion;
01644 
01650      CMPIStatus (*release)
01651               (CMPIArgs* as);
01652 
01659      CMPIArgs* (*clone)
01660               (const CMPIArgs* as, CMPIStatus* rc);
01661 
01669      CMPIStatus (*addArg)
01670               (CMPIArgs* as, const char* name ,const CMPIValue* value,
01671                const CMPIType type);
01672 
01679      CMPIData (*getArg)
01680               (const CMPIArgs* as, const char* name, CMPIStatus* rc);
01681 
01689      CMPIData (*getArgAt)
01690               (const CMPIArgs* as, unsigned int index, CMPIString** name,
01691           CMPIStatus* rc);
01692 
01698      unsigned int (*getArgCount)
01699               (const CMPIArgs* as, CMPIStatus* rc);
01700    };
01701 
01702 
01703 
01704 
01705   /*
01706    //---------------------------------------------------
01707    //--
01708    // _CMPIString Encapsulated object
01709    //--
01710    //---------------------------------------------------
01711    */
01712 
01713 
01716    struct _CMPIString {
01717 
01720       /* Spec says this should be const, but it isn't in pegasus */
01721      void *hdl;
01722 
01725     /* Spec says this should be const, but it isn't in pegasus */
01726      CMPIStringFT* ft;
01727    };
01728 
01729 
01730 
01731   /*
01732    //---------------------------------------------------
01733    //--
01734    // _CMPIStringFT Function Table
01735    //--
01736    //---------------------------------------------------
01737    */
01738 
01739 
01743    struct _CMPIStringFT {
01744 
01747      int ftVersion;
01748 
01754      CMPIStatus (*release)
01755              (CMPIString* st);
01756 
01763      CMPIString* (*clone)
01764              (const CMPIString* st, CMPIStatus* rc);
01765 
01771      char* (*getCharPtr)
01772              (const CMPIString* st, CMPIStatus* rc);
01773    };
01774 
01775 
01776 
01777 
01778   /*
01779    //---------------------------------------------------
01780    //--
01781    // _CMPIArray Encapsulated object
01782    //--
01783    //---------------------------------------------------
01784    */
01785 
01786 
01789    struct _CMPIArray {
01790 
01793       /* Spec says this should be const, but it isn't in pegasus */
01794      void *hdl;
01795 
01798     /* Spec says this should be const, but it isn't in pegasus */
01799      CMPIArrayFT* ft;
01800    };
01801 
01802 
01803 
01804   /*
01805    //---------------------------------------------------
01806    //--
01807    // _CMPIArrayFT Function Table
01808    //--
01809    //---------------------------------------------------
01810    */
01811 
01812 
01816    struct _CMPIArrayFT {
01817 
01820      int ftVersion;
01821 
01827      CMPIStatus (*release)
01828              (CMPIArray* ar);
01829 
01836      CMPIArray* (*clone)
01837              (const CMPIArray* ar, CMPIStatus* rc);
01838 
01844      CMPICount (*getSize)
01845              (const CMPIArray* ar, CMPIStatus* rc);
01846 
01852      CMPIType (*getSimpleType)
01853              (const CMPIArray* ar, CMPIStatus* rc);
01854 
01861      CMPIData (*getElementAt)
01862              (const CMPIArray* ar, CMPICount index, CMPIStatus* rc);
01863 
01871      CMPIStatus (*setElementAt)
01872              (CMPIArray* ar, CMPICount index, const CMPIValue* value, CMPIType type);
01873    };
01874 
01875 
01876 
01877 
01878 
01879   /*
01880    //---------------------------------------------------
01881    //--
01882    // _CMPIEnumeration Encapsulated object
01883    //--
01884    //---------------------------------------------------
01885    */
01886 
01887 
01890    struct _CMPIEnumeration {
01891 
01894       /* Spec says this should be const, but it isn't in pegasus */
01895      void *hdl;
01896 
01899     /* Spec says this should be const, but it isn't in pegasus */
01900      CMPIEnumerationFT* ft;
01901    };
01902 
01903 
01904 
01905   /*
01906    //---------------------------------------------------
01907    //--
01908    // _CMPIEnumerationFT Function Table
01909    //--
01910    //---------------------------------------------------
01911    */
01912 
01913 
01917    struct _CMPIEnumerationFT {
01918 
01921      int ftVersion;
01922 
01928      CMPIStatus (*release)
01929              (CMPIEnumeration* en);
01930 
01937      CMPIEnumeration* (*clone)
01938              (const CMPIEnumeration* en, CMPIStatus* rc);
01939 
01945      CMPIData (*getNext)
01946              (const CMPIEnumeration* en, CMPIStatus* rc);
01947 
01953      CMPIBoolean (*hasNext)
01954              (const CMPIEnumeration* en, CMPIStatus* rc);
01955 
01961      CMPIArray* (*toArray)
01962              (const CMPIEnumeration* en, CMPIStatus* rc);
01963   };
01964 
01965 
01966 
01967 
01968 
01969   /*
01970    //---------------------------------------------------
01971    //--
01972    // _CMPIDateTime Encapsulated object
01973    //--
01974    //---------------------------------------------------
01975    */
01976 
01977 
01980   struct _CMPIDateTime {
01981 
01984      /* Spec says this should be const, but it isn't in pegasus */
01985      void *hdl;
01986 
01989     /* Spec says this should be const, but it isn't in pegasus */
01990      CMPIDateTimeFT *ft;
01991    };
01992 
01993 
01994 
01995   /*
01996    //---------------------------------------------------
01997    //--
01998    // _CMPIDateTimeFT Function Table
01999    //--
02000    //---------------------------------------------------
02001    */
02002 
02003 
02007    struct _CMPIDateTimeFT {
02008 
02011      int ftVersion;
02012 
02018      CMPIStatus (*release)
02019              (CMPIDateTime* dt);
02020 
02027      CMPIDateTime* (*clone)
02028              (const CMPIDateTime* dt, CMPIStatus* rc);
02029 
02036      CMPIUint64 (*getBinaryFormat)
02037              (const CMPIDateTime* dt, CMPIStatus* rc);
02038 
02044      CMPIString* (*getStringFormat)
02045              (const CMPIDateTime* dt, CMPIStatus* rc);
02046 
02052      CMPIBoolean (*isInterval)
02053               (const CMPIDateTime* dt, CMPIStatus* rc);
02054   };
02055 
02056 
02057 
02058 
02059 
02060 
02061   /*
02062    //---------------------------------------------------
02063    //--
02064    // _CMPIInstanceMI Instance Provider object
02065    //--
02066    //---------------------------------------------------
02067    */
02068 
02069 
02072    typedef struct _CMPIInstanceMIFT CMPIInstanceMIFT;
02073    typedef struct _CMPIInstanceMI {
02074 
02077       void *hdl;
02078 
02081       CMPIInstanceMIFT *ft;
02082    } CMPIInstanceMI;
02083 
02084 
02085 
02086   /*
02087    //---------------------------------------------------
02088    //--
02089    // _CMPIInstanceMIFT Function Table
02090    //--
02091    //---------------------------------------------------
02092    */
02093 
02094 
02099    struct _CMPIInstanceMIFT {
02100 
02103      int ftVersion;
02104 
02107      int miVersion;
02108 
02111      char *miName;            
02112 
02123      CMPIStatus (*cleanup)
02124             (CMPIInstanceMI* mi, const CMPIContext* ctx, CMPIBoolean terminating);
02125 
02133      CMPIStatus (*enumInstanceNames)
02134              (CMPIInstanceMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
02135               const CMPIObjectPath* op);
02136 
02147      CMPIStatus (*enumInstances)
02148              (CMPIInstanceMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
02149               const CMPIObjectPath* op, const char** properties);
02150 
02161      CMPIStatus (*getInstance)
02162              (CMPIInstanceMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
02163               const CMPIObjectPath* op, const char** properties);
02164 
02173      CMPIStatus (*createInstance)
02174              (CMPIInstanceMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
02175               const CMPIObjectPath* op, const CMPIInstance* inst);
02176 
02189      CMPIStatus (*modifyInstance)
02190              (CMPIInstanceMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
02191               const CMPIObjectPath* op, const CMPIInstance* inst, const char** properties);
02192 
02200      CMPIStatus (*deleteInstance)
02201              (CMPIInstanceMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
02202               const CMPIObjectPath* op);
02203 
02214      CMPIStatus (*execQuery)
02215              (CMPIInstanceMI*,const CMPIContext*,const CMPIResult*,
02216               const CMPIObjectPath*,const char*,const char*);
02217    };
02218 
02219 
02220 
02221 
02222 
02223 
02224   /*
02225    //---------------------------------------------------
02226    //--
02227    // _CMPIAssociationMI Association Provider object
02228    //--
02229    //---------------------------------------------------
02230    */
02231 
02232 
02235    typedef struct _CMPIAssociationMIFT CMPIAssociationMIFT;
02236    typedef struct _CMPIAssociationMI {
02237 
02240       void *hdl;
02241 
02244       CMPIAssociationMIFT *ft;
02245    } CMPIAssociationMI;
02246 
02247 
02248   /*
02249    //---------------------------------------------------
02250    //--
02251    // _CMPIAssociationMIFT Function Table
02252    //--
02253    //---------------------------------------------------
02254    */
02255 
02256 
02261    struct _CMPIAssociationMIFT {
02262 
02265      int ftVersion;
02266 
02269      int miVersion;
02270 
02273      char *miName;
02274 
02285      CMPIStatus (*cleanup)
02286              (CMPIAssociationMI* mi, const CMPIContext* ctx, CMPIBoolean terminating);
02287 
02318      CMPIStatus (*associators)
02319              (CMPIAssociationMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
02320               const CMPIObjectPath* op, const char* asscClass, const char* resultClass,
02321               const char* role, const char* resultRole, const char** properties);
02322 
02350      CMPIStatus (*associatorNames)
02351              (CMPIAssociationMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
02352               const CMPIObjectPath* op, const char* assocClass, const char* resultClass,
02353               const char* role, const char* resultRole);
02354 
02376      CMPIStatus (*references)
02377              (CMPIAssociationMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
02378               const CMPIObjectPath* op, const char* resultClass, const char* role ,
02379          const char** properties);
02380 
02399      CMPIStatus (*referenceNames)
02400              (CMPIAssociationMI*, const CMPIContext*, const CMPIResult*,
02401               const CMPIObjectPath*, const char*, const char*);
02402    };
02403 
02404 
02405 
02406 
02407 
02408 
02409   /*
02410    //---------------------------------------------------
02411    //--
02412    // _CMPIMethodMI Method Provider object
02413    //--
02414    //---------------------------------------------------
02415    */
02416 
02417 
02420    typedef struct _CMPIMethodMIFT CMPIMethodMIFT;
02421    typedef struct _CMPIMethodMI {
02422 
02425       void *hdl;
02426 
02429       CMPIMethodMIFT *ft;
02430    } CMPIMethodMI;
02431 
02432 
02433   /*
02434    //---------------------------------------------------
02435    //--
02436    // _CMPIMethodMIFT Function Table
02437    //--
02438    //---------------------------------------------------
02439    */
02440 
02441 
02446    struct _CMPIMethodMIFT {
02447 
02450      int ftVersion;
02451 
02454      int miVersion;
02455 
02458      char *miName;
02459 
02470      CMPIStatus (*cleanup)
02471              (CMPIMethodMI* mi, const CMPIContext* ctx, CMPIBoolean terminating);
02472 
02484      CMPIStatus (*invokeMethod)
02485              (CMPIMethodMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
02486               const CMPIObjectPath* op, const char* method, const CMPIArgs* in, CMPIArgs* out);
02487    };
02488 
02489 
02490 
02491 
02492 
02493   /*
02494    //---------------------------------------------------
02495    //--
02496    // _CMPIPropertyMI Property Provider object
02497    //--
02498    //---------------------------------------------------
02499    */
02500 
02501 
02504    typedef struct _CMPIPropertyMIFT CMPIPropertyMIFT;
02505    typedef struct _CMPIPropertyMI {
02506 
02509       void *hdl;
02510 
02513       CMPIPropertyMIFT *ft;
02514    } CMPIPropertyMI;
02515 
02516 
02517 
02518   /*
02519    //---------------------------------------------------
02520    //--
02521    // _CMPIPropertyMIFT Function Table
02522    //--
02523    //---------------------------------------------------
02524    */
02525 
02526 
02531    struct _CMPIPropertyMIFT {
02532 
02535      int ftVersion;
02536 
02539      int miVersion;
02540 
02543      char *miName;
02544 
02550      CMPIStatus (*cleanup)
02551              (CMPIPropertyMI* mi, const CMPIContext* ctx, CMPIBoolean terminating);
02552 
02562      CMPIStatus (*setProperty)
02563              (CMPIPropertyMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
02564               const CMPIObjectPath* op, const char* name, const CMPIData data);
02565 
02574      CMPIStatus (*getProperty)
02575              (CMPIPropertyMI*,const CMPIContext*,const CMPIResult*,
02576               const CMPIObjectPath*,const char*);
02577    };
02578 
02579 
02580 
02581 
02582 
02583   /*
02584    //---------------------------------------------------
02585    //--
02586    // _CMPIIndicationMI Indication Provider object
02587    //--
02588    //---------------------------------------------------
02589    */
02590 
02591 
02594    typedef struct _CMPIIndicationMIFT CMPIIndicationMIFT;
02595    typedef struct _CMPIIndicationMI {
02596 
02599       void *hdl;
02600 
02603       CMPIIndicationMIFT *ft;
02604    } CMPIIndicationMI;
02605 
02606 
02607 
02608   /*
02609    //---------------------------------------------------
02610    //--
02611    // _CMPIIndicationMIFT Function Table
02612    //--
02613    //---------------------------------------------------
02614    */
02615 
02616 
02621    struct _CMPIIndicationMIFT {
02622 
02625      int ftVersion;
02626 
02629      int miVersion;
02630 
02633      char *miName;
02634 
02645      CMPIStatus (*cleanup)
02646              (CMPIIndicationMI* mi, const CMPIContext* ctx, CMPIBoolean terminating);
02647      CMPIStatus (*authorizeFilter)
02648              (CMPIIndicationMI* mi, const CMPIContext* ctx, // CMPIResult* rslt,
02649               const CMPISelectExp* se, const char* ns, const CMPIObjectPath* op, const char* user);
02650      CMPIStatus (*mustPoll)
02651              (CMPIIndicationMI* mi, const CMPIContext* ctx, // CMPIResult* rslt,
02652               const CMPISelectExp* se, const char* ns, const CMPIObjectPath* op);
02653      CMPIStatus (*activateFilter)
02654             (CMPIIndicationMI* mi, const CMPIContext* ctx, // CMPIResult* rslt,
02655              const CMPISelectExp* se, const char* ns, const CMPIObjectPath* op, CMPIBoolean first);
02656      CMPIStatus (*deActivateFilter)
02657              (CMPIIndicationMI* mi, const CMPIContext* ctx, // CMPIResult* rslt,
02658               const CMPISelectExp* se, const char* ns, const CMPIObjectPath* op, CMPIBoolean last);
02659     CMPIStatus (*enableIndications)
02660             (CMPIIndicationMI* mi, const CMPIContext* ctx); 
02661     CMPIStatus (*disableIndications)
02662             (CMPIIndicationMI* mi, const CMPIContext* ctx); 
02663    };
02664 
02665 
02666 #include <cmpimacs.h>
02667 
02668 #ifdef __cplusplus
02669  };
02670 #endif
02671 
02672 #endif /* _CMPIFT_H_ */

Generated on Thu Feb 9 08:47:48 2006 for openwbem by  doxygen 1.4.6