cmpift.h

Go to the documentation of this file.

/*
 *
 * cmpift.h
 *
 * (C) Copyright IBM Corp. 2003
 *
 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE COMMON PUBLIC LICENSE
 * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
 * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
 *
 * You can obtain a current copy of the Common Public License from
 * http://oss.software.ibm.com/developerworks/opensource/license-cpl.html
 *
 * Author:        Adrian Schuur <schuur@de.ibm.com>
 * Contributors:
 *
 * Description: CMPI Encapsulated types Function Tables
 *
 */

#ifndef _CMPIFT_H_
#define _CMPIFT_H_
#include "OW_config.h"

#include <cmpidt.h>

#ifdef __cplusplus
extern "C" {
#endif



   /*
   //---------------------------------------------------
   //--
   // _CMPIBrokerEncFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIBrokerEncFT {

     int ftVersion;

     CMPIInstance* (*newInstance)
                 (const CMPIBroker* mb,
              const CMPIObjectPath* op, CMPIStatus* rc);

     CMPIObjectPath* (*newObjectPath)
                 (const CMPIBroker* mb, 
              const char* ns, const char* cn, CMPIStatus* rc);

     CMPIArgs* (*newArgs)
                 (const CMPIBroker* mb, CMPIStatus* rc);

     CMPIString* (*newString)
                 (const CMPIBroker* mb, const char* data, CMPIStatus* rc);

     CMPIArray* (*newArray)
                 (const CMPIBroker* mb, CMPICount max, CMPIType type, CMPIStatus* rc);

     CMPIDateTime* (*newDateTime)
                 (const CMPIBroker* mb, CMPIStatus* rc);

     CMPIDateTime* (*newDateTimeFromBinary)
                 (const CMPIBroker* mb, CMPIUint64 binTime, CMPIBoolean interval,
        CMPIStatus* rc);

     CMPIDateTime* (*newDateTimeFromChars)
                 (const CMPIBroker* mb, const char* utcTime, CMPIStatus* rc);

     CMPISelectExp* (*newSelectExp)
                 (const CMPIBroker* mb, const char* query, const char* lang,
                  CMPIArray** projection, CMPIStatus* st);

     CMPIBoolean (*classPathIsA)
                 (const CMPIBroker* mb, const CMPIObjectPath* op, 
              const char* type, CMPIStatus* rc);

     CMPIString* (*toString)
                 (const CMPIBroker* mb, const void* object, CMPIStatus* rc);

     CMPIBoolean (*isOfType)
                 (const CMPIBroker* mb, const void* object, const char* type, CMPIStatus* rc);

     CMPIString* (*getType)
                 (const CMPIBroker* mb, const void* object, CMPIStatus* rc);

     #if defined(CMPI_VER_85)
     CMPIString* (*getMessage)
                 (const CMPIBroker* mb, const char *msgId, const char *defMsg, CMPIStatus* rc, unsigned int count, ...);
     #endif /* CMPI_VER_85 */

    #if defined(CMPI_VER_90)
    CMPIStatus (*logMessage)
      (const CMPIBroker*,int,const char*,const char*,
       const CMPIString*);
    CMPIStatus (*trace)
      (const CMPIBroker*,int,const char*,const char*,
       const CMPIString*);
    #endif /* CMPI_VER_90 */ 
   };



   /*
   //---------------------------------------------------
   //--
   // _CMPIBrokerFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIBrokerFT {

     unsigned long brokerClassification;
     int brokerVersion;
     char *brokerName;

     CMPIContext* (*prepareAttachThread)
                (const CMPIBroker* mb, const CMPIContext* ctx);

     CMPIStatus (*attachThread)
                (const CMPIBroker*,const CMPIContext*);

     CMPIStatus (*detachThread)
                (const CMPIBroker* mb, const CMPIContext* ctx);

     /* class 0 services */

     CMPIStatus (*deliverIndication)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const char* ns, const CMPIInstance* ind);
     /* class 1 services */

     CMPIEnumeration* (*enumInstanceNames)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const CMPIObjectPath* op, CMPIStatus* rc);

     CMPIInstance* (*getInstance)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const CMPIObjectPath* op, const char** properties, CMPIStatus* rc);

     /* class 2 services */

     CMPIObjectPath* (*createInstance)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const CMPIObjectPath* op, const CMPIInstance* inst, CMPIStatus* rc);

     CMPIStatus (*modifyInstance)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const CMPIObjectPath* op,  const CMPIInstance* inst, const char ** properties);

     CMPIStatus (*deleteInstance)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const CMPIObjectPath* op);

     CMPIEnumeration* (*execQuery)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const CMPIObjectPath* op, const char* query, const char* lang, CMPIStatus* rc);

     CMPIEnumeration* (*enumInstances)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const CMPIObjectPath* op, const char** properties, CMPIStatus* rc);

     CMPIEnumeration* (*associators)
                (const CMPIBroker* mb,const CMPIContext* ctx,
                 const CMPIObjectPath* op, const char* assocClass, const char* resultClass,
       const char* role, const char* resultRole, const char** properties, CMPIStatus* rc);

     CMPIEnumeration* (*associatorNames)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const CMPIObjectPath* op, const char* assocClass, const char* resultClass,
       const char* role, const char* resultRole, CMPIStatus* rc);

     CMPIEnumeration* (*references)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const CMPIObjectPath* op, const char* resultClass ,const char* role ,
       const char** properties, CMPIStatus* rc);

     CMPIEnumeration* (*referenceNames)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const CMPIObjectPath* op, const char* resultClass, const char* role,
                 CMPIStatus* rc);

     CMPIData (*invokeMethod)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const CMPIObjectPath* op,const char* method,
       const CMPIArgs* in, CMPIArgs* out, CMPIStatus* rc);

     CMPIStatus (*setProperty)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const CMPIObjectPath* op, const char* name , const CMPIValue* value,
                 CMPIType type);

     CMPIData (*getProperty)
                (const CMPIBroker* mb, const CMPIContext* ctx,
                 const CMPIObjectPath*,const char*,CMPIStatus*);
   };



   /*
   //---------------------------------------------------
   //--
   // _CMPIBroker Encapsulated object
   //--
   //---------------------------------------------------
   */


   struct _CMPIBroker {

     void *hdl;

     CMPIBrokerFT *bft;

     CMPIBrokerEncFT *eft;

#if defined(CMPI_VER_90)
     CMPIBrokerExtFT *xft;
#endif
   };



    //---------------------------------------------------
   //--
   // _CMPIBrokerExtFT Function Table
   //--
   //---------------------------------------------------

#if defined(CMPI_VER_90)

#include "cmpios.h"

   struct timespec;

   struct _CMPIBrokerExtFT {
     int ftVersion;

     char *(*resolveFileName)
         (const char *filename);



     CMPI_THREAD_TYPE (*newThread)
        (CMPI_THREAD_RETURN (CMPI_THREAD_CDECL *start)(void *), void *parm, int detached);

     int (*joinThread)
        (CMPI_THREAD_TYPE thread, CMPI_THREAD_RETURN *retval );

     int (*exitThread)
        (CMPI_THREAD_RETURN return_code);

     int (*cancelThread)
        (CMPI_THREAD_TYPE thread);

     int (*threadSleep)
        (CMPIUint32 msec);

     int (*threadOnce)
        (int *once, void (*init)(void));


     int (*createThreadKey)
        (CMPI_THREAD_KEY_TYPE *key, void (*cleanup)(void*));

     int (*destroyThreadKey)
        (CMPI_THREAD_KEY_TYPE key);

     void *(*getThreadSpecific)
        (CMPI_THREAD_KEY_TYPE key);

     int (*setThreadSpecific)
        (CMPI_THREAD_KEY_TYPE key, void * value);



     CMPI_MUTEX_TYPE (*newMutex)
        (int opt);

     void (*destroyMutex)
        (CMPI_MUTEX_TYPE);

     void (*lockMutex)
        (CMPI_MUTEX_TYPE);

     void (*unlockMutex)
        (CMPI_MUTEX_TYPE);



     CMPI_COND_TYPE (*newCondition)
        (int opt);

     void (*destroyCondition)
        (CMPI_COND_TYPE);

     int (*condWait)
        (CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex);

     int (*timedCondWait)
        (CMPI_COND_TYPE cond, CMPI_MUTEX_TYPE mutex, struct timespec *wait);

     int (*signalCondition)
        (CMPI_COND_TYPE cond);
  };

#endif


   /*
   //---------------------------------------------------
   //--
   // _CMPIContext Function Table
   //--
   //---------------------------------------------------
   */


  struct _CMPIContextFT {

     int ftVersion;

     CMPIStatus (*release)
              (CMPIContext* ctx);

     CMPIContext* (*clone)
              (const CMPIContext* ctx, CMPIStatus* rc);

     CMPIData (*getEntry)
              (const CMPIContext* ctx, const char* name, CMPIStatus* rc);

     CMPIData (*getEntryAt)
              (const CMPIContext* ctx, unsigned int index, CMPIString** name,
          CMPIStatus* rc);

     unsigned int (*getEntryCount)
              (const CMPIContext* ctx, CMPIStatus* rc);

     CMPIStatus (*addEntry)
              (const CMPIContext* ctx, const char* name, const CMPIValue* value, const CMPIType type);
  };




  /*
   //---------------------------------------------------
   //--
   // _CMPIContextr Encapsulated object
   //--
   //---------------------------------------------------
   */


  struct _CMPIContext {

     /* spec says this should be const, but pegasus isn't */ 
    void *hdl;

   /* spec says this should be const, but pegasus isn't */ 
    CMPIContextFT *ft;
  };




  /*
   //---------------------------------------------------
   //--
   // _CMPIResult Encapsulated object
   //--
   //---------------------------------------------------
   */


  struct _CMPIResult {

     /* spec says this should be const, but pegasus isn't */ 
     void *hdl;

    /* spec says this should be const, but pegasus isn't */ 
     CMPIResultFT *ft;
  };


  /*
   //---------------------------------------------------
   //--
   // _CMPIResult Function Table
   //--
   //---------------------------------------------------
   */


  struct _CMPIResultFT {

     int ftVersion;

     CMPIStatus (*release)
              (CMPIResult* rslt);

     CMPIResult* (*clone)
              (const CMPIResult* rslt,CMPIStatus* rc);

     CMPIStatus (*returnData)
              (const CMPIResult* rslt,const CMPIValue* value,const CMPIType type);

     CMPIStatus (*returnInstance)
              (const CMPIResult* rslt,const CMPIInstance* inst);

     CMPIStatus (*returnObjectPath)
              (const CMPIResult* rslt, const CMPIObjectPath* ref);

     CMPIStatus (*returnDone)
              (const CMPIResult* rslt);
  };




  /*
   //---------------------------------------------------
   //--
   // _CMPIInstance Encapsulated object
   //--
   //---------------------------------------------------
   */


   struct _CMPIInstance {

      /* Spec says this should be const, but it isn't in pegasus */
     void *hdl;

    /* Spec says this should be const, but it isn't in pegasus */
     CMPIInstanceFT* ft;
   };



  /*
   //---------------------------------------------------
   //--
   // _CMPIInstance Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIInstanceFT {

     int ftVersion;

     CMPIStatus (*release)
              (CMPIInstance* inst);

     CMPIInstance* (*clone)
              (const CMPIInstance* inst, CMPIStatus* rc);

     CMPIData (*getProperty)
              (const CMPIInstance* inst, const char* name, CMPIStatus* rc);

     CMPIData (*getPropertyAt)
              (const CMPIInstance* inst, unsigned int index, CMPIString** name,
          CMPIStatus* rc);

     unsigned int (*getPropertyCount)
              (const CMPIInstance* inst, CMPIStatus* rc);

     CMPIStatus (*setProperty)
              (const CMPIInstance* inst, const char* name,
               const CMPIValue* value, CMPIType type);

     CMPIObjectPath* (*getObjectPath)
              (const CMPIInstance* inst, CMPIStatus* rc);

     CMPIStatus (*setPropertyFilter)
              (CMPIInstance* inst, const char **propertyList, const char **keys);

#ifdef CMPI_VER_100
     CMPIStatus (*setObjectPath)
         (CMPIInstance*, const CMPIObjectPath*);
#endif
   };




  /*
   //---------------------------------------------------
   //--
   // _CMPIObjectPath Encapsulated object
   //--
   //---------------------------------------------------
   */


   struct _CMPIObjectPath {

      /* Spec says this should be const, but it isn't in pegasus */
     void *hdl;

    /* Spec says this should be const, but it isn't in pegasus */
     CMPIObjectPathFT* ft;
   };



  /*
   //---------------------------------------------------
   //--
   // _CMPIObjectPath Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIObjectPathFT {

     int ftVersion;

     CMPIStatus (*release)
              (CMPIObjectPath* op);

     CMPIObjectPath* (*clone)
              (const CMPIObjectPath* op,CMPIStatus* rc);

     CMPIStatus (*setNameSpace)
              (CMPIObjectPath* op,const char* ns);

     CMPIString* (*getNameSpace)
              (const CMPIObjectPath* op, CMPIStatus* rc);

     CMPIStatus (*setHostname)
              (CMPIObjectPath* op, const char* hn);

     CMPIString* (*getHostname)
              (const CMPIObjectPath* op,CMPIStatus* rc);

     CMPIStatus (*setClassName)
              (CMPIObjectPath* op, const char* cn);

     CMPIString* (*getClassName)
              (const CMPIObjectPath* op,CMPIStatus* rc);

     CMPIStatus (*addKey)
              (CMPIObjectPath* op,const char* name,
               const CMPIValue* value, const CMPIType type);

     CMPIData (*getKey)
              (const CMPIObjectPath* op, const char* name, CMPIStatus* rc);

     CMPIData (*getKeyAt)
              (const CMPIObjectPath* op,unsigned int index, CMPIString** name,
          CMPIStatus* rc);

     unsigned int (*getKeyCount)
              (const CMPIObjectPath* op, CMPIStatus* rc);

     CMPIStatus (*setNameSpaceFromObjectPath)
              (CMPIObjectPath* op, const CMPIObjectPath* src);

     CMPIStatus (*setHostAndNameSpaceFromObjectPath)
              (CMPIObjectPath* op,
               const CMPIObjectPath* src);



     /* optional qualifier support */


     CMPIData (*getClassQualifier)
              (const CMPIObjectPath* op,
               const char *qName,
               CMPIStatus *rc);

     CMPIData (*getPropertyQualifier)
              (const CMPIObjectPath* op,
               const char *pName,
               const char *qName,
               CMPIStatus *rc);

     CMPIData (*getMethodQualifier)
              (const CMPIObjectPath* op,
               const char *methodName,
               const char *qName,
               CMPIStatus *rc);

     CMPIData (*getParameterQualifier)
              (const CMPIObjectPath* op,
               const char *mName,
               const char *pName,
               const char *qName,
               CMPIStatus *rc);

#if defined(CMPI_VER_86)

     CMPIString *(*toString)
              (const CMPIObjectPath* op, CMPIStatus *rc);
#endif
   };




  /*
   //---------------------------------------------------
   //--
   // _CMPISelectExp Encapsulated object
   //--
   //---------------------------------------------------
   */


   struct _CMPISelectExp {

      /* Spec says this should be const, but it isn't in pegasus */
     void *hdl;

    /* Spec says this should be const, but it isn't in pegasus */
     CMPISelectExpFT* ft;
   };



  /*
   //---------------------------------------------------
   //--
   // _CMPISelectExpFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPISelectExpFT {

     int ftVersion;

     CMPIStatus (*release)
              (CMPISelectExp* se);

     CMPISelectExp* (*clone)
              (const CMPISelectExp* se, CMPIStatus* rc);

     CMPIBoolean (*evaluate)
              (const CMPISelectExp* se, const CMPIInstance* inst, CMPIStatus* rc);

     CMPIString* (*getString)
              (const CMPISelectExp* se, CMPIStatus* rc);

     CMPISelectCond* (*getDOC)
              (const CMPISelectExp* se, CMPIStatus* rc);

     CMPISelectCond* (*getCOD)
              (const CMPISelectExp* se, CMPIStatus* rc);

#if defined(CMPI_VER_87)
     CMPIBoolean (*evaluateUsingAccessor)
              (const CMPISelectExp* se,  CMPIAccessor *accessor, void *parm, CMPIStatus* rc);
#endif
   };




  /*
   //---------------------------------------------------
   //--
   // _CMPISelectCond Encapsulated object
   //--
   //---------------------------------------------------
   */


   struct _CMPISelectCond {

     void *hdl;

     CMPISelectCondFT* ft;
   };



  /*
   //---------------------------------------------------
   //--
   // _CMPISelectCondFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPISelectCondFT {

     int ftVersion;

     CMPIStatus (*release)
             (CMPISelectCond* sc);

     CMPISelectCond* (*clone)
              (const CMPISelectCond* sc, CMPIStatus* rc);

     CMPICount (*getCountAndType)
              (const CMPISelectCond* sc, int* type, CMPIStatus* rc);

     CMPISubCond* (*getSubCondAt)
              (const CMPISelectCond* sc, unsigned int index, CMPIStatus* rc);
   };




  /*
   //---------------------------------------------------
   //--
   // _CMPISubCond Encapsulated object
   //--
   //---------------------------------------------------
   */


   struct _CMPISubCond {

     void *hdl;

     CMPISubCondFT* ft;
   };



  /*
   //---------------------------------------------------
   //--
   // _CMPISubCondFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPISubCondFT {

     int ftVersion;

     CMPIStatus (*release)
             (CMPISubCond* sc);

     CMPISubCond* (*clone)
              (const CMPISubCond* sc,CMPIStatus* rc);

     CMPICount (*getCount)
              (const CMPISubCond* sc, CMPIStatus* rc);

     CMPIPredicate* (*getPredicateAt)
              (const CMPISubCond* sc, unsigned int index, CMPIStatus* rc);

     CMPIPredicate* (*getPredicate)
              (const CMPISubCond* sc, const char* name, CMPIStatus* rc);
   };




  /*
   //---------------------------------------------------
   //--
   // _CMPIPredicate Encapsulated object
   //--
   //---------------------------------------------------
   */


  struct _CMPIPredicate {

     void *hdl;

     CMPIPredicateFT* ft;
   };




  /*
   //---------------------------------------------------
   //--
   // _CMPIPredicateFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIPredicateFT {

     int ftVersion;

     CMPIStatus (*release)
             (CMPIPredicate* pr);

     CMPIPredicate* (*clone)
              (const CMPIPredicate* pr, CMPIStatus* rc);

     CMPIStatus (*getData)
              (const CMPIPredicate* pr, CMPIType* type,
               CMPIPredOp* op, CMPIString** lhs, CMPIString** rhs);

#if defined(CMPI_VER_87) && !defined(CMPI_VER_100)
// Deprecated in the CMPI spec.
     int (*evaluate)
        (CMPIPredicate* pr, CMPIValue* value,
               CMPIType type, CMPIStatus* rc);
#endif

#if defined(CMPI_VER_100)
     CMPIBoolean (*evaluateUsingAccessor)
       (const CMPIPredicate*,  CMPIAccessor *, void *, CMPIStatus *rc);
#endif
   };




  /*
   //---------------------------------------------------
   //--
   // _CMPIArgs Encapsulated object
   //--
   //---------------------------------------------------
   */


   struct _CMPIArgs {

     void *hdl;

     CMPIArgsFT* ft;
   };



  /*
   //---------------------------------------------------
   //--
   // _CMPIArgsFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIArgsFT{

     int ftVersion;

     CMPIStatus (*release)
              (CMPIArgs* as);

     CMPIArgs* (*clone)
              (const CMPIArgs* as, CMPIStatus* rc);

     CMPIStatus (*addArg)
              (CMPIArgs* as, const char* name ,const CMPIValue* value,
               const CMPIType type);

     CMPIData (*getArg)
              (const CMPIArgs* as, const char* name, CMPIStatus* rc);

     CMPIData (*getArgAt)
              (const CMPIArgs* as, unsigned int index, CMPIString** name,
          CMPIStatus* rc);

     unsigned int (*getArgCount)
              (const CMPIArgs* as, CMPIStatus* rc);
   };




  /*
   //---------------------------------------------------
   //--
   // _CMPIString Encapsulated object
   //--
   //---------------------------------------------------
   */


   struct _CMPIString {

      /* Spec says this should be const, but it isn't in pegasus */
     void *hdl;

    /* Spec says this should be const, but it isn't in pegasus */
     CMPIStringFT* ft;
   };



  /*
   //---------------------------------------------------
   //--
   // _CMPIStringFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIStringFT {

     int ftVersion;

     CMPIStatus (*release)
             (CMPIString* st);

     CMPIString* (*clone)
             (const CMPIString* st, CMPIStatus* rc);

     char* (*getCharPtr)
             (const CMPIString* st, CMPIStatus* rc);
   };




  /*
   //---------------------------------------------------
   //--
   // _CMPIArray Encapsulated object
   //--
   //---------------------------------------------------
   */


   struct _CMPIArray {

      /* Spec says this should be const, but it isn't in pegasus */
     void *hdl;

    /* Spec says this should be const, but it isn't in pegasus */
     CMPIArrayFT* ft;
   };



  /*
   //---------------------------------------------------
   //--
   // _CMPIArrayFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIArrayFT {

     int ftVersion;

     CMPIStatus (*release)
             (CMPIArray* ar);

     CMPIArray* (*clone)
             (const CMPIArray* ar, CMPIStatus* rc);

     CMPICount (*getSize)
             (const CMPIArray* ar, CMPIStatus* rc);

     CMPIType (*getSimpleType)
             (const CMPIArray* ar, CMPIStatus* rc);

     CMPIData (*getElementAt)
             (const CMPIArray* ar, CMPICount index, CMPIStatus* rc);

     CMPIStatus (*setElementAt)
             (CMPIArray* ar, CMPICount index, const CMPIValue* value, CMPIType type);
   };





  /*
   //---------------------------------------------------
   //--
   // _CMPIEnumeration Encapsulated object
   //--
   //---------------------------------------------------
   */


   struct _CMPIEnumeration {

      /* Spec says this should be const, but it isn't in pegasus */
     void *hdl;

    /* Spec says this should be const, but it isn't in pegasus */
     CMPIEnumerationFT* ft;
   };



  /*
   //---------------------------------------------------
   //--
   // _CMPIEnumerationFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIEnumerationFT {

     int ftVersion;

     CMPIStatus (*release)
             (CMPIEnumeration* en);

     CMPIEnumeration* (*clone)
             (const CMPIEnumeration* en, CMPIStatus* rc);

     CMPIData (*getNext)
             (const CMPIEnumeration* en, CMPIStatus* rc);

     CMPIBoolean (*hasNext)
             (const CMPIEnumeration* en, CMPIStatus* rc);

     CMPIArray* (*toArray)
             (const CMPIEnumeration* en, CMPIStatus* rc);
  };





  /*
   //---------------------------------------------------
   //--
   // _CMPIDateTime Encapsulated object
   //--
   //---------------------------------------------------
   */


  struct _CMPIDateTime {

     /* Spec says this should be const, but it isn't in pegasus */
     void *hdl;

    /* Spec says this should be const, but it isn't in pegasus */
     CMPIDateTimeFT *ft;
   };



  /*
   //---------------------------------------------------
   //--
   // _CMPIDateTimeFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIDateTimeFT {

     int ftVersion;

     CMPIStatus (*release)
             (CMPIDateTime* dt);

     CMPIDateTime* (*clone)
             (const CMPIDateTime* dt, CMPIStatus* rc);

     CMPIUint64 (*getBinaryFormat)
             (const CMPIDateTime* dt, CMPIStatus* rc);

     CMPIString* (*getStringFormat)
             (const CMPIDateTime* dt, CMPIStatus* rc);

     CMPIBoolean (*isInterval)
              (const CMPIDateTime* dt, CMPIStatus* rc);
  };






  /*
   //---------------------------------------------------
   //--
   // _CMPIInstanceMI Instance Provider object
   //--
   //---------------------------------------------------
   */


   typedef struct _CMPIInstanceMIFT CMPIInstanceMIFT;
   typedef struct _CMPIInstanceMI {

      void *hdl;

      CMPIInstanceMIFT *ft;
   } CMPIInstanceMI;



  /*
   //---------------------------------------------------
   //--
   // _CMPIInstanceMIFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIInstanceMIFT {

     int ftVersion;

     int miVersion;

     char *miName;            

     CMPIStatus (*cleanup)
            (CMPIInstanceMI* mi, const CMPIContext* ctx, CMPIBoolean terminating);

     CMPIStatus (*enumInstanceNames)
             (CMPIInstanceMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
              const CMPIObjectPath* op);

     CMPIStatus (*enumInstances)
             (CMPIInstanceMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
              const CMPIObjectPath* op, const char** properties);

     CMPIStatus (*getInstance)
             (CMPIInstanceMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
              const CMPIObjectPath* op, const char** properties);

     CMPIStatus (*createInstance)
             (CMPIInstanceMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
              const CMPIObjectPath* op, const CMPIInstance* inst);

     CMPIStatus (*modifyInstance)
             (CMPIInstanceMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
              const CMPIObjectPath* op, const CMPIInstance* inst, const char** properties);

     CMPIStatus (*deleteInstance)
             (CMPIInstanceMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
              const CMPIObjectPath* op);

     CMPIStatus (*execQuery)
             (CMPIInstanceMI*,const CMPIContext*,const CMPIResult*,
              const CMPIObjectPath*,const char*,const char*);
   };






  /*
   //---------------------------------------------------
   //--
   // _CMPIAssociationMI Association Provider object
   //--
   //---------------------------------------------------
   */


   typedef struct _CMPIAssociationMIFT CMPIAssociationMIFT;
   typedef struct _CMPIAssociationMI {

      void *hdl;

      CMPIAssociationMIFT *ft;
   } CMPIAssociationMI;


  /*
   //---------------------------------------------------
   //--
   // _CMPIAssociationMIFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIAssociationMIFT {

     int ftVersion;

     int miVersion;

     char *miName;

     CMPIStatus (*cleanup)
             (CMPIAssociationMI* mi, const CMPIContext* ctx, CMPIBoolean terminating);

     CMPIStatus (*associators)
             (CMPIAssociationMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
              const CMPIObjectPath* op, const char* asscClass, const char* resultClass,
              const char* role, const char* resultRole, const char** properties);

     CMPIStatus (*associatorNames)
             (CMPIAssociationMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
              const CMPIObjectPath* op, const char* assocClass, const char* resultClass,
              const char* role, const char* resultRole);

     CMPIStatus (*references)
             (CMPIAssociationMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
              const CMPIObjectPath* op, const char* resultClass, const char* role ,
         const char** properties);

     CMPIStatus (*referenceNames)
             (CMPIAssociationMI*, const CMPIContext*, const CMPIResult*,
              const CMPIObjectPath*, const char*, const char*);
   };






  /*
   //---------------------------------------------------
   //--
   // _CMPIMethodMI Method Provider object
   //--
   //---------------------------------------------------
   */


   typedef struct _CMPIMethodMIFT CMPIMethodMIFT;
   typedef struct _CMPIMethodMI {

      void *hdl;

      CMPIMethodMIFT *ft;
   } CMPIMethodMI;


  /*
   //---------------------------------------------------
   //--
   // _CMPIMethodMIFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIMethodMIFT {

     int ftVersion;

     int miVersion;

     char *miName;

     CMPIStatus (*cleanup)
             (CMPIMethodMI* mi, const CMPIContext* ctx, CMPIBoolean terminating);

     CMPIStatus (*invokeMethod)
             (CMPIMethodMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
              const CMPIObjectPath* op, const char* method, const CMPIArgs* in, CMPIArgs* out);
   };





  /*
   //---------------------------------------------------
   //--
   // _CMPIPropertyMI Property Provider object
   //--
   //---------------------------------------------------
   */


   typedef struct _CMPIPropertyMIFT CMPIPropertyMIFT;
   typedef struct _CMPIPropertyMI {

      void *hdl;

      CMPIPropertyMIFT *ft;
   } CMPIPropertyMI;



  /*
   //---------------------------------------------------
   //--
   // _CMPIPropertyMIFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIPropertyMIFT {

     int ftVersion;

     int miVersion;

     char *miName;

     CMPIStatus (*cleanup)
             (CMPIPropertyMI* mi, const CMPIContext* ctx, CMPIBoolean terminating);

     CMPIStatus (*setProperty)
             (CMPIPropertyMI* mi, const CMPIContext* ctx, const CMPIResult* rslt,
              const CMPIObjectPath* op, const char* name, const CMPIData data);

     CMPIStatus (*getProperty)
             (CMPIPropertyMI*,const CMPIContext*,const CMPIResult*,
              const CMPIObjectPath*,const char*);
   };





  /*
   //---------------------------------------------------
   //--
   // _CMPIIndicationMI Indication Provider object
   //--
   //---------------------------------------------------
   */


   typedef struct _CMPIIndicationMIFT CMPIIndicationMIFT;
   typedef struct _CMPIIndicationMI {

      void *hdl;

      CMPIIndicationMIFT *ft;
   } CMPIIndicationMI;



  /*
   //---------------------------------------------------
   //--
   // _CMPIIndicationMIFT Function Table
   //--
   //---------------------------------------------------
   */


   struct _CMPIIndicationMIFT {

     int ftVersion;

     int miVersion;

     char *miName;

     CMPIStatus (*cleanup)
             (CMPIIndicationMI* mi, const CMPIContext* ctx, CMPIBoolean terminating);
     CMPIStatus (*authorizeFilter)
             (CMPIIndicationMI* mi, const CMPIContext* ctx, // CMPIResult* rslt,
              const CMPISelectExp* se, const char* ns, const CMPIObjectPath* op, const char* user);
     CMPIStatus (*mustPoll)
             (CMPIIndicationMI* mi, const CMPIContext* ctx, // CMPIResult* rslt,
              const CMPISelectExp* se, const char* ns, const CMPIObjectPath* op);
     CMPIStatus (*activateFilter)
            (CMPIIndicationMI* mi, const CMPIContext* ctx, // CMPIResult* rslt,
             const CMPISelectExp* se, const char* ns, const CMPIObjectPath* op, CMPIBoolean first);
     CMPIStatus (*deActivateFilter)
             (CMPIIndicationMI* mi, const CMPIContext* ctx, // CMPIResult* rslt,
              const CMPISelectExp* se, const char* ns, const CMPIObjectPath* op, CMPIBoolean last);
    CMPIStatus (*enableIndications)
            (CMPIIndicationMI* mi, const CMPIContext* ctx); 
    CMPIStatus (*disableIndications)
            (CMPIIndicationMI* mi, const CMPIContext* ctx); 
   };


#include <cmpimacs.h>

#ifdef __cplusplus
 };
#endif

#endif /* _CMPIFT_H_ */

---