Main Page   Compound List   File List   Compound Members   File Members  

alchemist.h

Go to the documentation of this file.
00001 #ifndef __ALCHEMIST__
00002 #define __ALCHEMIST__
00003 
00004 #include <sys/types.h> /* for: uid_t, gid_t */
00005 
00006 /*
00007  * alchemist.h
00008  */
00009 
00010 /* bump the major version every time a change made which would break existing
00011 * compiled wodules. */
00012 #define ALCHEMIST_ABI_MAJOR_VER 0
00013 
00014 /* bump the minor version every time a change is made which would not break
00015 * existing modules with an equivalent major and equall or smaller minor version
00016 */
00017 #define ALCHEMIST_ABI_MINOR_VER 0
00018 
00019 typedef struct AdmError AdmError;
00020 
00030 void            AdmError_create         (AdmError       **error,
00031                                          int              num,
00032                                          const char      *format,
00033                                                           ...);
00034 
00039 void             AdmError_ref           (AdmError        *error);
00040 
00047 void             AdmError_unref         (AdmError        *error);
00048 
00059 const char      *AdmError_strerr        (AdmError        *error);
00060 
00070 int              AdmError_errno         (AdmError        *error);
00071 
00072 /* AdmError Numbers */
00073 #define ADM_EDEADNODE           1       
00074 #define ADM_EBADTYPE            2       
00076 #define ADM_EBADNAME            3       
00077 #define ADM_EBADDATA            4       
00078 #define ADM_ECONSTRAINT         5       
00080 #define ADM_ENOINDEX            51      
00081 #define ADM_ENONAME             52      
00082 #define ADM_ENOPATH             53      
00084 #define ADM_EACCESSFAILED       101     
00085 #define ADM_ENONAMESPACE        102     
00086 #define ADM_ENOSUBSPACE         103     
00088 #define ADM_ENOWRITE            201     
00089 #define ADM_ENOREAD             202     
00090 #define ADM_ENOLISTSERIAL       203     
00091 #define ADM_ENOREADSERIAL       204     
00092 #define ADM_ENOCACHE            205     
00094 #define ADM_ENOBOXTYPE          251     
00096 #define ADM_EPARSE              301     
00098 typedef struct AdmRefStr AdmRefStr;
00099 
00100 AdmRefStr *     AdmRefStr_ref           (AdmRefStr      *refstr);
00101 void            AdmRefStr_unref         (AdmRefStr      *refstr);
00102 
00103 size_t          AdmRefStr_len           (AdmRefStr      *refstr);
00104 
00105 #define AdmRefStr_str(REFSTR) \
00106 ({ \
00107         AdmRefStr *__tok = (REFSTR); \
00108         (const char *) __tok; \
00109 })
00110 
00118 AdmRefStr *     AdmRefStr_get           (const char     *str,
00119                                          int             force);
00120 
00129 AdmRefStr *     AdmRefStr_nget          (const char     *str,
00130                                          size_t          len,
00131                                          int             force);
00132 
00133 typedef struct AdmData AdmData;
00134 
00135 typedef struct AdmList AdmList;
00136 
00137 typedef struct AdmInt AdmInt;
00138 
00139 typedef struct AdmBool AdmBool;
00140 
00141 typedef struct AdmFloat AdmFloat;
00142 
00143 typedef struct AdmString AdmString;
00144 
00145 typedef struct AdmString AdmBase64;
00146 
00147 typedef struct AdmString AdmCopy;
00148 
00149 typedef struct AdmIdentity AdmIdentity;
00150 
00151 typedef struct AdmContext AdmContext;
00152 
00153 typedef enum {
00154         ADM_TYPE_UNKNOWN = 0,
00155         ADM_TYPE_LIST    = 1,
00156         ADM_TYPE_COPY    = 2,
00157         ADM_TYPE_INT     = 3,
00158         ADM_TYPE_FLOAT   = 4,
00159         ADM_TYPE_BOOL    = 5,
00160         ADM_TYPE_STRING  = 6,
00161         ADM_TYPE_BASE64  = 7
00162 } AdmDataType;
00163 
00164 /* context create and destroy */
00179 AdmContext * AdmContext_new                 (const char  *name,
00180                                              unsigned int serial,
00181                                              AdmError **error);
00182 
00193 AdmContext * AdmContext_ref                 (AdmContext   *context,
00194                                              AdmError **error);
00195 
00209 void         AdmContext_unref               (AdmContext   *context,
00210                                              AdmError **error);
00211 
00212 
00213 /* context merge, copy, and flatten */
00223 AdmContext * AdmContext_copy                (AdmContext  *context,
00224                                              AdmError **error);
00225 
00244 AdmContext * AdmContext_merge               (const char  *name,
00245                                              unsigned int serial,
00246                                              AdmContext   *contextA,
00247                                              AdmContext   *contextB,
00248                                              AdmError **error);
00249 
00260 void         AdmContext_flatten             (AdmContext   *context,
00261                                              AdmError **error);
00262 
00272 void         AdmContext_strip               (AdmContext   *context,
00273                                              AdmError **error);
00274 
00275 
00276 /* context encode and decode */
00277 char *       AdmContext_toXML               (AdmContext   *context,
00278                                              AdmError **error);
00279 AdmContext * AdmContext_fromXML             (const char  *xml,
00280                                              AdmError **error);
00281 int          AdmContext_readFromFile        (AdmContext  **context,
00282                                              const char   *path,
00283                                              AdmError **error);
00284 
00285 int          AdmContext_writeToFile         (AdmContext   *context,
00286                                              const char   *path,
00287                                              int           mode,
00288                                              uid_t         uid,
00289                                              gid_t         gid,
00290                                              AdmError **error);
00291 
00292 /* context mask manuipulators */
00310 AdmRefStr * AdmContext_getMask           (AdmContext   *context,
00311                                              unsigned int index,
00312                                              AdmError **error);
00313 
00328 int         AdmContext_setMask           (AdmContext  *context,
00329                                              const char  *path,
00330                                              AdmError **error);
00331 
00346 int         AdmContext_clearMaskByIndex  (AdmContext  *context,
00347                                              unsigned int index,
00348                                              AdmError **error);
00349 
00363 int         AdmContext_clearMaskByPath   (AdmContext  *context,
00364                                              const char  *path,
00365                                              AdmError **error);
00366 
00378 unsigned int AdmContext_getNumMasks       (AdmContext  *context,
00379                                              AdmError **error);
00380 
00381 
00382 /* identity related funcs */
00395 AdmIdentity *AdmContext_getIdentityRoot     (AdmContext   *context,
00396                                              AdmError **error);
00397 #define AdmContext_getIdentityRoot_b(CONTEXT, ERROR) \
00398 ({ \
00399         AdmError **__err = (ERROR); \
00400         AdmIdentity *__id; \
00401         __id = AdmContext_getIdentityRoot((CONTEXT), __err); \
00402         if (__id != NULL) \
00403                 AdmIdentity_unref(__id, __err); \
00404         __id; \
00405 })
00406 
00418 AdmIdentity *AdmIdentity_getParentA         (AdmIdentity  *identity,
00419                                              AdmError **error);
00420 #define AdmIdentity_getParentA_b(ID, ERROR) \
00421 ({ \
00422         AdmError **__err = (ERROR); \
00423         AdmIdentity *__id; \
00424         __id = AdmIdentity_getParentA((ID), __err); \
00425         if (__id != NULL) \
00426                 AdmIdentity_unref(__id, __err); \
00427         __id; \
00428 })
00429 
00441 AdmIdentity *AdmIdentity_getParentB         (AdmIdentity  *identity,
00442                                              AdmError **error);
00443 #define AdmIdentity_getParentB_b(ID, ERROR) \
00444 ({ \
00445         AdmError **__err = (ERROR); \
00446         AdmIdentity *__id; \
00447         __id = AdmIdentity_getParentB((ID), __err); \
00448         if (__id != NULL) \
00449                 AdmIdentity_unref(__id, __err); \
00450         __id; \
00451 })
00452 
00468 AdmRefStr    *AdmIdentity_getName            (AdmIdentity  *identity,
00469                                              AdmError **error);
00470 
00482 int         AdmIdentity_setName            (AdmIdentity  *identity,
00483                                              const char   *name,
00484                                              AdmError **error);
00485 
00496 unsigned int AdmIdentity_getSerial         (AdmIdentity  *identity,
00497                                              AdmError **error);
00498 
00510 int         AdmIdentity_setSerial          (AdmIdentity  *identity,
00511                                              unsigned int  serial,
00512                                              AdmError **error);
00513 
00525 AdmIdentity *AdmIdentity_ref                (AdmIdentity  *identity,
00526                                              AdmError **error);
00527 
00540 void         AdmIdentity_unref              (AdmIdentity  *identity,
00541                                              AdmError **error);
00542 
00554 AdmContext * AdmIdentity_getContext         (AdmIdentity  *identity,
00555                                              AdmError **error);
00556 #define AdmIdentity_getContext_b(ID, ERROR) \
00557 ({ \
00558         AdmError **__err = (ERROR); \
00559         AdmContext *__ctx; \
00560         __ctx = AdmIdentity_getContext((ID), __err); \
00561         if (__ctx != NULL) \
00562                 AdmContext_unref(__ctx, __err); \
00563         __ctx; \
00564 })
00565 
00581 int          AdmIdentity_isAlive            (AdmIdentity  *identity,
00582                                              AdmError **error);
00583 
00584 
00585 /* data group structure funcs */
00597 AdmData *    AdmContext_getDataRoot         (AdmContext   *context,
00598                                              AdmError **error);
00599 #define AdmContext_getDataRoot_b(CONTEXT, ERROR) \
00600 ({ \
00601         AdmError **__err = (ERROR); \
00602         AdmData *__data; \
00603         __data = AdmContext_getDataRoot((CONTEXT), __err); \
00604         if (__data != NULL) \
00605                 AdmData_unref(__data, __err); \
00606         __data; \
00607 })
00608 
00621 AdmData *    AdmData_getContainer           (AdmData      *data,
00622                                              AdmError **error);
00623 #define AdmData_getContainer_b(DATA, ERROR) \
00624 ({ \
00625         AdmError **__err = (ERROR); \
00626         AdmData *__data; \
00627         __data = AdmData_getContainer((DATA), __err); \
00628         if (__data != NULL) \
00629                 AdmData_unref(__data, __err); \
00630         __data; \
00631 })
00632 
00640 AdmData *    AdmData_getPrev                (AdmData      *data,
00641                                              int           wrap,
00642                                              AdmError **error);
00643 #define AdmData_getPrev_b(DATA, WRAP, ERROR) \
00644 ({ \
00645         AdmError **__err = (ERROR); \
00646         AdmData *__data; \
00647         __data = AdmData_getPrev((DATA), (WRAP), __err); \
00648         if (__data != NULL) \
00649                 AdmData_unref(__data, __err); \
00650         __data; \
00651 })
00652 
00660 AdmData *    AdmData_getNext                (AdmData      *data,
00661                                              int           wrap,
00662                                              AdmError **error);
00663 #define AdmData_getNext_b(DATA, WRAP, ERROR) \
00664 ({ \
00665         AdmError **__err = (ERROR); \
00666         AdmData *__data; \
00667         __data = AdmData_getNext((DATA), (WRAP), __err); \
00668         if (__data != NULL) \
00669                 AdmData_unref(__data, __err); \
00670         __data; \
00671 })
00672 
00684 AdmContext * AdmData_getContext             (AdmData      *data,
00685                                              AdmError **error);
00686 #define AdmData_getContext_b(DATA, ERROR) \
00687 ({ \
00688         AdmError **__err = (ERROR); \
00689         AdmContext *__ctx; \
00690         __ctx = AdmData_getContext((DATA), __err); \
00691         if (__ctx != NULL) \
00692                 AdmContext_unref(__ctx, __err); \
00693         __ctx; \
00694 })
00695         
00709 AdmData *    AdmContext_getDataByPath       (AdmContext   *context,
00710                                              const char  *path,
00711                                              AdmError **error);
00712 #define AdmContext_getDataByPath_b(CONTEXT, PATH, ERROR) \
00713 ({ \
00714         AdmError **__err = (ERROR); \
00715         AdmData *__data; \
00716         __data = AdmContext_getDataByPath((CONTEXT), (PATH), __err); \
00717         if (__data != NULL) \
00718                 AdmData_unref(__data, __err); \
00719         __data; \
00720 })
00721 
00722 /* data group meta funcs */
00733 AdmDataType  AdmData_getType                (AdmData      *data,
00734                                              AdmError **error);
00735 
00747 AdmData *   AdmData_ref                    (AdmData      *data,
00748                                              AdmError **error);
00749 
00762 void         AdmData_unref                  (AdmData      *data,
00763                                              AdmError **error);
00764 
00780 int          AdmData_isAlive                (AdmData      *data,
00781                                              AdmError **error);
00782 
00796 int         AdmData_unlink                 (AdmData      *data,
00797                                              AdmError **error);
00798 
00809 int         AdmData_validName              (const char   *name);
00810 
00826 AdmRefStr  * AdmData_getName                (AdmData      *data,
00827                                              AdmError **error);
00828 
00843 int         AdmData_setName                (AdmData      *data,
00844                                              const char   *name,
00845                                              AdmError **error);
00846 
00863 AdmRefStr * AdmData_getSource              (AdmData      *data,
00864                                              AdmError **error);
00865 
00880 int         AdmData_setSource              (AdmData      *data,
00881                                              const char   *source,
00882                                              AdmError **error);
00883 
00895 int          AdmData_isProtected            (AdmData      *data,
00896                                              AdmError **error);
00897 
00913 int         AdmData_setProtected           (AdmData      *data,
00914                                              int           state,
00915                                              AdmError **error);
00916 
00917 
00918 /* list meta funcs */
00930 int          AdmList_isAnonymous            (AdmList      *list,
00931                                              AdmError **error);
00932 
00949 int         AdmList_setAnonymous           (AdmList      *list,
00950                                              int           state,
00951                                              AdmError **error);
00952 
00964 int          AdmList_isAtomic               (AdmList      *list,
00965                                              AdmError **error);
00966 
00982 int         AdmList_setAtomic              (AdmList      *list,
00983                                              int           state,
00984                                              AdmError **error);
00985 
00997 int          AdmList_isPrepend              (AdmList      *list,
00998                                              AdmError **error);
00999 
01015 int         AdmList_setPrepend             (AdmList      *list,
01016                                              int           state,
01017                                              AdmError **error);
01018 
01019 
01020 /* list child funcs */
01032 unsigned int AdmList_getNumData         (AdmList      *list,
01033                                              AdmError **error);
01034 
01048 AdmData *    AdmList_getDataByIndex        (AdmList      *list,
01049                                              unsigned int  index,
01050                                              AdmError **error);
01051 #define AdmList_getDataByIndex_b(LIST, INDEX, ERROR) \
01052 ({ \
01053         AdmError **__err = (ERROR); \
01054         AdmData *__data; \
01055         __data = AdmList_getDataByIndex((LIST), (INDEX), __err); \
01056         if (__data != NULL) \
01057                 AdmData_unref(__data, __err); \
01058         __data; \
01059 })
01060 
01074 AdmData *    AdmList_getDataByName         (AdmList      *list,
01075                                              const char   *name,
01076                                              AdmError **error);
01077 #define AdmList_getDataByName_b(LIST, NAME, ERROR) \
01078 ({ \
01079         AdmError **__err = (ERROR); \
01080         AdmData *__data; \
01081         __data = AdmList_getDataByName((LIST), (NAME), __err); \
01082         if (__data != NULL) \
01083                 AdmData_unref(__data, __err); \
01084         __data; \
01085 })
01086 
01100 AdmData *    AdmList_getDataByPath         (AdmList      *list,
01101                                              const char   *path,
01102                                              AdmError **error);
01103 #define AdmList_getDataByPath_b(LIST, PATH, ERROR) \
01104 ({ \
01105         AdmError **__err = (ERROR); \
01106         AdmData *__data; \
01107         __data = AdmList_getDataByPath((LIST), (PATH), __err); \
01108         if (__data != NULL) \
01109                 AdmData_unref(__data, __err); \
01110         __data; \
01111 })
01112 
01133 AdmData *    AdmList_addData               (AdmList      *list,
01134                                              AdmDataType   type,
01135                                              const char   *name,
01136                                              AdmError **error);
01137 #define AdmList_addData_b(LIST, TYPE, NAME, ERROR) \
01138 ({ \
01139         AdmError **__err = (ERROR); \
01140         AdmData *__data; \
01141         __data = AdmList_addData((LIST), (TYPE), (NAME), __err); \
01142         if (__data != NULL) \
01143                 AdmData_unref(__data, __err); \
01144         __data; \
01145 })
01146 
01161 int         AdmList_moveData              (AdmList      *list,
01162                                              AdmData      *data,
01163                                              unsigned int  index,
01164                                              AdmError **error);
01165 
01180 int         AdmList_reparentData             (AdmList      *list,
01181                                              AdmData      *data,
01182                                              const char *name,
01183                                              unsigned int  index,
01184                                              AdmError **error);
01185 
01186 
01201 AdmData *    AdmList_copyData               (AdmList      *list,
01202                                              AdmData      *data,
01203                                              AdmError **error);
01204 #define AdmList_copyData_b(LIST, DATA, ERROR) \
01205 ({ \
01206         AdmError **__err = (ERROR); \
01207         AdmData *__data; \
01208         __data = AdmList_copyData((LIST), (DATA), __err); \
01209         if (__data != NULL) \
01210                 AdmData_unref(__data, __err); \
01211         __data; \
01212 })
01213 
01225 unsigned int AdmData_getPos                 (AdmData      *data,
01226                                              AdmError **error);
01227 
01228 
01229 /* scalar functions */
01239 int          AdmInt_getValue                (AdmInt       *int_scalar,
01240                                              AdmError **error);
01241 
01252 int         AdmInt_setValue                (AdmInt       *int_scalar,
01253                                              int          value,
01254                                              AdmError **error);
01255 
01265 double       AdmFloat_getValue              (AdmFloat     *float_scalar,
01266                                              AdmError **error);
01267 
01278 int         AdmFloat_setValue              (AdmFloat     *float_scalar,
01279                                              double        value,
01280                                              AdmError **error);
01281 
01291 int          AdmBool_getValue               (AdmBool      *bool_scalar,
01292                                              AdmError **error);
01293 
01304 int         AdmBool_setValue               (AdmBool      *bool_scalar,
01305                                              int           value,
01306                                              AdmError **error);
01307 
01324 AdmRefStr * AdmString_getValue             (AdmString    *string_scalar,
01325                                              AdmError **error);
01326 
01338 int         AdmString_setValue             (AdmString    *string_scalar,
01339                                              const char   *value,
01340                                              AdmError **error);
01341 
01353 AdmRefStr * AdmBase64_getValue             (AdmBase64    *base64_scalar,
01354                                              AdmError **error);
01355 
01366 int         AdmBase64_setValue             (AdmBase64    *base64_scalar,
01367                                              const char   *value,
01368                                                 AdmError **error);
01381 size_t       AdmBase64_getBinValue          (AdmBase64    *base64_scalar,
01382                                              void        **value,
01383                                              AdmError **error);
01395 int          AdmBase64_setBinValue          (AdmBase64    *base64_scalar,
01396                                              const void  *value,
01397                                              size_t       size,
01398                                              AdmError **error);
01399 
01413 AdmRefStr * AdmCopy_getValue               (AdmCopy      *copy_scalar,
01414                                              AdmError **error);
01415 
01426 int         AdmCopy_setValue               (AdmCopy      *copy_scalar,
01427                                              const char   *value,
01428                                              AdmError **error);
01429 
01430 /* blackbox prototypes */
01431 typedef struct AdmBlackBox AdmBlackBox;
01432 
01433 
01440 AdmRefStr * AdmBlackBox_getCacheDir       (AdmError **error);
01441 
01449 int          AdmBlackBox_setCacheDir       (const char *path,
01450                                              AdmError **error);
01451 
01452 AdmBlackBox *AdmBlackBox_getBox             (AdmList      *box_cfg,
01453                                              AdmError **error);
01454 
01455 typedef struct {
01456         unsigned char array[1];
01457 } adm_bb_cap_t;
01466 adm_bb_cap_t AdmBlackBox_caps                   (AdmBlackBox  *box,
01467                                                  AdmError **error);
01468 #define ADM_BBCAP_SUP_WRITE(CAP)        ((CAP).array[0] & (1 << 0))
01469 #define ADM_BBCAP_SUP_READ(CAP)         ((CAP).array[0] & (1 << 1))
01470 #define ADM_BBCAP_SUP_LISTSERIAL(CAP)   ((CAP).array[0] & (1 << 2))
01471 #define ADM_BBCAP_SUP_READSERIAL(CAP)   ((CAP).array[0] & (1 << 3))
01472 #define ADM_BBCAP_CACHED(CAP)           ((CAP).array[0] & (1 << 4))
01473 
01481 void         AdmBlackBox_ref                (AdmBlackBox  *box,
01482                                              AdmError **error);
01483 
01491 void         AdmBlackBox_unref              (AdmBlackBox  *box,
01492                                              AdmError **error);
01493 
01504 AdmContext * AdmBlackBox_read               (AdmBlackBox  *box,
01505                                              AdmError **error);
01506 
01525 int          AdmBlackBox_listSerial         (AdmBlackBox   *box,
01526                                              unsigned int  *array,
01527                                              unsigned int   array_len,
01528                                              unsigned int   top_serial,
01529                                              AdmError **error);
01530 
01541 AdmContext * AdmBlackBox_readSerial         (AdmBlackBox  *box,
01542                                              unsigned int  serial,
01543                                              AdmError **error);
01544 
01555 int          AdmBlackBox_write              (AdmBlackBox  *box,
01556                                              AdmContext   *context,
01557                                              AdmError **error);
01558 
01571 unsigned int AdmBlackBox_getMark            (AdmBlackBox  *box,
01572                                              const char   *mark,
01573                                              AdmError **error);
01598 int          AdmBlackBox_setMark            (AdmBlackBox  *box,
01599                                              const char   *mark,
01600                                              AdmError **error);
01601 
01611 int          AdmBlackBox_clearMark          (AdmBlackBox  *box,
01612                                              const char   *mark,
01613                                              AdmError **error);
01614 
01615 /* switchboard */
01622 AdmRefStr * AdmSwitchboard_getSwbDir       (AdmError **error);
01623 
01631 int          AdmSwitchboard_setSwbDir       (const char *path,
01632                                              AdmError **error);
01633 
01634 int          AdmSwitchboard_markNsp (const char   *namespace,
01635                                                 const char   *subspace,
01636                                                 const char   *mark,
01637                                                 AdmError **error);
01638 
01639 int          AdmSwitchboard_markNspWithConfig (
01640                                                 AdmList      *namespace_cfg,
01641                                                 const char   *subspace,
01642                                                 const char   *mark,
01643                                                 AdmError **error);
01644 
01645 int          AdmSwitchboard_checkNspMark     (const char   *namespace,
01646                                                 const char   *subspace,
01647                                                 const char   *mark,
01648                                                 AdmError **error);
01649 
01650 int          AdmSwitchboard_checkNspMarkWithConfig (
01651                                                 AdmList      *namespace_cfg,
01652                                                 const char   *subspace,
01653                                                 const char   *mark,
01654                                                 AdmError **error);
01655 
01663 AdmContext  *AdmSwitchboard_readNsp   (const char   *namespace,
01664                                      const char   *subspace,
01665                                      unsigned int depth,
01666                                              AdmError **error);
01667 
01668 AdmContext  *AdmSwitchboard_readNspWithConfig   (
01669                                                 AdmList      *namespace_cfg,
01670                                                 const char   *subspace,
01671                                                 unsigned int depth,
01672                                                 AdmError **error);
01673 
01681 int          AdmSwitchboard_writeNsp  (const char   *namespace,
01682                                              const char   *subspace,
01683                                              AdmContext   *context,
01684                                              AdmError **error);
01685 
01686 int          AdmSwitchboard_writeNspWithConfig  (
01687                                                 AdmList      *namespace_cfg,
01688                                                 const char   *subspace,
01689                                                 AdmContext   *context,
01690                                                 AdmError **error);
01691 
01698 AdmContext  *AdmSwitchboard_readNspCtx  (const char   *namespace,
01699                                                AdmError **error);
01700 
01711 int          AdmSwitchboard_writeNspCtx (const char   *namespace,
01712                                                AdmContext   *namespace_ctx,
01713                                                int           mode,
01714                                                uid_t         uid,
01715                                                gid_t         gid,
01716                                                AdmError    **error);
01717 
01723 AdmList     *AdmSwitchboard_getNspCfg   (
01724                                                AdmContext   *namespace_ctx,
01725                                                 const char   *namespace,
01726                                                AdmError **error);
01727 #define AdmSwitchboard_getNspCfg_b(CTX, NAMESPACE, ERROR) \
01728 ({ \
01729         AdmError **__err = (ERROR); \
01730         AdmList *__list; \
01731         __list = AdmSwitchboard_getNspCfg((CTX), (NAMESPACE), __err); \
01732         if (__list != NULL) \
01733                 AdmData_unref((AdmData *) __list, __err); \
01734         __list; \
01735 })
01736 
01743 AdmList     *AdmSwitchboard_getSubspCfg      (
01744                                                AdmList   *namespace_cfg,
01745                                                 const char   *subspace,
01746                                                AdmError **error);
01747 #define AdmSwitchboard_getSubspCfg_b(CTX, SUBSPACE, ERROR) \
01748 ({ \
01749         AdmError **__err = (ERROR); \
01750         AdmList *__list; \
01751         __list = AdmSwitchboard_getSubspCfg((CTX), (SUBSPACE), __err); \
01752         if (__list != NULL) \
01753                 AdmData_unref((AdmData *) __list, __err); \
01754         __list; \
01755 })
01756 
01757 
01763 AdmBlackBox *AdmSwitchboard_getBox         (
01764                                                AdmList   *subspace_cfg,
01765                                                 const char   *box_name,
01766                                                AdmError **error);
01767 
01768 #endif /* __ALCHEMIST__ */

Generated at Thu Aug 23 18:09:04 2001 for Alchemist by doxygen1.2.8.1 written by Dimitri van Heesch, © 1997-2001