• Main Page
  • Classes
  • Files
  • File List

/var/tmp/axbld-24884/rpm/BUILD/pegasus/src/Pegasus/Provider/CMPI/docs/cmpimacs.h

00001 # 1 "macs.h"
00002 # 1 "<built-in>"
00003 # 1 "<command-line>"
00004 # 1 "macs.h"
00005 //%LICENSE////////////////////////////////////////////////////////////////
00006 //
00007 // Licensed to The Open Group (TOG) under one or more contributor license
00008 // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
00009 // this work for additional information regarding copyright ownership.
00010 // Each contributor licenses this file to you under the OpenPegasus Open
00011 // Source License; you may not use this file except in compliance with the
00012 // License.
00013 //
00014 // Permission is hereby granted, free of charge, to any person obtaining a
00015 // copy of this software and associated documentation files (the "Software"),
00016 // to deal in the Software without restriction, including without limitation
00017 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
00018 // and/or sell copies of the Software, and to permit persons to whom the
00019 // Software is furnished to do so, subject to the following conditions:
00020 //
00021 // The above copyright notice and this permission notice shall be included
00022 // in all copies or substantial portions of the Software.
00023 //
00024 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
00025 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00026 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
00027 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
00028 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
00029 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
00030 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00031 //
00033 //
00034 //%////////////////////////////////////////////////////////////////////////////
00035 # 45 "macs.h"
00036 
00042  noReturn CMReturn(CMPIrc rc);
00043 # 64 "macs.h"
00044 
00051  noReturn CMReturnWithString(CMPIrc rc, CMPIString * str);
00052 # 84 "macs.h"
00053 
00061  noReturn CMReturnWithChars(const CMPIBroker * mb, CMPIrc rc, char *msg);
00062 # 109 "macs.h"
00063 
00068 inline static void CMSetStatus(CMPIStatus * st, CMPIrc rcp)
00069 {
00070     if (st)
00071     {
00072         (st)->rc = (rcp);
00073         (st)->msg = NULL;
00074     }
00075 }
00076 # 136 "macs.h"
00077 
00083 inline static void CMSetStatusWithString(
00084     CMPIStatus * st,
00085     CMPIrc rcp,
00086     const CMPIString * string)
00087 {
00088     if (st)
00089     {
00090         (st)->rc = (rcp);
00091         (st)->msg = (string);
00092     }
00093 }
00094 # 167 "macs.h"
00095 
00102 inline static void CMSetStatusWithChars(
00103     const CMPIBroker * mb,
00104     CMPIStatus * st,
00105     CMPIrc rcp,
00106     const char *chars)
00107 {
00108     if (st)
00109     {
00110         (st)->rc = (rcp);
00111         if (mb)
00112         {
00113             (st)->msg = (mb)->eft->newString ((mb), (chars), NULL);
00114         }
00115         else
00116         {
00117             (st)->msg = NULL;
00118         }
00119     }
00120 }
00121 # 210 "macs.h"
00122 
00126 inline static CMPIBoolean CMIsNullObject(const void *obj)
00127 {
00128     return((obj) == NULL || *((void **) (obj)) == NULL);
00129 }
00130 
00131 
00132 
00133 
00134 
00139 inline static CMPIBoolean CMIsNullValue(const CMPIData val)
00140 
00141 {
00142     return((val.state) & CMPI_nullValue);
00143 }
00144 
00145 
00146 
00147 
00148 
00153 inline static CMPIBoolean CMIsKeyValue(CMPIData val)
00154 {
00155     return((val.state) & CMPI_keyValue);
00156 }
00157 
00158 
00159 
00160 
00161 
00166 inline static CMPIBoolean CMIsArray(const CMPIData val)
00167 {
00168     return((val.type) & CMPI_ARRAY);
00169 }
00170 
00171 
00172 
00173 
00174 
00175 // Life-cycle macros
00176 
00177 
00178 
00179 
00180 // CMPIBroker factory macros
00181 
00182 
00190 inline static CMPIInstance *CMNewInstance(
00191     const CMPIBroker * mb,
00192     const CMPIObjectPath * op,
00193     CMPIStatus * rc)
00194 {
00195     return((mb)->eft->newInstance ((mb), (op), (rc)));
00196 }
00197 
00198 
00199 
00200 
00201 
00210 inline static CMPIObjectPath *CMNewObjectPath(
00211         const CMPIBroker * mb,
00212         const char *ns,
00213         const char *cn,
00214         CMPIStatus * rc)
00215 {
00216     return((mb)->eft->newObjectPath ((mb), (ns), (cn), (rc)));
00217 }
00218 
00219 
00220 
00221 
00222 
00223 
00231 inline static CMPIString *CMNewString(
00232     const CMPIBroker * mb,
00233     const char *data,
00234     CMPIStatus * rc)
00235 {
00236     return((mb)->eft->newString ((mb), (data), (rc)));
00237 }
00238 
00239 
00240 
00241 
00242 
00249 inline static CMPIArgs * CMNewArgs(const CMPIBroker * mb, CMPIStatus * rc)
00250 {
00251     return((mb)->eft->newArgs ((mb), (rc)));
00252 }
00253 
00254 
00255 
00256 
00257 
00266 inline static CMPIArray * CMNewArray(
00267         const CMPIBroker * mb,
00268         CMPICount max,
00269         CMPIType type,
00270         CMPIStatus * rc)
00271 {
00272     return((mb)->eft->newArray((mb), (max), (type), (rc)));
00273 }
00274 
00275 
00276 
00277 
00278 
00285 inline static CMPIDateTime *CMNewDateTime(
00286     const CMPIBroker * mb,
00287     CMPIStatus * rc)
00288 {
00289     return((mb)->eft->newDateTime ((mb), (rc)));
00290 }
00291 
00292 
00293 
00294 
00295 
00306 inline static CMPIDateTime *CMNewDateTimeFromBinary(
00307     const CMPIBroker * mb,
00308     CMPIUint64 binTime,
00309     CMPIBoolean interval,
00310     CMPIStatus * rc)
00311 {
00312     return((mb)->eft->
00313         newDateTimeFromBinary((mb), (binTime), (interval), (rc)));
00314 }
00315 
00316 
00317 
00318 
00319 
00320 
00328 inline static CMPIDateTime *CMNewDateTimeFromChars(
00329     const CMPIBroker * mb,
00330     const char *utcTime,
00331     CMPIStatus * rc)
00332 {
00333     return((mb)->eft->newDateTimeFromChars ((mb), (utcTime), (rc)));
00334 }
00335 
00336 
00337 
00338 
00339 
00340 
00351 inline static CMPISelectExp *CMNewSelectExp(
00352     const CMPIBroker * mb,
00353     const char *query,
00354     const char *lang,
00355     CMPIArray ** projection,
00356     CMPIStatus * rc)
00357 {
00358     return((mb)->eft->
00359         newSelectExp ((mb), (query), (lang), (projection), (rc)));
00360 }
00361 
00362 
00363 
00364 
00365 
00366 
00376 inline static CMPIBoolean CMClassPathIsA(
00377     const CMPIBroker * mb,
00378     const CMPIObjectPath * op,
00379     const char *type,
00380     CMPIStatus * rc)
00381 {
00382     return((mb)->eft->classPathIsA ((mb), (op), (type), (rc)));
00383 }
00384 
00385 
00386 
00387 
00388 
00389 // Debugging macros
00390 
00391 
00400 inline static CMPIString *CDToString(
00401     const CMPIBroker * mb,
00402     const void *object,
00403     CMPIStatus * rc)
00404 {
00405     return((mb)->eft->toString ((mb), (void *) (object), (rc)));
00406 }
00407 
00408 
00409 
00410 
00411 
00422 inline static CMPIBoolean CDIsOfType(
00423     const CMPIBroker * mb,
00424     const void *object,
00425     const char *type,
00426     CMPIStatus * rc)
00427 {
00428     return((mb)->eft->isOfType ((mb), (void *) (object), (type), (rc)));
00429 }
00430 
00431 
00432 
00433 
00434 
00435 
00444 inline static CMPIString *CDGetType
00445     (const CMPIBroker * mb, const void *object, CMPIStatus * rc)
00446 {
00447     return((mb)->eft->getType ((mb), (object), (rc)));
00448 }
00449 # 803 "macs.h"
00450 // CMPIInstance macros
00451 
00452 
00453 
00461 inline static CMPIData CMGetProperty(
00462     const CMPIInstance * inst,
00463     const char *name,
00464     CMPIStatus * rc)
00465 {
00466     return((inst)->ft->getProperty ((inst), (name), (rc)));
00467 }
00468 
00469 
00470 
00471 
00472 
00481 inline static CMPIData CMGetPropertyAt(
00482     const CMPIInstance * inst,
00483     CMPICount index,
00484     CMPIString ** name,
00485     CMPIStatus * rc)
00486 {
00487     return((inst)->ft->getPropertyAt ((inst), (index), (name), (rc)));
00488 }
00489 
00490 
00491 
00492 
00493 
00494 
00503 inline static CMPIStatus CMSetProperty(
00504     const CMPIInstance * inst,
00505     const char *name,
00506     const CMPIValue * value,
00507     CMPIType type)
00508 {
00509     return((inst)->ft->setProperty ((inst), (name), (value), (type)));
00510 }
00511 
00512 
00513 
00514 
00515 
00516 
00523 inline static CMPICount CMGetPropertyCount(
00524     const CMPIInstance * inst,
00525     CMPIStatus * rc)
00526 {
00527     return((inst)->ft->getPropertyCount ((inst), (rc)));
00528 }
00529 
00530 
00531 
00532 
00533 
00541 inline static CMPIObjectPath *CMGetObjectPath(
00542     const CMPIInstance * inst,
00543     CMPIStatus * rc)
00544 {
00545     return((inst)->ft->getObjectPath ((inst), (rc)));
00546 }
00547 # 927 "macs.h"
00548 
00557 inline static CMPIStatus CMSetPropertyFilter(
00558     CMPIInstance * inst,
00559     const char **propertyList,
00560     char **keys)
00561 {
00562     return((inst)->ft->setPropertyFilter ((inst), (propertyList), (keys)));
00563 }
00564 # 982 "macs.h"
00565 // CMPIObjectPath macros
00566 
00567 
00568 
00575 inline static CMPIStatus CMSetHostname(
00576     CMPIObjectPath * op,
00577     const char *hn)
00578 {
00579     return((op)->ft->setHostname ((op), (hn)));
00580 }
00581 
00582 
00583 
00584 
00585 
00592 inline static CMPIString *CMGetHostname(
00593     const CMPIObjectPath * op,
00594     CMPIStatus * rc)
00595 {
00596     return((op)->ft->getHostname ((op), (rc)));
00597 }
00598 
00599 
00600 
00601 
00602 
00609 inline static CMPIStatus CMSetNameSpace(
00610     CMPIObjectPath * op,
00611     const char *ns)
00612 {
00613     return((op)->ft->setNameSpace ((op), (ns)));
00614 }
00615 
00616 
00617 
00618 
00619 
00626 inline static CMPIString *CMGetNameSpace(
00627     const CMPIObjectPath * op,
00628     CMPIStatus * rc)
00629 {
00630     return((op)->ft->getNameSpace ((op), (rc)));
00631 }
00632 
00633 
00634 
00635 
00636 
00643 inline static CMPIStatus CMSetClassName(
00644     CMPIObjectPath * op,
00645     const char *cn)
00646 {
00647     return((op)->ft->setClassName ((op), (cn)));
00648 }
00649 
00650 
00651 
00652 
00653 
00660 inline static CMPIString *CMGetClassName(
00661     const CMPIObjectPath * op,
00662     CMPIStatus * rc)
00663 {
00664     return((op)->ft->getClassName ((op), (rc)));
00665 }
00666 
00667 
00668 
00669 
00670 
00679 inline static CMPIStatus CMAddKey(
00680     CMPIObjectPath * op,
00681     const char *name,
00682     const CMPIValue * value,
00683     const CMPIType type)
00684 {
00685     return((op)->ft->addKey ((op), (name), (value), (type)));
00686 }
00687 
00688 
00689 
00690 
00691 
00692 
00700 inline static CMPIData CMGetKey(
00701     const CMPIObjectPath * op,
00702     const char *name,
00703     CMPIStatus * rc)
00704 {
00705     return((op)->ft->getKey ((op), (name), (rc)));
00706 }
00707 
00708 
00709 
00710 
00711 
00720 inline static CMPIData CMGetKeyAt(
00721     const CMPIObjectPath * op,
00722     CMPICount index,
00723     CMPIString ** name,
00724     CMPIStatus * rc)
00725 {
00726     return((op)->ft->getKeyAt ((op), (index), (name), (rc)));
00727 }
00728 
00729 
00730 
00731 
00732 
00733 
00740 inline static CMPICount CMGetKeyCount(
00741     const CMPIObjectPath * op,
00742     CMPIStatus * rc)
00743 {
00744     return((op)->ft->getKeyCount ((op), (rc)));
00745 }
00746 
00747 
00748 
00749 
00750 
00757 inline static CMPIStatus CMSetNameSpaceFromObjectPath(
00758     CMPIObjectPath * op,
00759     const CMPIObjectPath * src)
00760 {
00761     return((op)->ft->setNameSpaceFromObjectPath ((op), (src)));
00762 }
00763 
00764 
00765 
00766 
00767 
00768 
00775 inline static CMPIStatus CMSetHostAndNameSpaceFromObjectPath(
00776     CMPIObjectPath * op,
00777     const CMPIObjectPath * src)
00778 {
00779     return((op)->ft->setHostAndNameSpaceFromObjectPath ((op), (src)));
00780 }
00781 
00782 
00783 
00784 
00785 
00786 
00794 inline static CMPIData CMGetClassQualifier(
00795     const CMPIObjectPath* op,
00796     const char *qName,
00797     CMPIStatus *rc)
00798 {
00799     return((op)->ft->getClassQualifier((op),(qName),(rc)));
00800 }
00801 
00802 
00803 
00804 
00805 
00806 
00815 inline static CMPIData CMGetPropertyQualifier(
00816     const CMPIObjectPath* op,
00817     const char *pName,
00818     const char *qName,
00819     CMPIStatus *rc)
00820 {
00821     return((op)->ft->getPropertyQualifier((op),(pName),(qName),(rc)));
00822 }
00823 
00824 
00825 
00826 
00827 
00828 
00837 inline static CMPIData CMGetMethodQualifier(
00838     const CMPIObjectPath* op,
00839     const char *methodName,
00840     const char *qName,
00841     CMPIStatus *rc)
00842 {
00843     return((op)->ft->getMethodQualifier((op),(methodName),(qName),(rc)));
00844 }
00845 
00846 
00847 
00848 
00849 
00850 
00860 inline static CMPIData CMGetParameterQualifier(
00861     const CMPIObjectPath* op,
00862     const char *mName,
00863     const char *pName,
00864     const char *qName,
00865     CMPIStatus *rc)
00866 {
00867     return((op)->ft->getParameterQualifier((op),(mName),(pName),(qName),(rc)));
00868 }
00869 # 1311 "macs.h"
00870 // CMPIArray macros
00871 
00872 
00873 
00880 inline static CMPICount CMGetArrayCount(
00881     const CMPIArray * ar,
00882     CMPIStatus * rc)
00883 {
00884     return((ar)->ft->getSize ((ar), (rc)));
00885 }
00886 
00887 
00888 
00889 
00890 
00897 inline static CMPIType CMGetArrayType(
00898     const CMPIArray * ar,
00899     CMPIStatus * rc)
00900 {
00901     return((ar)->ft->getSimpleType ((ar), (rc)));
00902 }
00903 
00904 
00905 
00906 
00907 
00915 inline static CMPIData CMGetArrayElementAt(
00916     const CMPIArray * ar,
00917     CMPICount index,
00918     CMPIStatus * rc)
00919 {
00920     return((ar)->ft->getElementAt ((ar), (index), (rc)));
00921 }
00922 
00923 
00924 
00925 
00926 
00927 
00936 inline static CMPIStatus CMSetArrayElementAt(
00937     CMPIArray * ar,
00938     CMPICount index,
00939     const CMPIValue * value,
00940     CMPIType type)
00941 {
00942     return((ar)->ft->setElementAt ((ar), (index), (value), (type)));
00943 }
00944 
00945 
00946 
00947 
00948 
00949 // CMPIArgs macros
00950 
00951 
00960 inline static CMPIStatus CMAddArg(
00961     CMPIArgs * as,
00962     char *name,
00963     const CMPIValue * value,
00964     const CMPIType type)
00965 {
00966     return((as)->ft->addArg ((as), (name), (CMPIValue*)(value), (type)));
00967 }
00968 
00969 
00970 
00971 
00972 
00973 
00981 inline static CMPIData CMGetArg(
00982     const CMPIArgs * as,
00983     const char *name,
00984     CMPIStatus * rc)
00985 {
00986     return((as)->ft->getArg ((as), (name), (rc)));
00987 }
00988 
00989 
00990 
00991 
00992 
01001 inline static CMPIData CMGetArgAt(
01002     const CMPIArgs * as,
01003     CMPICount index,
01004     CMPIString ** name,
01005     CMPIStatus * rc)
01006 {
01007     return((as)->ft->getArgAt ((as), (index), (name), (rc)));
01008 }
01009 
01010 
01011 
01012 
01013 
01020 inline static CMPICount CMGetArgCount(const CMPIArgs * as, CMPIStatus * rc)
01021 {
01022     return((as)->ft->getArgCount ((as), (rc)));
01023 }
01024 
01025 
01026 
01027 
01028 
01029 // CMPIString Macros
01030 
01031 // CMGetCharPtr is deprecated. It will be removed in the
01032 // future versions.
01033 
01034 
01035 
01042 inline static char * CMGetCharsPtr(
01043     const CMPIString * st,
01044     CMPIStatus * rc)
01045 {
01046     return((st)->ft->getCharPtr ((st), (rc)));
01047 }
01048 
01049 
01050 
01051 
01052 // CMPIDateTime macros
01053 
01054 
01061 inline static CMPIString *CMGetStringFormat(
01062     const CMPIDateTime * dt,
01063     CMPIStatus * rc)
01064 {
01065     return((dt)->ft->getStringFormat ((dt), (rc)));
01066 }
01067 
01068 
01069 
01070 
01071 
01079 inline static CMPIUint64 CMGetBinaryFormat(
01080     const CMPIDateTime * dt,
01081     CMPIStatus * rc)
01082 {
01083     return((dt)->ft->getBinaryFormat ((dt), (rc)));
01084 }
01085 
01086 
01087 
01088 
01089 
01096 inline static CMPIBoolean CMIsInterval(
01097     const CMPIDateTime * dt,
01098     CMPIStatus * rc)
01099 {
01100     return((dt)->ft->isInterval ((dt), (rc)));
01101 }
01102 
01103 
01104 
01105 
01106 
01107 // CMPIError macros
01108 # 1979 "macs.h"
01109 // CMPIEnumeration Macros
01110 
01111 
01112 
01119 inline static CMPIData CMGetNext(
01120     const CMPIEnumeration * en,
01121     CMPIStatus * rc)
01122 {
01123     return((en)->ft->getNext ((en), (rc)));
01124 }
01125 
01126 
01127 
01128 
01129 
01136 inline static CMPIBoolean CMHasNext(
01137     const CMPIEnumeration * en,
01138     CMPIStatus * rc)
01139 {
01140     return((en)->ft->hasNext ((en), (rc)));
01141 }
01142 
01143 
01144 
01145 
01146 
01153 inline static CMPIArray *CMToArray(
01154     const CMPIEnumeration * en,
01155     CMPIStatus * rc)
01156 {
01157     return((en)->ft->toArray ((en), (rc)));
01158 }
01159 
01160 
01161 
01162 
01163 
01164 // CMPIResult Macros
01165 
01166 
01167 
01175 inline static CMPIStatus CMReturnData(
01176     const CMPIResult * rslt,
01177     const CMPIValue * value,
01178     const CMPIType type)
01179 {
01180     return((rslt)->ft->returnData ((rslt), (value), (type)));
01181 }
01182 
01183 
01184 
01185 
01186 
01187 
01194 inline static CMPIStatus CMReturnInstance(
01195     const CMPIResult * rslt,
01196     const CMPIInstance * inst)
01197 {
01198     return((rslt)->ft->returnInstance ((rslt), (inst)));
01199 }
01200 
01201 
01202 
01203 
01204 
01211 inline static CMPIStatus CMReturnObjectPath(
01212     const CMPIResult * rslt,
01213     const CMPIObjectPath * ref)
01214 {
01215     return((rslt)->ft->returnObjectPath ((rslt), (ref)));
01216 }
01217 
01218 
01219 
01220 
01221 
01227 inline static CMPIStatus CMReturnDone(
01228     const CMPIResult * rslt)
01229 {
01230     return((rslt)->ft->returnDone ((rslt)));
01231 }
01232 # 2127 "macs.h"
01233 // CMPIContext Macros
01234 
01235 
01236 
01244 inline static CMPIData CMGetContextEntry(
01245     const CMPIContext * ctx,
01246     const char *name,
01247     CMPIStatus * rc)
01248 {
01249     return((ctx)->ft->getEntry ((ctx), (name), (rc)));
01250 }
01251 
01252 
01253 
01254 
01255 
01256 
01265 inline static CMPIData CMGetContextEntryAt(
01266     const CMPIContext * ctx,
01267     CMPICount index,
01268     CMPIString ** name,
01269     CMPIStatus * rc)
01270 {
01271     return((ctx)->ft->getEntryAt ((ctx), (index), (name), (rc)));
01272 }
01273 
01274 
01275 
01276 
01277 
01278 
01285 inline static CMPICount CMGetContextEntryCount(
01286     const CMPIContext * ctx,
01287     CMPIStatus * rc)
01288 {
01289     return((ctx)->ft->getEntryCount ((ctx), (rc)));
01290 }
01291 
01292 
01293 
01294 
01295 
01296 
01305 inline static CMPIStatus CMAddContextEntry(
01306     const CMPIContext * ctx,
01307     const char *name,
01308     const CMPIValue * value,
01309     const CMPIType type)
01310 {
01311     return((ctx)->ft->addEntry ((ctx), (name), (value), (type)));
01312 }
01313 
01314 
01315 
01316 
01317 
01318 // CMPISelectExp macros
01319 
01320 
01327 inline static CMPIString *CMGetSelExpString(
01328     const CMPISelectExp * se,
01329     CMPIStatus * rc)
01330 {
01331     return((se)->ft->getString ((se), (rc)));
01332 }
01333 
01334 
01335 
01336 
01337 
01345 inline static CMPIBoolean CMEvaluateSelExp(
01346     const CMPISelectExp * se,
01347     const CMPIInstance * inst,
01348     CMPIStatus * rc)
01349 {
01350     return((se)->ft->evaluate ((se), (inst), (rc)));
01351 }
01352 # 2275 "macs.h"
01353 
01359 inline static CMPISelectCond *CMGetDoc(
01360     const CMPISelectExp * se,
01361     CMPIStatus * rc)
01362 {
01363     return((se)->ft->getDOC ((se), (rc)));
01364 }
01365 
01366 
01367 
01368 
01369 
01376 inline static CMPISelectCond *CMGetCod(
01377     const CMPISelectExp * se,
01378     CMPIStatus * rc)
01379 {
01380     return((se)->ft->getCOD ((se), (rc)));
01381 }
01382 
01383 
01384 
01385 
01386 
01387 // CMPISelectCond macros
01388 
01389 
01390 
01399 inline static CMPICount CMGetSubCondCountAndType(
01400     const CMPISelectCond * sc,
01401     int * type,
01402     CMPIStatus * rc)
01403 {
01404     return((sc)->ft->getCountAndType ((sc), (type), (rc)));
01405 }
01406 
01407 
01408 
01409 
01410 
01411 
01419 inline static CMPISubCond *CMGetSubCondAt(
01420     const CMPISelectCond * sc,
01421     CMPICount index,
01422     CMPIStatus * rc)
01423 {
01424     return((sc)->ft->getSubCondAt ((sc), (index), (rc)));
01425 }
01426 
01427 
01428 
01429 
01430 // CMPISubCond macros
01431 
01432 
01439 inline static CMPICount CMGetPredicateCount(
01440     const CMPISubCond * sc,
01441     CMPIStatus * rc)
01442 {
01443     return((sc)->ft->getCount ((sc), (rc)));
01444 }
01445 
01446 
01447 
01448 
01449 
01457 inline static CMPIPredicate *CMGetPredicateAt(
01458     const CMPISubCond * sc,
01459     CMPICount index,
01460     CMPIStatus * rc)
01461 {
01462     return((sc)->ft->getPredicateAt ((sc), (index), (rc)));
01463 }
01464 
01465 
01466 
01467 
01468 
01469 
01477 inline static CMPIPredicate *CMGetPredicate(
01478     const CMPISubCond * sc,
01479     const char *name,
01480     CMPIStatus * rc)
01481 {
01482     return((sc)->ft->getPredicate ((sc), (name), (rc)));
01483 }
01484 
01485 
01486 
01487 
01488 
01489 // CMPIPredicate macros
01490 
01491 
01492 
01502 inline static CMPIStatus CMGetPredicateData(
01503     const CMPIPredicate * pr,
01504     CMPIType * type,
01505     CMPIPredOp * op,
01506     CMPIString ** lhs,
01507     CMPIString ** rhs)
01508 {
01509     return((pr)->ft->getData ((pr), (type), (op), (lhs), (rhs)));
01510 }
01511 # 2487 "macs.h"
01512 // CMPIBroker Macros
01513 
01514 
01515 
01520 inline static unsigned long CBGetBrokerCapabilities(const CMPIBroker * mb)
01521 {
01522     return((mb)->bft-> brokerCapabilities);
01523 }
01524 
01525 
01526 
01527 
01528 
01532 inline static int CBBrokerVersion(const CMPIBroker * mb)
01533 {
01534     return((mb)->bft->brokerVersion);
01535 }
01536 
01537 
01538 
01539 
01540 
01544 inline static const char *CBBrokerName(const CMPIBroker * mb)
01545 {
01546     return((mb)->bft->brokerName);
01547 }
01548 
01549 
01550 
01551 
01552 
01562 inline static CMPIContext *CBPrepareAttachThread(
01563     const CMPIBroker * mb,
01564     const CMPIContext * ctx)
01565 {
01566     return((mb)->bft->prepareAttachThread ((mb), (ctx)));
01567 }
01568 
01569 
01570 
01571 
01572 
01573 
01581 inline static CMPIStatus CBAttachThread(
01582     const CMPIBroker * mb,
01583     const CMPIContext * ctx)
01584 {
01585     return((mb)->bft->attachThread ((mb), (ctx)));
01586 }
01587 
01588 
01589 
01590 
01591 
01600 inline static CMPIStatus CBDetachThread(
01601     const CMPIBroker * mb,
01602     const CMPIContext * ctx)
01603 {
01604     return((mb)->bft->detachThread ((mb), (ctx)));
01605 }
01606 
01607 
01608 
01609 
01610 
01611 
01621 inline static CMPIStatus CBDeliverIndication(
01622     const CMPIBroker * mb,
01623     const CMPIContext * ctx,
01624     const char *ns,
01625     const CMPIInstance * ind)
01626 {
01627     return((mb)->bft->deliverIndication ((mb), (ctx), (ns), (ind)));
01628 }
01629 
01630 
01631 
01632 
01633 
01634 
01644 inline static CMPIEnumeration *CBEnumInstanceNames(
01645     const CMPIBroker * mb,
01646     const CMPIContext * ctx,
01647     const CMPIObjectPath * op,
01648     CMPIStatus * rc)
01649 {
01650     return((mb)->bft->enumerateInstanceNames ((mb), (ctx), (op), (rc)));
01651 }
01652 
01653 
01654 
01655 
01656 
01657 
01671 inline static CMPIEnumeration *CBEnumInstances(
01672     const CMPIBroker * mb,
01673     const CMPIContext * ctx,
01674     const CMPIObjectPath * op,
01675     const char **properties,
01676     CMPIStatus * rc)
01677 {
01678     return((mb)->bft->enumerateInstances ((mb),(ctx),(op),(properties),(rc)));
01679 }
01680 
01681 
01682 
01683 
01684 
01685 
01698 inline static CMPIInstance *CBGetInstance(
01699     const CMPIBroker * mb,
01700     const CMPIContext * ctx,
01701     const CMPIObjectPath * op,
01702     const char **properties,
01703     CMPIStatus * rc)
01704 {
01705     return((mb)->bft->getInstance ((mb), (ctx), (op), (properties), (rc)));
01706 }
01707 
01708 
01709 
01710 
01711 
01712 
01722 inline static CMPIObjectPath *CBCreateInstance(
01723     const CMPIBroker * mb,
01724     const CMPIContext * ctx,
01725     const CMPIObjectPath * op,
01726     const CMPIInstance * inst,
01727     CMPIStatus * rc)
01728 {
01729     return((mb)->bft->createInstance ((mb), (ctx), (op), (inst), (rc)));
01730 }
01731 # 2758 "macs.h"
01732 
01741 inline static CMPIStatus CBSetInstance(
01742     CMPIBroker* mb,
01743     CMPIContext* ctx,
01744     CMPIObjectPath* op,
01745     CMPIInstance* inst)
01746 {
01747     return((mb)->bft->
01748         setInstance ((mb), (ctx), (op), (inst), NULL));
01749 }
01750 
01751 
01752 
01753 
01754 
01755 
01756 
01764 inline static CMPIStatus CBDeleteInstance(
01765     const CMPIBroker * mb,
01766     const CMPIContext * ctx,
01767     const CMPIObjectPath * op)
01768 {
01769     return((mb)->bft->deleteInstance ((mb), (ctx), (op)));
01770 }
01771 
01772 
01773 
01774 
01775 
01787 inline static CMPIEnumeration *CBExecQuery(
01788     const CMPIBroker * mb,
01789     const CMPIContext * ctx,
01790     const CMPIObjectPath * op,
01791     const char *query,
01792     const char *lang,
01793     CMPIStatus * rc)
01794 {
01795     return((mb)->bft->execQuery ((mb), (ctx), (op), (query), (lang), (rc)));
01796 }
01797 
01798 
01799 
01800 
01801 
01802 
01803 
01836 inline static CMPIEnumeration *CBAssociators(
01837     const CMPIBroker * mb,
01838     const CMPIContext * ctx,
01839     const CMPIObjectPath * op,
01840     const char *assocClass,
01841     const char *resultClass,
01842     const char *role,
01843     const char *resultRole,
01844     const char **properties,
01845     CMPIStatus * rc)
01846 {
01847     return((mb)->bft->
01848         associators ((mb), (ctx), (op), (assocClass), (resultClass), (role),
01849         (resultRole), (properties), (rc)));
01850 }
01851 
01852 
01853 
01854 
01855 
01856 
01886 inline static CMPIEnumeration *CBAssociatorNames(
01887     const CMPIBroker * mb,
01888     const CMPIContext * ctx,
01889     const CMPIObjectPath * op,
01890     const char *assocClass,
01891     const char *resultClass,
01892     const char *role,
01893     const char *resultRole,
01894     CMPIStatus * rc)
01895 {
01896     return((mb)->bft->associatorNames ((mb), (ctx), (op),
01897         (assocClass), (resultClass), (role),
01898         (resultRole), (rc)));
01899 }
01900 
01901 
01902 
01903 
01904 
01905 
01929 inline static CMPIEnumeration *CBReferences(
01930     const CMPIBroker * mb,
01931     const CMPIContext * ctx,
01932     const CMPIObjectPath * op,
01933     const char *resultClass,
01934     const char *role,
01935     const char **properties,
01936     CMPIStatus * rc)
01937 {
01938     return((mb)->bft->references ((mb), (ctx), (op),
01939         (resultClass), (role), (properties), (rc)));
01940 }
01941 
01942 
01943 
01944 
01945 
01946 
01967 inline static CMPIEnumeration *CBReferenceNames(
01968     const CMPIBroker * mb,
01969     const CMPIContext * ctx,
01970     const CMPIObjectPath * op,
01971     const char *resultClass,
01972     const char *role,
01973     CMPIStatus * rc)
01974 {
01975     return((mb)->bft->
01976         referenceNames ((mb), (ctx), (op), (resultClass), (role), (rc)));
01977 }
01978 
01979 
01980 
01981 
01982 
01983 
01984 
01997 inline static CMPIData CBInvokeMethod(
01998     const CMPIBroker * mb,
01999     const CMPIContext * ctx,
02000     const CMPIObjectPath * op,
02001     const char *method,
02002     const CMPIArgs * in,
02003     CMPIArgs * out,
02004     CMPIStatus * rc)
02005 {
02006     return((mb)->bft->
02007         invokeMethod ((mb), (ctx), (op), (method), (in), (out), (rc)));
02008 }
02009 
02010 
02011 
02012 
02013 
02014 
02026 inline static CMPIStatus CBSetProperty(
02027     const CMPIBroker * mb,
02028     const CMPIContext * ctx,
02029     const CMPIObjectPath * op,
02030     const char *name,
02031     const CMPIValue * value,
02032     const CMPIType type)
02033 {
02034     return((mb)->bft->setProperty ((mb), (ctx), (op), (name),
02035         (CMPIValue *) (value), (type)));
02036 }
02037 
02038 
02039 
02040 
02041 
02042 
02053 inline static CMPIData CBGetProperty(
02054     const CMPIBroker * mb,
02055     const CMPIContext * ctx,
02056     const CMPIObjectPath * op,
02057     const char *name,
02058     CMPIStatus * rc)
02059 {
02060     return(mb)->bft->getProperty ((mb), (ctx), (op), (name), (rc));
02061 }
02062 # 3102 "macs.h"
02063 /*
02064     -----------------  C provider factories ---------------------
02065 */
02066 
02067 
02089 CMPIInstanceMI *CMInstanceMIStub(
02090     chars pfx,
02091     chars pn,
02092     CMPIBroker * broker,
02093     statement hook);
02094 # 3172 "macs.h"
02095 
02117 CMPIAssociationMI *CMAssociationMIStub(
02118     chars pfx,
02119     chars pn,
02120     CMPIBroker * broker,
02121     statement hook);
02122 # 3227 "macs.h"
02123 
02142 CMPIMethodMI *CMMethodMIStub(
02143     chars pfx,
02144     chars pn,
02145     CMPIBroker * broker,
02146     statement hook);
02147 # 3276 "macs.h"
02148 
02168 CMPIPropertyMI *CMPropertyMIStub(
02169     chars pfx,
02170     chars pn,
02171     CMPIBroker * broker,
02172     statement hook);
02173 # 3327 "macs.h"
02174 
02195 CMPIIndicationMI *CMIndicationMIStub(
02196     chars pfx,
02197     chars pn,
02198     CMPIBroker * broker,
02199     statement hook);
02200 # 3388 "macs.h"
02201 /*
02202     -----------------  C++ provider factories ---------------------
02203 */
02204 
02205 
02219 CMPIInstanceMI *CMInstanceMIFactory(chars cn, chars pn);
02220 # 3470 "macs.h"
02221 
02234 CMPIAssociationMI *CMAssociationMIFactory(chars cn, chars pn);
02235 # 3544 "macs.h"
02236 
02249 CMPIMethodMI *CMMethodMIFactory(chars cn, chars pn);
02250 # 3615 "macs.h"
02251 
02264 CMPIPropertyMI *CMPropertyMIFactory(chars cn, chars pn);
02265 # 3688 "macs.h"
02266 
02279 CMPIIndicationMI *CMIndicationMIFactory(chars cn, chars pn);