cmpift.h

Go to the documentation of this file.

/*
 *
 * $Id: cmpift.h,v 1.9 2009/02/28 03:18:20 tyreld Exp $
 *
 * (C) Copyright IBM Corp. 2003, 2005, 2006, 2008
 *
 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE ECLIPSE 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 Eclipse Public License from
 * http://www.opensource.org/licenses/eclipse-1.0.txt
 *
 * Author:        Adrian Schuur <schuur@de.ibm.com>
 * Contributors:  Konrad Rzeszutek <darnok@us.ibm.com>
 *
 * Description: CMPI Function Table Definions
 *
 */

/* ------------------------------------------------------------------------- */
/*                                                                           */
/* Copyright (c) 2006 The Open Group                                         */
/*                                                                           */
/* Permission is hereby granted, free of charge, to any person obtaining a   */
/* copy of this software (the "Software"), to deal in the Software without   */
/* restriction, including without limitation the rights to use, copy,        */
/* modify, merge, publish, distribute, sublicense, and/or sell copies of     */
/* the Software, and to permit persons to whom the Software is furnished     */
/* to do so, subject to the following conditions:                            */
/*                                                                           */
/* The above copyright notice and this permission notice shall be included   */
/* in all copies or substantial portions of the Software.                    */
/*                                                                           */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS   */
/* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF                */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.    */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY      */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT */
/* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR  */
/* THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                */
/*                                                                           */
/* ------------------------------------------------------------------------- */

#ifndef _CMPIFT_H_
#   define _CMPIFT_H_

#   include "cmpidt.h"
#   include "cmpios.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);

    CMPIString *(*getMessage)
      (const CMPIBroker * mb, const char *msgId, const char *defMsg,
       CMPIStatus * rc, CMPICount count, ...);

      CMPIStatus (*logMessage)
      (const CMPIBroker *, int severity, const char *id,
       const char *text, const CMPIString * string);

      CMPIStatus (*trace)
      (const CMPIBroker *, int level, const char *component,
       const char *text, const CMPIString * string);

#       ifdef CMPI_VER_200

          CMPIError* (*newCMPIError)
          (const CMPIBroker*, const char*, const char*, const char*,
           const CMPIErrorSeverity, const CMPIErrorProbableCause,const CMPIrc,
           CMPIStatus *rc);
     CMPIStatus (*openMessageFile)
      (const CMPIBroker* mb, const char *msgFile,
       CMPIMsgFileHandle* msgFileHandle);

     CMPIStatus (*closeMessageFile)
      (const CMPIBroker* mb, const CMPIMsgFileHandle msgFileHandle);

     CMPIString* (*getMessage2)
      (const CMPIBroker* mb, const char *msgId,
       const CMPIMsgFileHandle msgFileHandle, const char *defMsg,
       CMPIStatus* rc, CMPICount count, ...);
#       endif /* CMPI_VER_200 */

  };



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


  struct _CMPIBrokerFT
  {

    unsigned int brokerCapabilities;
    unsigned int brokerVersion;
    const 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 *(*enumerateInstanceNames)
      (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 *(*enumerateInstances)
      (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 * op, const char *name, CMPIStatus * rc);
  };


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


  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));

    /* Create a POSIX threading conformant thread key. This key can be used as a key to access the thread local store.
       @param key The address for the key to be returned.
       @param cleanup Function to be invoked during thread local store cleanup.
       @return Completion code as defined by POSIX threading semantics.
     */
    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 mutex);

    void (*lockMutex) (CMPI_MUTEX_TYPE mutex);

    void (*unlockMutex) (CMPI_MUTEX_TYPE mutex);

      CMPI_COND_TYPE (*newCondition) (int opt);

    void (*destroyCondition) (CMPI_COND_TYPE cond);

    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);
  };



#   if defined (CMPI_VER_200)
  //---------------------------------------------------
  //--
  //   _CMPIBroker Memory Function Table
  //--
  //---------------------------------------------------

  struct _CMPIBrokerMemFT
  {

    const int ftVersion;

    CMPIGcStat *(*mark) (const CMPIBroker * mb, CMPIStatus * rc);

      CMPIStatus (*release) (const CMPIBroker * mb, const CMPIGcStat * gc);

    void *(*cmpiMalloc) (const CMPIBroker * mb, size_t size);

    void *(*cmpiCalloc) (const CMPIBroker * mb, size_t, size_t);

    void *(*cmpiRealloc) (const CMPIBroker * mb, void *, size_t);


    char *(*cmpiStrDup) (const CMPIBroker * mb, const char *);

    void (*cmpiFree) (const CMPIBroker * mb, void *);

    void (*freeInstance) (const CMPIBroker * mb, CMPIInstance * inst);

    void (*freeObjectPath) (const CMPIBroker * mb, CMPIObjectPath * obj);

    void (*freeArgs) (const CMPIBroker * mb, CMPIArgs * args);

    void (*freeString) (const CMPIBroker * mb, CMPIString * str);

    void (*freeArray) (const CMPIBroker * mb, CMPIArray * array);

    void (*freeDateTime) (const CMPIBroker * mb, CMPIDateTime * date);

    void (*freeSelectExp) (const CMPIBroker * mb, CMPISelectExp * se);
  };

#   endif

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


  struct _CMPIBroker
  {

    void *hdl;

    CMPIBrokerFT *bft;

    CMPIBrokerEncFT *eft;

    CMPIBrokerExtFT *xft;

#   ifdef CMPI_VER_200

    CMPIBrokerMemFT *mft;
#   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, CMPICount index, CMPIString ** name,
       CMPIStatus * rc);

      CMPICount (*getEntryCount) (const CMPIContext * ctx, CMPIStatus * rc);

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




  //---------------------------------------------------
  //--
  //   _CMPIContext Encapsulated object
  //--
  //---------------------------------------------------


  struct _CMPIContext
  {

    void *hdl;

    CMPIContextFT *ft;
  };




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


  struct _CMPIResult
  {

    void *hdl;

    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);

#       ifdef CMPI_VER_200

        CMPIStatus (*returnError)(const CMPIResult* rslt,
                const CMPIError* er);
#       endif
  };

#       ifdef CMPI_VER_200
        struct _CMPIError {
                void *hdl;
                CMPIErrorFT *ft;
        };

  //---------------------------------------------------
  //--
  //   _CMPIErrorFT Function Table
  //--
  //---------------------------------------------------


struct _CMPIErrorFT {
    CMPISint32 ftVersion;
    CMPIStatus (*release)(CMPIError*);
    CMPIError* (*clone)(const CMPIError*, CMPIStatus*);
    CMPIErrorType (*getErrorType)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getOtherErrorType)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getOwningEntity)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getMessageID)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getMessage)(const CMPIError*, CMPIStatus*);
    CMPIErrorSeverity (*getPerceivedSeverity)(const CMPIError*, CMPIStatus*);
    CMPIErrorProbableCause (*getProbableCause)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getProbableCauseDescription)(const CMPIError*, CMPIStatus*);
    CMPIArray* (*getRecommendedActions)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getErrorSource)(const CMPIError*, CMPIStatus*);
    CMPIErrorSrcFormat (*getErrorSourceFormat)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getOtherErrorSourceFormat)(const CMPIError*, CMPIStatus*);
    CMPIrc (*getCIMStatusCode)(const CMPIError*, CMPIStatus*);
    CMPIString* (*getCIMStatusCodeDescription)(const CMPIError*, CMPIStatus*);
        CMPIArray* (*getMessageArguments)(const CMPIError*, CMPIStatus*);
    CMPIStatus (*setErrorType)(CMPIError*, const CMPIErrorType);
    CMPIStatus (*setOtherErrorType)(CMPIError*, const char *);
    CMPIStatus (*setProbableCauseDescription)(CMPIError*, const char *);
    CMPIStatus (*setRecommendedActions)(CMPIError*, const CMPIArray*);
    CMPIStatus (*setErrorSource)(CMPIError*, const char*);
    CMPIStatus (*setErrorSourceFormat)(CMPIError*, const CMPIErrorSrcFormat );
    CMPIStatus (*setOtherErrorSourceFormat)(CMPIError*, const char*);
    CMPIStatus (*setCIMStatusCodeDescription)(CMPIError*, const char*);
        CMPIStatus (*setMessageArguments)(CMPIError*, CMPIArray*);
};
#       endif /* CMPI_VER_200 */


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


  struct _CMPIInstance
  {

    void *hdl;

    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, CMPICount index, CMPIString ** name,
       CMPIStatus * rc);
      CMPICount (*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);

      CMPIStatus (*setObjectPath) (CMPIInstance * inst,
                                   const CMPIObjectPath * op);
#ifdef CMPI_VER_200

          CMPIStatus (*setPropertyWithOrigin)(const CMPIInstance*, const char*,
                    const CMPIValue*, const CMPIType, const char*);
#endif /* CMPI_VER_200 */

  };




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


  struct _CMPIObjectPath
  {

    void *hdl;

    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, CMPICount index, CMPIString ** name,
       CMPIStatus * rc);
      CMPICount (*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);

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

  };




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


  struct _CMPISelectExp
  {

    void *hdl;

    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);

      CMPIBoolean (*evaluateUsingAccessor)
      (const CMPISelectExp * se, CMPIAccessor * accessor, void *parm,
       CMPIStatus * rc);
  };



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


  struct _CMPISelectCond
  {

    void *hdl;

    CMPISelectCondFT *ft;
  };



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


  struct _CMPISelectCondFT
  {

    const 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, CMPICount 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, CMPICount 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);

      CMPIBoolean (*evaluateUsingAccessor)
      (const CMPIPredicate * pr, CMPIAccessor * accessorFnc, void *parm,
       CMPIStatus * rc);
  };




  //---------------------------------------------------
  //--
  //   _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)
      (const 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, CMPICount index, CMPIString ** name,
       CMPIStatus * rc);

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




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


  struct _CMPIString
  {

    void *hdl;

    CMPIStringFT *ft;
  };



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


  struct _CMPIStringFT
  {

    int ftVersion;

      CMPIStatus (*release) (CMPIString * st);

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

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




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


  struct _CMPIArray
  {

    void *hdl;

    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
  {

    void *hdl;

    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
  {

    void *hdl;

    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;

    const char *miName;

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

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

      CMPIStatus (*enumerateInstances)
      (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 * mi, const CMPIContext * ctx, const CMPIResult * rslt,
       const CMPIObjectPath * op, const char *query, const char *lang);
  };






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


  typedef struct _CMPIAssociationMIFT CMPIAssociationMIFT;
  typedef struct _CMPIAssociationMI
  {

    void *hdl;

    CMPIAssociationMIFT *ft;
  } CMPIAssociationMI;


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


  struct _CMPIAssociationMIFT
  {

    int ftVersion;

    const CMPISint32 miVersion;

    const 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 * mi, const CMPIContext * ctx,
       const CMPIResult * rslt, const CMPIObjectPath * op,
       const char *resultClass, const char *role);
  };






  //---------------------------------------------------
  //--
  //   _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;

    const 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;

    const 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 *name);
#ifdef CMPI_VER_200

          CMPIStatus (*setPropertyWithOrigin)(CMPIPropertyMI*, const CMPIContext*,
                  const CMPIResult*, CMPIObjectPath * op,
          const char *name, const CMPIData data, const char*);
#endif /* CMPI_VER_200 */
  };





  //---------------------------------------------------
  //--
  //   _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;

    const char *miName;

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

      CMPIStatus (*authorizeFilter) (CMPIIndicationMI * mi,
                                     const CMPIContext * ctx,
                                     const CMPISelectExp * filter,
                                     const char *className,
                                     const CMPIObjectPath * op,
                                     const char *owner);
      CMPIStatus (*mustPoll) (CMPIIndicationMI * mi, const CMPIContext * ctx,
                              const CMPISelectExp * filter,
                              const char *className,
                              const CMPIObjectPath * classPath);

      CMPIStatus (*activateFilter) (CMPIIndicationMI * mi,
                                    const CMPIContext * ctx,
                                    const CMPISelectExp * filter,
                                    const char *className,
                                    const CMPIObjectPath * classPath,
                                    CMPIBoolean firstActivation);

      CMPIStatus (*deActivateFilter) (CMPIIndicationMI * mi,
                                      const CMPIContext * ctx,
                                      const CMPISelectExp * filter,
                                      const char *className,
                                      const CMPIObjectPath * classPath,
                                      CMPIBoolean lastActiviation);

      CMPIStatus (*enableIndications) (CMPIIndicationMI * mi,
                                       const CMPIContext *);
      CMPIStatus (*disableIndications) (CMPIIndicationMI * mi,
                                        const CMPIContext *);

  };

#   include "cmpimacs.h"


#   ifdef __cplusplus
};
#   endif

#endif // _CMPIFT_H_