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