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 AdmData *    AdmList_copyData               (AdmList      *list,
01181                                              AdmData      *data,
01182                                              AdmError **error);
01183 #define AdmList_copyData_b(LIST, DATA, ERROR) \
01184 ({ \
01185         AdmError **__err = (ERROR); \
01186         AdmData *__data; \
01187         __data = AdmList_copyData((LIST), (DATA), __err); \
01188         if (__data != NULL) \
01189                 AdmData_unref(__data, __err); \
01190         __data; \
01191 })
01192 
01208 AdmData *    AdmList_renameCopyData      (AdmList      *list,
01209                                              AdmData      *data,
01210                                              const char *name,
01211                                              AdmError **error);
01212 #define AdmList_renameCopyData_b(LIST, DATA, NAME, ERROR) \
01213 ({ \
01214         AdmError **__err = (ERROR); \
01215         AdmData *__data; \
01216         __data = AdmList_renameCopyData((LIST), (DATA), (NAME), __err); \
01217         if (__data != NULL) \
01218                 AdmData_unref(__data, __err); \
01219         __data; \
01220 })
01221 
01233 unsigned int AdmData_getPos                 (AdmData      *data,
01234                                              AdmError **error);
01235 
01236 
01237 /* scalar functions */
01247 int          AdmInt_getValue                (AdmInt       *int_scalar,
01248                                              AdmError **error);
01249 
01260 int         AdmInt_setValue                (AdmInt       *int_scalar,
01261                                              int          value,
01262                                              AdmError **error);
01263 
01273 double       AdmFloat_getValue              (AdmFloat     *float_scalar,
01274                                              AdmError **error);
01275 
01286 int         AdmFloat_setValue              (AdmFloat     *float_scalar,
01287                                              double        value,
01288                                              AdmError **error);
01289 
01299 int          AdmBool_getValue               (AdmBool      *bool_scalar,
01300                                              AdmError **error);
01301 
01312 int         AdmBool_setValue               (AdmBool      *bool_scalar,
01313                                              int           value,
01314                                              AdmError **error);
01315 
01332 AdmRefStr * AdmString_getValue             (AdmString    *string_scalar,
01333                                              AdmError **error);
01334 
01346 int         AdmString_setValue             (AdmString    *string_scalar,
01347                                              const char   *value,
01348                                              AdmError **error);
01349 
01361 AdmRefStr * AdmBase64_getValue             (AdmBase64    *base64_scalar,
01362                                              AdmError **error);
01363 
01374 int         AdmBase64_setValue             (AdmBase64    *base64_scalar,
01375                                              const char   *value,
01376                                                 AdmError **error);
01389 size_t       AdmBase64_getBinValue          (AdmBase64    *base64_scalar,
01390                                              void        **value,
01391                                              AdmError **error);
01403 int          AdmBase64_setBinValue          (AdmBase64    *base64_scalar,
01404                                              const void  *value,
01405                                              size_t       size,
01406                                              AdmError **error);
01407 
01421 AdmRefStr * AdmCopy_getValue               (AdmCopy      *copy_scalar,
01422                                              AdmError **error);
01423 
01434 int         AdmCopy_setValue               (AdmCopy      *copy_scalar,
01435                                              const char   *value,
01436                                              AdmError **error);
01437 
01438 /* blackbox prototypes */
01439 typedef struct AdmBlackBox AdmBlackBox;
01440 
01441 
01448 AdmRefStr * AdmBlackBox_getCacheDir       (AdmError **error);
01449 
01457 int          AdmBlackBox_setCacheDir       (const char *path,
01458                                              AdmError **error);
01459 
01460 AdmBlackBox *AdmBlackBox_getBox             (AdmList      *box_cfg,
01461                                              AdmError **error);
01462 
01463 typedef struct {
01464         unsigned char array[1];
01465 } adm_bb_cap_t;
01474 adm_bb_cap_t AdmBlackBox_caps                   (AdmBlackBox  *box,
01475                                                  AdmError **error);
01476 #define ADM_BBCAP_SUP_WRITE(CAP)        ((CAP).array[0] & (1 << 0))
01477 #define ADM_BBCAP_SUP_READ(CAP)         ((CAP).array[0] & (1 << 1))
01478 #define ADM_BBCAP_SUP_LISTSERIAL(CAP)   ((CAP).array[0] & (1 << 2))
01479 #define ADM_BBCAP_SUP_READSERIAL(CAP)   ((CAP).array[0] & (1 << 3))
01480 #define ADM_BBCAP_CACHED(CAP)           ((CAP).array[0] & (1 << 4))
01481 
01489 void         AdmBlackBox_ref                (AdmBlackBox  *box,
01490                                              AdmError **error);
01491 
01499 void         AdmBlackBox_unref              (AdmBlackBox  *box,
01500                                              AdmError **error);
01501 
01512 AdmContext * AdmBlackBox_read               (AdmBlackBox  *box,
01513                                              AdmError **error);
01514 
01533 int          AdmBlackBox_listSerial         (AdmBlackBox   *box,
01534                                              unsigned int  *array,
01535                                              unsigned int   array_len,
01536                                              unsigned int   top_serial,
01537                                              AdmError **error);
01538 
01549 AdmContext * AdmBlackBox_readSerial         (AdmBlackBox  *box,
01550                                              unsigned int  serial,
01551                                              AdmError **error);
01552 
01563 int          AdmBlackBox_write              (AdmBlackBox  *box,
01564                                              AdmContext   *context,
01565                                              AdmError **error);
01566 
01579 unsigned int AdmBlackBox_getMark            (AdmBlackBox  *box,
01580                                              const char   *mark,
01581                                              AdmError **error);
01606 int          AdmBlackBox_setMark            (AdmBlackBox  *box,
01607                                              const char   *mark,
01608                                              AdmError **error);
01609 
01619 int          AdmBlackBox_clearMark          (AdmBlackBox  *box,
01620                                              const char   *mark,
01621                                              AdmError **error);
01622 
01623 /* switchboard */
01630 AdmRefStr * AdmSwitchboard_getSwbDir       (AdmError **error);
01631 
01639 int          AdmSwitchboard_setSwbDir       (const char *path,
01640                                              AdmError **error);
01641 
01642 int          AdmSwitchboard_markNsp (const char   *namespace,
01643                                                 const char   *subspace,
01644                                                 const char   *mark,
01645                                                 AdmError **error);
01646 
01647 int          AdmSwitchboard_markNspWithConfig (
01648                                                 AdmList      *namespace_cfg,
01649                                                 const char   *subspace,
01650                                                 const char   *mark,
01651                                                 AdmError **error);
01652 
01653 int          AdmSwitchboard_checkNspMark     (const char   *namespace,
01654                                                 const char   *subspace,
01655                                                 const char   *mark,
01656                                                 AdmError **error);
01657 
01658 int          AdmSwitchboard_checkNspMarkWithConfig (
01659                                                 AdmList      *namespace_cfg,
01660                                                 const char   *subspace,
01661                                                 const char   *mark,
01662                                                 AdmError **error);
01663 
01671 AdmContext  *AdmSwitchboard_readNsp   (const char   *namespace,
01672                                      const char   *subspace,
01673                                      unsigned int depth,
01674                                              AdmError **error);
01675 
01676 AdmContext  *AdmSwitchboard_readNspWithConfig   (
01677                                                 AdmList      *namespace_cfg,
01678                                                 const char   *subspace,
01679                                                 unsigned int depth,
01680                                                 AdmError **error);
01681 
01689 int          AdmSwitchboard_writeNsp  (const char   *namespace,
01690                                              const char   *subspace,
01691                                              AdmContext   *context,
01692                                              AdmError **error);
01693 
01694 int          AdmSwitchboard_writeNspWithConfig  (
01695                                                 AdmList      *namespace_cfg,
01696                                                 const char   *subspace,
01697                                                 AdmContext   *context,
01698                                                 AdmError **error);
01699 
01706 AdmContext  *AdmSwitchboard_readNspCtx  (const char   *namespace,
01707                                                AdmError **error);
01708 
01719 int          AdmSwitchboard_writeNspCtx (const char   *namespace,
01720                                                AdmContext   *namespace_ctx,
01721                                                int           mode,
01722                                                uid_t         uid,
01723                                                gid_t         gid,
01724                                                AdmError    **error);
01725 
01731 AdmList     *AdmSwitchboard_getNspCfg   (
01732                                                AdmContext   *namespace_ctx,
01733                                                 const char   *namespace,
01734                                                AdmError **error);
01735 #define AdmSwitchboard_getNspCfg_b(CTX, NAMESPACE, ERROR) \
01736 ({ \
01737         AdmError **__err = (ERROR); \
01738         AdmList *__list; \
01739         __list = AdmSwitchboard_getNspCfg((CTX), (NAMESPACE), __err); \
01740         if (__list != NULL) \
01741                 AdmData_unref((AdmData *) __list, __err); \
01742         __list; \
01743 })
01744 
01751 AdmList     *AdmSwitchboard_getSubspCfg      (
01752                                                AdmList   *namespace_cfg,
01753                                                 const char   *subspace,
01754                                                AdmError **error);
01755 #define AdmSwitchboard_getSubspCfg_b(CTX, SUBSPACE, ERROR) \
01756 ({ \
01757         AdmError **__err = (ERROR); \
01758         AdmList *__list; \
01759         __list = AdmSwitchboard_getSubspCfg((CTX), (SUBSPACE), __err); \
01760         if (__list != NULL) \
01761                 AdmData_unref((AdmData *) __list, __err); \
01762         __list; \
01763 })
01764 
01765 
01771 AdmBlackBox *AdmSwitchboard_getBox         (
01772                                                AdmList   *subspace_cfg,
01773                                                 const char   *box_name,
01774                                                AdmError **error);
01775 
01776 #endif /* __ALCHEMIST__ */

Generated on Thu Jul 11 13:12:26 2002 for Alchemist by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002