NCBI C Toolkit Cross Reference

C/access/objent2.c

  1 #include <asn.h>
  2 
  3 #define NLM_GENERATED_CODE_PROTO
  4 
  5 #include <objent2.h>
  6 
  7 static Boolean loaded = FALSE;
  8 
  9 #include <asnent2.h>
 10 
 11 #ifndef NLM_EXTERN_LOADS
 12 #define NLM_EXTERN_LOADS {}
 13 #endif
 14 
 15 NLM_EXTERN Boolean LIBCALL
 16 objent2AsnLoad(void)
 17 {
 18 
 19    if ( ! loaded) {
 20       NLM_EXTERN_LOADS
 21 
 22       if ( ! AsnLoad ())
 23       return FALSE;
 24       loaded = TRUE;
 25    }
 26 
 27    return TRUE;
 28 }
 29 
 30 
 31 
 32 /**************************************************
 33 *    Generated object loaders for Module NCBI-Entrez2
 34 *    Generated using ASNCODE Revision: 6.13 at Jan 28, 2002 12:12 PM
 35 *    Manual addition to swap bytes in id list if IS_LITTLE_ENDIAN
 36 *
 37 **************************************************/
 38 
 39 
 40 /**************************************************
 41 *
 42 *    Entrez2IdListNew()
 43 *
 44 **************************************************/
 45 NLM_EXTERN 
 46 Entrez2IdListPtr LIBCALL
 47 Entrez2IdListNew(void)
 48 {
 49    Entrez2IdListPtr ptr = MemNew((size_t) sizeof(Entrez2IdList));
 50 
 51    return ptr;
 52 
 53 }
 54 
 55 
 56 /**************************************************
 57 *
 58 *    Entrez2IdListFree()
 59 *
 60 **************************************************/
 61 NLM_EXTERN 
 62 Entrez2IdListPtr LIBCALL
 63 Entrez2IdListFree(Entrez2IdListPtr ptr)
 64 {
 65 
 66    if(ptr == NULL) {
 67       return NULL;
 68    }
 69    MemFree(ptr -> db);
 70    BSFree(ptr -> uids);
 71    return MemFree(ptr);
 72 }
 73 
 74 
 75 /**************************************************
 76 *
 77 *    Entrez2IdListAsnRead()
 78 *
 79 **************************************************/
 80 NLM_EXTERN 
 81 Entrez2IdListPtr LIBCALL
 82 Entrez2IdListAsnRead(AsnIoPtr aip, AsnTypePtr orig)
 83 {
 84    DataVal av;
 85    AsnTypePtr atp;
 86    Boolean isError = FALSE;
 87    AsnReadFunc func;
 88    Entrez2IdListPtr ptr;
 89 
 90    if (! loaded)
 91    {
 92       if (! objent2AsnLoad()) {
 93          return NULL;
 94       }
 95    }
 96 
 97    if (aip == NULL) {
 98       return NULL;
 99    }
100 
101    if (orig == NULL) {         /* Entrez2IdList ::= (self contained) */
102       atp = AsnReadId(aip, amp, ENTREZ2_ID_LIST);
103    } else {
104       atp = AsnLinkType(orig, ENTREZ2_ID_LIST);
105    }
106    /* link in local tree */
107    if (atp == NULL) {
108       return NULL;
109    }
110 
111    ptr = Entrez2IdListNew();
112    if (ptr == NULL) {
113       goto erret;
114    }
115    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
116       goto erret;
117    }
118 
119    atp = AsnReadId(aip,amp, atp);
120    func = NULL;
121 
122    if (atp == ENTREZ2_ID_LIST_db) {
123       if ( AsnReadVal(aip, atp, &av) <= 0) {
124          goto erret;
125       }
126       ptr -> db = av.ptrvalue;
127       atp = AsnReadId(aip,amp, atp);
128    }
129    if (atp == ENTREZ2_ID_LIST_num) {
130       if ( AsnReadVal(aip, atp, &av) <= 0) {
131          goto erret;
132       }
133       ptr -> num = av.intvalue;
134       atp = AsnReadId(aip,amp, atp);
135    }
136    if (atp == ENTREZ2_ID_LIST_uids) {
137       if ( AsnReadVal(aip, atp, &av) <= 0) {
138          goto erret;
139       }
140       /* ptr -> uids = av.ptrvalue; */
141 
142       /* manually added */
143       ptr -> uids = BSDupAndSwapUint4 ((ByteStorePtr) av.ptrvalue);
144       BSFree ((ByteStorePtr) av.ptrvalue);
145 
146       atp = AsnReadId(aip,amp, atp);
147    }
148 
149    if (AsnReadVal(aip, atp, &av) <= 0) {
150       goto erret;
151    }
152    /* end struct */
153 
154 ret:
155    AsnUnlinkType(orig);       /* unlink local tree */
156    return ptr;
157 
158 erret:
159    aip -> io_failure = TRUE;
160    ptr = Entrez2IdListFree(ptr);
161    goto ret;
162 }
163 
164 
165 
166 /**************************************************
167 *
168 *    Entrez2IdListAsnWrite()
169 *
170 **************************************************/
171 NLM_EXTERN Boolean LIBCALL 
172 Entrez2IdListAsnWrite(Entrez2IdListPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
173 {
174    DataVal av;
175    AsnTypePtr atp;
176    Boolean retval = FALSE;
177 
178    if (! loaded)
179    {
180       if (! objent2AsnLoad()) {
181          return FALSE;
182       }
183    }
184 
185    if (aip == NULL) {
186       return FALSE;
187    }
188 
189    atp = AsnLinkType(orig, ENTREZ2_ID_LIST);   /* link local tree */
190    if (atp == NULL) {
191       return FALSE;
192    }
193 
194    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
195    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
196       goto erret;
197    }
198 
199    if (ptr -> db != NULL) {
200       av.ptrvalue = ptr -> db;
201       retval = AsnWrite(aip, ENTREZ2_ID_LIST_db,  &av);
202    }
203    av.intvalue = ptr -> num;
204    retval = AsnWrite(aip, ENTREZ2_ID_LIST_num,  &av);
205    if (ptr -> uids != NULL) {
206       /* av.ptrvalue = ptr -> uids; */
207 
208       /* manually added */
209       av.ptrvalue = BSDupAndSwapUint4 ((ByteStorePtr) ptr -> uids);
210 
211       retval = AsnWrite(aip, ENTREZ2_ID_LIST_uids,  &av);
212 
213       /* manually added */
214       BSFree ((ByteStorePtr) av.ptrvalue);
215    }
216    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
217       goto erret;
218    }
219    retval = TRUE;
220 
221 erret:
222    AsnUnlinkType(orig);       /* unlink local tree */
223    return retval;
224 }
225 
226 
227 
228 /**************************************************
229 *
230 *    Entrez2BooleanExpNew()
231 *
232 **************************************************/
233 NLM_EXTERN 
234 Entrez2BooleanExpPtr LIBCALL
235 Entrez2BooleanExpNew(void)
236 {
237    Entrez2BooleanExpPtr ptr = MemNew((size_t) sizeof(Entrez2BooleanExp));
238 
239    return ptr;
240 
241 }
242 
243 
244 /**************************************************
245 *
246 *    Entrez2BooleanExpFree()
247 *
248 **************************************************/
249 NLM_EXTERN 
250 Entrez2BooleanExpPtr LIBCALL
251 Entrez2BooleanExpFree(Entrez2BooleanExpPtr ptr)
252 {
253 
254    if(ptr == NULL) {
255       return NULL;
256    }
257    MemFree(ptr -> db);
258    AsnGenericChoiceSeqOfFree(ptr -> exp, (AsnOptFreeFunc) Entrez2BooleanElementFree);
259    Entrez2LimitsFree(ptr -> limits);
260    return MemFree(ptr);
261 }
262 
263 
264 /**************************************************
265 *
266 *    Entrez2BooleanExpAsnRead()
267 *
268 **************************************************/
269 NLM_EXTERN 
270 Entrez2BooleanExpPtr LIBCALL
271 Entrez2BooleanExpAsnRead(AsnIoPtr aip, AsnTypePtr orig)
272 {
273    DataVal av;
274    AsnTypePtr atp;
275    Boolean isError = FALSE;
276    AsnReadFunc func;
277    Entrez2BooleanExpPtr ptr;
278 
279    if (! loaded)
280    {
281       if (! objent2AsnLoad()) {
282          return NULL;
283       }
284    }
285 
286    if (aip == NULL) {
287       return NULL;
288    }
289 
290    if (orig == NULL) {         /* Entrez2BooleanExp ::= (self contained) */
291       atp = AsnReadId(aip, amp, ENTREZ2_BOOLEAN_EXP);
292    } else {
293       atp = AsnLinkType(orig, ENTREZ2_BOOLEAN_EXP);
294    }
295    /* link in local tree */
296    if (atp == NULL) {
297       return NULL;
298    }
299 
300    ptr = Entrez2BooleanExpNew();
301    if (ptr == NULL) {
302       goto erret;
303    }
304    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
305       goto erret;
306    }
307 
308    atp = AsnReadId(aip,amp, atp);
309    func = NULL;
310 
311    if (atp == ENTREZ2_BOOLEAN_EXP_db) {
312       if ( AsnReadVal(aip, atp, &av) <= 0) {
313          goto erret;
314       }
315       ptr -> db = av.ptrvalue;
316       atp = AsnReadId(aip,amp, atp);
317    }
318    if (atp == ENTREZ2_BOOLEAN_EXP_exp) {
319       ptr -> exp = AsnGenericChoiceSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Entrez2BooleanElementAsnRead, (AsnOptFreeFunc) Entrez2BooleanElementFree);
320       if (isError && ptr -> exp == NULL) {
321          goto erret;
322       }
323       atp = AsnReadId(aip,amp, atp);
324    }
325    if (atp == ENTREZ2_BOOLEAN_EXP_limits) {
326       ptr -> limits = Entrez2LimitsAsnRead(aip, atp);
327       if (aip -> io_failure) {
328          goto erret;
329       }
330       atp = AsnReadId(aip,amp, atp);
331    }
332 
333    if (AsnReadVal(aip, atp, &av) <= 0) {
334       goto erret;
335    }
336    /* end struct */
337 
338 ret:
339    AsnUnlinkType(orig);       /* unlink local tree */
340    return ptr;
341 
342 erret:
343    aip -> io_failure = TRUE;
344    ptr = Entrez2BooleanExpFree(ptr);
345    goto ret;
346 }
347 
348 
349 
350 /**************************************************
351 *
352 *    Entrez2BooleanExpAsnWrite()
353 *
354 **************************************************/
355 NLM_EXTERN Boolean LIBCALL 
356 Entrez2BooleanExpAsnWrite(Entrez2BooleanExpPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
357 {
358    DataVal av;
359    AsnTypePtr atp;
360    Boolean retval = FALSE;
361 
362    if (! loaded)
363    {
364       if (! objent2AsnLoad()) {
365          return FALSE;
366       }
367    }
368 
369    if (aip == NULL) {
370       return FALSE;
371    }
372 
373    atp = AsnLinkType(orig, ENTREZ2_BOOLEAN_EXP);   /* link local tree */
374    if (atp == NULL) {
375       return FALSE;
376    }
377 
378    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
379    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
380       goto erret;
381    }
382 
383    if (ptr -> db != NULL) {
384       av.ptrvalue = ptr -> db;
385       retval = AsnWrite(aip, ENTREZ2_BOOLEAN_EXP_db,  &av);
386    }
387    AsnGenericChoiceSeqOfAsnWrite(ptr -> exp, (AsnWriteFunc) Entrez2BooleanElementAsnWrite, aip, ENTREZ2_BOOLEAN_EXP_exp, ENTREZ2_BOOLEAN_EXP_exp_E);
388    if (ptr -> limits != NULL) {
389       if ( ! Entrez2LimitsAsnWrite(ptr -> limits, aip, ENTREZ2_BOOLEAN_EXP_limits)) {
390          goto erret;
391       }
392    }
393    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
394       goto erret;
395    }
396    retval = TRUE;
397 
398 erret:
399    AsnUnlinkType(orig);       /* unlink local tree */
400    return retval;
401 }
402 
403 
404 
405 /**************************************************
406 *
407 *    Entrez2BooleanElementFree()
408 *
409 **************************************************/
410 NLM_EXTERN 
411 Entrez2BooleanElementPtr LIBCALL
412 Entrez2BooleanElementFree(ValNodePtr anp)
413 {
414    Pointer pnt;
415 
416    if (anp == NULL) {
417       return NULL;
418    }
419 
420    pnt = anp->data.ptrvalue;
421    switch (anp->choice)
422    {
423    default:
424       break;
425    case Entrez2BooleanElement_str:
426       MemFree(anp -> data.ptrvalue);
427       break;
428    case Entrez2BooleanElement_term:
429       Entrez2BooleanTermFree(anp -> data.ptrvalue);
430       break;
431    case Entrez2BooleanElement_ids:
432       Entrez2IdListFree(anp -> data.ptrvalue);
433       break;
434    case Entrez2BooleanElement_key:
435       MemFree(anp -> data.ptrvalue);
436       break;
437    }
438    return MemFree(anp);
439 }
440 
441 
442 /**************************************************
443 *
444 *    Entrez2BooleanElementAsnRead()
445 *
446 **************************************************/
447 NLM_EXTERN 
448 Entrez2BooleanElementPtr LIBCALL
449 Entrez2BooleanElementAsnRead(AsnIoPtr aip, AsnTypePtr orig)
450 {
451    DataVal av;
452    AsnTypePtr atp;
453    ValNodePtr anp;
454    Uint1 choice;
455    Boolean isError = FALSE;
456    Boolean nullIsError = FALSE;
457    AsnReadFunc func;
458 
459    if (! loaded)
460    {
461       if (! objent2AsnLoad()) {
462          return NULL;
463       }
464    }
465 
466    if (aip == NULL) {
467       return NULL;
468    }
469 
470    if (orig == NULL) {         /* Entrez2BooleanElement ::= (self contained) */
471       atp = AsnReadId(aip, amp, ENTREZ2_BOOLEAN_ELEMENT);
472    } else {
473       atp = AsnLinkType(orig, ENTREZ2_BOOLEAN_ELEMENT);    /* link in local tree */
474    }
475    if (atp == NULL) {
476       return NULL;
477    }
478 
479    anp = ValNodeNew(NULL);
480    if (anp == NULL) {
481       goto erret;
482    }
483    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
484       goto erret;
485    }
486 
487    func = NULL;
488 
489    atp = AsnReadId(aip, amp, atp);  /* find the choice */
490    if (atp == NULL) {
491       goto erret;
492    }
493    if (atp == ENTREZ2_BOOLEAN_ELEMENT_str) {
494       choice = Entrez2BooleanElement_str;
495       if (AsnReadVal(aip, atp, &av) <= 0) {
496          goto erret;
497       }
498       anp->data.ptrvalue = av.ptrvalue;
499    }
500    else if (atp == ENTREZ2_BOOLEAN_ELEMENT_op) {
501       choice = Entrez2BooleanElement_op;
502       if (AsnReadVal(aip, atp, &av) <= 0) {
503          goto erret;
504       }
505       anp->data.intvalue = av.intvalue;
506    }
507    else if (atp == ENTREZ2_BOOLEAN_ELEMENT_term) {
508       choice = Entrez2BooleanElement_term;
509       func = (AsnReadFunc) Entrez2BooleanTermAsnRead;
510    }
511    else if (atp == ENTREZ2_BOOLEAN_ELEMENT_ids) {
512       choice = Entrez2BooleanElement_ids;
513       func = (AsnReadFunc) Entrez2IdListAsnRead;
514    }
515    else if (atp == ENTREZ2_BOOLEAN_ELEMENT_key) {
516       choice = Entrez2BooleanElement_key;
517       if (AsnReadVal(aip, atp, &av) <= 0) {
518          goto erret;
519       }
520       anp->data.ptrvalue = av.ptrvalue;
521    }
522    anp->choice = choice;
523    if (func != NULL)
524    {
525       anp->data.ptrvalue = (* func)(aip, atp);
526       if (aip -> io_failure) goto erret;
527 
528       if (nullIsError && anp->data.ptrvalue == NULL) {
529          goto erret;
530       }
531    }
532 
533 ret:
534    AsnUnlinkType(orig);       /* unlink local tree */
535    return anp;
536 
537 erret:
538    anp = MemFree(anp);
539    aip -> io_failure = TRUE;
540    goto ret;
541 }
542 
543 
544 /**************************************************
545 *
546 *    Entrez2BooleanElementAsnWrite()
547 *
548 **************************************************/
549 NLM_EXTERN Boolean LIBCALL 
550 Entrez2BooleanElementAsnWrite(Entrez2BooleanElementPtr anp, AsnIoPtr aip, AsnTypePtr orig)
551 
552 {
553    DataVal av;
554    AsnTypePtr atp, writetype = NULL;
555    Pointer pnt;
556    AsnWriteFunc func = NULL;
557    Boolean retval = FALSE;
558 
559    if (! loaded)
560    {
561       if (! objent2AsnLoad())
562       return FALSE;
563    }
564 
565    if (aip == NULL)
566    return FALSE;
567 
568    atp = AsnLinkType(orig, ENTREZ2_BOOLEAN_ELEMENT);   /* link local tree */
569    if (atp == NULL) {
570       return FALSE;
571    }
572 
573    if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
574 
575    av.ptrvalue = (Pointer)anp;
576    if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
577       goto erret;
578    }
579 
580    pnt = anp->data.ptrvalue;
581    switch (anp->choice)
582    {
583    case Entrez2BooleanElement_str:
584       av.ptrvalue = anp->data.ptrvalue;
585       retval = AsnWrite(aip, ENTREZ2_BOOLEAN_ELEMENT_str, &av);
586       break;
587    case Entrez2BooleanElement_op:
588       av.intvalue = anp->data.intvalue;
589       retval = AsnWrite(aip, ENTREZ2_BOOLEAN_ELEMENT_op, &av);
590       break;
591    case Entrez2BooleanElement_term:
592       writetype = ENTREZ2_BOOLEAN_ELEMENT_term;
593       func = (AsnWriteFunc) Entrez2BooleanTermAsnWrite;
594       break;
595    case Entrez2BooleanElement_ids:
596       writetype = ENTREZ2_BOOLEAN_ELEMENT_ids;
597       func = (AsnWriteFunc) Entrez2IdListAsnWrite;
598       break;
599    case Entrez2BooleanElement_key:
600       av.ptrvalue = anp->data.ptrvalue;
601       retval = AsnWrite(aip, ENTREZ2_BOOLEAN_ELEMENT_key, &av);
602       break;
603    }
604    if (writetype != NULL) {
605       retval = (* func)(pnt, aip, writetype);   /* write it out */
606    }
607    if (!retval) {
608       goto erret;
609    }
610    retval = TRUE;
611 
612 erret:
613    AsnUnlinkType(orig);       /* unlink local tree */
614    return retval;
615 }
616 
617 
618 /**************************************************
619 *
620 *    Entrez2LimitsNew()
621 *
622 **************************************************/
623 NLM_EXTERN 
624 Entrez2LimitsPtr LIBCALL
625 Entrez2LimitsNew(void)
626 {
627    Entrez2LimitsPtr ptr = MemNew((size_t) sizeof(Entrez2Limits));
628 
629    return ptr;
630 
631 }
632 
633 
634 /**************************************************
635 *
636 *    Entrez2LimitsFree()
637 *
638 **************************************************/
639 NLM_EXTERN 
640 Entrez2LimitsPtr LIBCALL
641 Entrez2LimitsFree(Entrez2LimitsPtr ptr)
642 {
643 
644    if(ptr == NULL) {
645       return NULL;
646    }
647    Entrez2DtFilterFree(ptr -> filter_date);
648    return MemFree(ptr);
649 }
650 
651 
652 /**************************************************
653 *
654 *    Entrez2LimitsAsnRead()
655 *
656 **************************************************/
657 NLM_EXTERN 
658 Entrez2LimitsPtr LIBCALL
659 Entrez2LimitsAsnRead(AsnIoPtr aip, AsnTypePtr orig)
660 {
661    DataVal av;
662    AsnTypePtr atp;
663    Boolean isError = FALSE;
664    AsnReadFunc func;
665    Entrez2LimitsPtr ptr;
666 
667    if (! loaded)
668    {
669       if (! objent2AsnLoad()) {
670          return NULL;
671       }
672    }
673 
674    if (aip == NULL) {
675       return NULL;
676    }
677 
678    if (orig == NULL) {         /* Entrez2Limits ::= (self contained) */
679       atp = AsnReadId(aip, amp, ENTREZ2_LIMITS);
680    } else {
681       atp = AsnLinkType(orig, ENTREZ2_LIMITS);
682    }
683    /* link in local tree */
684    if (atp == NULL) {
685       return NULL;
686    }
687 
688    ptr = Entrez2LimitsNew();
689    if (ptr == NULL) {
690       goto erret;
691    }
692    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
693       goto erret;
694    }
695 
696    atp = AsnReadId(aip,amp, atp);
697    func = NULL;
698 
699    if (atp == ENTREZ2_LIMITS_filter_date) {
700       ptr -> filter_date = Entrez2DtFilterAsnRead(aip, atp);
701       if (aip -> io_failure) {
702          goto erret;
703       }
704       atp = AsnReadId(aip,amp, atp);
705    }
706    if (atp == ENTREZ2_LIMITS_max_UIDs) {
707       if ( AsnReadVal(aip, atp, &av) <= 0) {
708          goto erret;
709       }
710       ptr -> max_UIDs = av.intvalue;
711       atp = AsnReadId(aip,amp, atp);
712    }
713    if (atp == ENTREZ2_LIMITS_offset_UIDs) {
714       if ( AsnReadVal(aip, atp, &av) <= 0) {
715          goto erret;
716       }
717       ptr -> offset_UIDs = av.intvalue;
718       atp = AsnReadId(aip,amp, atp);
719    }
720 
721    if (AsnReadVal(aip, atp, &av) <= 0) {
722       goto erret;
723    }
724    /* end struct */
725 
726 ret:
727    AsnUnlinkType(orig);       /* unlink local tree */
728    return ptr;
729 
730 erret:
731    aip -> io_failure = TRUE;
732    ptr = Entrez2LimitsFree(ptr);
733    goto ret;
734 }
735 
736 
737 
738 /**************************************************
739 *
740 *    Entrez2LimitsAsnWrite()
741 *
742 **************************************************/
743 NLM_EXTERN Boolean LIBCALL 
744 Entrez2LimitsAsnWrite(Entrez2LimitsPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
745 {
746    DataVal av;
747    AsnTypePtr atp;
748    Boolean retval = FALSE;
749 
750    if (! loaded)
751    {
752       if (! objent2AsnLoad()) {
753          return FALSE;
754       }
755    }
756 
757    if (aip == NULL) {
758       return FALSE;
759    }
760 
761    atp = AsnLinkType(orig, ENTREZ2_LIMITS);   /* link local tree */
762    if (atp == NULL) {
763       return FALSE;
764    }
765 
766    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
767    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
768       goto erret;
769    }
770 
771    if (ptr -> filter_date != NULL) {
772       if ( ! Entrez2DtFilterAsnWrite(ptr -> filter_date, aip, ENTREZ2_LIMITS_filter_date)) {
773          goto erret;
774       }
775    }
776    av.intvalue = ptr -> max_UIDs;
777    retval = AsnWrite(aip, ENTREZ2_LIMITS_max_UIDs,  &av);
778    av.intvalue = ptr -> offset_UIDs;
779    retval = AsnWrite(aip, ENTREZ2_LIMITS_offset_UIDs,  &av);
780    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
781       goto erret;
782    }
783    retval = TRUE;
784 
785 erret:
786    AsnUnlinkType(orig);       /* unlink local tree */
787    return retval;
788 }
789 
790 
791 
792 /**************************************************
793 *
794 *    Entrez2BooleanTermNew()
795 *
796 **************************************************/
797 NLM_EXTERN 
798 Entrez2BooleanTermPtr LIBCALL
799 Entrez2BooleanTermNew(void)
800 {
801    Entrez2BooleanTermPtr ptr = MemNew((size_t) sizeof(Entrez2BooleanTerm));
802 
803    ptr -> do_not_explode = 0;
804    ptr -> do_not_translate = 0;
805    return ptr;
806 
807 }
808 
809 
810 /**************************************************
811 *
812 *    Entrez2BooleanTermFree()
813 *
814 **************************************************/
815 NLM_EXTERN 
816 Entrez2BooleanTermPtr LIBCALL
817 Entrez2BooleanTermFree(Entrez2BooleanTermPtr ptr)
818 {
819 
820    if(ptr == NULL) {
821       return NULL;
822    }
823    MemFree(ptr -> field);
824    MemFree(ptr -> term);
825    return MemFree(ptr);
826 }
827 
828 
829 /**************************************************
830 *
831 *    Entrez2BooleanTermAsnRead()
832 *
833 **************************************************/
834 NLM_EXTERN 
835 Entrez2BooleanTermPtr LIBCALL
836 Entrez2BooleanTermAsnRead(AsnIoPtr aip, AsnTypePtr orig)
837 {
838    DataVal av;
839    AsnTypePtr atp;
840    Boolean isError = FALSE;
841    AsnReadFunc func;
842    Entrez2BooleanTermPtr ptr;
843 
844    if (! loaded)
845    {
846       if (! objent2AsnLoad()) {
847          return NULL;
848       }
849    }
850 
851    if (aip == NULL) {
852       return NULL;
853    }
854 
855    if (orig == NULL) {         /* Entrez2BooleanTerm ::= (self contained) */
856       atp = AsnReadId(aip, amp, ENTREZ2_BOOLEAN_TERM);
857    } else {
858       atp = AsnLinkType(orig, ENTREZ2_BOOLEAN_TERM);
859    }
860    /* link in local tree */
861    if (atp == NULL) {
862       return NULL;
863    }
864 
865    ptr = Entrez2BooleanTermNew();
866    if (ptr == NULL) {
867       goto erret;
868    }
869    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
870       goto erret;
871    }
872 
873    atp = AsnReadId(aip,amp, atp);
874    func = NULL;
875 
876    if (atp == ENTREZ2_BOOLEAN_TERM_field) {
877       if ( AsnReadVal(aip, atp, &av) <= 0) {
878          goto erret;
879       }
880       ptr -> field = av.ptrvalue;
881       atp = AsnReadId(aip,amp, atp);
882    }
883    if (atp == ENTREZ2_BOOLEAN_TERM_term) {
884       if ( AsnReadVal(aip, atp, &av) <= 0) {
885          goto erret;
886       }
887       ptr -> term = av.ptrvalue;
888       atp = AsnReadId(aip,amp, atp);
889    }
890    if (atp == ENTREZ2_BOOLEAN_TERM_term_count) {
891       if ( AsnReadVal(aip, atp, &av) <= 0) {
892          goto erret;
893       }
894       ptr -> term_count = av.intvalue;
895       atp = AsnReadId(aip,amp, atp);
896    }
897    if (atp == BOOLEAN_TERM_do_not_explode) {
898       if ( AsnReadVal(aip, atp, &av) <= 0) {
899          goto erret;
900       }
901       ptr -> do_not_explode = av.boolvalue;
902       atp = AsnReadId(aip,amp, atp);
903    }
904    if (atp == BOOLEAN_TERM_do_not_translate) {
905       if ( AsnReadVal(aip, atp, &av) <= 0) {
906          goto erret;
907       }
908       ptr -> do_not_translate = av.boolvalue;
909       atp = AsnReadId(aip,amp, atp);
910    }
911 
912    if (AsnReadVal(aip, atp, &av) <= 0) {
913       goto erret;
914    }
915    /* end struct */
916 
917 ret:
918    AsnUnlinkType(orig);       /* unlink local tree */
919    return ptr;
920 
921 erret:
922    aip -> io_failure = TRUE;
923    ptr = Entrez2BooleanTermFree(ptr);
924    goto ret;
925 }
926 
927 
928 
929 /**************************************************
930 *
931 *    Entrez2BooleanTermAsnWrite()
932 *
933 **************************************************/
934 NLM_EXTERN Boolean LIBCALL 
935 Entrez2BooleanTermAsnWrite(Entrez2BooleanTermPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
936 {
937    DataVal av;
938    AsnTypePtr atp;
939    Boolean retval = FALSE;
940 
941    if (! loaded)
942    {
943       if (! objent2AsnLoad()) {
944          return FALSE;
945       }
946    }
947 
948    if (aip == NULL) {
949       return FALSE;
950    }
951 
952    atp = AsnLinkType(orig, ENTREZ2_BOOLEAN_TERM);   /* link local tree */
953    if (atp == NULL) {
954       return FALSE;
955    }
956 
957    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
958    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
959       goto erret;
960    }
961 
962    if (ptr -> field != NULL) {
963       av.ptrvalue = ptr -> field;
964       retval = AsnWrite(aip, ENTREZ2_BOOLEAN_TERM_field,  &av);
965    }
966    if (ptr -> term != NULL) {
967       av.ptrvalue = ptr -> term;
968       retval = AsnWrite(aip, ENTREZ2_BOOLEAN_TERM_term,  &av);
969    }
970    av.intvalue = ptr -> term_count;
971    retval = AsnWrite(aip, ENTREZ2_BOOLEAN_TERM_term_count,  &av);
972    av.boolvalue = ptr -> do_not_explode;
973    retval = AsnWrite(aip, BOOLEAN_TERM_do_not_explode,  &av);
974    av.boolvalue = ptr -> do_not_translate;
975    retval = AsnWrite(aip, BOOLEAN_TERM_do_not_translate,  &av);
976    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
977       goto erret;
978    }
979    retval = TRUE;
980 
981 erret:
982    AsnUnlinkType(orig);       /* unlink local tree */
983    return retval;
984 }
985 
986 
987 
988 /**************************************************
989 *
990 *    Entrez2RequestNew()
991 *
992 **************************************************/
993 NLM_EXTERN 
994 Entrez2RequestPtr LIBCALL
995 Entrez2RequestNew(void)
996 {
997    Entrez2RequestPtr ptr = MemNew((size_t) sizeof(Entrez2Request));
998 
999    ptr -> use_history = 0;
1000    return ptr;
1001 
1002 }
1003 
1004 
1005 /**************************************************
1006 *
1007 *    Entrez2RequestFree()
1008 *
1009 **************************************************/
1010 NLM_EXTERN 
1011 Entrez2RequestPtr LIBCALL
1012 Entrez2RequestFree(Entrez2RequestPtr ptr)
1013 {
1014 
1015    if(ptr == NULL) {
1016       return NULL;
1017    }
1018    E2RequestFree(ptr -> request);
1019    MemFree(ptr -> tool);
1020    MemFree(ptr -> cookie);
1021    return MemFree(ptr);
1022 }
1023 
1024 
1025 /**************************************************
1026 *
1027 *    Entrez2RequestAsnRead()
1028 *
1029 **************************************************/
1030 NLM_EXTERN 
1031 Entrez2RequestPtr LIBCALL
1032 Entrez2RequestAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1033 {
1034    DataVal av;
1035    AsnTypePtr atp;
1036    Boolean isError = FALSE;
1037    AsnReadFunc func;
1038    Entrez2RequestPtr ptr;
1039 
1040    if (! loaded)
1041    {
1042       if (! objent2AsnLoad()) {
1043          return NULL;
1044       }
1045    }
1046 
1047    if (aip == NULL) {
1048       return NULL;
1049    }
1050 
1051    if (orig == NULL) {         /* Entrez2Request ::= (self contained) */
1052       atp = AsnReadId(aip, amp, ENTREZ2_REQUEST);
1053    } else {
1054       atp = AsnLinkType(orig, ENTREZ2_REQUEST);
1055    }
1056    /* link in local tree */
1057    if (atp == NULL) {
1058       return NULL;
1059    }
1060 
1061    ptr = Entrez2RequestNew();
1062    if (ptr == NULL) {
1063       goto erret;
1064    }
1065    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1066       goto erret;
1067    }
1068 
1069    atp = AsnReadId(aip,amp, atp);
1070    func = NULL;
1071 
1072    if (atp == ENTREZ2_REQUEST_request) {
1073       ptr -> request = E2RequestAsnRead(aip, atp);
1074       if (aip -> io_failure) {
1075          goto erret;
1076       }
1077       atp = AsnReadId(aip,amp, atp);
1078    }
1079    if (atp == ENTREZ2_REQUEST_version) {
1080       if ( AsnReadVal(aip, atp, &av) <= 0) {
1081          goto erret;
1082       }
1083       ptr -> version = av.intvalue;
1084       atp = AsnReadId(aip,amp, atp);
1085    }
1086    if (atp == ENTREZ2_REQUEST_tool) {
1087       if ( AsnReadVal(aip, atp, &av) <= 0) {
1088          goto erret;
1089       }
1090       ptr -> tool = av.ptrvalue;
1091       atp = AsnReadId(aip,amp, atp);
1092    }
1093    if (atp == ENTREZ2_REQUEST_cookie) {
1094       if ( AsnReadVal(aip, atp, &av) <= 0) {
1095          goto erret;
1096       }
1097       ptr -> cookie = av.ptrvalue;
1098       atp = AsnReadId(aip,amp, atp);
1099    }
1100    if (atp == ENTREZ2_REQUEST_use_history) {
1101       if ( AsnReadVal(aip, atp, &av) <= 0) {
1102          goto erret;
1103       }
1104       ptr -> use_history = av.boolvalue;
1105       atp = AsnReadId(aip,amp, atp);
1106    }
1107 
1108    if (AsnReadVal(aip, atp, &av) <= 0) {
1109       goto erret;
1110    }
1111    /* end struct */
1112 
1113 ret:
1114    AsnUnlinkType(orig);       /* unlink local tree */
1115    return ptr;
1116 
1117 erret:
1118    aip -> io_failure = TRUE;
1119    ptr = Entrez2RequestFree(ptr);
1120    goto ret;
1121 }
1122 
1123 
1124 
1125 /**************************************************
1126 *
1127 *    Entrez2RequestAsnWrite()
1128 *
1129 **************************************************/
1130 NLM_EXTERN Boolean LIBCALL 
1131 Entrez2RequestAsnWrite(Entrez2RequestPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1132 {
1133    DataVal av;
1134    AsnTypePtr atp;
1135    Boolean retval = FALSE;
1136 
1137    if (! loaded)
1138    {
1139       if (! objent2AsnLoad()) {
1140          return FALSE;
1141       }
1142    }
1143 
1144    if (aip == NULL) {
1145       return FALSE;
1146    }
1147 
1148    atp = AsnLinkType(orig, ENTREZ2_REQUEST);   /* link local tree */
1149    if (atp == NULL) {
1150       return FALSE;
1151    }
1152 
1153    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1154    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1155       goto erret;
1156    }
1157 
1158    if (ptr -> request != NULL) {
1159       if ( ! E2RequestAsnWrite(ptr -> request, aip, ENTREZ2_REQUEST_request)) {
1160          goto erret;
1161       }
1162    }
1163    av.intvalue = ptr -> version;
1164    retval = AsnWrite(aip, ENTREZ2_REQUEST_version,  &av);
1165    if (ptr -> tool != NULL) {
1166       av.ptrvalue = ptr -> tool;
1167       retval = AsnWrite(aip, ENTREZ2_REQUEST_tool,  &av);
1168    }
1169    if (ptr -> cookie != NULL) {
1170       av.ptrvalue = ptr -> cookie;
1171       retval = AsnWrite(aip, ENTREZ2_REQUEST_cookie,  &av);
1172    }
1173    av.boolvalue = ptr -> use_history;
1174    if (ptr -> use_history) { /* temporary until server has new spec */
1175      retval = AsnWrite(aip, ENTREZ2_REQUEST_use_history,  &av);
1176    }
1177    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1178       goto erret;
1179    }
1180    retval = TRUE;
1181 
1182 erret:
1183    AsnUnlinkType(orig);       /* unlink local tree */
1184    return retval;
1185 }
1186 
1187 
1188 
1189 /**************************************************
1190 *
1191 *    E2RequestFree()
1192 *
1193 **************************************************/
1194 NLM_EXTERN 
1195 E2RequestPtr LIBCALL
1196 E2RequestFree(ValNodePtr anp)
1197 {
1198    Pointer pnt;
1199 
1200    if (anp == NULL) {
1201       return NULL;
1202    }
1203 
1204    pnt = anp->data.ptrvalue;
1205    switch (anp->choice)
1206    {
1207    default:
1208       break;
1209    case E2Request_eval_boolean:
1210       Entrez2EvalBooleanFree(anp -> data.ptrvalue);
1211       break;
1212    case E2Request_get_docsum:
1213       Entrez2IdListFree(anp -> data.ptrvalue);
1214       break;
1215    case E2Request_get_term_pos:
1216       Entrez2TermQueryFree(anp -> data.ptrvalue);
1217       break;
1218    case E2Request_get_term_list:
1219       Entrez2TermPosFree(anp -> data.ptrvalue);
1220       break;
1221    case E2Request_get_term_hierarchy:
1222       Entrez2HierQueryFree(anp -> data.ptrvalue);
1223       break;
1224    case E2Request_get_links:
1225       Entrez2GetLinksFree(anp -> data.ptrvalue);
1226       break;
1227    case E2Request_get_linked:
1228       Entrez2GetLinksFree(anp -> data.ptrvalue);
1229       break;
1230    case E2Request_get_link_counts:
1231       Entrez2IdFree(anp -> data.ptrvalue);
1232       break;
1233    }
1234    return MemFree(anp);
1235 }
1236 
1237 
1238 /**************************************************
1239 *
1240 *    E2RequestAsnRead()
1241 *
1242 **************************************************/
1243 NLM_EXTERN 
1244 E2RequestPtr LIBCALL
1245 E2RequestAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1246 {
1247    DataVal av;
1248    AsnTypePtr atp;
1249    ValNodePtr anp;
1250    Uint1 choice;
1251    Boolean isError = FALSE;
1252    Boolean nullIsError = FALSE;
1253    AsnReadFunc func;
1254 
1255    if (! loaded)
1256    {
1257       if (! objent2AsnLoad()) {
1258          return NULL;
1259       }
1260    }
1261 
1262    if (aip == NULL) {
1263       return NULL;
1264    }
1265 
1266    if (orig == NULL) {         /* E2Request ::= (self contained) */
1267       atp = AsnReadId(aip, amp, E2REQUEST);
1268    } else {
1269       atp = AsnLinkType(orig, E2REQUEST);    /* link in local tree */
1270    }
1271    if (atp == NULL) {
1272       return NULL;
1273    }
1274 
1275    anp = ValNodeNew(NULL);
1276    if (anp == NULL) {
1277       goto erret;
1278    }
1279    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
1280       goto erret;
1281    }
1282 
1283    func = NULL;
1284 
1285    atp = AsnReadId(aip, amp, atp);  /* find the choice */
1286    if (atp == NULL) {
1287       goto erret;
1288    }
1289    if (atp == E2REQUEST_get_info) {
1290       choice = E2Request_get_info;
1291       if (AsnReadVal(aip, atp, &av) <= 0) {
1292          goto erret;
1293       }
1294       anp->data.boolvalue = av.boolvalue;
1295    }
1296    else if (atp == E2REQUEST_eval_boolean) {
1297       choice = E2Request_eval_boolean;
1298       func = (AsnReadFunc) Entrez2EvalBooleanAsnRead;
1299    }
1300    else if (atp == E2REQUEST_get_docsum) {
1301       choice = E2Request_get_docsum;
1302       func = (AsnReadFunc) Entrez2IdListAsnRead;
1303    }
1304    else if (atp == E2REQUEST_get_term_pos) {
1305       choice = E2Request_get_term_pos;
1306       func = (AsnReadFunc) Entrez2TermQueryAsnRead;
1307    }
1308    else if (atp == E2REQUEST_get_term_list) {
1309       choice = E2Request_get_term_list;
1310       func = (AsnReadFunc) Entrez2TermPosAsnRead;
1311    }
1312    else if (atp == E2REQUEST_get_term_hierarchy) {
1313       choice = E2Request_get_term_hierarchy;
1314       func = (AsnReadFunc) Entrez2HierQueryAsnRead;
1315    }
1316    else if (atp == E2REQUEST_get_links) {
1317       choice = E2Request_get_links;
1318       func = (AsnReadFunc) Entrez2GetLinksAsnRead;
1319    }
1320    else if (atp == E2REQUEST_get_linked) {
1321       choice = E2Request_get_linked;
1322       func = (AsnReadFunc) Entrez2GetLinksAsnRead;
1323    }
1324    else if (atp == E2REQUEST_get_link_counts) {
1325       choice = E2Request_get_link_counts;
1326       func = (AsnReadFunc) Entrez2IdAsnRead;
1327    }
1328    anp->choice = choice;
1329    if (func != NULL)
1330    {
1331       anp->data.ptrvalue = (* func)(aip, atp);
1332       if (aip -> io_failure) goto erret;
1333 
1334       if (nullIsError && anp->data.ptrvalue == NULL) {
1335          goto erret;
1336       }
1337    }
1338 
1339 ret:
1340    AsnUnlinkType(orig);       /* unlink local tree */
1341    return anp;
1342 
1343 erret:
1344    anp = MemFree(anp);
1345    aip -> io_failure = TRUE;
1346    goto ret;
1347 }
1348 
1349 
1350 /**************************************************
1351 *
1352 *    E2RequestAsnWrite()
1353 *
1354 **************************************************/
1355 NLM_EXTERN Boolean LIBCALL 
1356 E2RequestAsnWrite(E2RequestPtr anp, AsnIoPtr aip, AsnTypePtr orig)
1357 
1358 {
1359    DataVal av;
1360    AsnTypePtr atp, writetype = NULL;
1361    Pointer pnt;
1362    AsnWriteFunc func = NULL;
1363    Boolean retval = FALSE;
1364 
1365    if (! loaded)
1366    {
1367       if (! objent2AsnLoad())
1368       return FALSE;
1369    }
1370 
1371    if (aip == NULL)
1372    return FALSE;
1373 
1374    atp = AsnLinkType(orig, E2REQUEST);   /* link local tree */
1375    if (atp == NULL) {
1376       return FALSE;
1377    }
1378 
1379    if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1380 
1381    av.ptrvalue = (Pointer)anp;
1382    if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
1383       goto erret;
1384    }
1385 
1386    pnt = anp->data.ptrvalue;
1387    switch (anp->choice)
1388    {
1389    case E2Request_get_info:
1390       av.boolvalue = anp->data.boolvalue;
1391       retval = AsnWrite(aip, E2REQUEST_get_info, &av);
1392       break;
1393    case E2Request_eval_boolean:
1394       writetype = E2REQUEST_eval_boolean;
1395       func = (AsnWriteFunc) Entrez2EvalBooleanAsnWrite;
1396       break;
1397    case E2Request_get_docsum:
1398       writetype = E2REQUEST_get_docsum;
1399       func = (AsnWriteFunc) Entrez2IdListAsnWrite;
1400       break;
1401    case E2Request_get_term_pos:
1402       writetype = E2REQUEST_get_term_pos;
1403       func = (AsnWriteFunc) Entrez2TermQueryAsnWrite;
1404       break;
1405    case E2Request_get_term_list:
1406       writetype = E2REQUEST_get_term_list;
1407       func = (AsnWriteFunc) Entrez2TermPosAsnWrite;
1408       break;
1409    case E2Request_get_term_hierarchy:
1410       writetype = E2REQUEST_get_term_hierarchy;
1411       func = (AsnWriteFunc) Entrez2HierQueryAsnWrite;
1412       break;
1413    case E2Request_get_links:
1414       writetype = E2REQUEST_get_links;
1415       func = (AsnWriteFunc) Entrez2GetLinksAsnWrite;
1416       break;
1417    case E2Request_get_linked:
1418       writetype = E2REQUEST_get_linked;
1419       func = (AsnWriteFunc) Entrez2GetLinksAsnWrite;
1420       break;
1421    case E2Request_get_link_counts:
1422       writetype = E2REQUEST_get_link_counts;
1423       func = (AsnWriteFunc) Entrez2IdAsnWrite;
1424       break;
1425    }
1426    if (writetype != NULL) {
1427       retval = (* func)(pnt, aip, writetype);   /* write it out */
1428    }
1429    if (!retval) {
1430       goto erret;
1431    }
1432    retval = TRUE;
1433 
1434 erret:
1435    AsnUnlinkType(orig);       /* unlink local tree */
1436    return retval;
1437 }
1438 
1439 
1440 /**************************************************
1441 *
1442 *    Entrez2EvalBooleanNew()
1443 *
1444 **************************************************/
1445 NLM_EXTERN 
1446 Entrez2EvalBooleanPtr LIBCALL
1447 Entrez2EvalBooleanNew(void)
1448 {
1449    Entrez2EvalBooleanPtr ptr = MemNew((size_t) sizeof(Entrez2EvalBoolean));
1450 
1451    ptr -> return_UIDs = 0;
1452    ptr -> return_parse = 0;
1453    return ptr;
1454 
1455 }
1456 
1457 
1458 /**************************************************
1459 *
1460 *    Entrez2EvalBooleanFree()
1461 *
1462 **************************************************/
1463 NLM_EXTERN 
1464 Entrez2EvalBooleanPtr LIBCALL
1465 Entrez2EvalBooleanFree(Entrez2EvalBooleanPtr ptr)
1466 {
1467 
1468    if(ptr == NULL) {
1469       return NULL;
1470    }
1471    Entrez2BooleanExpFree(ptr -> query);
1472    return MemFree(ptr);
1473 }
1474 
1475 
1476 /**************************************************
1477 *
1478 *    Entrez2EvalBooleanAsnRead()
1479 *
1480 **************************************************/
1481 NLM_EXTERN 
1482 Entrez2EvalBooleanPtr LIBCALL
1483 Entrez2EvalBooleanAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1484 {
1485    DataVal av;
1486    AsnTypePtr atp;
1487    Boolean isError = FALSE;
1488    AsnReadFunc func;
1489    Entrez2EvalBooleanPtr ptr;
1490 
1491    if (! loaded)
1492    {
1493       if (! objent2AsnLoad()) {
1494          return NULL;
1495       }
1496    }
1497 
1498    if (aip == NULL) {
1499       return NULL;
1500    }
1501 
1502    if (orig == NULL) {         /* Entrez2EvalBoolean ::= (self contained) */
1503       atp = AsnReadId(aip, amp, ENTREZ2_EVAL_BOOLEAN);
1504    } else {
1505       atp = AsnLinkType(orig, ENTREZ2_EVAL_BOOLEAN);
1506    }
1507    /* link in local tree */
1508    if (atp == NULL) {
1509       return NULL;
1510    }
1511 
1512    ptr = Entrez2EvalBooleanNew();
1513    if (ptr == NULL) {
1514       goto erret;
1515    }
1516    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1517       goto erret;
1518    }
1519 
1520    atp = AsnReadId(aip,amp, atp);
1521    func = NULL;
1522 
1523    if (atp == EVAL_BOOLEAN_return_UIDs) {
1524       if ( AsnReadVal(aip, atp, &av) <= 0) {
1525          goto erret;
1526       }
1527       ptr -> return_UIDs = av.boolvalue;
1528       atp = AsnReadId(aip,amp, atp);
1529    }
1530    if (atp == EVAL_BOOLEAN_return_parse) {
1531       if ( AsnReadVal(aip, atp, &av) <= 0) {
1532          goto erret;
1533       }
1534       ptr -> return_parse = av.boolvalue;
1535       atp = AsnReadId(aip,amp, atp);
1536    }
1537    if (atp == ENTREZ2_EVAL_BOOLEAN_query) {
1538       ptr -> query = Entrez2BooleanExpAsnRead(aip, atp);
1539       if (aip -> io_failure) {
1540          goto erret;
1541       }
1542       atp = AsnReadId(aip,amp, atp);
1543    }
1544 
1545    if (AsnReadVal(aip, atp, &av) <= 0) {
1546       goto erret;
1547    }
1548    /* end struct */
1549 
1550 ret:
1551    AsnUnlinkType(orig);       /* unlink local tree */
1552    return ptr;
1553 
1554 erret:
1555    aip -> io_failure = TRUE;
1556    ptr = Entrez2EvalBooleanFree(ptr);
1557    goto ret;
1558 }
1559 
1560 
1561 
1562 /**************************************************
1563 *
1564 *    Entrez2EvalBooleanAsnWrite()
1565 *
1566 **************************************************/
1567 NLM_EXTERN Boolean LIBCALL 
1568 Entrez2EvalBooleanAsnWrite(Entrez2EvalBooleanPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1569 {
1570    DataVal av;
1571    AsnTypePtr atp;
1572    Boolean retval = FALSE;
1573 
1574    if (! loaded)
1575    {
1576       if (! objent2AsnLoad()) {
1577          return FALSE;
1578       }
1579    }
1580 
1581    if (aip == NULL) {
1582       return FALSE;
1583    }
1584 
1585    atp = AsnLinkType(orig, ENTREZ2_EVAL_BOOLEAN);   /* link local tree */
1586    if (atp == NULL) {
1587       return FALSE;
1588    }
1589 
1590    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1591    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1592       goto erret;
1593    }
1594 
1595    av.boolvalue = ptr -> return_UIDs;
1596    retval = AsnWrite(aip, EVAL_BOOLEAN_return_UIDs,  &av);
1597    av.boolvalue = ptr -> return_parse;
1598    retval = AsnWrite(aip, EVAL_BOOLEAN_return_parse,  &av);
1599    if (ptr -> query != NULL) {
1600       if ( ! Entrez2BooleanExpAsnWrite(ptr -> query, aip, ENTREZ2_EVAL_BOOLEAN_query)) {
1601          goto erret;
1602       }
1603    }
1604    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1605       goto erret;
1606    }
1607    retval = TRUE;
1608 
1609 erret:
1610    AsnUnlinkType(orig);       /* unlink local tree */
1611    return retval;
1612 }
1613 
1614 
1615 
1616 /**************************************************
1617 *
1618 *    Entrez2TermQueryNew()
1619 *
1620 **************************************************/
1621 NLM_EXTERN 
1622 Entrez2TermQueryPtr LIBCALL
1623 Entrez2TermQueryNew(void)
1624 {
1625    Entrez2TermQueryPtr ptr = MemNew((size_t) sizeof(Entrez2TermQuery));
1626 
1627    return ptr;
1628 
1629 }
1630 
1631 
1632 /**************************************************
1633 *
1634 *    Entrez2TermQueryFree()
1635 *
1636 **************************************************/
1637 NLM_EXTERN 
1638 Entrez2TermQueryPtr LIBCALL
1639 Entrez2TermQueryFree(Entrez2TermQueryPtr ptr)
1640 {
1641 
1642    if(ptr == NULL) {
1643       return NULL;
1644    }
1645    MemFree(ptr -> db);
1646    MemFree(ptr -> field);
1647    MemFree(ptr -> term);
1648    return MemFree(ptr);
1649 }
1650 
1651 
1652 /**************************************************
1653 *
1654 *    Entrez2TermQueryAsnRead()
1655 *
1656 **************************************************/
1657 NLM_EXTERN 
1658 Entrez2TermQueryPtr LIBCALL
1659 Entrez2TermQueryAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1660 {
1661    DataVal av;
1662    AsnTypePtr atp;
1663    Boolean isError = FALSE;
1664    AsnReadFunc func;
1665    Entrez2TermQueryPtr ptr;
1666 
1667    if (! loaded)
1668    {
1669       if (! objent2AsnLoad()) {
1670          return NULL;
1671       }
1672    }
1673 
1674    if (aip == NULL) {
1675       return NULL;
1676    }
1677 
1678    if (orig == NULL) {         /* Entrez2TermQuery ::= (self contained) */
1679       atp = AsnReadId(aip, amp, ENTREZ2_TERM_QUERY);
1680    } else {
1681       atp = AsnLinkType(orig, ENTREZ2_TERM_QUERY);
1682    }
1683    /* link in local tree */
1684    if (atp == NULL) {
1685       return NULL;
1686    }
1687 
1688    ptr = Entrez2TermQueryNew();
1689    if (ptr == NULL) {
1690       goto erret;
1691    }
1692    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1693       goto erret;
1694    }
1695 
1696    atp = AsnReadId(aip,amp, atp);
1697    func = NULL;
1698 
1699    if (atp == ENTREZ2_TERM_QUERY_db) {
1700       if ( AsnReadVal(aip, atp, &av) <= 0) {
1701          goto erret;
1702       }
1703       ptr -> db = av.ptrvalue;
1704       atp = AsnReadId(aip,amp, atp);
1705    }
1706    if (atp == ENTREZ2_TERM_QUERY_field) {
1707       if ( AsnReadVal(aip, atp, &av) <= 0) {
1708          goto erret;
1709       }
1710       ptr -> field = av.ptrvalue;
1711       atp = AsnReadId(aip,amp, atp);
1712    }
1713    if (atp == ENTREZ2_TERM_QUERY_term) {
1714       if ( AsnReadVal(aip, atp, &av) <= 0) {
1715          goto erret;
1716       }
1717       ptr -> term = av.ptrvalue;
1718       atp = AsnReadId(aip,amp, atp);
1719    }
1720 
1721    if (AsnReadVal(aip, atp, &av) <= 0) {
1722       goto erret;
1723    }
1724    /* end struct */
1725 
1726 ret:
1727    AsnUnlinkType(orig);       /* unlink local tree */
1728    return ptr;
1729 
1730 erret:
1731    aip -> io_failure = TRUE;
1732    ptr = Entrez2TermQueryFree(ptr);
1733    goto ret;
1734 }
1735 
1736 
1737 
1738 /**************************************************
1739 *
1740 *    Entrez2TermQueryAsnWrite()
1741 *
1742 **************************************************/
1743 NLM_EXTERN Boolean LIBCALL 
1744 Entrez2TermQueryAsnWrite(Entrez2TermQueryPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1745 {
1746    DataVal av;
1747    AsnTypePtr atp;
1748    Boolean retval = FALSE;
1749 
1750    if (! loaded)
1751    {
1752       if (! objent2AsnLoad()) {
1753          return FALSE;
1754       }
1755    }
1756 
1757    if (aip == NULL) {
1758       return FALSE;
1759    }
1760 
1761    atp = AsnLinkType(orig, ENTREZ2_TERM_QUERY);   /* link local tree */
1762    if (atp == NULL) {
1763       return FALSE;
1764    }
1765 
1766    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1767    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1768       goto erret;
1769    }
1770 
1771    if (ptr -> db != NULL) {
1772       av.ptrvalue = ptr -> db;
1773       retval = AsnWrite(aip, ENTREZ2_TERM_QUERY_db,  &av);
1774    }
1775    if (ptr -> field != NULL) {
1776       av.ptrvalue = ptr -> field;
1777       retval = AsnWrite(aip, ENTREZ2_TERM_QUERY_field,  &av);
1778    }
1779    if (ptr -> term != NULL) {
1780       av.ptrvalue = ptr -> term;
1781       retval = AsnWrite(aip, ENTREZ2_TERM_QUERY_term,  &av);
1782    }
1783    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1784       goto erret;
1785    }
1786    retval = TRUE;
1787 
1788 erret:
1789    AsnUnlinkType(orig);       /* unlink local tree */
1790    return retval;
1791 }
1792 
1793 
1794 
1795 /**************************************************
1796 *
1797 *    Entrez2TermPosNew()
1798 *
1799 **************************************************/
1800 NLM_EXTERN 
1801 Entrez2TermPosPtr LIBCALL
1802 Entrez2TermPosNew(void)
1803 {
1804    Entrez2TermPosPtr ptr = MemNew((size_t) sizeof(Entrez2TermPos));
1805 
1806    return ptr;
1807 
1808 }
1809 
1810 
1811 /**************************************************
1812 *
1813 *    Entrez2TermPosFree()
1814 *
1815 **************************************************/
1816 NLM_EXTERN 
1817 Entrez2TermPosPtr LIBCALL
1818 Entrez2TermPosFree(Entrez2TermPosPtr ptr)
1819 {
1820 
1821    if(ptr == NULL) {
1822       return NULL;
1823    }
1824    MemFree(ptr -> db);
1825    MemFree(ptr -> field);
1826    return MemFree(ptr);
1827 }
1828 
1829 
1830 /**************************************************
1831 *
1832 *    Entrez2TermPosAsnRead()
1833 *
1834 **************************************************/
1835 NLM_EXTERN 
1836 Entrez2TermPosPtr LIBCALL
1837 Entrez2TermPosAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1838 {
1839    DataVal av;
1840    AsnTypePtr atp;
1841    Boolean isError = FALSE;
1842    AsnReadFunc func;
1843    Entrez2TermPosPtr ptr;
1844 
1845    if (! loaded)
1846    {
1847       if (! objent2AsnLoad()) {
1848          return NULL;
1849       }
1850    }
1851 
1852    if (aip == NULL) {
1853       return NULL;
1854    }
1855 
1856    if (orig == NULL) {         /* Entrez2TermPos ::= (self contained) */
1857       atp = AsnReadId(aip, amp, ENTREZ2_TERM_POS);
1858    } else {
1859       atp = AsnLinkType(orig, ENTREZ2_TERM_POS);
1860    }
1861    /* link in local tree */
1862    if (atp == NULL) {
1863       return NULL;
1864    }
1865 
1866    ptr = Entrez2TermPosNew();
1867    if (ptr == NULL) {
1868       goto erret;
1869    }
1870    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1871       goto erret;
1872    }
1873 
1874    atp = AsnReadId(aip,amp, atp);
1875    func = NULL;
1876 
1877    if (atp == ENTREZ2_TERM_POS_db) {
1878       if ( AsnReadVal(aip, atp, &av) <= 0) {
1879          goto erret;
1880       }
1881       ptr -> db = av.ptrvalue;
1882       atp = AsnReadId(aip,amp, atp);
1883    }
1884    if (atp == ENTREZ2_TERM_POS_field) {
1885       if ( AsnReadVal(aip, atp, &av) <= 0) {
1886          goto erret;
1887       }
1888       ptr -> field = av.ptrvalue;
1889       atp = AsnReadId(aip,amp, atp);
1890    }
1891    if (atp == ENTREZ2_TERM_POS_first_term_pos) {
1892       if ( AsnReadVal(aip, atp, &av) <= 0) {
1893          goto erret;
1894       }
1895       ptr -> first_term_pos = av.intvalue;
1896       atp = AsnReadId(aip,amp, atp);
1897    }
1898    if (atp == TERM_POS_number_of_terms) {
1899       if ( AsnReadVal(aip, atp, &av) <= 0) {
1900          goto erret;
1901       }
1902       ptr -> number_of_terms = av.intvalue;
1903       atp = AsnReadId(aip,amp, atp);
1904    }
1905 
1906    if (AsnReadVal(aip, atp, &av) <= 0) {
1907       goto erret;
1908    }
1909    /* end struct */
1910 
1911 ret:
1912    AsnUnlinkType(orig);       /* unlink local tree */
1913    return ptr;
1914 
1915 erret:
1916    aip -> io_failure = TRUE;
1917    ptr = Entrez2TermPosFree(ptr);
1918    goto ret;
1919 }
1920 
1921 
1922 
1923 /**************************************************
1924 *
1925 *    Entrez2TermPosAsnWrite()
1926 *
1927 **************************************************/
1928 NLM_EXTERN Boolean LIBCALL 
1929 Entrez2TermPosAsnWrite(Entrez2TermPosPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1930 {
1931    DataVal av;
1932    AsnTypePtr atp;
1933    Boolean retval = FALSE;
1934 
1935    if (! loaded)
1936    {
1937       if (! objent2AsnLoad()) {
1938          return FALSE;
1939       }
1940    }
1941 
1942    if (aip == NULL) {
1943       return FALSE;
1944    }
1945 
1946    atp = AsnLinkType(orig, ENTREZ2_TERM_POS);   /* link local tree */
1947    if (atp == NULL) {
1948       return FALSE;
1949    }
1950 
1951    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1952    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1953       goto erret;
1954    }
1955 
1956    if (ptr -> db != NULL) {
1957       av.ptrvalue = ptr -> db;
1958       retval = AsnWrite(aip, ENTREZ2_TERM_POS_db,  &av);
1959    }
1960    if (ptr -> field != NULL) {
1961       av.ptrvalue = ptr -> field;
1962       retval = AsnWrite(aip, ENTREZ2_TERM_POS_field,  &av);
1963    }
1964    av.intvalue = ptr -> first_term_pos;
1965    retval = AsnWrite(aip, ENTREZ2_TERM_POS_first_term_pos,  &av);
1966    av.intvalue = ptr -> number_of_terms;
1967    retval = AsnWrite(aip, TERM_POS_number_of_terms,  &av);
1968    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1969       goto erret;
1970    }
1971    retval = TRUE;
1972 
1973 erret:
1974    AsnUnlinkType(orig);       /* unlink local tree */
1975    return retval;
1976 }
1977 
1978 
1979 
1980 /**************************************************
1981 *
1982 *    Entrez2HierQueryNew()
1983 *
1984 **************************************************/
1985 NLM_EXTERN 
1986 Entrez2HierQueryPtr LIBCALL
1987 Entrez2HierQueryNew(void)
1988 {
1989    Entrez2HierQueryPtr ptr = MemNew((size_t) sizeof(Entrez2HierQuery));
1990 
1991    return ptr;
1992 
1993 }
1994 
1995 
1996 /**************************************************
1997 *
1998 *    Entrez2HierQueryFree()
1999 *
2000 **************************************************/
2001 NLM_EXTERN 
2002 Entrez2HierQueryPtr LIBCALL
2003 Entrez2HierQueryFree(Entrez2HierQueryPtr ptr)
2004 {
2005 
2006    if(ptr == NULL) {
2007       return NULL;
2008    }
2009    MemFree(ptr -> db);
2010    MemFree(ptr -> field);
2011    MemFree(ptr -> term);
2012    return MemFree(ptr);
2013 }
2014 
2015 
2016 /**************************************************
2017 *
2018 *    Entrez2HierQueryAsnRead()
2019 *
2020 **************************************************/
2021 NLM_EXTERN 
2022 Entrez2HierQueryPtr LIBCALL
2023 Entrez2HierQueryAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2024 {
2025    DataVal av;
2026    AsnTypePtr atp;
2027    Boolean isError = FALSE;
2028    AsnReadFunc func;
2029    Entrez2HierQueryPtr ptr;
2030 
2031    if (! loaded)
2032    {
2033       if (! objent2AsnLoad()) {
2034          return NULL;
2035       }
2036    }
2037 
2038    if (aip == NULL) {
2039       return NULL;
2040    }
2041 
2042    if (orig == NULL) {         /* Entrez2HierQuery ::= (self contained) */
2043       atp = AsnReadId(aip, amp, ENTREZ2_HIER_QUERY);
2044    } else {
2045       atp = AsnLinkType(orig, ENTREZ2_HIER_QUERY);
2046    }
2047    /* link in local tree */
2048    if (atp == NULL) {
2049       return NULL;
2050    }
2051 
2052    ptr = Entrez2HierQueryNew();
2053    if (ptr == NULL) {
2054       goto erret;
2055    }
2056    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
2057       goto erret;
2058    }
2059 
2060    atp = AsnReadId(aip,amp, atp);
2061    func = NULL;
2062 
2063    if (atp == ENTREZ2_HIER_QUERY_db) {
2064       if ( AsnReadVal(aip, atp, &av) <= 0) {
2065          goto erret;
2066       }
2067       ptr -> db = av.ptrvalue;
2068       atp = AsnReadId(aip,amp, atp);
2069    }
2070    if (atp == ENTREZ2_HIER_QUERY_field) {
2071       if ( AsnReadVal(aip, atp, &av) <= 0) {
2072          goto erret;
2073       }
2074       ptr -> field = av.ptrvalue;
2075       atp = AsnReadId(aip,amp, atp);
2076    }
2077    if (atp == ENTREZ2_HIER_QUERY_term) {
2078       if ( AsnReadVal(aip, atp, &av) <= 0) {
2079          goto erret;
2080       }
2081       ptr -> term = av.ptrvalue;
2082       atp = AsnReadId(aip,amp, atp);
2083    }
2084    if (atp == ENTREZ2_HIER_QUERY_txid) {
2085       if ( AsnReadVal(aip, atp, &av) <= 0) {
2086          goto erret;
2087       }
2088       ptr -> txid = av.intvalue;
2089       atp = AsnReadId(aip,amp, atp);
2090    }
2091 
2092    if (AsnReadVal(aip, atp, &av) <= 0) {
2093       goto erret;
2094    }
2095    /* end struct */
2096 
2097 ret:
2098    AsnUnlinkType(orig);       /* unlink local tree */
2099    return ptr;
2100 
2101 erret:
2102    aip -> io_failure = TRUE;
2103    ptr = Entrez2HierQueryFree(ptr);
2104    goto ret;
2105 }
2106 
2107 
2108 
2109 /**************************************************
2110 *
2111 *    Entrez2HierQueryAsnWrite()
2112 *
2113 **************************************************/
2114 NLM_EXTERN Boolean LIBCALL 
2115 Entrez2HierQueryAsnWrite(Entrez2HierQueryPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
2116 {
2117    DataVal av;
2118    AsnTypePtr atp;
2119    Boolean retval = FALSE;
2120 
2121    if (! loaded)
2122    {
2123       if (! objent2AsnLoad()) {
2124          return FALSE;
2125       }
2126    }
2127 
2128    if (aip == NULL) {
2129       return FALSE;
2130    }
2131 
2132    atp = AsnLinkType(orig, ENTREZ2_HIER_QUERY);   /* link local tree */
2133    if (atp == NULL) {
2134       return FALSE;
2135    }
2136 
2137    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2138    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
2139       goto erret;
2140    }
2141 
2142    if (ptr -> db != NULL) {
2143       av.ptrvalue = ptr -> db;
2144       retval = AsnWrite(aip, ENTREZ2_HIER_QUERY_db,  &av);
2145    }
2146    if (ptr -> field != NULL) {
2147       av.ptrvalue = ptr -> field;
2148       retval = AsnWrite(aip, ENTREZ2_HIER_QUERY_field,  &av);
2149    }
2150    if (ptr -> term != NULL) {
2151       av.ptrvalue = ptr -> term;
2152       retval = AsnWrite(aip, ENTREZ2_HIER_QUERY_term,  &av);
2153    }
2154    av.intvalue = ptr -> txid;
2155    retval = AsnWrite(aip, ENTREZ2_HIER_QUERY_txid,  &av);
2156    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
2157       goto erret;
2158    }
2159    retval = TRUE;
2160 
2161 erret:
2162    AsnUnlinkType(orig);       /* unlink local tree */
2163    return retval;
2164 }
2165 
2166 
2167 
2168 /**************************************************
2169 *
2170 *    Entrez2GetLinksNew()
2171 *
2172 **************************************************/
2173 NLM_EXTERN 
2174 Entrez2GetLinksPtr LIBCALL
2175 Entrez2GetLinksNew(void)
2176 {
2177    Entrez2GetLinksPtr ptr = MemNew((size_t) sizeof(Entrez2GetLinks));
2178 
2179    return ptr;
2180 
2181 }
2182 
2183 
2184 /**************************************************
2185 *
2186 *    Entrez2GetLinksFree()
2187 *
2188 **************************************************/
2189 NLM_EXTERN 
2190 Entrez2GetLinksPtr LIBCALL
2191 Entrez2GetLinksFree(Entrez2GetLinksPtr ptr)
2192 {
2193 
2194    if(ptr == NULL) {
2195       return NULL;
2196    }
2197    Entrez2IdListFree(ptr -> uids);
2198    MemFree(ptr -> linktype);
2199    return MemFree(ptr);
2200 }
2201 
2202 
2203 /**************************************************
2204 *
2205 *    Entrez2GetLinksAsnRead()
2206 *
2207 **************************************************/
2208 NLM_EXTERN 
2209 Entrez2GetLinksPtr LIBCALL
2210 Entrez2GetLinksAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2211 {
2212    DataVal av;
2213    AsnTypePtr atp;
2214    Boolean isError = FALSE;
2215    AsnReadFunc func;
2216    Entrez2GetLinksPtr ptr;
2217 
2218    if (! loaded)
2219    {
2220       if (! objent2AsnLoad()) {
2221          return NULL;
2222       }
2223    }
2224 
2225    if (aip == NULL) {
2226       return NULL;
2227    }
2228 
2229    if (orig == NULL) {         /* Entrez2GetLinks ::= (self contained) */
2230       atp = AsnReadId(aip, amp, ENTREZ2_GET_LINKS);
2231    } else {
2232       atp = AsnLinkType(orig, ENTREZ2_GET_LINKS);
2233    }
2234    /* link in local tree */
2235    if (atp == NULL) {
2236       return NULL;
2237    }
2238 
2239    ptr = Entrez2GetLinksNew();
2240    if (ptr == NULL) {
2241       goto erret;
2242    }
2243    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
2244       goto erret;
2245    }
2246 
2247    atp = AsnReadId(aip,amp, atp);
2248    func = NULL;
2249 
2250    if (atp == ENTREZ2_GET_LINKS_uids) {
2251       ptr -> uids = Entrez2IdListAsnRead(aip, atp);
2252       if (aip -> io_failure) {
2253          goto erret;
2254       }
2255       atp = AsnReadId(aip,amp, atp);
2256    }
2257    if (atp == ENTREZ2_GET_LINKS_linktype) {
2258       if ( AsnReadVal(aip, atp, &av) <= 0) {
2259          goto erret;
2260       }
2261       ptr -> linktype = av.ptrvalue;
2262       atp = AsnReadId(aip,amp, atp);
2263    }
2264    if (atp == ENTREZ2_GET_LINKS_max_UIDS) {
2265       if ( AsnReadVal(aip, atp, &av) <= 0) {
2266          goto erret;
2267       }
2268       ptr -> max_UIDS = av.intvalue;
2269       atp = AsnReadId(aip,amp, atp);
2270    }
2271    if (atp == ENTREZ2_GET_LINKS_count_only) {
2272       if ( AsnReadVal(aip, atp, &av) <= 0) {
2273          goto erret;
2274       }
2275       ptr -> count_only = av.boolvalue;
2276       atp = AsnReadId(aip,amp, atp);
2277    }
2278    if (atp == GET_LINKS_parents_persist) {
2279       if ( AsnReadVal(aip, atp, &av) <= 0) {
2280          goto erret;
2281       }
2282       ptr -> parents_persist = av.boolvalue;
2283       atp = AsnReadId(aip,amp, atp);
2284    }
2285 
2286    if (AsnReadVal(aip, atp, &av) <= 0) {
2287       goto erret;
2288    }
2289    /* end struct */
2290 
2291 ret:
2292    AsnUnlinkType(orig);       /* unlink local tree */
2293    return ptr;
2294 
2295 erret:
2296    aip -> io_failure = TRUE;
2297    ptr = Entrez2GetLinksFree(ptr);
2298    goto ret;
2299 }
2300 
2301 
2302 
2303 /**************************************************
2304 *
2305 *    Entrez2GetLinksAsnWrite()
2306 *
2307 **************************************************/
2308 NLM_EXTERN Boolean LIBCALL 
2309 Entrez2GetLinksAsnWrite(Entrez2GetLinksPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
2310 {
2311    DataVal av;
2312    AsnTypePtr atp;
2313    Boolean retval = FALSE;
2314 
2315    if (! loaded)
2316    {
2317       if (! objent2AsnLoad()) {
2318          return FALSE;
2319       }
2320    }
2321 
2322    if (aip == NULL) {
2323       return FALSE;
2324    }
2325 
2326    atp = AsnLinkType(orig, ENTREZ2_GET_LINKS);   /* link local tree */
2327    if (atp == NULL) {
2328       return FALSE;
2329    }
2330 
2331    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2332    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
2333       goto erret;
2334    }
2335 
2336    if (ptr -> uids != NULL) {
2337       if ( ! Entrez2IdListAsnWrite(ptr -> uids, aip, ENTREZ2_GET_LINKS_uids)) {
2338          goto erret;
2339       }
2340    }
2341    if (ptr -> linktype != NULL) {
2342       av.ptrvalue = ptr -> linktype;
2343       retval = AsnWrite(aip, ENTREZ2_GET_LINKS_linktype,  &av);
2344    }
2345    av.intvalue = ptr -> max_UIDS;
2346    retval = AsnWrite(aip, ENTREZ2_GET_LINKS_max_UIDS,  &av);
2347    av.boolvalue = ptr -> count_only;
2348    retval = AsnWrite(aip, ENTREZ2_GET_LINKS_count_only,  &av);
2349    av.boolvalue = ptr -> parents_persist;
2350    retval = AsnWrite(aip, GET_LINKS_parents_persist,  &av);
2351    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
2352       goto erret;
2353    }
2354    retval = TRUE;
2355 
2356 erret:
2357    AsnUnlinkType(orig);       /* unlink local tree */
2358    return retval;
2359 }
2360 
2361 
2362 
2363 /**************************************************
2364 *
2365 *    Entrez2IdNew()
2366 *
2367 **************************************************/
2368 NLM_EXTERN 
2369 Entrez2IdPtr LIBCALL
2370 Entrez2IdNew(void)
2371 {
2372    Entrez2IdPtr ptr = MemNew((size_t) sizeof(Entrez2Id));
2373 
2374    return ptr;
2375 
2376 }
2377 
2378 
2379 /**************************************************
2380 *
2381 *    Entrez2IdFree()
2382 *
2383 **************************************************/
2384 NLM_EXTERN 
2385 Entrez2IdPtr LIBCALL
2386 Entrez2IdFree(Entrez2IdPtr ptr)
2387 {
2388 
2389    if(ptr == NULL) {
2390       return NULL;
2391    }
2392    MemFree(ptr -> db);
2393    return MemFree(ptr);
2394 }
2395 
2396 
2397 /**************************************************
2398 *
2399 *    Entrez2IdAsnRead()
2400 *
2401 **************************************************/
2402 NLM_EXTERN 
2403 Entrez2IdPtr LIBCALL
2404 Entrez2IdAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2405 {
2406    DataVal av;
2407    AsnTypePtr atp;
2408    Boolean isError = FALSE;
2409    AsnReadFunc func;
2410    Entrez2IdPtr ptr;
2411 
2412    if (! loaded)
2413    {
2414       if (! objent2AsnLoad()) {
2415          return NULL;
2416       }
2417    }
2418 
2419    if (aip == NULL) {
2420       return NULL;
2421    }
2422 
2423    if (orig == NULL) {         /* Entrez2Id ::= (self contained) */
2424       atp = AsnReadId(aip, amp, ENTREZ2_ID);
2425    } else {
2426       atp = AsnLinkType(orig, ENTREZ2_ID);
2427    }
2428    /* link in local tree */
2429    if (atp == NULL) {
2430       return NULL;
2431    }
2432 
2433    ptr = Entrez2IdNew();
2434    if (ptr == NULL) {
2435       goto erret;
2436    }
2437    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
2438       goto erret;
2439    }
2440 
2441    atp = AsnReadId(aip,amp, atp);
2442    func = NULL;
2443 
2444    if (atp == ENTREZ2_ID_db) {
2445       if ( AsnReadVal(aip, atp, &av) <= 0) {
2446          goto erret;
2447       }
2448       ptr -> db = av.ptrvalue;
2449       atp = AsnReadId(aip,amp, atp);
2450    }
2451    if (atp == ENTREZ2_ID_uid) {
2452       if ( AsnReadVal(aip, atp, &av) <= 0) {
2453          goto erret;
2454       }
2455       ptr -> uid = av.intvalue;
2456       atp = AsnReadId(aip,amp, atp);
2457    }
2458 
2459    if (AsnReadVal(aip, atp, &av) <= 0) {
2460       goto erret;
2461    }
2462    /* end struct */
2463 
2464 ret:
2465    AsnUnlinkType(orig);       /* unlink local tree */
2466    return ptr;
2467 
2468 erret:
2469    aip -> io_failure = TRUE;
2470    ptr = Entrez2IdFree(ptr);
2471    goto ret;
2472 }
2473 
2474 
2475 
2476 /**************************************************
2477 *
2478 *    Entrez2IdAsnWrite()
2479 *
2480 **************************************************/
2481 NLM_EXTERN Boolean LIBCALL 
2482 Entrez2IdAsnWrite(Entrez2IdPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
2483 {
2484    DataVal av;
2485    AsnTypePtr atp;
2486    Boolean retval = FALSE;
2487 
2488    if (! loaded)
2489    {
2490       if (! objent2AsnLoad()) {
2491          return FALSE;
2492       }
2493    }
2494 
2495    if (aip == NULL) {
2496       return FALSE;
2497    }
2498 
2499    atp = AsnLinkType(orig, ENTREZ2_ID);   /* link local tree */
2500    if (atp == NULL) {
2501       return FALSE;
2502    }
2503 
2504    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2505    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
2506       goto erret;
2507    }
2508 
2509    if (ptr -> db != NULL) {
2510       av.ptrvalue = ptr -> db;
2511       retval = AsnWrite(aip, ENTREZ2_ID_db,  &av);
2512    }
2513    av.intvalue = ptr -> uid;
2514    retval = AsnWrite(aip, ENTREZ2_ID_uid,  &av);
2515    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
2516       goto erret;
2517    }
2518    retval = TRUE;
2519 
2520 erret:
2521    AsnUnlinkType(orig);       /* unlink local tree */
2522    return retval;
2523 }
2524 
2525 
2526 
2527 /**************************************************
2528 *
2529 *    Entrez2DtFilterNew()
2530 *
2531 **************************************************/
2532 NLM_EXTERN 
2533 Entrez2DtFilterPtr LIBCALL
2534 Entrez2DtFilterNew(void)
2535 {
2536    Entrez2DtFilterPtr ptr = MemNew((size_t) sizeof(Entrez2DtFilter));
2537 
2538    return ptr;
2539 
2540 }
2541 
2542 
2543 /**************************************************
2544 *
2545 *    Entrez2DtFilterFree()
2546 *
2547 **************************************************/
2548 NLM_EXTERN 
2549 Entrez2DtFilterPtr LIBCALL
2550 Entrez2DtFilterFree(Entrez2DtFilterPtr ptr)
2551 {
2552 
2553    if(ptr == NULL) {
2554       return NULL;
2555    }
2556    MemFree(ptr -> type_date);
2557    return MemFree(ptr);
2558 }
2559 
2560 
2561 /**************************************************
2562 *
2563 *    Entrez2DtFilterAsnRead()
2564 *
2565 **************************************************/
2566 NLM_EXTERN 
2567 Entrez2DtFilterPtr LIBCALL
2568 Entrez2DtFilterAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2569 {
2570    DataVal av;
2571    AsnTypePtr atp;
2572    Boolean isError = FALSE;
2573    AsnReadFunc func;
2574    Entrez2DtFilterPtr ptr;
2575 
2576    if (! loaded)
2577    {
2578       if (! objent2AsnLoad()) {
2579          return NULL;
2580       }
2581    }
2582 
2583    if (aip == NULL) {
2584       return NULL;
2585    }
2586 
2587    if (orig == NULL) {         /* Entrez2DtFilter ::= (self contained) */
2588       atp = AsnReadId(aip, amp, ENTREZ2_DT_FILTER);
2589    } else {
2590       atp = AsnLinkType(orig, ENTREZ2_DT_FILTER);
2591    }
2592    /* link in local tree */
2593    if (atp == NULL) {
2594       return NULL;
2595    }
2596 
2597    ptr = Entrez2DtFilterNew();
2598    if (ptr == NULL) {
2599       goto erret;
2600    }
2601    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
2602       goto erret;
2603    }
2604 
2605    atp = AsnReadId(aip,amp, atp);
2606    func = NULL;
2607 
2608    if (atp == ENTREZ2_DT_FILTER_begin_date) {
2609       if ( AsnReadVal(aip, atp, &av) <= 0) {
2610          goto erret;
2611       }
2612       ptr -> begin_date = av.intvalue;
2613       atp = AsnReadId(aip,amp, atp);
2614    }
2615    if (atp == ENTREZ2_DT_FILTER_end_date) {
2616       if ( AsnReadVal(aip, atp, &av) <= 0) {
2617          goto erret;
2618       }
2619       ptr -> end_date = av.intvalue;
2620       atp = AsnReadId(aip,amp, atp);
2621    }
2622    if (atp == ENTREZ2_DT_FILTER_type_date) {
2623       if ( AsnReadVal(aip, atp, &av) <= 0) {
2624          goto erret;
2625       }
2626       ptr -> type_date = av.ptrvalue;
2627       atp = AsnReadId(aip,amp, atp);
2628    }
2629 
2630    if (AsnReadVal(aip, atp, &av) <= 0) {
2631       goto erret;
2632    }
2633    /* end struct */
2634 
2635 ret:
2636    AsnUnlinkType(orig);       /* unlink local tree */
2637    return ptr;
2638 
2639 erret:
2640    aip -> io_failure = TRUE;
2641    ptr = Entrez2DtFilterFree(ptr);
2642    goto ret;
2643 }
2644 
2645 
2646 
2647 /**************************************************
2648 *
2649 *    Entrez2DtFilterAsnWrite()
2650 *
2651 **************************************************/
2652 NLM_EXTERN Boolean LIBCALL 
2653 Entrez2DtFilterAsnWrite(Entrez2DtFilterPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
2654 {
2655    DataVal av;
2656    AsnTypePtr atp;
2657    Boolean retval = FALSE;
2658 
2659    if (! loaded)
2660    {
2661       if (! objent2AsnLoad()) {
2662          return FALSE;
2663       }
2664    }
2665 
2666    if (aip == NULL) {
2667       return FALSE;
2668    }
2669 
2670    atp = AsnLinkType(orig, ENTREZ2_DT_FILTER);   /* link local tree */
2671    if (atp == NULL) {
2672       return FALSE;
2673    }
2674 
2675    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2676    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
2677       goto erret;
2678    }
2679 
2680    av.intvalue = ptr -> begin_date;
2681    retval = AsnWrite(aip, ENTREZ2_DT_FILTER_begin_date,  &av);
2682    av.intvalue = ptr -> end_date;
2683    retval = AsnWrite(aip, ENTREZ2_DT_FILTER_end_date,  &av);
2684    if (ptr -> type_date != NULL) {
2685       av.ptrvalue = ptr -> type_date;
2686       retval = AsnWrite(aip, ENTREZ2_DT_FILTER_type_date,  &av);
2687    }
2688    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
2689       goto erret;
2690    }
2691    retval = TRUE;
2692 
2693 erret:
2694    AsnUnlinkType(orig);       /* unlink local tree */
2695    return retval;
2696 }
2697 
2698 
2699 
2700 /**************************************************
2701 *
2702 *    Entrez2ReplyNew()
2703 *
2704 **************************************************/
2705 NLM_EXTERN 
2706 Entrez2ReplyPtr LIBCALL
2707 Entrez2ReplyNew(void)
2708 {
2709    Entrez2ReplyPtr ptr = MemNew((size_t) sizeof(Entrez2Reply));
2710 
2711    return ptr;
2712 
2713 }
2714 
2715 
2716 /**************************************************
2717 *
2718 *    Entrez2ReplyFree()
2719 *
2720 **************************************************/
2721 NLM_EXTERN 
2722 Entrez2ReplyPtr LIBCALL
2723 Entrez2ReplyFree(Entrez2ReplyPtr ptr)
2724 {
2725 
2726    if(ptr == NULL) {
2727       return NULL;
2728    }
2729    E2ReplyFree(ptr -> reply);
2730    MemFree(ptr -> server);
2731    MemFree(ptr -> msg);
2732    MemFree(ptr -> key);
2733    MemFree(ptr -> cookie);
2734    return MemFree(ptr);
2735 }
2736 
2737 
2738 /**************************************************
2739 *
2740 *    Entrez2ReplyAsnRead()
2741 *
2742 **************************************************/
2743 NLM_EXTERN 
2744 Entrez2ReplyPtr LIBCALL
2745 Entrez2ReplyAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2746 {
2747    DataVal av;
2748    AsnTypePtr atp;
2749    Boolean isError = FALSE;
2750    AsnReadFunc func;
2751    Entrez2ReplyPtr ptr;
2752 
2753    if (! loaded)
2754    {
2755       if (! objent2AsnLoad()) {
2756          return NULL;
2757       }
2758    }
2759 
2760    if (aip == NULL) {
2761       return NULL;
2762    }
2763 
2764    if (orig == NULL) {         /* Entrez2Reply ::= (self contained) */
2765       atp = AsnReadId(aip, amp, ENTREZ2_REPLY);
2766    } else {
2767       atp = AsnLinkType(orig, ENTREZ2_REPLY);
2768    }
2769    /* link in local tree */
2770    if (atp == NULL) {
2771       return NULL;
2772    }
2773 
2774    ptr = Entrez2ReplyNew();
2775    if (ptr == NULL) {
2776       goto erret;
2777    }
2778    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
2779       goto erret;
2780    }
2781 
2782    atp = AsnReadId(aip,amp, atp);
2783    func = NULL;
2784 
2785    if (atp == ENTREZ2_REPLY_reply) {
2786       ptr -> reply = E2ReplyAsnRead(aip, atp);
2787       if (aip -> io_failure) {
2788          goto erret;
2789       }
2790       atp = AsnReadId(aip,amp, atp);
2791    }
2792    if (atp == ENTREZ2_REPLY_dt) {
2793       if ( AsnReadVal(aip, atp, &av) <= 0) {
2794          goto erret;
2795       }
2796       ptr -> dt = av.intvalue;
2797       atp = AsnReadId(aip,amp, atp);
2798    }
2799    if (atp == ENTREZ2_REPLY_server) {
2800       if ( AsnReadVal(aip, atp, &av) <= 0) {
2801          goto erret;
2802       }
2803       ptr -> server = av.ptrvalue;
2804       atp = AsnReadId(aip,amp, atp);
2805    }
2806    if (atp == ENTREZ2_REPLY_msg) {
2807       if ( AsnReadVal(aip, atp, &av) <= 0) {
2808          goto erret;
2809       }
2810       ptr -> msg = av.ptrvalue;
2811       atp = AsnReadId(aip,amp, atp);
2812    }
2813    if (atp == ENTREZ2_REPLY_key) {
2814       if ( AsnReadVal(aip, atp, &av) <= 0) {
2815          goto erret;
2816       }
2817       ptr -> key = av.ptrvalue;
2818       atp = AsnReadId(aip,amp, atp);
2819    }
2820    if (atp == ENTREZ2_REPLY_cookie) {
2821       if ( AsnReadVal(aip, atp, &av) <= 0) {
2822          goto erret;
2823       }
2824       ptr -> cookie = av.ptrvalue;
2825       atp = AsnReadId(aip,amp, atp);
2826    }
2827 
2828    if (AsnReadVal(aip, atp, &av) <= 0) {
2829       goto erret;
2830    }
2831    /* end struct */
2832 
2833 ret:
2834    AsnUnlinkType(orig);       /* unlink local tree */
2835    return ptr;
2836 
2837 erret:
2838    aip -> io_failure = TRUE;
2839    ptr = Entrez2ReplyFree(ptr);
2840    goto ret;
2841 }
2842 
2843 
2844 
2845 /**************************************************
2846 *
2847 *    Entrez2ReplyAsnWrite()
2848 *
2849 **************************************************/
2850 NLM_EXTERN Boolean LIBCALL 
2851 Entrez2ReplyAsnWrite(Entrez2ReplyPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
2852 {
2853    DataVal av;
2854    AsnTypePtr atp;
2855    Boolean retval = FALSE;
2856 
2857    if (! loaded)
2858    {
2859       if (! objent2AsnLoad()) {
2860          return FALSE;
2861       }
2862    }
2863 
2864    if (aip == NULL) {
2865       return FALSE;
2866    }
2867 
2868    atp = AsnLinkType(orig, ENTREZ2_REPLY);   /* link local tree */
2869    if (atp == NULL) {
2870       return FALSE;
2871    }
2872 
2873    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2874    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
2875       goto erret;
2876    }
2877 
2878    if (ptr -> reply != NULL) {
2879       if ( ! E2ReplyAsnWrite(ptr -> reply, aip, ENTREZ2_REPLY_reply)) {
2880          goto erret;
2881       }
2882    }
2883    av.intvalue = ptr -> dt;
2884    retval = AsnWrite(aip, ENTREZ2_REPLY_dt,  &av);
2885    if (ptr -> server != NULL) {
2886       av.ptrvalue = ptr -> server;
2887       retval = AsnWrite(aip, ENTREZ2_REPLY_server,  &av);
2888    }
2889    if (ptr -> msg != NULL) {
2890       av.ptrvalue = ptr -> msg;
2891       retval = AsnWrite(aip, ENTREZ2_REPLY_msg,  &av);
2892    }
2893    if (ptr -> key != NULL) {
2894       av.ptrvalue = ptr -> key;
2895       retval = AsnWrite(aip, ENTREZ2_REPLY_key,  &av);
2896    }
2897    if (ptr -> cookie != NULL) {
2898       av.ptrvalue = ptr -> cookie;
2899       retval = AsnWrite(aip, ENTREZ2_REPLY_cookie,  &av);
2900    }
2901    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
2902       goto erret;
2903    }
2904    retval = TRUE;
2905 
2906 erret:
2907    AsnUnlinkType(orig);       /* unlink local tree */
2908    return retval;
2909 }
2910 
2911 
2912 
2913 /**************************************************
2914 *
2915 *    E2ReplyFree()
2916 *
2917 **************************************************/
2918 NLM_EXTERN 
2919 E2ReplyPtr LIBCALL
2920 E2ReplyFree(ValNodePtr anp)
2921 {
2922    Pointer pnt;
2923 
2924    if (anp == NULL) {
2925       return NULL;
2926    }
2927 
2928    pnt = anp->data.ptrvalue;
2929    switch (anp->choice)
2930    {
2931    default:
2932       break;
2933    case E2Reply_error:
2934       MemFree(anp -> data.ptrvalue);
2935       break;
2936    case E2Reply_get_info:
2937       Entrez2InfoFree(anp -> data.ptrvalue);
2938       break;
2939    case E2Reply_eval_boolean:
2940       Entrez2BooleanReplyFree(anp -> data.ptrvalue);
2941       break;
2942    case E2Reply_get_docsum:
2943       Entrez2DocsumListFree(anp -> data.ptrvalue);
2944       break;
2945    case E2Reply_get_term_list:
2946       Entrez2TermListFree(anp -> data.ptrvalue);
2947       break;
2948    case E2Reply_get_term_hierarchy:
2949       Entrez2HierNodeFree(anp -> data.ptrvalue);
2950       break;
2951    case E2Reply_get_links:
2952       Entrez2LinkSetFree(anp -> data.ptrvalue);
2953       break;
2954    case E2Reply_get_linked:
2955       Entrez2IdListFree(anp -> data.ptrvalue);
2956       break;
2957    case E2Reply_get_link_counts:
2958       Entrez2LinkCountListFree(anp -> data.ptrvalue);
2959       break;
2960    }
2961    return MemFree(anp);
2962 }
2963 
2964 
2965 /**************************************************
2966 *
2967 *    E2ReplyAsnRead()
2968 *
2969 **************************************************/
2970 NLM_EXTERN 
2971 E2ReplyPtr LIBCALL
2972 E2ReplyAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2973 {
2974    DataVal av;
2975    AsnTypePtr atp;
2976    ValNodePtr anp;
2977    Uint1 choice;
2978    Boolean isError = FALSE;
2979    Boolean nullIsError = FALSE;
2980    AsnReadFunc func;
2981 
2982    if (! loaded)
2983    {
2984       if (! objent2AsnLoad()) {
2985          return NULL;
2986       }
2987    }
2988 
2989    if (aip == NULL) {
2990       return NULL;
2991    }
2992 
2993    if (orig == NULL) {         /* E2Reply ::= (self contained) */
2994       atp = AsnReadId(aip, amp, E2REPLY);
2995    } else {
2996       atp = AsnLinkType(orig, E2REPLY);    /* link in local tree */
2997    }
2998    if (atp == NULL) {
2999       return NULL;
3000    }
3001 
3002    anp = ValNodeNew(NULL);
3003    if (anp == NULL) {
3004       goto erret;
3005    }
3006    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
3007       goto erret;
3008    }
3009 
3010    func = NULL;
3011 
3012    atp = AsnReadId(aip, amp, atp);  /* find the choice */
3013    if (atp == NULL) {
3014       goto erret;
3015    }
3016    if (atp == E2REPLY_error) {
3017       choice = E2Reply_error;
3018       if (AsnReadVal(aip, atp, &av) <= 0) {
3019          goto erret;
3020       }
3021       anp->data.ptrvalue = av.ptrvalue;
3022    }
3023    else if (atp == E2REPLY_get_info) {
3024       choice = E2Reply_get_info;
3025       func = (AsnReadFunc) Entrez2InfoAsnRead;
3026    }
3027    else if (atp == E2REPLY_eval_boolean) {
3028       choice = E2Reply_eval_boolean;
3029       func = (AsnReadFunc) Entrez2BooleanReplyAsnRead;
3030    }
3031    else if (atp == E2REPLY_get_docsum) {
3032       choice = E2Reply_get_docsum;
3033       func = (AsnReadFunc) Entrez2DocsumListAsnRead;
3034    }
3035    else if (atp == E2REPLY_get_term_pos) {
3036       choice = E2Reply_get_term_pos;
3037       if (AsnReadVal(aip, atp, &av) <= 0) {
3038          goto erret;
3039       }
3040       anp->data.intvalue = av.intvalue;
3041    }
3042    else if (atp == E2REPLY_get_term_list) {
3043       choice = E2Reply_get_term_list;
3044       func = (AsnReadFunc) Entrez2TermListAsnRead;
3045    }
3046    else if (atp == E2REPLY_get_term_hierarchy) {
3047       choice = E2Reply_get_term_hierarchy;
3048       func = (AsnReadFunc) Entrez2HierNodeAsnRead;
3049    }
3050    else if (atp == E2REPLY_get_links) {
3051       choice = E2Reply_get_links;
3052       func = (AsnReadFunc) Entrez2LinkSetAsnRead;
3053    }
3054    else if (atp == E2REPLY_get_linked) {
3055       choice = E2Reply_get_linked;
3056       func = (AsnReadFunc) Entrez2IdListAsnRead;
3057    }
3058    else if (atp == E2REPLY_get_link_counts) {
3059       choice = E2Reply_get_link_counts;
3060       func = (AsnReadFunc) Entrez2LinkCountListAsnRead;
3061    }
3062    anp->choice = choice;
3063    if (func != NULL)
3064    {
3065       anp->data.ptrvalue = (* func)(aip, atp);
3066       if (aip -> io_failure) goto erret;
3067 
3068       if (nullIsError && anp->data.ptrvalue == NULL) {
3069          goto erret;
3070       }
3071    }
3072 
3073 ret:
3074    AsnUnlinkType(orig);       /* unlink local tree */
3075    return anp;
3076 
3077 erret:
3078    anp = MemFree(anp);
3079    aip -> io_failure = TRUE;
3080    goto ret;
3081 }
3082 
3083 
3084 /**************************************************
3085 *
3086 *    E2ReplyAsnWrite()
3087 *
3088 **************************************************/
3089 NLM_EXTERN Boolean LIBCALL 
3090 E2ReplyAsnWrite(E2ReplyPtr anp, AsnIoPtr aip, AsnTypePtr orig)
3091 
3092 {
3093    DataVal av;
3094    AsnTypePtr atp, writetype = NULL;
3095    Pointer pnt;
3096    AsnWriteFunc func = NULL;
3097    Boolean retval = FALSE;
3098 
3099    if (! loaded)
3100    {
3101       if (! objent2AsnLoad())
3102       return FALSE;
3103    }
3104 
3105    if (aip == NULL)
3106    return FALSE;
3107 
3108    atp = AsnLinkType(orig, E2REPLY);   /* link local tree */
3109    if (atp == NULL) {
3110       return FALSE;
3111    }
3112 
3113    if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3114 
3115    av.ptrvalue = (Pointer)anp;
3116    if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
3117       goto erret;
3118    }
3119 
3120    pnt = anp->data.ptrvalue;
3121    switch (anp->choice)
3122    {
3123    case E2Reply_error:
3124       av.ptrvalue = anp->data.ptrvalue;
3125       retval = AsnWrite(aip, E2REPLY_error, &av);
3126       break;
3127    case E2Reply_get_info:
3128       writetype = E2REPLY_get_info;
3129       func = (AsnWriteFunc) Entrez2InfoAsnWrite;
3130       break;
3131    case E2Reply_eval_boolean:
3132       writetype = E2REPLY_eval_boolean;
3133       func = (AsnWriteFunc) Entrez2BooleanReplyAsnWrite;
3134       break;
3135    case E2Reply_get_docsum:
3136       writetype = E2REPLY_get_docsum;
3137       func = (AsnWriteFunc) Entrez2DocsumListAsnWrite;
3138       break;
3139    case E2Reply_get_term_pos:
3140       av.intvalue = anp->data.intvalue;
3141       retval = AsnWrite(aip, E2REPLY_get_term_pos, &av);
3142       break;
3143    case E2Reply_get_term_list:
3144       writetype = E2REPLY_get_term_list;
3145       func = (AsnWriteFunc) Entrez2TermListAsnWrite;
3146       break;
3147    case E2Reply_get_term_hierarchy:
3148       writetype = E2REPLY_get_term_hierarchy;
3149       func = (AsnWriteFunc) Entrez2HierNodeAsnWrite;
3150       break;
3151    case E2Reply_get_links:
3152       writetype = E2REPLY_get_links;
3153       func = (AsnWriteFunc) Entrez2LinkSetAsnWrite;
3154       break;
3155    case E2Reply_get_linked:
3156       writetype = E2REPLY_get_linked;
3157       func = (AsnWriteFunc) Entrez2IdListAsnWrite;
3158       break;
3159    case E2Reply_get_link_counts:
3160       writetype = E2REPLY_get_link_counts;
3161       func = (AsnWriteFunc) Entrez2LinkCountListAsnWrite;
3162       break;
3163    }
3164    if (writetype != NULL) {
3165       retval = (* func)(pnt, aip, writetype);   /* write it out */
3166    }
3167    if (!retval) {
3168       goto erret;
3169    }
3170    retval = TRUE;
3171 
3172 erret:
3173    AsnUnlinkType(orig);       /* unlink local tree */
3174    return retval;
3175 }
3176 
3177 
3178 /**************************************************
3179 *
3180 *    Entrez2InfoNew()
3181 *
3182 **************************************************/
3183 NLM_EXTERN 
3184 Entrez2InfoPtr LIBCALL
3185 Entrez2InfoNew(void)
3186 {
3187    Entrez2InfoPtr ptr = MemNew((size_t) sizeof(Entrez2Info));
3188 
3189    return ptr;
3190 
3191 }
3192 
3193 
3194 /**************************************************
3195 *
3196 *    Entrez2InfoFree()
3197 *
3198 **************************************************/
3199 NLM_EXTERN 
3200 Entrez2InfoPtr LIBCALL
3201 Entrez2InfoFree(Entrez2InfoPtr ptr)
3202 {
3203 
3204    if(ptr == NULL) {
3205       return NULL;
3206    }
3207    AsnGenericUserSeqOfFree(ptr -> db_info, (AsnOptFreeFunc) Entrez2DbInfoFree);
3208    return MemFree(ptr);
3209 }
3210 
3211 
3212 /**************************************************
3213 *
3214 *    Entrez2InfoAsnRead()
3215 *
3216 **************************************************/
3217 NLM_EXTERN 
3218 Entrez2InfoPtr LIBCALL
3219 Entrez2InfoAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3220 {
3221    DataVal av;
3222    AsnTypePtr atp;
3223    Boolean isError = FALSE;
3224    AsnReadFunc func;
3225    Entrez2InfoPtr ptr;
3226 
3227    if (! loaded)
3228    {
3229       if (! objent2AsnLoad()) {
3230          return NULL;
3231       }
3232    }
3233 
3234    if (aip == NULL) {
3235       return NULL;
3236    }
3237 
3238    if (orig == NULL) {         /* Entrez2Info ::= (self contained) */
3239       atp = AsnReadId(aip, amp, ENTREZ2_INFO);
3240    } else {
3241       atp = AsnLinkType(orig, ENTREZ2_INFO);
3242    }
3243    /* link in local tree */
3244    if (atp == NULL) {
3245       return NULL;
3246    }
3247 
3248    ptr = Entrez2InfoNew();
3249    if (ptr == NULL) {
3250       goto erret;
3251    }
3252    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
3253       goto erret;
3254    }
3255 
3256    atp = AsnReadId(aip,amp, atp);
3257    func = NULL;
3258 
3259    if (atp == ENTREZ2_INFO_db_count) {
3260       if ( AsnReadVal(aip, atp, &av) <= 0) {
3261          goto erret;
3262       }
3263       ptr -> db_count = av.intvalue;
3264       atp = AsnReadId(aip,amp, atp);
3265    }
3266    if (atp == ENTREZ2_INFO_build_date) {
3267       if ( AsnReadVal(aip, atp, &av) <= 0) {
3268          goto erret;
3269       }
3270       ptr -> build_date = av.intvalue;
3271       atp = AsnReadId(aip,amp, atp);
3272    }
3273    if (atp == ENTREZ2_INFO_db_info) {
3274       ptr -> db_info = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Entrez2DbInfoAsnRead, (AsnOptFreeFunc) Entrez2DbInfoFree);
3275       if (isError && ptr -> db_info == NULL) {
3276          goto erret;
3277       }
3278       atp = AsnReadId(aip,amp, atp);
3279    }
3280 
3281    if (AsnReadVal(aip, atp, &av) <= 0) {
3282       goto erret;
3283    }
3284    /* end struct */
3285 
3286 ret:
3287    AsnUnlinkType(orig);       /* unlink local tree */
3288    return ptr;
3289 
3290 erret:
3291    aip -> io_failure = TRUE;
3292    ptr = Entrez2InfoFree(ptr);
3293    goto ret;
3294 }
3295 
3296 
3297 
3298 /**************************************************
3299 *
3300 *    Entrez2InfoAsnWrite()
3301 *
3302 **************************************************/
3303 NLM_EXTERN Boolean LIBCALL 
3304 Entrez2InfoAsnWrite(Entrez2InfoPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
3305 {
3306    DataVal av;
3307    AsnTypePtr atp;
3308    Boolean retval = FALSE;
3309 
3310    if (! loaded)
3311    {
3312       if (! objent2AsnLoad()) {
3313          return FALSE;
3314       }
3315    }
3316 
3317    if (aip == NULL) {
3318       return FALSE;
3319    }
3320 
3321    atp = AsnLinkType(orig, ENTREZ2_INFO);   /* link local tree */
3322    if (atp == NULL) {
3323       return FALSE;
3324    }
3325 
3326    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3327    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
3328       goto erret;
3329    }
3330 
3331    av.intvalue = ptr -> db_count;
3332    retval = AsnWrite(aip, ENTREZ2_INFO_db_count,  &av);
3333    av.intvalue = ptr -> build_date;
3334    retval = AsnWrite(aip, ENTREZ2_INFO_build_date,  &av);
3335    AsnGenericUserSeqOfAsnWrite(ptr -> db_info, (AsnWriteFunc) Entrez2DbInfoAsnWrite, aip, ENTREZ2_INFO_db_info, ENTREZ2_INFO_db_info_E);
3336    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
3337       goto erret;
3338    }
3339    retval = TRUE;
3340 
3341 erret:
3342    AsnUnlinkType(orig);       /* unlink local tree */
3343    return retval;
3344 }
3345 
3346 
3347 
3348 /**************************************************
3349 *
3350 *    Entrez2BooleanReplyNew()
3351 *
3352 **************************************************/
3353 NLM_EXTERN 
3354 Entrez2BooleanReplyPtr LIBCALL
3355 Entrez2BooleanReplyNew(void)
3356 {
3357    Entrez2BooleanReplyPtr ptr = MemNew((size_t) sizeof(Entrez2BooleanReply));
3358 
3359    return ptr;
3360 
3361 }
3362 
3363 
3364 /**************************************************
3365 *
3366 *    Entrez2BooleanReplyFree()
3367 *
3368 **************************************************/
3369 NLM_EXTERN 
3370 Entrez2BooleanReplyPtr LIBCALL
3371 Entrez2BooleanReplyFree(Entrez2BooleanReplyPtr ptr)
3372 {
3373 
3374    if(ptr == NULL) {
3375       return NULL;
3376    }
3377    Entrez2IdListFree(ptr -> uids);
3378    Entrez2BooleanExpFree(ptr -> query);
3379    return MemFree(ptr);
3380 }
3381 
3382 
3383 /**************************************************
3384 *
3385 *    Entrez2BooleanReplyAsnRead()
3386 *
3387 **************************************************/
3388 NLM_EXTERN 
3389 Entrez2BooleanReplyPtr LIBCALL
3390 Entrez2BooleanReplyAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3391 {
3392    DataVal av;
3393    AsnTypePtr atp;
3394    Boolean isError = FALSE;
3395    AsnReadFunc func;
3396    Entrez2BooleanReplyPtr ptr;
3397 
3398    if (! loaded)
3399    {
3400       if (! objent2AsnLoad()) {
3401          return NULL;
3402       }
3403    }
3404 
3405    if (aip == NULL) {
3406       return NULL;
3407    }
3408 
3409    if (orig == NULL) {         /* Entrez2BooleanReply ::= (self contained) */
3410       atp = AsnReadId(aip, amp, ENTREZ2_BOOLEAN_REPLY);
3411    } else {
3412       atp = AsnLinkType(orig, ENTREZ2_BOOLEAN_REPLY);
3413    }
3414    /* link in local tree */
3415    if (atp == NULL) {
3416       return NULL;
3417    }
3418 
3419    ptr = Entrez2BooleanReplyNew();
3420    if (ptr == NULL) {
3421       goto erret;
3422    }
3423    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
3424       goto erret;
3425    }
3426 
3427    atp = AsnReadId(aip,amp, atp);
3428    func = NULL;
3429 
3430    if (atp == ENTREZ2_BOOLEAN_REPLY_count) {
3431       if ( AsnReadVal(aip, atp, &av) <= 0) {
3432          goto erret;
3433       }
3434       ptr -> count = av.intvalue;
3435       atp = AsnReadId(aip,amp, atp);
3436    }
3437    if (atp == ENTREZ2_BOOLEAN_REPLY_uids) {
3438       ptr -> uids = Entrez2IdListAsnRead(aip, atp);
3439       if (aip -> io_failure) {
3440          goto erret;
3441       }
3442       atp = AsnReadId(aip,amp, atp);
3443    }
3444    if (atp == ENTREZ2_BOOLEAN_REPLY_query) {
3445       ptr -> query = Entrez2BooleanExpAsnRead(aip, atp);
3446       if (aip -> io_failure) {
3447          goto erret;
3448       }
3449       atp = AsnReadId(aip,amp, atp);
3450    }
3451 
3452    if (AsnReadVal(aip, atp, &av) <= 0) {
3453       goto erret;
3454    }
3455    /* end struct */
3456 
3457 ret:
3458    AsnUnlinkType(orig);       /* unlink local tree */
3459    return ptr;
3460 
3461 erret:
3462    aip -> io_failure = TRUE;
3463    ptr = Entrez2BooleanReplyFree(ptr);
3464    goto ret;
3465 }
3466 
3467 
3468 
3469 /**************************************************
3470 *
3471 *    Entrez2BooleanReplyAsnWrite()
3472 *
3473 **************************************************/
3474 NLM_EXTERN Boolean LIBCALL 
3475 Entrez2BooleanReplyAsnWrite(Entrez2BooleanReplyPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
3476 {
3477    DataVal av;
3478    AsnTypePtr atp;
3479    Boolean retval = FALSE;
3480 
3481    if (! loaded)
3482    {
3483       if (! objent2AsnLoad()) {
3484          return FALSE;
3485       }
3486    }
3487 
3488    if (aip == NULL) {
3489       return FALSE;
3490    }
3491 
3492    atp = AsnLinkType(orig, ENTREZ2_BOOLEAN_REPLY);   /* link local tree */
3493    if (atp == NULL) {
3494       return FALSE;
3495    }
3496 
3497    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3498    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
3499       goto erret;
3500    }
3501 
3502    av.intvalue = ptr -> count;
3503    retval = AsnWrite(aip, ENTREZ2_BOOLEAN_REPLY_count,  &av);
3504    if (ptr -> uids != NULL) {
3505       if ( ! Entrez2IdListAsnWrite(ptr -> uids, aip, ENTREZ2_BOOLEAN_REPLY_uids)) {
3506          goto erret;
3507       }
3508    }
3509    if (ptr -> query != NULL) {
3510       if ( ! Entrez2BooleanExpAsnWrite(ptr -> query, aip, ENTREZ2_BOOLEAN_REPLY_query)) {
3511          goto erret;
3512       }
3513    }
3514    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
3515       goto erret;
3516    }
3517    retval = TRUE;
3518 
3519 erret:
3520    AsnUnlinkType(orig);       /* unlink local tree */
3521    return retval;
3522 }
3523 
3524 
3525 
3526 /**************************************************
3527 *
3528 *    Entrez2DocsumListNew()
3529 *
3530 **************************************************/
3531 NLM_EXTERN 
3532 Entrez2DocsumListPtr LIBCALL
3533 Entrez2DocsumListNew(void)
3534 {
3535    Entrez2DocsumListPtr ptr = MemNew((size_t) sizeof(Entrez2DocsumList));
3536 
3537    return ptr;
3538 
3539 }
3540 
3541 
3542 /**************************************************
3543 *
3544 *    Entrez2DocsumListFree()
3545 *
3546 **************************************************/
3547 NLM_EXTERN 
3548 Entrez2DocsumListPtr LIBCALL
3549 Entrez2DocsumListFree(Entrez2DocsumListPtr ptr)
3550 {
3551 
3552    if(ptr == NULL) {
3553       return NULL;
3554    }
3555    AsnGenericUserSeqOfFree(ptr -> list, (AsnOptFreeFunc) Entrez2DocsumFree);
3556    return MemFree(ptr);
3557 }
3558 
3559 
3560 /**************************************************
3561 *
3562 *    Entrez2DocsumListAsnRead()
3563 *
3564 **************************************************/
3565 NLM_EXTERN 
3566 Entrez2DocsumListPtr LIBCALL
3567 Entrez2DocsumListAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3568 {
3569    DataVal av;
3570    AsnTypePtr atp;
3571    Boolean isError = FALSE;
3572    AsnReadFunc func;
3573    Entrez2DocsumListPtr ptr;
3574 
3575    if (! loaded)
3576    {
3577       if (! objent2AsnLoad()) {
3578          return NULL;
3579       }
3580    }
3581 
3582    if (aip == NULL) {
3583       return NULL;
3584    }
3585 
3586    if (orig == NULL) {         /* Entrez2DocsumList ::= (self contained) */
3587       atp = AsnReadId(aip, amp, ENTREZ2_DOCSUM_LIST);
3588    } else {
3589       atp = AsnLinkType(orig, ENTREZ2_DOCSUM_LIST);
3590    }
3591    /* link in local tree */
3592    if (atp == NULL) {
3593       return NULL;
3594    }
3595 
3596    ptr = Entrez2DocsumListNew();
3597    if (ptr == NULL) {
3598       goto erret;
3599    }
3600    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
3601       goto erret;
3602    }
3603 
3604    atp = AsnReadId(aip,amp, atp);
3605    func = NULL;
3606 
3607    if (atp == ENTREZ2_DOCSUM_LIST_count) {
3608       if ( AsnReadVal(aip, atp, &av) <= 0) {
3609          goto erret;
3610       }
3611       ptr -> count = av.intvalue;
3612       atp = AsnReadId(aip,amp, atp);
3613    }
3614    if (atp == ENTREZ2_DOCSUM_LIST_list) {
3615       ptr -> list = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Entrez2DocsumAsnRead, (AsnOptFreeFunc) Entrez2DocsumFree);
3616       if (isError && ptr -> list == NULL) {
3617          goto erret;
3618       }
3619       atp = AsnReadId(aip,amp, atp);
3620    }
3621 
3622    if (AsnReadVal(aip, atp, &av) <= 0) {
3623       goto erret;
3624    }
3625    /* end struct */
3626 
3627 ret:
3628    AsnUnlinkType(orig);       /* unlink local tree */
3629    return ptr;
3630 
3631 erret:
3632    aip -> io_failure = TRUE;
3633    ptr = Entrez2DocsumListFree(ptr);
3634    goto ret;
3635 }
3636 
3637 
3638 
3639 /**************************************************
3640 *
3641 *    Entrez2DocsumListAsnWrite()
3642 *
3643 **************************************************/
3644 NLM_EXTERN Boolean LIBCALL 
3645 Entrez2DocsumListAsnWrite(Entrez2DocsumListPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
3646 {
3647    DataVal av;
3648    AsnTypePtr atp;
3649    Boolean retval = FALSE;
3650 
3651    if (! loaded)
3652    {
3653       if (! objent2AsnLoad()) {
3654          return FALSE;
3655       }
3656    }
3657 
3658    if (aip == NULL) {
3659       return FALSE;
3660    }
3661 
3662    atp = AsnLinkType(orig, ENTREZ2_DOCSUM_LIST);   /* link local tree */
3663    if (atp == NULL) {
3664       return FALSE;
3665    }
3666 
3667    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3668    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
3669       goto erret;
3670    }
3671 
3672    av.intvalue = ptr -> count;
3673    retval = AsnWrite(aip, ENTREZ2_DOCSUM_LIST_count,  &av);
3674    AsnGenericUserSeqOfAsnWrite(ptr -> list, (AsnWriteFunc) Entrez2DocsumAsnWrite, aip, ENTREZ2_DOCSUM_LIST_list, ENTREZ2_DOCSUM_LIST_list_E);
3675    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
3676       goto erret;
3677    }
3678    retval = TRUE;
3679 
3680 erret:
3681    AsnUnlinkType(orig);       /* unlink local tree */
3682    return retval;
3683 }
3684 
3685 
3686 
3687 /**************************************************
3688 *
3689 *    Entrez2TermListNew()
3690 *
3691 **************************************************/
3692 NLM_EXTERN 
3693 Entrez2TermListPtr LIBCALL
3694 Entrez2TermListNew(void)
3695 {
3696    Entrez2TermListPtr ptr = MemNew((size_t) sizeof(Entrez2TermList));
3697 
3698    return ptr;
3699 
3700 }
3701 
3702 
3703 /**************************************************
3704 *
3705 *    Entrez2TermListFree()
3706 *
3707 **************************************************/
3708 NLM_EXTERN 
3709 Entrez2TermListPtr LIBCALL
3710 Entrez2TermListFree(Entrez2TermListPtr ptr)
3711 {
3712 
3713    if(ptr == NULL) {
3714       return NULL;
3715    }
3716    AsnGenericUserSeqOfFree(ptr -> list, (AsnOptFreeFunc) Entrez2TermFree);
3717    return MemFree(ptr);
3718 }
3719 
3720 
3721 /**************************************************
3722 *
3723 *    Entrez2TermListAsnRead()
3724 *
3725 **************************************************/
3726 NLM_EXTERN 
3727 Entrez2TermListPtr LIBCALL
3728 Entrez2TermListAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3729 {
3730    DataVal av;
3731    AsnTypePtr atp;
3732    Boolean isError = FALSE;
3733    AsnReadFunc func;
3734    Entrez2TermListPtr ptr;
3735 
3736    if (! loaded)
3737    {
3738       if (! objent2AsnLoad()) {
3739          return NULL;
3740       }
3741    }
3742 
3743    if (aip == NULL) {
3744       return NULL;
3745    }
3746 
3747    if (orig == NULL) {         /* Entrez2TermList ::= (self contained) */
3748       atp = AsnReadId(aip, amp, ENTREZ2_TERM_LIST);
3749    } else {
3750       atp = AsnLinkType(orig, ENTREZ2_TERM_LIST);
3751    }
3752    /* link in local tree */
3753    if (atp == NULL) {
3754       return NULL;
3755    }
3756 
3757    ptr = Entrez2TermListNew();
3758    if (ptr == NULL) {
3759       goto erret;
3760    }
3761    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
3762       goto erret;
3763    }
3764 
3765    atp = AsnReadId(aip,amp, atp);
3766    func = NULL;
3767 
3768    if (atp == ENTREZ2_TERM_LIST_pos) {
3769       if ( AsnReadVal(aip, atp, &av) <= 0) {
3770          goto erret;
3771       }
3772       ptr -> pos = av.intvalue;
3773       atp = AsnReadId(aip,amp, atp);
3774    }
3775    if (atp == ENTREZ2_TERM_LIST_num) {
3776       if ( AsnReadVal(aip, atp, &av) <= 0) {
3777          goto erret;
3778       }
3779       ptr -> num = av.intvalue;
3780       atp = AsnReadId(aip,amp, atp);
3781    }
3782    if (atp == ENTREZ2_TERM_LIST_list) {
3783       ptr -> list = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Entrez2TermAsnRead, (AsnOptFreeFunc) Entrez2TermFree);
3784       if (isError && ptr -> list == NULL) {
3785          goto erret;
3786       }
3787       atp = AsnReadId(aip,amp, atp);
3788    }
3789 
3790    if (AsnReadVal(aip, atp, &av) <= 0) {
3791       goto erret;
3792    }
3793    /* end struct */
3794 
3795 ret:
3796    AsnUnlinkType(orig);       /* unlink local tree */
3797    return ptr;
3798 
3799 erret:
3800    aip -> io_failure = TRUE;
3801    ptr = Entrez2TermListFree(ptr);
3802    goto ret;
3803 }
3804 
3805 
3806 
3807 /**************************************************
3808 *
3809 *    Entrez2TermListAsnWrite()
3810 *
3811 **************************************************/
3812 NLM_EXTERN Boolean LIBCALL 
3813 Entrez2TermListAsnWrite(Entrez2TermListPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
3814 {
3815    DataVal av;
3816    AsnTypePtr atp;
3817    Boolean retval = FALSE;
3818 
3819    if (! loaded)
3820    {
3821       if (! objent2AsnLoad()) {
3822          return FALSE;
3823       }
3824    }
3825 
3826    if (aip == NULL) {
3827       return FALSE;
3828    }
3829 
3830    atp = AsnLinkType(orig, ENTREZ2_TERM_LIST);   /* link local tree */
3831    if (atp == NULL) {
3832       return FALSE;
3833    }
3834 
3835    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3836    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
3837       goto erret;
3838    }
3839 
3840    av.intvalue = ptr -> pos;
3841    retval = AsnWrite(aip, ENTREZ2_TERM_LIST_pos,  &av);
3842    av.intvalue = ptr -> num;
3843    retval = AsnWrite(aip, ENTREZ2_TERM_LIST_num,  &av);
3844    AsnGenericUserSeqOfAsnWrite(ptr -> list, (AsnWriteFunc) Entrez2TermAsnWrite, aip, ENTREZ2_TERM_LIST_list, ENTREZ2_TERM_LIST_list_E);
3845    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
3846       goto erret;
3847    }
3848    retval = TRUE;
3849 
3850 erret:
3851    AsnUnlinkType(orig);       /* unlink local tree */
3852    return retval;
3853 }
3854 
3855 
3856 
3857 /**************************************************
3858 *
3859 *    Entrez2HierNodeNew()
3860 *
3861 **************************************************/
3862 NLM_EXTERN 
3863 Entrez2HierNodePtr LIBCALL
3864 Entrez2HierNodeNew(void)
3865 {
3866    Entrez2HierNodePtr ptr = MemNew((size_t) sizeof(Entrez2HierNode));
3867 
3868    return ptr;
3869 
3870 }
3871 
3872 
3873 /**************************************************
3874 *
3875 *    Entrez2HierNodeFree()
3876 *
3877 **************************************************/
3878 NLM_EXTERN 
3879 Entrez2HierNodePtr LIBCALL
3880 Entrez2HierNodeFree(Entrez2HierNodePtr ptr)
3881 {
3882 
3883    if(ptr == NULL) {
3884       return NULL;
3885    }
3886    MemFree(ptr -> cannonical_form);
3887    AsnGenericUserSeqOfFree(ptr -> lineage, (AsnOptFreeFunc) Entrez2TermFree);
3888    AsnGenericUserSeqOfFree(ptr -> children, (AsnOptFreeFunc) Entrez2TermFree);
3889    return MemFree(ptr);
3890 }
3891 
3892 
3893 /**************************************************
3894 *
3895 *    Entrez2HierNodeAsnRead()
3896 *
3897 **************************************************/
3898 NLM_EXTERN 
3899 Entrez2HierNodePtr LIBCALL
3900 Entrez2HierNodeAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3901 {
3902    DataVal av;
3903    AsnTypePtr atp;
3904    Boolean isError = FALSE;
3905    AsnReadFunc func;
3906    Entrez2HierNodePtr ptr;
3907 
3908    if (! loaded)
3909    {
3910       if (! objent2AsnLoad()) {
3911          return NULL;
3912       }
3913    }
3914 
3915    if (aip == NULL) {
3916       return NULL;
3917    }
3918 
3919    if (orig == NULL) {         /* Entrez2HierNode ::= (self contained) */
3920       atp = AsnReadId(aip, amp, ENTREZ2_HIER_NODE);
3921    } else {
3922       atp = AsnLinkType(orig, ENTREZ2_HIER_NODE);
3923    }
3924    /* link in local tree */
3925    if (atp == NULL) {
3926       return NULL;
3927    }
3928 
3929    ptr = Entrez2HierNodeNew();
3930    if (ptr == NULL) {
3931       goto erret;
3932    }
3933    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
3934       goto erret;
3935    }
3936 
3937    atp = AsnReadId(aip,amp, atp);
3938    func = NULL;
3939 
3940    if (atp == HIER_NODE_cannonical_form) {
3941       if ( AsnReadVal(aip, atp, &av) <= 0) {
3942          goto erret;
3943       }
3944       ptr -> cannonical_form = av.ptrvalue;
3945       atp = AsnReadId(aip,amp, atp);
3946    }
3947    if (atp == ENTREZ2_HIER_NODE_lineage_count) {
3948       if ( AsnReadVal(aip, atp, &av) <= 0) {
3949          goto erret;
3950       }
3951       ptr -> lineage_count = av.intvalue;
3952       atp = AsnReadId(aip,amp, atp);
3953    }
3954    if (atp == ENTREZ2_HIER_NODE_lineage) {
3955       ptr -> lineage = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Entrez2TermAsnRead, (AsnOptFreeFunc) Entrez2TermFree);
3956       if (isError && ptr -> lineage == NULL) {
3957          goto erret;
3958       }
3959       atp = AsnReadId(aip,amp, atp);
3960    }
3961    if (atp == ENTREZ2_HIER_NODE_child_count) {
3962       if ( AsnReadVal(aip, atp, &av) <= 0) {
3963          goto erret;
3964       }
3965       ptr -> child_count = av.intvalue;
3966       atp = AsnReadId(aip,amp, atp);
3967    }
3968    if (atp == ENTREZ2_HIER_NODE_children) {
3969       ptr -> children = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Entrez2TermAsnRead, (AsnOptFreeFunc) Entrez2TermFree);
3970       if (isError && ptr -> children == NULL) {
3971          goto erret;
3972       }
3973       atp = AsnReadId(aip,amp, atp);
3974    }
3975    if (atp == ENTREZ2_HIER_NODE_is_ambiguous) {
3976       if ( AsnReadVal(aip, atp, &av) <= 0) {
3977          goto erret;
3978       }
3979       ptr -> is_ambiguous = av.boolvalue;
3980       atp = AsnReadId(aip,amp, atp);
3981    }
3982 
3983    if (AsnReadVal(aip, atp, &av) <= 0) {
3984       goto erret;
3985    }
3986    /* end struct */
3987 
3988 ret:
3989    AsnUnlinkType(orig);       /* unlink local tree */
3990    return ptr;
3991 
3992 erret:
3993    aip -> io_failure = TRUE;
3994    ptr = Entrez2HierNodeFree(ptr);
3995    goto ret;
3996 }
3997 
3998 
3999 
4000 /**************************************************
4001 *
4002 *    Entrez2HierNodeAsnWrite()
4003 *
4004 **************************************************/
4005 NLM_EXTERN Boolean LIBCALL 
4006 Entrez2HierNodeAsnWrite(Entrez2HierNodePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
4007 {
4008    DataVal av;
4009    AsnTypePtr atp;
4010    Boolean retval = FALSE;
4011 
4012    if (! loaded)
4013    {
4014       if (! objent2AsnLoad()) {
4015          return FALSE;
4016       }
4017    }
4018 
4019    if (aip == NULL) {
4020       return FALSE;
4021    }
4022 
4023    atp = AsnLinkType(orig, ENTREZ2_HIER_NODE);   /* link local tree */
4024    if (atp == NULL) {
4025       return FALSE;
4026    }
4027 
4028    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4029    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
4030       goto erret;
4031    }
4032 
4033    if (ptr -> cannonical_form != NULL) {
4034       av.ptrvalue = ptr -> cannonical_form;
4035       retval = AsnWrite(aip, HIER_NODE_cannonical_form,  &av);
4036    }
4037    av.intvalue = ptr -> lineage_count;
4038    retval = AsnWrite(aip, ENTREZ2_HIER_NODE_lineage_count,  &av);
4039    AsnGenericUserSeqOfAsnWrite(ptr -> lineage, (AsnWriteFunc) Entrez2TermAsnWrite, aip, ENTREZ2_HIER_NODE_lineage, ENTREZ2_HIER_NODE_lineage_E);
4040    av.intvalue = ptr -> child_count;
4041    retval = AsnWrite(aip, ENTREZ2_HIER_NODE_child_count,  &av);
4042    AsnGenericUserSeqOfAsnWrite(ptr -> children, (AsnWriteFunc) Entrez2TermAsnWrite, aip, ENTREZ2_HIER_NODE_children, ENTREZ2_HIER_NODE_children_E);
4043    av.boolvalue = ptr -> is_ambiguous;
4044    retval = AsnWrite(aip, ENTREZ2_HIER_NODE_is_ambiguous,  &av);
4045    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4046       goto erret;
4047    }
4048    retval = TRUE;
4049 
4050 erret:
4051    AsnUnlinkType(orig);       /* unlink local tree */
4052    return retval;
4053 }
4054 
4055 
4056 
4057 /**************************************************
4058 *
4059 *    Entrez2LinkSetNew()
4060 *
4061 **************************************************/
4062 NLM_EXTERN 
4063 Entrez2LinkSetPtr LIBCALL
4064 Entrez2LinkSetNew(void)
4065 {
4066    Entrez2LinkSetPtr ptr = MemNew((size_t) sizeof(Entrez2LinkSet));
4067 
4068    return ptr;
4069 
4070 }
4071 
4072 
4073 /**************************************************
4074 *
4075 *    Entrez2LinkSetFree()
4076 *
4077 **************************************************/
4078 NLM_EXTERN 
4079 Entrez2LinkSetPtr LIBCALL
4080 Entrez2LinkSetFree(Entrez2LinkSetPtr ptr)
4081 {
4082 
4083    if(ptr == NULL) {
4084       return NULL;
4085    }
4086    Entrez2IdListFree(ptr -> ids);
4087    BSFree(ptr -> data);
4088    return MemFree(ptr);
4089 }
4090 
4091 
4092 /**************************************************
4093 *
4094 *    Entrez2LinkSetAsnRead()
4095 *
4096 **************************************************/
4097 NLM_EXTERN 
4098 Entrez2LinkSetPtr LIBCALL
4099 Entrez2LinkSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4100 {
4101    DataVal av;
4102    AsnTypePtr atp;
4103    Boolean isError = FALSE;
4104    AsnReadFunc func;
4105    Entrez2LinkSetPtr ptr;
4106 
4107    if (! loaded)
4108    {
4109       if (! objent2AsnLoad()) {
4110          return NULL;
4111       }
4112    }
4113 
4114    if (aip == NULL) {
4115       return NULL;
4116    }
4117 
4118    if (orig == NULL) {         /* Entrez2LinkSet ::= (self contained) */
4119       atp = AsnReadId(aip, amp, ENTREZ2_LINK_SET);
4120    } else {
4121       atp = AsnLinkType(orig, ENTREZ2_LINK_SET);
4122    }
4123    /* link in local tree */
4124    if (atp == NULL) {
4125       return NULL;
4126    }
4127 
4128    ptr = Entrez2LinkSetNew();
4129    if (ptr == NULL) {
4130       goto erret;
4131    }
4132    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4133       goto erret;
4134    }
4135 
4136    atp = AsnReadId(aip,amp, atp);
4137    func = NULL;
4138 
4139    if (atp == ENTREZ2_LINK_SET_ids) {
4140       ptr -> ids = Entrez2IdListAsnRead(aip, atp);
4141       if (aip -> io_failure) {
4142          goto erret;
4143       }
4144       atp = AsnReadId(aip,amp, atp);
4145    }
4146    if (atp == ENTREZ2_LINK_SET_data_size) {
4147       if ( AsnReadVal(aip, atp, &av) <= 0) {
4148          goto erret;
4149       }
4150       ptr -> data_size = av.intvalue;
4151       atp = AsnReadId(aip,amp, atp);
4152    }
4153    if (atp == ENTREZ2_LINK_SET_data) {
4154       if ( AsnReadVal(aip, atp, &av) <= 0) {
4155          goto erret;
4156       }
4157       ptr -> data = av.ptrvalue;
4158       atp = AsnReadId(aip,amp, atp);
4159    }
4160 
4161    if (AsnReadVal(aip, atp, &av) <= 0) {
4162       goto erret;
4163    }
4164    /* end struct */
4165 
4166 ret:
4167    AsnUnlinkType(orig);       /* unlink local tree */
4168    return ptr;
4169 
4170 erret:
4171    aip -> io_failure = TRUE;
4172    ptr = Entrez2LinkSetFree(ptr);
4173    goto ret;
4174 }
4175 
4176 
4177 
4178 /**************************************************
4179 *
4180 *    Entrez2LinkSetAsnWrite()
4181 *
4182 **************************************************/
4183 NLM_EXTERN Boolean LIBCALL 
4184 Entrez2LinkSetAsnWrite(Entrez2LinkSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
4185 {
4186    DataVal av;
4187    AsnTypePtr atp;
4188    Boolean retval = FALSE;
4189 
4190    if (! loaded)
4191    {
4192       if (! objent2AsnLoad()) {
4193          return FALSE;
4194       }
4195    }
4196 
4197    if (aip == NULL) {
4198       return FALSE;
4199    }
4200 
4201    atp = AsnLinkType(orig, ENTREZ2_LINK_SET);   /* link local tree */
4202    if (atp == NULL) {
4203       return FALSE;
4204    }
4205 
4206    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4207    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
4208       goto erret;
4209    }
4210 
4211    if (ptr -> ids != NULL) {
4212       if ( ! Entrez2IdListAsnWrite(ptr -> ids, aip, ENTREZ2_LINK_SET_ids)) {
4213          goto erret;
4214       }
4215    }
4216    av.intvalue = ptr -> data_size;
4217    retval = AsnWrite(aip, ENTREZ2_LINK_SET_data_size,  &av);
4218    if (ptr -> data != NULL) {
4219       av.ptrvalue = ptr -> data;
4220       retval = AsnWrite(aip, ENTREZ2_LINK_SET_data,  &av);
4221    }
4222    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4223       goto erret;
4224    }
4225    retval = TRUE;
4226 
4227 erret:
4228    AsnUnlinkType(orig);       /* unlink local tree */
4229    return retval;
4230 }
4231 
4232 
4233 
4234 /**************************************************
4235 *
4236 *    Entrez2LinkCountListNew()
4237 *
4238 **************************************************/
4239 NLM_EXTERN 
4240 Entrez2LinkCountListPtr LIBCALL
4241 Entrez2LinkCountListNew(void)
4242 {
4243    Entrez2LinkCountListPtr ptr = MemNew((size_t) sizeof(Entrez2LinkCountList));
4244 
4245    return ptr;
4246 
4247 }
4248 
4249 
4250 /**************************************************
4251 *
4252 *    Entrez2LinkCountListFree()
4253 *
4254 **************************************************/
4255 NLM_EXTERN 
4256 Entrez2LinkCountListPtr LIBCALL
4257 Entrez2LinkCountListFree(Entrez2LinkCountListPtr ptr)
4258 {
4259 
4260    if(ptr == NULL) {
4261       return NULL;
4262    }
4263    AsnGenericUserSeqOfFree(ptr -> links, (AsnOptFreeFunc) Entrez2LinkCountFree);
4264    return MemFree(ptr);
4265 }
4266 
4267 
4268 /**************************************************
4269 *
4270 *    Entrez2LinkCountListAsnRead()
4271 *
4272 **************************************************/
4273 NLM_EXTERN 
4274 Entrez2LinkCountListPtr LIBCALL
4275 Entrez2LinkCountListAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4276 {
4277    DataVal av;
4278    AsnTypePtr atp;
4279    Boolean isError = FALSE;
4280    AsnReadFunc func;
4281    Entrez2LinkCountListPtr ptr;
4282 
4283    if (! loaded)
4284    {
4285       if (! objent2AsnLoad()) {
4286          return NULL;
4287       }
4288    }
4289 
4290    if (aip == NULL) {
4291       return NULL;
4292    }
4293 
4294    if (orig == NULL) {         /* Entrez2LinkCountList ::= (self contained) */
4295       atp = AsnReadId(aip, amp, ENTREZ2_LINK_COUNT_LIST);
4296    } else {
4297       atp = AsnLinkType(orig, ENTREZ2_LINK_COUNT_LIST);
4298    }
4299    /* link in local tree */
4300    if (atp == NULL) {
4301       return NULL;
4302    }
4303 
4304    ptr = Entrez2LinkCountListNew();
4305    if (ptr == NULL) {
4306       goto erret;
4307    }
4308    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4309       goto erret;
4310    }
4311 
4312    atp = AsnReadId(aip,amp, atp);
4313    func = NULL;
4314 
4315    if (atp == COUNT_LIST_link_type_count) {
4316       if ( AsnReadVal(aip, atp, &av) <= 0) {
4317          goto erret;
4318       }
4319       ptr -> link_type_count = av.intvalue;
4320       atp = AsnReadId(aip,amp, atp);
4321    }
4322    if (atp == ENTREZ2_LINK_COUNT_LIST_links) {
4323       ptr -> links = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Entrez2LinkCountAsnRead, (AsnOptFreeFunc) Entrez2LinkCountFree);
4324       if (isError && ptr -> links == NULL) {
4325          goto erret;
4326       }
4327       atp = AsnReadId(aip,amp, atp);
4328    }
4329 
4330    if (AsnReadVal(aip, atp, &av) <= 0) {
4331       goto erret;
4332    }
4333    /* end struct */
4334 
4335 ret:
4336    AsnUnlinkType(orig);       /* unlink local tree */
4337    return ptr;
4338 
4339 erret:
4340    aip -> io_failure = TRUE;
4341    ptr = Entrez2LinkCountListFree(ptr);
4342    goto ret;
4343 }
4344 
4345 
4346 
4347 /**************************************************
4348 *
4349 *    Entrez2LinkCountListAsnWrite()
4350 *
4351 **************************************************/
4352 NLM_EXTERN Boolean LIBCALL 
4353 Entrez2LinkCountListAsnWrite(Entrez2LinkCountListPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
4354 {
4355    DataVal av;
4356    AsnTypePtr atp;
4357    Boolean retval = FALSE;
4358 
4359    if (! loaded)
4360    {
4361       if (! objent2AsnLoad()) {
4362          return FALSE;
4363       }
4364    }
4365 
4366    if (aip == NULL) {
4367       return FALSE;
4368    }
4369 
4370    atp = AsnLinkType(orig, ENTREZ2_LINK_COUNT_LIST);   /* link local tree */
4371    if (atp == NULL) {
4372       return FALSE;
4373    }
4374 
4375    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4376    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
4377       goto erret;
4378    }
4379 
4380    av.intvalue = ptr -> link_type_count;
4381    retval = AsnWrite(aip, COUNT_LIST_link_type_count,  &av);
4382    AsnGenericUserSeqOfAsnWrite(ptr -> links, (AsnWriteFunc) Entrez2LinkCountAsnWrite, aip, ENTREZ2_LINK_COUNT_LIST_links, ENTREZ2_LINK_COUNT_LIST_links_E);
4383    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4384       goto erret;
4385    }
4386    retval = TRUE;
4387 
4388 erret:
4389    AsnUnlinkType(orig);       /* unlink local tree */
4390    return retval;
4391 }
4392 
4393 
4394 
4395 /**************************************************
4396 *
4397 *    Entrez2DbInfoNew()
4398 *
4399 **************************************************/
4400 NLM_EXTERN 
4401 Entrez2DbInfoPtr LIBCALL
4402 Entrez2DbInfoNew(void)
4403 {
4404    Entrez2DbInfoPtr ptr = MemNew((size_t) sizeof(Entrez2DbInfo));
4405 
4406    return ptr;
4407 
4408 }
4409 
4410 
4411 /**************************************************
4412 *
4413 *    Entrez2DbInfoFree()
4414 *
4415 **************************************************/
4416 NLM_EXTERN 
4417 Entrez2DbInfoPtr LIBCALL
4418 Entrez2DbInfoFree(Entrez2DbInfoPtr ptr)
4419 {
4420 
4421    if(ptr == NULL) {
4422       return NULL;
4423    }
4424    MemFree(ptr -> db_name);
4425    MemFree(ptr -> db_menu);
4426    MemFree(ptr -> db_descr);
4427    AsnGenericUserSeqOfFree(ptr -> fields, (AsnOptFreeFunc) Entrez2FieldInfoFree);
4428    AsnGenericUserSeqOfFree(ptr -> links, (AsnOptFreeFunc) Entrez2LinkInfoFree);
4429    AsnGenericUserSeqOfFree(ptr -> docsum_fields, (AsnOptFreeFunc) Entrez2DocsumFieldInfoFree);
4430    return MemFree(ptr);
4431 }
4432 
4433 
4434 /**************************************************
4435 *
4436 *    Entrez2DbInfoAsnRead()
4437 *
4438 **************************************************/
4439 NLM_EXTERN 
4440 Entrez2DbInfoPtr LIBCALL
4441 Entrez2DbInfoAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4442 {
4443    DataVal av;
4444    AsnTypePtr atp;
4445    Boolean isError = FALSE;
4446    AsnReadFunc func;
4447    Entrez2DbInfoPtr ptr;
4448 
4449    if (! loaded)
4450    {
4451       if (! objent2AsnLoad()) {
4452          return NULL;
4453       }
4454    }
4455 
4456    if (aip == NULL) {
4457       return NULL;
4458    }
4459 
4460    if (orig == NULL) {         /* Entrez2DbInfo ::= (self contained) */
4461       atp = AsnReadId(aip, amp, ENTREZ2_DB_INFO);
4462    } else {
4463       atp = AsnLinkType(orig, ENTREZ2_DB_INFO);
4464    }
4465    /* link in local tree */
4466    if (atp == NULL) {
4467       return NULL;
4468    }
4469 
4470    ptr = Entrez2DbInfoNew();
4471    if (ptr == NULL) {
4472       goto erret;
4473    }
4474    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4475       goto erret;
4476    }
4477 
4478    atp = AsnReadId(aip,amp, atp);
4479    func = NULL;
4480 
4481    if (atp == ENTREZ2_DB_INFO_db_name) {
4482       if ( AsnReadVal(aip, atp, &av) <= 0) {
4483          goto erret;
4484       }
4485       ptr -> db_name = av.ptrvalue;
4486       atp = AsnReadId(aip,amp, atp);
4487    }
4488    if (atp == ENTREZ2_DB_INFO_db_menu) {
4489       if ( AsnReadVal(aip, atp, &av) <= 0) {
4490          goto erret;
4491       }
4492       ptr -> db_menu = av.ptrvalue;
4493       atp = AsnReadId(aip,amp, atp);
4494    }
4495    if (atp == ENTREZ2_DB_INFO_db_descr) {
4496       if ( AsnReadVal(aip, atp, &av) <= 0) {
4497          goto erret;
4498       }
4499       ptr -> db_descr = av.ptrvalue;
4500       atp = AsnReadId(aip,amp, atp);
4501    }
4502    if (atp == ENTREZ2_DB_INFO_doc_count) {
4503       if ( AsnReadVal(aip, atp, &av) <= 0) {
4504          goto erret;
4505       }
4506       ptr -> doc_count = av.intvalue;
4507       atp = AsnReadId(aip,amp, atp);
4508    }
4509    if (atp == ENTREZ2_DB_INFO_field_count) {
4510       if ( AsnReadVal(aip, atp, &av) <= 0) {
4511          goto erret;
4512       }
4513       ptr -> field_count = av.intvalue;
4514       atp = AsnReadId(aip,amp, atp);
4515    }
4516    if (atp == ENTREZ2_DB_INFO_fields) {
4517       ptr -> fields = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Entrez2FieldInfoAsnRead, (AsnOptFreeFunc) Entrez2FieldInfoFree);
4518       if (isError && ptr -> fields == NULL) {
4519          goto erret;
4520       }
4521       atp = AsnReadId(aip,amp, atp);
4522    }
4523    if (atp == ENTREZ2_DB_INFO_link_count) {
4524       if ( AsnReadVal(aip, atp, &av) <= 0) {
4525          goto erret;
4526       }
4527       ptr -> link_count = av.intvalue;
4528       atp = AsnReadId(aip,amp, atp);
4529    }
4530    if (atp == ENTREZ2_DB_INFO_links) {
4531       ptr -> links = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Entrez2LinkInfoAsnRead, (AsnOptFreeFunc) Entrez2LinkInfoFree);
4532       if (isError && ptr -> links == NULL) {
4533          goto erret;
4534       }
4535       atp = AsnReadId(aip,amp, atp);
4536    }
4537    if (atp == DB_INFO_docsum_field_count) {
4538       if ( AsnReadVal(aip, atp, &av) <= 0) {
4539          goto erret;
4540       }
4541       ptr -> docsum_field_count = av.intvalue;
4542       atp = AsnReadId(aip,amp, atp);
4543    }
4544    if (atp == ENTREZ2_DB_INFO_docsum_fields) {
4545       ptr -> docsum_fields = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Entrez2DocsumFieldInfoAsnRead, (AsnOptFreeFunc) Entrez2DocsumFieldInfoFree);
4546       if (isError && ptr -> docsum_fields == NULL) {
4547          goto erret;
4548       }
4549       atp = AsnReadId(aip,amp, atp);
4550    }
4551 
4552    if (AsnReadVal(aip, atp, &av) <= 0) {
4553       goto erret;
4554    }
4555    /* end struct */
4556 
4557 ret:
4558    AsnUnlinkType(orig);       /* unlink local tree */
4559    return ptr;
4560 
4561 erret:
4562    aip -> io_failure = TRUE;
4563    ptr = Entrez2DbInfoFree(ptr);
4564    goto ret;
4565 }
4566 
4567 
4568 
4569 /**************************************************
4570 *
4571 *    Entrez2DbInfoAsnWrite()
4572 *
4573 **************************************************/
4574 NLM_EXTERN Boolean LIBCALL 
4575 Entrez2DbInfoAsnWrite(Entrez2DbInfoPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
4576 {
4577    DataVal av;
4578    AsnTypePtr atp;
4579    Boolean retval = FALSE;
4580 
4581    if (! loaded)
4582    {
4583       if (! objent2AsnLoad()) {
4584          return FALSE;
4585       }
4586    }
4587 
4588    if (aip == NULL) {
4589       return FALSE;
4590    }
4591 
4592    atp = AsnLinkType(orig, ENTREZ2_DB_INFO);   /* link local tree */
4593    if (atp == NULL) {
4594       return FALSE;
4595    }
4596 
4597    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4598    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
4599       goto erret;
4600    }
4601 
4602    if (ptr -> db_name != NULL) {
4603       av.ptrvalue = ptr -> db_name;
4604       retval = AsnWrite(aip, ENTREZ2_DB_INFO_db_name,  &av);
4605    }
4606    if (ptr -> db_menu != NULL) {
4607       av.ptrvalue = ptr -> db_menu;
4608       retval = AsnWrite(aip, ENTREZ2_DB_INFO_db_menu,  &av);
4609    }
4610    if (ptr -> db_descr != NULL) {
4611       av.ptrvalue = ptr -> db_descr;
4612       retval = AsnWrite(aip, ENTREZ2_DB_INFO_db_descr,  &av);
4613    }
4614    av.intvalue = ptr -> doc_count;
4615    retval = AsnWrite(aip, ENTREZ2_DB_INFO_doc_count,  &av);
4616    av.intvalue = ptr -> field_count;
4617    retval = AsnWrite(aip, ENTREZ2_DB_INFO_field_count,  &av);
4618    AsnGenericUserSeqOfAsnWrite(ptr -> fields, (AsnWriteFunc) Entrez2FieldInfoAsnWrite, aip, ENTREZ2_DB_INFO_fields, ENTREZ2_DB_INFO_fields_E);
4619    av.intvalue = ptr -> link_count;
4620    retval = AsnWrite(aip, ENTREZ2_DB_INFO_link_count,  &av);
4621    AsnGenericUserSeqOfAsnWrite(ptr -> links, (AsnWriteFunc) Entrez2LinkInfoAsnWrite, aip, ENTREZ2_DB_INFO_links, ENTREZ2_DB_INFO_links_E);
4622    av.intvalue = ptr -> docsum_field_count;
4623    retval = AsnWrite(aip, DB_INFO_docsum_field_count,  &av);
4624    AsnGenericUserSeqOfAsnWrite(ptr -> docsum_fields, (AsnWriteFunc) Entrez2DocsumFieldInfoAsnWrite, aip, ENTREZ2_DB_INFO_docsum_fields, ENTREZ2_DB_INFO_docsum_fields_E);
4625    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4626       goto erret;
4627    }
4628    retval = TRUE;
4629 
4630 erret:
4631    AsnUnlinkType(orig);       /* unlink local tree */
4632    return retval;
4633 }
4634 
4635 
4636 
4637 /**************************************************
4638 *
4639 *    Entrez2FieldInfoNew()
4640 *
4641 **************************************************/
4642 NLM_EXTERN 
4643 Entrez2FieldInfoPtr LIBCALL
4644 Entrez2FieldInfoNew(void)
4645 {
4646    Entrez2FieldInfoPtr ptr = MemNew((size_t) sizeof(Entrez2FieldInfo));
4647 
4648    return ptr;
4649 
4650 }
4651 
4652 
4653 /**************************************************
4654 *
4655 *    Entrez2FieldInfoFree()
4656 *
4657 **************************************************/
4658 NLM_EXTERN 
4659 Entrez2FieldInfoPtr LIBCALL
4660 Entrez2FieldInfoFree(Entrez2FieldInfoPtr ptr)
4661 {
4662 
4663    if(ptr == NULL) {
4664       return NULL;
4665    }
4666    MemFree(ptr -> field_name);
4667    MemFree(ptr -> field_menu);
4668    MemFree(ptr -> field_descr);
4669    return MemFree(ptr);
4670 }
4671 
4672 
4673 /**************************************************
4674 *
4675 *    Entrez2FieldInfoAsnRead()
4676 *
4677 **************************************************/
4678 NLM_EXTERN 
4679 Entrez2FieldInfoPtr LIBCALL
4680 Entrez2FieldInfoAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4681 {
4682    DataVal av;
4683    AsnTypePtr atp;
4684    Boolean isError = FALSE;
4685    AsnReadFunc func;
4686    Entrez2FieldInfoPtr ptr;
4687 
4688    if (! loaded)
4689    {
4690       if (! objent2AsnLoad()) {
4691          return NULL;
4692       }
4693    }
4694 
4695    if (aip == NULL) {
4696       return NULL;
4697    }
4698 
4699    if (orig == NULL) {         /* Entrez2FieldInfo ::= (self contained) */
4700       atp = AsnReadId(aip, amp, ENTREZ2_FIELD_INFO);
4701    } else {
4702       atp = AsnLinkType(orig, ENTREZ2_FIELD_INFO);
4703    }
4704    /* link in local tree */
4705    if (atp == NULL) {
4706       return NULL;
4707    }
4708 
4709    ptr = Entrez2FieldInfoNew();
4710    if (ptr == NULL) {
4711       goto erret;
4712    }
4713    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4714       goto erret;
4715    }
4716 
4717    atp = AsnReadId(aip,amp, atp);
4718    func = NULL;
4719 
4720    if (atp == ENTREZ2_FIELD_INFO_field_name) {
4721       if ( AsnReadVal(aip, atp, &av) <= 0) {
4722          goto erret;
4723       }
4724       ptr -> field_name = av.ptrvalue;
4725       atp = AsnReadId(aip,amp, atp);
4726    }
4727    if (atp == ENTREZ2_FIELD_INFO_field_menu) {
4728       if ( AsnReadVal(aip, atp, &av) <= 0) {
4729          goto erret;
4730       }
4731       ptr -> field_menu = av.ptrvalue;
4732       atp = AsnReadId(aip,amp, atp);
4733    }
4734    if (atp == ENTREZ2_FIELD_INFO_field_descr) {
4735       if ( AsnReadVal(aip, atp, &av) <= 0) {
4736          goto erret;
4737       }
4738       ptr -> field_descr = av.ptrvalue;
4739       atp = AsnReadId(aip,amp, atp);
4740    }
4741    if (atp == ENTREZ2_FIELD_INFO_term_count) {
4742       if ( AsnReadVal(aip, atp, &av) <= 0) {
4743          goto erret;
4744       }
4745       ptr -> term_count = av.intvalue;
4746       atp = AsnReadId(aip,amp, atp);
4747    }
4748    if (atp == ENTREZ2_FIELD_INFO_is_date) {
4749       if ( AsnReadVal(aip, atp, &av) <= 0) {
4750          goto erret;
4751       }
4752       ptr -> is_date = av.boolvalue;
4753       atp = AsnReadId(aip,amp, atp);
4754    }
4755    if (atp == ENTREZ2_FIELD_INFO_is_numerical) {
4756       if ( AsnReadVal(aip, atp, &av) <= 0) {
4757          goto erret;
4758       }
4759       ptr -> is_numerical = av.boolvalue;
4760       atp = AsnReadId(aip,amp, atp);
4761    }
4762    if (atp == ENTREZ2_FIELD_INFO_single_token) {
4763       if ( AsnReadVal(aip, atp, &av) <= 0) {
4764          goto erret;
4765       }
4766       ptr -> single_token = av.boolvalue;
4767       atp = AsnReadId(aip,amp, atp);
4768    }
4769    if (atp == FIELD_INFO_hierarchy_avail) {
4770       if ( AsnReadVal(aip, atp, &av) <= 0) {
4771          goto erret;
4772       }
4773       ptr -> hierarchy_avail = av.boolvalue;
4774       atp = AsnReadId(aip,amp, atp);
4775    }
4776    if (atp == ENTREZ2_FIELD_INFO_is_rangable) {
4777       if ( AsnReadVal(aip, atp, &av) <= 0) {
4778          goto erret;
4779       }
4780       ptr -> is_rangable = av.boolvalue;
4781       atp = AsnReadId(aip,amp, atp);
4782    }
4783    if (atp == FIELD_INFO_is_truncatable) {
4784       if ( AsnReadVal(aip, atp, &av) <= 0) {
4785          goto erret;
4786       }
4787       ptr -> is_truncatable = av.boolvalue;
4788       atp = AsnReadId(aip,amp, atp);
4789    }
4790 
4791    if (AsnReadVal(aip, atp, &av) <= 0) {
4792       goto erret;
4793    }
4794    /* end struct */
4795 
4796 ret:
4797    AsnUnlinkType(orig);       /* unlink local tree */
4798    return ptr;
4799 
4800 erret:
4801    aip -> io_failure = TRUE;
4802    ptr = Entrez2FieldInfoFree(ptr);
4803    goto ret;
4804 }
4805 
4806 
4807 
4808 /**************************************************
4809 *
4810 *    Entrez2FieldInfoAsnWrite()
4811 *
4812 **************************************************/
4813 NLM_EXTERN Boolean LIBCALL 
4814 Entrez2FieldInfoAsnWrite(Entrez2FieldInfoPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
4815 {
4816    DataVal av;
4817    AsnTypePtr atp;
4818    Boolean retval = FALSE;
4819 
4820    if (! loaded)
4821    {
4822       if (! objent2AsnLoad()) {
4823          return FALSE;
4824       }
4825    }
4826 
4827    if (aip == NULL) {
4828       return FALSE;
4829    }
4830 
4831    atp = AsnLinkType(orig, ENTREZ2_FIELD_INFO);   /* link local tree */
4832    if (atp == NULL) {
4833       return FALSE;
4834    }
4835 
4836    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4837    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
4838       goto erret;
4839    }
4840 
4841    if (ptr -> field_name != NULL) {
4842       av.ptrvalue = ptr -> field_name;
4843       retval = AsnWrite(aip, ENTREZ2_FIELD_INFO_field_name,  &av);
4844    }
4845    if (ptr -> field_menu != NULL) {
4846       av.ptrvalue = ptr -> field_menu;
4847       retval = AsnWrite(aip, ENTREZ2_FIELD_INFO_field_menu,  &av);
4848    }
4849    if (ptr -> field_descr != NULL) {
4850       av.ptrvalue = ptr -> field_descr;
4851       retval = AsnWrite(aip, ENTREZ2_FIELD_INFO_field_descr,  &av);
4852    }
4853    av.intvalue = ptr -> term_count;
4854    retval = AsnWrite(aip, ENTREZ2_FIELD_INFO_term_count,  &av);
4855    av.boolvalue = ptr -> is_date;
4856    retval = AsnWrite(aip, ENTREZ2_FIELD_INFO_is_date,  &av);
4857    av.boolvalue = ptr -> is_numerical;
4858    retval = AsnWrite(aip, ENTREZ2_FIELD_INFO_is_numerical,  &av);
4859    av.boolvalue = ptr -> single_token;
4860    retval = AsnWrite(aip, ENTREZ2_FIELD_INFO_single_token,  &av);
4861    av.boolvalue = ptr -> hierarchy_avail;
4862    retval = AsnWrite(aip, FIELD_INFO_hierarchy_avail,  &av);
4863    av.boolvalue = ptr -> is_rangable;
4864    retval = AsnWrite(aip, ENTREZ2_FIELD_INFO_is_rangable,  &av);
4865    av.boolvalue = ptr -> is_truncatable;
4866    retval = AsnWrite(aip, FIELD_INFO_is_truncatable,  &av);
4867    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4868       goto erret;
4869    }
4870    retval = TRUE;
4871 
4872 erret:
4873    AsnUnlinkType(orig);       /* unlink local tree */
4874    return retval;
4875 }
4876 
4877 
4878 
4879 /**************************************************
4880 *
4881 *    Entrez2LinkInfoNew()
4882 *
4883 **************************************************/
4884 NLM_EXTERN 
4885 Entrez2LinkInfoPtr LIBCALL
4886 Entrez2LinkInfoNew(void)
4887 {
4888    Entrez2LinkInfoPtr ptr = MemNew((size_t) sizeof(Entrez2LinkInfo));
4889 
4890    return ptr;
4891 
4892 }
4893 
4894 
4895 /**************************************************
4896 *
4897 *    Entrez2LinkInfoFree()
4898 *
4899 **************************************************/
4900 NLM_EXTERN 
4901 Entrez2LinkInfoPtr LIBCALL
4902 Entrez2LinkInfoFree(Entrez2LinkInfoPtr ptr)
4903 {
4904 
4905    if(ptr == NULL) {
4906       return NULL;
4907    }
4908    MemFree(ptr -> link_name);
4909    MemFree(ptr -> link_menu);
4910    MemFree(ptr -> link_descr);
4911    MemFree(ptr -> db_to);
4912    return MemFree(ptr);
4913 }
4914 
4915 
4916 /**************************************************
4917 *
4918 *    Entrez2LinkInfoAsnRead()
4919 *
4920 **************************************************/
4921 NLM_EXTERN 
4922 Entrez2LinkInfoPtr LIBCALL
4923 Entrez2LinkInfoAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4924 {
4925    DataVal av;
4926    AsnTypePtr atp;
4927    Boolean isError = FALSE;
4928    AsnReadFunc func;
4929    Entrez2LinkInfoPtr ptr;
4930 
4931    if (! loaded)
4932    {
4933       if (! objent2AsnLoad()) {
4934          return NULL;
4935       }
4936    }
4937 
4938    if (aip == NULL) {
4939       return NULL;
4940    }
4941 
4942    if (orig == NULL) {         /* Entrez2LinkInfo ::= (self contained) */
4943       atp = AsnReadId(aip, amp, ENTREZ2_LINK_INFO);
4944    } else {
4945       atp = AsnLinkType(orig, ENTREZ2_LINK_INFO);
4946    }
4947    /* link in local tree */
4948    if (atp == NULL) {
4949       return NULL;
4950    }
4951 
4952    ptr = Entrez2LinkInfoNew();
4953    if (ptr == NULL) {
4954       goto erret;
4955    }
4956    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4957       goto erret;
4958    }
4959 
4960    atp = AsnReadId(aip,amp, atp);
4961    func = NULL;
4962 
4963    if (atp == ENTREZ2_LINK_INFO_link_name) {
4964       if ( AsnReadVal(aip, atp, &av) <= 0) {
4965          goto erret;
4966       }
4967       ptr -> link_name = av.ptrvalue;
4968       atp = AsnReadId(aip,amp, atp);
4969    }
4970    if (atp == ENTREZ2_LINK_INFO_link_menu) {
4971       if ( AsnReadVal(aip, atp, &av) <= 0) {
4972          goto erret;
4973       }
4974       ptr -> link_menu = av.ptrvalue;
4975       atp = AsnReadId(aip,amp, atp);
4976    }
4977    if (atp == ENTREZ2_LINK_INFO_link_descr) {
4978       if ( AsnReadVal(aip, atp, &av) <= 0) {
4979          goto erret;
4980       }
4981       ptr -> link_descr = av.ptrvalue;
4982       atp = AsnReadId(aip,amp, atp);
4983    }
4984    if (atp == ENTREZ2_LINK_INFO_db_to) {
4985       if ( AsnReadVal(aip, atp, &av) <= 0) {
4986          goto erret;
4987       }
4988       ptr -> db_to = av.ptrvalue;
4989       atp = AsnReadId(aip,amp, atp);
4990    }
4991    if (atp == ENTREZ2_LINK_INFO_data_size) {
4992       if ( AsnReadVal(aip, atp, &av) <= 0) {
4993          goto erret;
4994       }
4995       ptr -> data_size = av.intvalue;
4996       atp = AsnReadId(aip,amp, atp);
4997    }
4998 
4999    if (AsnReadVal(aip, atp, &av) <= 0) {
5000       goto erret;
5001    }
5002    /* end struct */
5003 
5004 ret:
5005    AsnUnlinkType(orig);       /* unlink local tree */
5006    return ptr;
5007 
5008 erret:
5009    aip -> io_failure = TRUE;
5010    ptr = Entrez2LinkInfoFree(ptr);
5011    goto ret;
5012 }
5013 
5014 
5015 
5016 /**************************************************
5017 *
5018 *    Entrez2LinkInfoAsnWrite()
5019 *
5020 **************************************************/
5021 NLM_EXTERN Boolean LIBCALL 
5022 Entrez2LinkInfoAsnWrite(Entrez2LinkInfoPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
5023 {
5024    DataVal av;
5025    AsnTypePtr atp;
5026    Boolean retval = FALSE;
5027 
5028    if (! loaded)
5029    {
5030       if (! objent2AsnLoad()) {
5031          return FALSE;
5032       }
5033    }
5034 
5035    if (aip == NULL) {
5036       return FALSE;
5037    }
5038 
5039    atp = AsnLinkType(orig, ENTREZ2_LINK_INFO);   /* link local tree */
5040    if (atp == NULL) {
5041       return FALSE;
5042    }
5043 
5044    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5045    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
5046       goto erret;
5047    }
5048 
5049    if (ptr -> link_name != NULL) {
5050       av.ptrvalue = ptr -> link_name;
5051       retval = AsnWrite(aip, ENTREZ2_LINK_INFO_link_name,  &av);
5052    }
5053    if (ptr -> link_menu != NULL) {
5054       av.ptrvalue = ptr -> link_menu;
5055       retval = AsnWrite(aip, ENTREZ2_LINK_INFO_link_menu,  &av);
5056    }
5057    if (ptr -> link_descr != NULL) {
5058       av.ptrvalue = ptr -> link_descr;
5059       retval = AsnWrite(aip, ENTREZ2_LINK_INFO_link_descr,  &av);
5060    }
5061    if (ptr -> db_to != NULL) {
5062       av.ptrvalue = ptr -> db_to;
5063       retval = AsnWrite(aip, ENTREZ2_LINK_INFO_db_to,  &av);
5064    }
5065    av.intvalue = ptr -> data_size;
5066    retval = AsnWrite(aip, ENTREZ2_LINK_INFO_data_size,  &av);
5067    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
5068       goto erret;
5069    }
5070    retval = TRUE;
5071 
5072 erret:
5073    AsnUnlinkType(orig);       /* unlink local tree */
5074    return retval;
5075 }
5076 
5077 
5078 
5079 /**************************************************
5080 *
5081 *    Entrez2DocsumFieldInfoNew()
5082 *
5083 **************************************************/
5084 NLM_EXTERN 
5085 Entrez2DocsumFieldInfoPtr LIBCALL
5086 Entrez2DocsumFieldInfoNew(void)
5087 {
5088    Entrez2DocsumFieldInfoPtr ptr = MemNew((size_t) sizeof(Entrez2DocsumFieldInfo));
5089 
5090    return ptr;
5091 
5092 }
5093 
5094 
5095 /**************************************************
5096 *
5097 *    Entrez2DocsumFieldInfoFree()
5098 *
5099 **************************************************/
5100 NLM_EXTERN 
5101 Entrez2DocsumFieldInfoPtr LIBCALL
5102 Entrez2DocsumFieldInfoFree(Entrez2DocsumFieldInfoPtr ptr)
5103 {
5104 
5105    if(ptr == NULL) {
5106       return NULL;
5107    }
5108    MemFree(ptr -> field_name);
5109    MemFree(ptr -> field_description);
5110    return MemFree(ptr);
5111 }
5112 
5113 
5114 /**************************************************
5115 *
5116 *    Entrez2DocsumFieldInfoAsnRead()
5117 *
5118 **************************************************/
5119 NLM_EXTERN 
5120 Entrez2DocsumFieldInfoPtr LIBCALL
5121 Entrez2DocsumFieldInfoAsnRead(AsnIoPtr aip, AsnTypePtr orig)
5122 {
5123    DataVal av;
5124    AsnTypePtr atp;
5125    Boolean isError = FALSE;
5126    AsnReadFunc func;
5127    Entrez2DocsumFieldInfoPtr ptr;
5128 
5129    if (! loaded)
5130    {
5131       if (! objent2AsnLoad()) {
5132          return NULL;
5133       }
5134    }
5135 
5136    if (aip == NULL) {
5137       return NULL;
5138    }
5139 
5140    if (orig == NULL) {         /* Entrez2DocsumFieldInfo ::= (self contained) */
5141       atp = AsnReadId(aip, amp, ENTREZ2_DOCSUM_FIELD_INFO);
5142    } else {
5143       atp = AsnLinkType(orig, ENTREZ2_DOCSUM_FIELD_INFO);
5144    }
5145    /* link in local tree */
5146    if (atp == NULL) {
5147       return NULL;
5148    }
5149 
5150    ptr = Entrez2DocsumFieldInfoNew();
5151    if (ptr == NULL) {
5152       goto erret;
5153    }
5154    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
5155       goto erret;
5156    }
5157 
5158    atp = AsnReadId(aip,amp, atp);
5159    func = NULL;
5160 
5161    if (atp == DOCSUM_FIELD_INFO_field_name) {
5162       if ( AsnReadVal(aip, atp, &av) <= 0) {
5163          goto erret;
5164       }
5165       ptr -> field_name = av.ptrvalue;
5166       atp = AsnReadId(aip,amp, atp);
5167    }
5168    if (atp == FIELD_INFO_field_description) {
5169       if ( AsnReadVal(aip, atp, &av) <= 0) {
5170          goto erret;
5171       }
5172       ptr -> field_description = av.ptrvalue;
5173       atp = AsnReadId(aip,amp, atp);
5174    }
5175    if (atp == DOCSUM_FIELD_INFO_field_type) {
5176       if ( AsnReadVal(aip, atp, &av) <= 0) {
5177          goto erret;
5178       }
5179       ptr -> field_type = av.intvalue;
5180       atp = AsnReadId(aip,amp, atp);
5181    }
5182 
5183    if (AsnReadVal(aip, atp, &av) <= 0) {
5184       goto erret;
5185    }
5186    /* end struct */
5187 
5188 ret:
5189    AsnUnlinkType(orig);       /* unlink local tree */
5190    return ptr;
5191 
5192 erret:
5193    aip -> io_failure = TRUE;
5194    ptr = Entrez2DocsumFieldInfoFree(ptr);
5195    goto ret;
5196 }
5197 
5198 
5199 
5200 /**************************************************
5201 *
5202 *    Entrez2DocsumFieldInfoAsnWrite()
5203 *
5204 **************************************************/
5205 NLM_EXTERN Boolean LIBCALL 
5206 Entrez2DocsumFieldInfoAsnWrite(Entrez2DocsumFieldInfoPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
5207 {
5208    DataVal av;
5209    AsnTypePtr atp;
5210    Boolean retval = FALSE;
5211 
5212    if (! loaded)
5213    {
5214       if (! objent2AsnLoad()) {
5215          return FALSE;
5216       }
5217    }
5218 
5219    if (aip == NULL) {
5220       return FALSE;
5221    }
5222 
5223    atp = AsnLinkType(orig, ENTREZ2_DOCSUM_FIELD_INFO);   /* link local tree */
5224    if (atp == NULL) {
5225       return FALSE;
5226    }
5227 
5228    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5229    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
5230       goto erret;
5231    }
5232 
5233    if (ptr -> field_name != NULL) {
5234       av.ptrvalue = ptr -> field_name;
5235       retval = AsnWrite(aip, DOCSUM_FIELD_INFO_field_name,  &av);
5236    }
5237    if (ptr -> field_description != NULL) {
5238       av.ptrvalue = ptr -> field_description;
5239       retval = AsnWrite(aip, FIELD_INFO_field_description,  &av);
5240    }
5241    av.intvalue = ptr -> field_type;
5242    retval = AsnWrite(aip, DOCSUM_FIELD_INFO_field_type,  &av);
5243    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
5244       goto erret;
5245    }
5246    retval = TRUE;
5247 
5248 erret:
5249    AsnUnlinkType(orig);       /* unlink local tree */
5250    return retval;
5251 }
5252 
5253 
5254 
5255 /**************************************************
5256 *
5257 *    Entrez2DocsumNew()
5258 *
5259 **************************************************/
5260 NLM_EXTERN 
5261 Entrez2DocsumPtr LIBCALL
5262 Entrez2DocsumNew(void)
5263 {
5264    Entrez2DocsumPtr ptr = MemNew((size_t) sizeof(Entrez2Docsum));
5265 
5266    return ptr;
5267 
5268 }
5269 
5270 
5271 /**************************************************
5272 *
5273 *    Entrez2DocsumFree()
5274 *
5275 **************************************************/
5276 NLM_EXTERN 
5277 Entrez2DocsumPtr LIBCALL
5278 Entrez2DocsumFree(Entrez2DocsumPtr ptr)
5279 {
5280 
5281    if(ptr == NULL) {
5282       return NULL;
5283    }
5284    AsnGenericUserSeqOfFree(ptr -> docsum_data, (AsnOptFreeFunc) Entrez2DocsumDataFree);
5285    return MemFree(ptr);
5286 }
5287 
5288 
5289 /**************************************************
5290 *
5291 *    Entrez2DocsumAsnRead()
5292 *
5293 **************************************************/
5294 NLM_EXTERN 
5295 Entrez2DocsumPtr LIBCALL
5296 Entrez2DocsumAsnRead(AsnIoPtr aip, AsnTypePtr orig)
5297 {
5298    DataVal av;
5299    AsnTypePtr atp;
5300    Boolean isError = FALSE;
5301    AsnReadFunc func;
5302    Entrez2DocsumPtr ptr;
5303 
5304    if (! loaded)
5305    {
5306       if (! objent2AsnLoad()) {
5307          return NULL;
5308       }
5309    }
5310 
5311    if (aip == NULL) {
5312       return NULL;
5313    }
5314 
5315    if (orig == NULL) {         /* Entrez2Docsum ::= (self contained) */
5316       atp = AsnReadId(aip, amp, ENTREZ2_DOCSUM);
5317    } else {
5318       atp = AsnLinkType(orig, ENTREZ2_DOCSUM);
5319    }
5320    /* link in local tree */
5321    if (atp == NULL) {
5322       return NULL;
5323    }
5324 
5325    ptr = Entrez2DocsumNew();
5326    if (ptr == NULL) {
5327       goto erret;
5328    }
5329    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
5330       goto erret;
5331    }
5332 
5333    atp = AsnReadId(aip,amp, atp);
5334    func = NULL;
5335 
5336    if (atp == ENTREZ2_DOCSUM_uid) {
5337       if ( AsnReadVal(aip, atp, &av) <= 0) {
5338          goto erret;
5339       }
5340       ptr -> uid = av.intvalue;
5341       atp = AsnReadId(aip,amp, atp);
5342    }
5343    if (atp == ENTREZ2_DOCSUM_docsum_data) {
5344       ptr -> docsum_data = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Entrez2DocsumDataAsnRead, (AsnOptFreeFunc) Entrez2DocsumDataFree);
5345       if (isError && ptr -> docsum_data == NULL) {
5346          goto erret;
5347       }
5348       atp = AsnReadId(aip,amp, atp);
5349    }
5350 
5351    if (AsnReadVal(aip, atp, &av) <= 0) {
5352       goto erret;
5353    }
5354    /* end struct */
5355 
5356 ret:
5357    AsnUnlinkType(orig);       /* unlink local tree */
5358    return ptr;
5359 
5360 erret:
5361    aip -> io_failure = TRUE;
5362    ptr = Entrez2DocsumFree(ptr);
5363    goto ret;
5364 }
5365 
5366 
5367 
5368 /**************************************************
5369 *
5370 *    Entrez2DocsumAsnWrite()
5371 *
5372 **************************************************/
5373 NLM_EXTERN Boolean LIBCALL 
5374 Entrez2DocsumAsnWrite(Entrez2DocsumPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
5375 {
5376    DataVal av;
5377    AsnTypePtr atp;
5378    Boolean retval = FALSE;
5379 
5380    if (! loaded)
5381    {
5382       if (! objent2AsnLoad()) {
5383          return FALSE;
5384       }
5385    }
5386 
5387    if (aip == NULL) {
5388       return FALSE;
5389    }
5390 
5391    atp = AsnLinkType(orig, ENTREZ2_DOCSUM);   /* link local tree */
5392    if (atp == NULL) {
5393       return FALSE;
5394    }
5395 
5396    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5397    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
5398       goto erret;
5399    }
5400 
5401    av.intvalue = ptr -> uid;
5402    retval = AsnWrite(aip, ENTREZ2_DOCSUM_uid,  &av);
5403    AsnGenericUserSeqOfAsnWrite(ptr -> docsum_data, (AsnWriteFunc) Entrez2DocsumDataAsnWrite, aip, ENTREZ2_DOCSUM_docsum_data, ENTREZ2_DOCSUM_docsum_data_E);
5404    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
5405       goto erret;
5406    }
5407    retval = TRUE;
5408 
5409 erret:
5410    AsnUnlinkType(orig);       /* unlink local tree */
5411    return retval;
5412 }
5413 
5414 
5415 
5416 /**************************************************
5417 *
5418 *    Entrez2DocsumDataNew()
5419 *
5420 **************************************************/
5421 NLM_EXTERN 
5422 Entrez2DocsumDataPtr LIBCALL
5423 Entrez2DocsumDataNew(void)
5424 {
5425    Entrez2DocsumDataPtr ptr = MemNew((size_t) sizeof(Entrez2DocsumData));
5426 
5427    return ptr;
5428 
5429 }
5430 
5431 
5432 /**************************************************
5433 *
5434 *    Entrez2DocsumDataFree()
5435 *
5436 **************************************************/
5437 NLM_EXTERN 
5438 Entrez2DocsumDataPtr LIBCALL
5439 Entrez2DocsumDataFree(Entrez2DocsumDataPtr ptr)
5440 {
5441 
5442    if(ptr == NULL) {
5443       return NULL;
5444    }
5445    MemFree(ptr -> field_name);
5446    MemFree(ptr -> field_value);
5447    return MemFree(ptr);
5448 }
5449 
5450 
5451 /**************************************************
5452 *
5453 *    Entrez2DocsumDataAsnRead()
5454 *
5455 **************************************************/
5456 NLM_EXTERN 
5457 Entrez2DocsumDataPtr LIBCALL
5458 Entrez2DocsumDataAsnRead(AsnIoPtr aip, AsnTypePtr orig)
5459 {
5460    DataVal av;
5461    AsnTypePtr atp;
5462    Boolean isError = FALSE;
5463    AsnReadFunc func;
5464    Entrez2DocsumDataPtr ptr;
5465 
5466    if (! loaded)
5467    {
5468       if (! objent2AsnLoad()) {
5469          return NULL;
5470       }
5471    }
5472 
5473    if (aip == NULL) {
5474       return NULL;
5475    }
5476 
5477    if (orig == NULL) {         /* Entrez2DocsumData ::= (self contained) */
5478       atp = AsnReadId(aip, amp, ENTREZ2_DOCSUM_DATA);
5479    } else {
5480       atp = AsnLinkType(orig, ENTREZ2_DOCSUM_DATA);
5481    }
5482    /* link in local tree */
5483    if (atp == NULL) {
5484       return NULL;
5485    }
5486 
5487    ptr = Entrez2DocsumDataNew();
5488    if (ptr == NULL) {
5489       goto erret;
5490    }
5491    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
5492       goto erret;
5493    }
5494 
5495    atp = AsnReadId(aip,amp, atp);
5496    func = NULL;
5497 
5498    if (atp == ENTREZ2_DOCSUM_DATA_field_name) {
5499       if ( AsnReadVal(aip, atp, &av) <= 0) {
5500          goto erret;
5501       }
5502       ptr -> field_name = av.ptrvalue;
5503       atp = AsnReadId(aip,amp, atp);
5504    }
5505    if (atp == ENTREZ2_DOCSUM_DATA_field_value) {
5506       if ( AsnReadVal(aip, atp, &av) <= 0) {
5507          goto erret;
5508       }
5509       ptr -> field_value = av.ptrvalue;
5510       atp = AsnReadId(aip,amp, atp);
5511    }
5512 
5513    if (AsnReadVal(aip, atp, &av) <= 0) {
5514       goto erret;
5515    }
5516    /* end struct */
5517 
5518 ret:
5519    AsnUnlinkType(orig);       /* unlink local tree */
5520    return ptr;
5521 
5522 erret:
5523    aip -> io_failure = TRUE;
5524    ptr = Entrez2DocsumDataFree(ptr);
5525    goto ret;
5526 }
5527 
5528 
5529 
5530 /**************************************************
5531 *
5532 *    Entrez2DocsumDataAsnWrite()
5533 *
5534 **************************************************/
5535 NLM_EXTERN Boolean LIBCALL 
5536 Entrez2DocsumDataAsnWrite(Entrez2DocsumDataPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
5537 {
5538    DataVal av;
5539    AsnTypePtr atp;
5540    Boolean retval = FALSE;
5541 
5542    if (! loaded)
5543    {
5544       if (! objent2AsnLoad()) {
5545          return FALSE;
5546       }
5547    }
5548 
5549    if (aip == NULL) {
5550       return FALSE;
5551    }
5552 
5553    atp = AsnLinkType(orig, ENTREZ2_DOCSUM_DATA);   /* link local tree */
5554    if (atp == NULL) {
5555       return FALSE;
5556    }
5557 
5558    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5559    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
5560       goto erret;
5561    }
5562 
5563    if (ptr -> field_name != NULL) {
5564       av.ptrvalue = ptr -> field_name;
5565       retval = AsnWrite(aip, ENTREZ2_DOCSUM_DATA_field_name,  &av);
5566    }
5567    if (ptr -> field_value != NULL) {
5568       av.ptrvalue = ptr -> field_value;
5569       retval = AsnWrite(aip, ENTREZ2_DOCSUM_DATA_field_value,  &av);
5570    }
5571    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
5572       goto erret;
5573    }
5574    retval = TRUE;
5575 
5576 erret:
5577    AsnUnlinkType(orig);       /* unlink local tree */
5578    return retval;
5579 }
5580 
5581 
5582 
5583 /**************************************************
5584 *
5585 *    Entrez2TermNew()
5586 *
5587 **************************************************/
5588 NLM_EXTERN 
5589 Entrez2TermPtr LIBCALL
5590 Entrez2TermNew(void)
5591 {
5592    Entrez2TermPtr ptr = MemNew((size_t) sizeof(Entrez2Term));
5593 
5594    return ptr;
5595 
5596 }
5597 
5598 
5599 /**************************************************
5600 *
5601 *    Entrez2TermFree()
5602 *
5603 **************************************************/
5604 NLM_EXTERN 
5605 Entrez2TermPtr LIBCALL
5606 Entrez2TermFree(Entrez2TermPtr ptr)
5607 {
5608 
5609    if(ptr == NULL) {
5610       return NULL;
5611    }
5612    MemFree(ptr -> term);
5613    return MemFree(ptr);
5614 }
5615 
5616 
5617 /**************************************************
5618 *
5619 *    Entrez2TermAsnRead()
5620 *
5621 **************************************************/
5622 NLM_EXTERN 
5623 Entrez2TermPtr LIBCALL
5624 Entrez2TermAsnRead(AsnIoPtr aip, AsnTypePtr orig)
5625 {
5626    DataVal av;
5627    AsnTypePtr atp;
5628    Boolean isError = FALSE;
5629    AsnReadFunc func;
5630    Entrez2TermPtr ptr;
5631 
5632    if (! loaded)
5633    {
5634       if (! objent2AsnLoad()) {
5635          return NULL;
5636       }
5637    }
5638 
5639    if (aip == NULL) {
5640       return NULL;
5641    }
5642 
5643    if (orig == NULL) {         /* Entrez2Term ::= (self contained) */
5644       atp = AsnReadId(aip, amp, ENTREZ2_TERM);
5645    } else {
5646       atp = AsnLinkType(orig, ENTREZ2_TERM);
5647    }
5648    /* link in local tree */
5649    if (atp == NULL) {
5650       return NULL;
5651    }
5652 
5653    ptr = Entrez2TermNew();
5654    if (ptr == NULL) {
5655       goto erret;
5656    }
5657    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
5658       goto erret;
5659    }
5660 
5661    atp = AsnReadId(aip,amp, atp);
5662    func = NULL;
5663 
5664    if (atp == ENTREZ2_TERM_term) {
5665       if ( AsnReadVal(aip, atp, &av) <= 0) {
5666          goto erret;
5667       }
5668       ptr -> term = av.ptrvalue;
5669       atp = AsnReadId(aip,amp, atp);
5670    }
5671    if (atp == ENTREZ2_TERM_txid) {
5672       if ( AsnReadVal(aip, atp, &av) <= 0) {
5673          goto erret;
5674       }
5675       ptr -> txid = av.intvalue;
5676       atp = AsnReadId(aip,amp, atp);
5677    }
5678    if (atp == ENTREZ2_TERM_count) {
5679       if ( AsnReadVal(aip, atp, &av) <= 0) {
5680          goto erret;
5681       }
5682       ptr -> count = av.intvalue;
5683       atp = AsnReadId(aip,amp, atp);
5684    }
5685    if (atp == ENTREZ2_TERM_is_leaf_node) {
5686       if ( AsnReadVal(aip, atp, &av) <= 0) {
5687          goto erret;
5688       }
5689       ptr -> is_leaf_node = av.boolvalue;
5690       atp = AsnReadId(aip,amp, atp);
5691    }
5692 
5693    if (AsnReadVal(aip, atp, &av) <= 0) {
5694       goto erret;
5695    }
5696    /* end struct */
5697 
5698 ret:
5699    AsnUnlinkType(orig);       /* unlink local tree */
5700    return ptr;
5701 
5702 erret:
5703    aip -> io_failure = TRUE;
5704    ptr = Entrez2TermFree(ptr);
5705    goto ret;
5706 }
5707 
5708 
5709 
5710 /**************************************************
5711 *
5712 *    Entrez2TermAsnWrite()
5713 *
5714 **************************************************/
5715 NLM_EXTERN Boolean LIBCALL 
5716 Entrez2TermAsnWrite(Entrez2TermPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
5717 {
5718    DataVal av;
5719    AsnTypePtr atp;
5720    Boolean retval = FALSE;
5721 
5722    if (! loaded)
5723    {
5724       if (! objent2AsnLoad()) {
5725          return FALSE;
5726       }
5727    }
5728 
5729    if (aip == NULL) {
5730       return FALSE;
5731    }
5732 
5733    atp = AsnLinkType(orig, ENTREZ2_TERM);   /* link local tree */
5734    if (atp == NULL) {
5735       return FALSE;
5736    }
5737 
5738    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5739    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
5740       goto erret;
5741    }
5742 
5743    if (ptr -> term != NULL) {
5744       av.ptrvalue = ptr -> term;
5745       retval = AsnWrite(aip, ENTREZ2_TERM_term,  &av);
5746    }
5747    av.intvalue = ptr -> txid;
5748    retval = AsnWrite(aip, ENTREZ2_TERM_txid,  &av);
5749    av.intvalue = ptr -> count;
5750    retval = AsnWrite(aip, ENTREZ2_TERM_count,  &av);
5751    av.boolvalue = ptr -> is_leaf_node;
5752    retval = AsnWrite(aip, ENTREZ2_TERM_is_leaf_node,  &av);
5753    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
5754       goto erret;
5755    }
5756    retval = TRUE;
5757 
5758 erret:
5759    AsnUnlinkType(orig);       /* unlink local tree */
5760    return retval;
5761 }
5762 
5763 
5764 
5765 /**************************************************
5766 *
5767 *    Entrez2LinkCountNew()
5768 *
5769 **************************************************/
5770 NLM_EXTERN 
5771 Entrez2LinkCountPtr LIBCALL
5772 Entrez2LinkCountNew(void)
5773 {
5774    Entrez2LinkCountPtr ptr = MemNew((size_t) sizeof(Entrez2LinkCount));
5775 
5776    return ptr;
5777 
5778 }
5779 
5780 
5781 /**************************************************
5782 *
5783 *    Entrez2LinkCountFree()
5784 *
5785 **************************************************/
5786 NLM_EXTERN 
5787 Entrez2LinkCountPtr LIBCALL
5788 Entrez2LinkCountFree(Entrez2LinkCountPtr ptr)
5789 {
5790 
5791    if(ptr == NULL) {
5792       return NULL;
5793    }
5794    MemFree(ptr -> link_type);
5795    return MemFree(ptr);
5796 }
5797 
5798 
5799 /**************************************************
5800 *
5801 *    Entrez2LinkCountAsnRead()
5802 *
5803 **************************************************/
5804 NLM_EXTERN 
5805 Entrez2LinkCountPtr LIBCALL
5806 Entrez2LinkCountAsnRead(AsnIoPtr aip, AsnTypePtr orig)
5807 {
5808    DataVal av;
5809    AsnTypePtr atp;
5810    Boolean isError = FALSE;
5811    AsnReadFunc func;
5812    Entrez2LinkCountPtr ptr;
5813 
5814    if (! loaded)
5815    {
5816       if (! objent2AsnLoad()) {
5817          return NULL;
5818       }
5819    }
5820 
5821    if (aip == NULL) {
5822       return NULL;
5823    }
5824 
5825    if (orig == NULL) {         /* Entrez2LinkCount ::= (self contained) */
5826       atp = AsnReadId(aip, amp, ENTREZ2_LINK_COUNT);
5827    } else {
5828       atp = AsnLinkType(orig, ENTREZ2_LINK_COUNT);
5829    }
5830    /* link in local tree */
5831    if (atp == NULL) {
5832       return NULL;
5833    }
5834 
5835    ptr = Entrez2LinkCountNew();
5836    if (ptr == NULL) {
5837       goto erret;
5838    }
5839    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
5840       goto erret;
5841    }
5842 
5843    atp = AsnReadId(aip,amp, atp);
5844    func = NULL;
5845 
5846    if (atp == ENTREZ2_LINK_COUNT_link_type) {
5847       if ( AsnReadVal(aip, atp, &av) <= 0) {
5848          goto erret;
5849       }
5850       ptr -> link_type = av.ptrvalue;
5851       atp = AsnReadId(aip,amp, atp);
5852    }
5853    if (atp == ENTREZ2_LINK_COUNT_link_count) {
5854       if ( AsnReadVal(aip, atp, &av) <= 0) {
5855          goto erret;
5856       }
5857       ptr -> link_count = av.intvalue;
5858       atp = AsnReadId(aip,amp, atp);
5859    }
5860 
5861    if (AsnReadVal(aip, atp, &av) <= 0) {
5862       goto erret;
5863    }
5864    /* end struct */
5865 
5866 ret:
5867    AsnUnlinkType(orig);       /* unlink local tree */
5868    return ptr;
5869 
5870 erret:
5871    aip -> io_failure = TRUE;
5872    ptr = Entrez2LinkCountFree(ptr);
5873    goto ret;
5874 }
5875 
5876 
5877 
5878 /**************************************************
5879 *
5880 *    Entrez2LinkCountAsnWrite()
5881 *
5882 **************************************************/
5883 NLM_EXTERN Boolean LIBCALL 
5884 Entrez2LinkCountAsnWrite(Entrez2LinkCountPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
5885 {
5886    DataVal av;
5887    AsnTypePtr atp;
5888    Boolean retval = FALSE;
5889 
5890    if (! loaded)
5891    {
5892       if (! objent2AsnLoad()) {
5893          return FALSE;
5894       }
5895    }
5896 
5897    if (aip == NULL) {
5898       return FALSE;
5899    }
5900 
5901    atp = AsnLinkType(orig, ENTREZ2_LINK_COUNT);   /* link local tree */
5902    if (atp == NULL) {
5903       return FALSE;
5904    }
5905 
5906    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5907    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
5908       goto erret;
5909    }
5910 
5911    if (ptr -> link_type != NULL) {
5912       av.ptrvalue = ptr -> link_type;
5913       retval = AsnWrite(aip, ENTREZ2_LINK_COUNT_link_type,  &av);
5914    }
5915    av.intvalue = ptr -> link_count;
5916    retval = AsnWrite(aip, ENTREZ2_LINK_COUNT_link_count,  &av);
5917    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
5918       goto erret;
5919    }
5920    retval = TRUE;
5921 
5922 erret:
5923    AsnUnlinkType(orig);       /* unlink local tree */
5924    return retval;
5925 }
5926 
5927
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
This page was automatically generated by the LXR engine.
Visit the LXR main site for more information.