1 /* ncbimisc.h 2 * =========================================================================== 3 * 4 * PUBLIC DOMAIN NOTICE 5 * National Center for Biotechnology Information 6 * 7 * This software/database is a "United States Government Work" under the 8 * terms of the United States Copyright Act. It was written as part of 9 * the author's official duties as a United States Government employee and 10 * thus cannot be copyrighted. This software/database is freely available 11 * to the public for use. The National Library of Medicine and the U.S. 12 * Government have not placed any restriction on its use or reproduction. 13 * 14 * Although all reasonable efforts have been taken to ensure the accuracy 15 * and reliability of the software and data, the NLM and the U.S. 16 * Government do not and cannot warrant the performance or results that 17 * may be obtained by using this software or data. The NLM and the U.S. 18 * Government disclaim all warranties, express or implied, including 19 * warranties of performance, merchantability or fitness for any particular 20 * purpose. 21 * 22 * Please cite the author in any work or product based on this material. 23 * 24 * =========================================================================== 25 * 26 * File Name: ncbimisc.h 27 * 28 * Author: Gish, Kans, Ostell, Schuler 29 * 30 * Version Creation Date: 10/23/91 31 * 32 * $Revision: 6.45 $ 33 * 34 * File Description: 35 * prototypes of miscellaneous functions 36 * 37 * Modifications: 38 * -------------------------------------------------------------------------- 39 * Date Name Description of modification 40 * ------- ---------- ----------------------------------------------------- 41 * 42 * ========================================================================== 43 */ 44 45 #ifndef _NCBIMISC_ 46 #define _NCBIMISC_ 47 48 #undef NLM_EXTERN 49 #ifdef NLM_IMPORT 50 #define NLM_EXTERN NLM_IMPORT 51 #else 52 #define NLM_EXTERN extern 53 #endif 54 55 56 #ifdef __cplusplus 57 extern "C" { 58 #endif 59 60 /* Obtain length of ASCII representation of signed and unsigned long integers */ 61 /* opts&1 ==> use commas before thousands, millions, etc. when |value| >=10000*/ 62 /* opts&2 ==> use commas before thousands, millions, etc. when |value| >=1000 */ 63 /* opts&4 ==> prepend + sign to any positive values */ 64 NLM_EXTERN int LIBCALL Nlm_Lwidth PROTO((long x, int opts)); 65 NLM_EXTERN int LIBCALL Nlm_Ulwidth PROTO((unsigned long x, int opts)); 66 67 /* convert integers to ASCII in static storage */ 68 /* Same 1,2,4 opts as Nlm_Lwidth and Nlm_Ulwidth */ 69 NLM_EXTERN char * LIBCALL Nlm_Ltostr PROTO((long x, int opts)); 70 NLM_EXTERN char * LIBCALL Nlm_Ultostr PROTO((unsigned long x, int opts)); 71 /* Nlm_Int8tostr -- convert a signed long integer to ASCII */ 72 NLM_EXTERN CharPtr LIBCALL Nlm_Int8tostr PROTO((Nlm_Int8 value, int opts)); 73 74 75 /* Sorting */ 76 NLM_EXTERN void LIBCALL Nlm_HeapSort PROTO((VoidPtr base, size_t nel, size_t width, int (LIBCALLBACK *cmp) (VoidPtr, VoidPtr) )); 77 /* Stable Sorting */ 78 NLM_EXTERN void LIBCALL Nlm_StableMergeSort PROTO((VoidPtr base, size_t nel, size_t width, int (LIBCALLBACK *cmp) (VoidPtr, VoidPtr) )); 79 80 /* Platform name */ 81 NLM_EXTERN const Nlm_Char* Nlm_PlatformName(void); 82 83 84 /***************************************************************************** 85 * 86 * DataVal = a universal data type 87 * ValNode = a linked list of DataVal 88 * 89 *****************************************************************************/ 90 91 92 typedef union dataval { 93 Nlm_VoidPtr ptrvalue; 94 Nlm_Int8 intvalue; 95 Nlm_FloatHi realvalue; 96 Nlm_Boolean boolvalue; 97 Nlm_FnPtr funcvalue; 98 Nlm_Int8 bigintvalue; 99 } DataVal, PNTR DataValPtr; 100 101 typedef struct valnode { 102 Nlm_Uint1 choice; /* to pick a choice */ 103 Nlm_Uint1 extended; /* extra fields reserved to NCBI allocated in structure */ 104 DataVal data; /* attached data */ 105 Nlm_Boolean fatal; 106 struct valnode PNTR next; /* next in linked list */ 107 } ValNode, PNTR ValNodePtr; 108 109 /***************************************************************************** 110 * 111 * ValNodeNew(vnp) 112 * adds after last node in list if vnp not NULL 113 * 114 * ValNodeLen(vnp) 115 * returns the number of nodes in the linked list 116 * 117 * ValNodeAdd(head) 118 * adds after last node in list if *head not NULL 119 * If *head is NULL, sets it to the new ValNode 120 * returns pointer to the NEW node added 121 * 122 * ValNodeLink(head, newnode) 123 * adds newnode at end of chain 124 * if (*head == NULL) *head = newnode 125 * ALWAYS returns pointer to START of chain 126 * 127 * ValNodeAddStr (head, choice, str) 128 * adds like ValNodeAdd() 129 * sets newnode->choice = choice (if choice does not matter, use 0) 130 * sets newnode->data.ptrvalue = str 131 * does NOT copy str 132 * if str == NULL, does NOT add a ValNode 133 * 134 * ValNodeCopyStr (head, choice, str) 135 * adds like ValNodeAdd() 136 * sets newnode->choice = choice (if choice does not matter, use 0) 137 * sets newnode->data.ptrvalue = str 138 * makes a COPY of str 139 * if str == NULL, does NOT add a ValNode 140 * 141 * ValNodeAddInt (head, choice, value) 142 * adds like ValNodeAdd() 143 * sets newnode->choice = choice (if choice does not matter, use 0) 144 * sets newnode->data.intvalue = value 145 * 146 * ValNodeAddBigInt (head, choice, value) 147 * adds like ValNodeAdd() 148 * sets newnode->choice = choice (if choice does not matter, use 0) 149 * sets newnode->data.bigintvalue = value 150 * 151 * ValNodeAddBoolean (head, choice, value) 152 * adds like ValNodeAdd() 153 * sets newnode->choice = choice (if choice does not matter, use 0) 154 * sets newnode->data.boolvalue = value 155 * 156 * ValNodeAddFloat (head, choice, value) 157 * adds like ValNodeAdd() 158 * sets newnode->choice = choice (if choice does not matter, use 0) 159 * sets newnode->data.realvalue = value 160 * 161 * ValNodeAddPointer (head, choice, value) 162 * adds like ValNodeAdd() 163 * sets newnode->choice = choice (if choice does not matter, use 0) 164 * sets newnode->data.ptrvalue = value 165 * 166 * ValNodeAddFunction (head, choice, value) 167 * adds like ValNodeAdd() 168 * sets newnode->choice = choice (if choice does not matter, use 0) 169 * sets newnode->data.funcvalue = value 170 * 171 * ValNodeFree(vnp) 172 * frees whole chain of ValNodes 173 * Does NOT free associated data pointers 174 * 175 * ValNodeFreeData(vnp) 176 * frees whole chain of ValNodes 177 * frees associated data pointers - BEWARE of this if these are not 178 * allocated single memory block structures. 179 * 180 * ValNodePtr ValNodeExtract(headptr, choice) 181 * removes first node in chain where ->choice == choice 182 * rejoins chain after removing the node 183 * sets node->next to NULL 184 * 185 * ValNodePtr ValNodeExtractList(headptr, choice) 186 * removes ALL nodes in chain where ->choice == choice 187 * rejoins chain after removing the nodes 188 * returns independent chain of extracted nodes 189 * 190 * ValNodeFindNext (head, curr, choice) 191 * Finds next ValNode with vnp->choice == choice after curr 192 * If curr == NULL, starts at head of list 193 * If choice < 0 , returns all ValNodes 194 * Returns NULL, when no more found 195 * 196 * ValNodeSort (list, compar) 197 * Copied from SortValNode in jzcoll, renamed, for more general access 198 * Makes array from ValNode list, calls HeapSort, reconnects ValNode list 199 * 200 * ValNodeMergeStrs(list) 201 * Merges chain of val node strings into a single character array 202 * 203 *****************************************************************************/ 204 NLM_EXTERN ValNodePtr LIBCALL ValNodeNew PROTO((ValNodePtr vnp)); 205 NLM_EXTERN Nlm_Int4 LIBCALL ValNodeLen PROTO((ValNodePtr vnp)); 206 NLM_EXTERN ValNodePtr LIBCALL ValNodeAdd PROTO((ValNodePtr PNTR head)); 207 NLM_EXTERN ValNodePtr LIBCALL ValNodeLink PROTO((ValNodePtr PNTR head, ValNodePtr newnode)); 208 NLM_EXTERN ValNodePtr LIBCALL ValNodeAddStr PROTO((ValNodePtr PNTR head, Nlm_Int2 choice, Nlm_CharPtr str)); 209 NLM_EXTERN ValNodePtr LIBCALL ValNodeCopyStr PROTO((ValNodePtr PNTR head, Nlm_Int2 choice, const char* str)); 210 NLM_EXTERN ValNodePtr LIBCALL ValNodeCopyStrEx PROTO((ValNodePtr PNTR head, ValNodePtr PNTR tail, Nlm_Int2 choice, const char* str)); 211 NLM_EXTERN ValNodePtr LIBCALL ValNodeCopyStrExEx PROTO((ValNodePtr PNTR head, ValNodePtr PNTR tail, Nlm_Int2 choice, const char* str, const char* pfx, const char* sfx)); 212 NLM_EXTERN ValNodePtr LIBCALL ValNodeAddInt PROTO((ValNodePtr PNTR head, Nlm_Int2 choice, Nlm_Int4 value)); 213 NLM_EXTERN ValNodePtr LIBCALL ValNodeAddBigInt (ValNodePtr PNTR head, Nlm_Int2 choice, Nlm_Int8 value); 214 NLM_EXTERN ValNodePtr LIBCALL ValNodeAddBoolean PROTO((ValNodePtr PNTR head, Nlm_Int2 choice, Nlm_Boolean value)); 215 NLM_EXTERN ValNodePtr LIBCALL ValNodeAddFloat PROTO((ValNodePtr PNTR head, Nlm_Int2 choice, Nlm_FloatHi value)); 216 NLM_EXTERN ValNodePtr LIBCALL ValNodeAddPointer PROTO((ValNodePtr PNTR head, Nlm_Int2 choice, Nlm_VoidPtr value)); 217 NLM_EXTERN ValNodePtr LIBCALL ValNodeAddPointerEx PROTO((ValNodePtr PNTR head, ValNodePtr PNTR tail, Nlm_Int2 choice, Nlm_VoidPtr value)); 218 NLM_EXTERN ValNodePtr LIBCALL ValNodeAddFunction PROTO((ValNodePtr PNTR head, Nlm_Int2 choice, Nlm_FnPtr value)); 219 NLM_EXTERN ValNodePtr LIBCALL ValNodeFree PROTO((ValNodePtr vnp)); 220 NLM_EXTERN ValNodePtr LIBCALL ValNodeFreeData PROTO((ValNodePtr vnp)); 221 NLM_EXTERN ValNodePtr LIBCALL ValNodeExtract PROTO((ValNodePtr PNTR headptr, Nlm_Int2 choice)); 222 NLM_EXTERN ValNodePtr LIBCALL ValNodeExtractList PROTO((ValNodePtr PNTR headptr, Nlm_Int2 choice)); 223 NLM_EXTERN ValNodePtr LIBCALL ValNodeFindNext PROTO((ValNodePtr head, ValNodePtr curr, Nlm_Int2 choice)); 224 NLM_EXTERN ValNodePtr LIBCALL ValNodeSort PROTO((ValNodePtr list, int (LIBCALLBACK *compar) (VoidPtr, VoidPtr))); 225 NLM_EXTERN Nlm_Boolean LIBCALL ValNodeIsSorted PROTO((ValNodePtr list, int (LIBCALLBACK *compar) (VoidPtr, VoidPtr))); 226 NLM_EXTERN void LIBCALL ValNodeUnique PROTO ((ValNodePtr PNTR list, int (LIBCALLBACK *compar )PROTO ((Nlm_VoidPtr, Nlm_VoidPtr )), ValNodePtr (LIBCALLBACK *valnodefree ) PROTO ((ValNodePtr)))); 227 NLM_EXTERN ValNodePtr LIBCALL ValNodeDupList PROTO((ValNodePtr orig, ValNodePtr (LIBCALLBACK *copy )PROTO ((ValNodePtr)))); 228 NLM_EXTERN void LIBCALL ValNodePurge PROTO ((ValNodePtr PNTR list, Nlm_Boolean (LIBCALLBACK *do_remove ) PROTO ((ValNodePtr)), ValNodePtr (LIBCALLBACK *valnodefree ) PROTO ((ValNodePtr)))); 229 NLM_EXTERN void LIBCALL ValNodeInsert PROTO ((ValNodePtr PNTR list, ValNodePtr new_item, int (LIBCALLBACK *compar )PROTO ((Nlm_VoidPtr, Nlm_VoidPtr )))); 230 NLM_EXTERN int LIBCALL ValNodeCompare PROTO ((ValNodePtr vnp1, ValNodePtr vnp2, int (LIBCALLBACK *compar) (VoidPtr, VoidPtr))); 231 NLM_EXTERN Nlm_CharPtr LIBCALL ValNodeMergeStrs PROTO((ValNodePtr list)); 232 NLM_EXTERN Nlm_CharPtr LIBCALL ValNodeMergeStrsEx PROTO((ValNodePtr list, Nlm_CharPtr separator)); 233 NLM_EXTERN Nlm_CharPtr LIBCALL ValNodeMergeStrsExEx PROTO((ValNodePtr list, Nlm_CharPtr separator, Nlm_CharPtr pfx, Nlm_CharPtr sfx)); 234 235 NLM_EXTERN Nlm_CharPtr LIBCALL MergeStringArray PROTO((Nlm_CharPtr PNTR local, size_t numitems)); 236 237 /* convenience structure for holding head and tail of ValNode list for efficient tail insertion */ 238 typedef struct valnodeblock { 239 ValNodePtr head; 240 ValNodePtr tail; 241 } ValNodeBlock, PNTR ValNodeBlockPtr; 242 243 /*** old prototypes ****** 244 NLM_EXTERN ValNodePtr LIBCALL ValNodeLink PROTO((ValNodePtr vnp, ValNodePtr newnode)); 245 NLM_EXTERN ValNodePtr LIBCALL ValNodeExtract PROTO((ValNodePtr PNTR headptr, Nlm_Uint1 choice)); 246 **************************/ 247 248 NLM_EXTERN ValNodePtr LIBCALL NodeListNew PROTO((void)); 249 NLM_EXTERN ValNodePtr LIBCALL NodeListFree PROTO((ValNodePtr head)); 250 NLM_EXTERN Nlm_Int2 LIBCALL NodeListLen PROTO((ValNodePtr head)); 251 NLM_EXTERN ValNodePtr LIBCALL NodeListFind PROTO((ValNodePtr head, Nlm_Int2 item, Nlm_Boolean extend)); 252 NLM_EXTERN Nlm_Boolean LIBCALL NodeListRead PROTO((ValNodePtr head, Nlm_Int2 item, Nlm_VoidPtr ptr, size_t size)); 253 NLM_EXTERN Nlm_Boolean LIBCALL NodeListWrite PROTO((ValNodePtr head, Nlm_Int2 item, Nlm_VoidPtr ptr, size_t size)); 254 NLM_EXTERN Nlm_Boolean LIBCALL NodeListAppend PROTO((ValNodePtr head, Nlm_VoidPtr ptr, size_t size)); 255 NLM_EXTERN Nlm_Boolean LIBCALL NodeListInsert PROTO((ValNodePtr head, Nlm_Int2 item, Nlm_VoidPtr ptr, size_t size)); 256 NLM_EXTERN Nlm_Boolean LIBCALL NodeListReplace PROTO((ValNodePtr head, Nlm_Int2 item, Nlm_VoidPtr ptr, size_t size)); 257 NLM_EXTERN Nlm_Boolean LIBCALL NodeListDelete PROTO((ValNodePtr head, Nlm_Int2 item)); 258 259 /* doubly-linked lists */ 260 typedef struct Node PNTR NodePtr; 261 typedef struct Node { 262 VoidPtr elem; /* pointer to the element */ 263 NodePtr last; /* previous element */ 264 NodePtr next; /* next element */ 265 } Node; 266 267 #define ASCEND 0 /* order for ListSort */ 268 #define DESCEND 1 269 270 /* functions for doubly-linked lists */ 271 272 NLM_EXTERN NodePtr LIBCALL ListInsert PROTO((VoidPtr elem, NodePtr after)); 273 274 NLM_EXTERN NodePtr LIBCALL ListInsertPrev PROTO((VoidPtr elem, NodePtr before)); 275 276 NLM_EXTERN NodePtr LIBCALL ListDelete PROTO((NodePtr node)); 277 278 NLM_EXTERN NodePtr LIBCALL ListGetNext PROTO((NodePtr after)); 279 280 NLM_EXTERN void LIBCALL ListSwapAdj PROTO((NodePtr priornode, NodePtr nextnode)); 281 282 NLM_EXTERN NodePtr LIBCALL ListSort PROTO((NodePtr sl, int (*cmpfunc)(NodePtr, NodePtr), int order)); 283 284 NLM_EXTERN void LIBCALL ListBreakRing PROTO((NodePtr np)); 285 286 NLM_EXTERN void LIBCALL ListConnectRing PROTO((NodePtr np)); 287 NLM_EXTERN NodePtr LIBCALL ListStrCopy PROTO((NodePtr strlist)); 288 NLM_EXTERN void LIBCALL ListStrDel PROTO((NodePtr np)); 289 290 291 /****** Choice is a compact variant of ValNode **********/ 292 293 typedef union _IntPnt_ { 294 Int4 intvalue; 295 Pointer ptrvalue; 296 } IntPnt; 297 298 typedef struct _Choice_ { 299 Uint1 choice; 300 IntPnt value; 301 } Choice, PNTR ChoicePtr; 302 303 #define Lwidth Nlm_Lwidth 304 #define Ulwidth Nlm_Ulwidth 305 #define Ltostr Nlm_Ltostr 306 #define Ultostr Nlm_Ultostr 307 #define HeapSort Nlm_HeapSort 308 #define StableMergeSort Nlm_StableMergeSort 309 310 #if defined(OS_MAC) || defined(OS_UNIX_DARWIN) 311 NLM_EXTERN void Nlm_CtoPstr PROTO((Nlm_CharPtr str)); 312 NLM_EXTERN void Nlm_PtoCstr PROTO((Nlm_CharPtr str)); 313 #endif 314 315 /* these functions reverse byte order in integers 316 calling the same function a second time switches it back 317 the native ENDIAN nature of the machine is not considered 318 */ 319 NLM_EXTERN Uint2 Nlm_SwitchUint2 PROTO ((Uint2 value)); 320 NLM_EXTERN void Nlm_SwitchUint2Buff PROTO ((Uint2 *buff, int count)); 321 NLM_EXTERN unsigned long Nlm_SwitchLong PROTO ((unsigned long value)); 322 NLM_EXTERN void Nlm_SwitchLongBuff PROTO ((unsigned long *buff, int count)); 323 NLM_EXTERN Uint4 Nlm_SwitchUint4 PROTO ((Uint4 value)); 324 NLM_EXTERN void Nlm_SwitchUint4Buff PROTO ((Uint4 *buff, int count)); 325 326 #define SwitchUint2 Nlm_SwitchUint2 327 #define SwitchUint2Buff Nlm_SwitchUint2Buff 328 #define SwitchLong Nlm_SwitchLong 329 #define SwitchLongBuff Nlm_SwitchLongBuff 330 #define SwitchUint4 Nlm_SwitchUint4 331 #define SwitchUint4Buff Nlm_SwitchUint4Buff 332 333 /** The following defines ALWAYS assume the value to switched is 334 BIG_ENDIAN. This is used to allow portable use of binary integers 335 in some NCBI applications such as BLAST and some indexes ****/ 336 337 #ifdef IS_LITTLE_ENDIAN 338 #define Nlm_SwapUint2(value) Nlm_SwitchUint2(value) 339 #define Nlm_SwapUint2Buff(buff, count) Nlm_SwitchUint2Buff(buff, count) 340 #define Nlm_SwapLong(value) Nlm_SwitchLong(value) 341 #define Nlm_SwapLongBuff(buff, count) Nlm_SwitchLongBuff(buff, count) 342 #define Nlm_SwapUint4(value) Nlm_SwitchUint4(value) 343 #define Nlm_SwapUint4Buff(buff, count) Nlm_SwitchUint4Buff(buff, count) 344 #else 345 #define Nlm_SwapUint2(value) (value) 346 #define Nlm_SwapUint2Buff(buff, count) 347 #define Nlm_SwapLong(value) (value) 348 #define Nlm_SwapLongBuff(buff, count) 349 #define Nlm_SwapUint4(value) (value) 350 #define Nlm_SwapUint4Buff(buff, count) 351 #endif 352 353 #define SwapUint2 Nlm_SwapUint2 354 #define SwapUint2Buff Nlm_SwapUint2Buff 355 #define SwapLong Nlm_SwapLong 356 #define SwapLongBuff Nlm_SwapLongBuff 357 #define SwapUint4 Nlm_SwapUint4 358 #define SwapUint4Buff Nlm_SwapUint4Buff 359 360 361 /** 362 * MD5 stuff 363 */ 364 typedef struct md5context_ { 365 Nlm_Uint4 buf[4]; 366 Nlm_Uint4 bits[2]; 367 Nlm_Uchar in[64]; 368 } Nlm_MD5Context, PNTR Nlm_MD5ContextPtr; 369 370 NLM_EXTERN void LIBCALL Nlm_MD5Init PROTO((Nlm_MD5ContextPtr context)); 371 NLM_EXTERN void LIBCALL Nlm_MD5Update PROTO((Nlm_MD5ContextPtr context, Nlm_UcharPtr buf, Nlm_Uint4 len)); 372 NLM_EXTERN void LIBCALL Nlm_MD5Final PROTO((Nlm_MD5ContextPtr context, Nlm_Uchar digest[16])); 373 NLM_EXTERN void LIBCALL Nlm_MD5Transform PROTO((Nlm_Uint4 buf[4], Nlm_Uint4 in[16])); 374 375 #define MD5Context Nlm_MD5Context 376 #define MD5ContextPtr Nlm_MD5ContextPtr 377 #define MD5Init Nlm_MD5Init 378 #define MD5Update Nlm_MD5Update 379 #define MD5Final Nlm_MD5Final 380 #define MD5Transform Nlm_MD5Transform 381 382 /* Error codes for the CTX_NCBIMISC context */ 383 384 Uint4 Nlm_GetChecksum(CharPtr p); 385 386 387 /* Simple XML Parsing */ 388 389 typedef struct xmlobj { 390 Nlm_CharPtr name; 391 Nlm_CharPtr contents; 392 Nlm_Int2 level; 393 struct xmlobj *attributes; 394 struct xmlobj *children; 395 struct xmlobj *next; 396 struct xmlobj *parent; 397 struct xmlobj *successor; /* linearizes a recursive exploration */ 398 } Nlm_XmlObj, PNTR Nlm_XmlObjPtr; 399 400 #define XmlObj Nlm_XmlObj 401 #define XmlObjPtr Nlm_XmlObjPtr 402 403 NLM_EXTERN Nlm_XmlObjPtr ParseXmlString ( 404 Nlm_CharPtr str 405 ); 406 407 NLM_EXTERN void WriteXmlObject ( 408 Nlm_XmlObjPtr xop, 409 FILE *fp 410 ); 411 412 NLM_EXTERN void WriteXmlObjectEx ( 413 Nlm_XmlObjPtr xop, 414 FILE *fp, 415 Nlm_Boolean useTabs, 416 Nlm_Boolean altSelfClose 417 ); 418 419 NLM_EXTERN Nlm_XmlObjPtr FreeXmlObject ( 420 Nlm_XmlObjPtr xop 421 ); 422 423 NLM_EXTERN Nlm_CharPtr DecodeXml ( 424 Nlm_CharPtr str 425 ); 426 427 NLM_EXTERN Nlm_CharPtr EncodeXml ( 428 Nlm_CharPtr str 429 ); 430 431 NLM_EXTERN Nlm_CharPtr EncodeXmlEx ( 432 Nlm_CharPtr str 433 ); 434 435 typedef void (*VisitXmlNodeFunc) (Nlm_XmlObjPtr xop, Nlm_XmlObjPtr parent, Nlm_Int2 level, Nlm_VoidPtr userdata); 436 437 /* VisitXmlNodes does a recursive exploration from the root node */ 438 439 NLM_EXTERN Nlm_Int4 VisitXmlNodes ( 440 Nlm_XmlObjPtr xop, 441 Nlm_VoidPtr userdata, 442 VisitXmlNodeFunc callback, 443 Nlm_CharPtr nodeFilter, 444 Nlm_CharPtr parentFilter, 445 Nlm_CharPtr attrTagFilter, 446 Nlm_CharPtr attrValFilter, 447 Nlm_Int2 maxDepth 448 ); 449 450 /* VisitXmlAttributes just scans attributes on the current node */ 451 452 NLM_EXTERN Nlm_Int4 VisitXmlAttributes ( 453 Nlm_XmlObjPtr xop, 454 Nlm_VoidPtr userdata, 455 VisitXmlNodeFunc callback, 456 Nlm_CharPtr attrTagFilter, 457 Nlm_CharPtr attrValFilter 458 ); 459 460 /* XmlPathSuffixIs allows /parent/node path check to be done in the callback */ 461 462 NLM_EXTERN Nlm_Boolean XmlPathSuffixIs ( 463 Nlm_XmlObjPtr xop, 464 Nlm_CharPtr suffix 465 ); 466 467 /* 468 Note: Use <urlquery.h> QUERY_CopyResultsToString (conn) to get XML string 469 directly from network connection without going through file intermediate. 470 */ 471 472 NLM_EXTERN Nlm_CharPtr XmlFileToString ( 473 FILE *ifp 474 ); 475 476 477 #ifdef __cplusplus 478 } 479 #endif 480 481 482 #undef NLM_EXTERN 483 #ifdef NLM_EXPORT 484 #define NLM_EXTERN NLM_EXPORT 485 #else 486 #define NLM_EXTERN 487 #endif 488 489 490 #endif /* !_NCBIMISC_ */ 491 492