1 #include <asn.h>
2
3 #define NLM_GENERATED_CODE_PROTO
4
5 #include <mapmla.h>
6 #include <objmla.h>
7
8 static Boolean loaded = FALSE;
9
10 #include <asnmla.h>
11
12 #ifndef NLM_EXTERN_LOADS
13 #define NLM_EXTERN_LOADS {}
14 #endif
15
16 NLM_EXTERN Boolean LIBCALL
objmlaAsnLoad(void)17 objmlaAsnLoad(void)
18 {
19
20 if ( ! loaded) {
21 NLM_EXTERN_LOADS
22
23 if ( ! AsnLoad ())
24 return FALSE;
25 loaded = TRUE;
26 }
27
28 return TRUE;
29 }
30
31
32
33 /**************************************************
34 * Generated object loaders for Module NCBI-MedArchive
35 * Generated using ASNCODE Revision: 5.2 at Feb 6, 1997 4:41 PM
36 *
37 **************************************************/
38
39
40 /**************************************************
41 *
42 * MlaRequestFree()
43 *
44 **************************************************/
45 NLM_EXTERN
46 MlaRequestPtr LIBCALL
MlaRequestFree(ValNodePtr anp)47 MlaRequestFree(ValNodePtr anp)
48 {
49 Pointer pnt;
50
51 if (anp == NULL) {
52 return NULL;
53 }
54
55 pnt = anp->data.ptrvalue;
56 switch (anp->choice)
57 {
58 default:
59 break;
60 case MlaRequest_gettitle:
61 TitleMsgFree(anp -> data.ptrvalue);
62 break;
63 case MlaRequest_citmatch:
64 PubFree(anp -> data.ptrvalue);
65 break;
66 case MlaRequest_getaccuids:
67 MedlineSiFree(anp -> data.ptrvalue);
68 break;
69 case MlaRequest_citmatchpmid:
70 PubFree(anp -> data.ptrvalue);
71 break;
72 case MlaRequest_getaccpmids:
73 MedlineSiFree(anp -> data.ptrvalue);
74 break;
75 case MlaRequest_citlstpmids:
76 PubFree(anp -> data.ptrvalue);
77 break;
78 }
79 return MemFree(anp);
80 }
81
82
83 /**************************************************
84 *
85 * MlaRequestAsnRead()
86 *
87 **************************************************/
88 NLM_EXTERN
89 MlaRequestPtr LIBCALL
MlaRequestAsnRead(AsnIoPtr aip,AsnTypePtr orig)90 MlaRequestAsnRead(AsnIoPtr aip, AsnTypePtr orig)
91 {
92 DataVal av;
93 AsnTypePtr atp;
94 ValNodePtr anp;
95 Uint1 choice;
96 Boolean isError = FALSE;
97 Boolean nullIsError = FALSE;
98 AsnReadFunc func;
99
100 if (! loaded)
101 {
102 if (! objmlaAsnLoad()) {
103 return NULL;
104 }
105 }
106
107 if (aip == NULL) {
108 return NULL;
109 }
110
111 if (orig == NULL) { /* MlaRequest ::= (self contained) */
112 atp = AsnReadId(aip, amp, MLA_REQUEST);
113 } else {
114 atp = AsnLinkType(orig, MLA_REQUEST); /* link in local tree */
115 }
116 if (atp == NULL) {
117 return NULL;
118 }
119
120 anp = ValNodeNew(NULL);
121 if (anp == NULL) {
122 goto erret;
123 }
124 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
125 goto erret;
126 }
127
128 func = NULL;
129
130 atp = AsnReadId(aip, amp, atp); /* find the choice */
131 if (atp == NULL) {
132 goto erret;
133 }
134 if (atp == MLA_REQUEST_init) {
135 choice = MlaRequest_init;
136 if (AsnReadVal(aip, atp, &av) <= 0) {
137 goto erret;
138 }
139 anp->data.boolvalue = av.boolvalue;
140 }
141 else if (atp == MLA_REQUEST_getmle) {
142 choice = MlaRequest_getmle;
143 if (AsnReadVal(aip, atp, &av) <= 0) {
144 goto erret;
145 }
146 anp->data.intvalue = av.intvalue;
147 }
148 else if (atp == MLA_REQUEST_getpub) {
149 choice = MlaRequest_getpub;
150 if (AsnReadVal(aip, atp, &av) <= 0) {
151 goto erret;
152 }
153 anp->data.intvalue = av.intvalue;
154 }
155 else if (atp == MLA_REQUEST_gettitle) {
156 choice = MlaRequest_gettitle;
157 func = (AsnReadFunc) TitleMsgAsnRead;
158 }
159 else if (atp == MLA_REQUEST_citmatch) {
160 choice = MlaRequest_citmatch;
161 func = (AsnReadFunc) PubAsnRead;
162 }
163 else if (atp == MLA_REQUEST_fini) {
164 choice = MlaRequest_fini;
165 if (AsnReadVal(aip, atp, &av) <= 0) {
166 goto erret;
167 }
168 anp->data.boolvalue = av.boolvalue;
169 }
170 else if (atp == MLA_REQUEST_getmriuids) {
171 choice = MlaRequest_getmriuids;
172 if (AsnReadVal(aip, atp, &av) <= 0) {
173 goto erret;
174 }
175 anp->data.intvalue = av.intvalue;
176 }
177 else if (atp == MLA_REQUEST_getaccuids) {
178 choice = MlaRequest_getaccuids;
179 func = (AsnReadFunc) MedlineSiAsnRead;
180 }
181 else if (atp == MLA_REQUEST_uidtopmid) {
182 choice = MlaRequest_uidtopmid;
183 if (AsnReadVal(aip, atp, &av) <= 0) {
184 goto erret;
185 }
186 anp->data.intvalue = av.intvalue;
187 }
188 else if (atp == MLA_REQUEST_pmidtouid) {
189 choice = MlaRequest_pmidtouid;
190 if (AsnReadVal(aip, atp, &av) <= 0) {
191 goto erret;
192 }
193 anp->data.intvalue = av.intvalue;
194 }
195 else if (atp == MLA_REQUEST_getmlepmid) {
196 choice = MlaRequest_getmlepmid;
197 if (AsnReadVal(aip, atp, &av) <= 0) {
198 goto erret;
199 }
200 anp->data.intvalue = av.intvalue;
201 }
202 else if (atp == MLA_REQUEST_getpubpmid) {
203 choice = MlaRequest_getpubpmid;
204 if (AsnReadVal(aip, atp, &av) <= 0) {
205 goto erret;
206 }
207 anp->data.intvalue = av.intvalue;
208 }
209 else if (atp == MLA_REQUEST_citmatchpmid) {
210 choice = MlaRequest_citmatchpmid;
211 func = (AsnReadFunc) PubAsnRead;
212 }
213 else if (atp == MLA_REQUEST_getmripmids) {
214 choice = MlaRequest_getmripmids;
215 if (AsnReadVal(aip, atp, &av) <= 0) {
216 goto erret;
217 }
218 anp->data.intvalue = av.intvalue;
219 }
220 else if (atp == MLA_REQUEST_getaccpmids) {
221 choice = MlaRequest_getaccpmids;
222 func = (AsnReadFunc) MedlineSiAsnRead;
223 }
224 else if (atp == MLA_REQUEST_citlstpmids) {
225 choice = MlaRequest_citlstpmids;
226 func = (AsnReadFunc) PubAsnRead;
227 }
228 else if (atp == MLA_REQUEST_getmleuid) {
229 choice = MlaRequest_getmleuid;
230 if (AsnReadVal(aip, atp, &av) <= 0) {
231 goto erret;
232 }
233 anp->data.intvalue = av.intvalue;
234 }
235 else if (atp == MLA_REQUEST_getmlrpmid) {
236 choice = MlaRequest_getmlrpmid;
237 if (AsnReadVal(aip, atp, &av) <= 0) {
238 goto erret;
239 }
240 anp->data.intvalue = av.intvalue;
241 }
242 else if (atp == MLA_REQUEST_getmlruid) {
243 choice = MlaRequest_getmlruid;
244 if (AsnReadVal(aip, atp, &av) <= 0) {
245 goto erret;
246 }
247 anp->data.intvalue = av.intvalue;
248 }
249 anp->choice = choice;
250 if (func != NULL)
251 {
252 anp->data.ptrvalue = (* func)(aip, atp);
253 if (aip -> io_failure) goto erret;
254
255 if (nullIsError && anp->data.ptrvalue == NULL) {
256 goto erret;
257 }
258 }
259
260 ret:
261 AsnUnlinkType(orig); /* unlink local tree */
262 return anp;
263
264 erret:
265 anp = MemFree(anp);
266 aip -> io_failure = TRUE;
267 goto ret;
268 }
269
270
271 /**************************************************
272 *
273 * MlaRequestAsnWrite()
274 *
275 **************************************************/
276 NLM_EXTERN Boolean LIBCALL
MlaRequestAsnWrite(MlaRequestPtr anp,AsnIoPtr aip,AsnTypePtr orig)277 MlaRequestAsnWrite(MlaRequestPtr anp, AsnIoPtr aip, AsnTypePtr orig)
278
279 {
280 DataVal av;
281 AsnTypePtr atp, writetype = NULL;
282 Pointer pnt;
283 AsnWriteFunc func = NULL;
284 Boolean retval = FALSE;
285
286 if (! loaded)
287 {
288 if (! objmlaAsnLoad())
289 return FALSE;
290 }
291
292 if (aip == NULL)
293 return FALSE;
294
295 atp = AsnLinkType(orig, MLA_REQUEST); /* link local tree */
296 if (atp == NULL) {
297 return FALSE;
298 }
299
300 if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
301
302 av.ptrvalue = (Pointer)anp;
303 if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
304 goto erret;
305 }
306
307 pnt = anp->data.ptrvalue;
308 switch (anp->choice)
309 {
310 case MlaRequest_init:
311 av.boolvalue = anp->data.boolvalue;
312 retval = AsnWrite(aip, MLA_REQUEST_init, &av);
313 break;
314 case MlaRequest_getmle:
315 av.intvalue = anp->data.intvalue;
316 retval = AsnWrite(aip, MLA_REQUEST_getmle, &av);
317 break;
318 case MlaRequest_getpub:
319 av.intvalue = anp->data.intvalue;
320 retval = AsnWrite(aip, MLA_REQUEST_getpub, &av);
321 break;
322 case MlaRequest_gettitle:
323 writetype = MLA_REQUEST_gettitle;
324 func = (AsnWriteFunc) TitleMsgAsnWrite;
325 break;
326 case MlaRequest_citmatch:
327 writetype = MLA_REQUEST_citmatch;
328 func = (AsnWriteFunc) PubAsnWrite;
329 break;
330 case MlaRequest_fini:
331 av.boolvalue = anp->data.boolvalue;
332 retval = AsnWrite(aip, MLA_REQUEST_fini, &av);
333 break;
334 case MlaRequest_getmriuids:
335 av.intvalue = anp->data.intvalue;
336 retval = AsnWrite(aip, MLA_REQUEST_getmriuids, &av);
337 break;
338 case MlaRequest_getaccuids:
339 writetype = MLA_REQUEST_getaccuids;
340 func = (AsnWriteFunc) MedlineSiAsnWrite;
341 break;
342 case MlaRequest_uidtopmid:
343 av.intvalue = anp->data.intvalue;
344 retval = AsnWrite(aip, MLA_REQUEST_uidtopmid, &av);
345 break;
346 case MlaRequest_pmidtouid:
347 av.intvalue = anp->data.intvalue;
348 retval = AsnWrite(aip, MLA_REQUEST_pmidtouid, &av);
349 break;
350 case MlaRequest_getmlepmid:
351 av.intvalue = anp->data.intvalue;
352 retval = AsnWrite(aip, MLA_REQUEST_getmlepmid, &av);
353 break;
354 case MlaRequest_getpubpmid:
355 av.intvalue = anp->data.intvalue;
356 retval = AsnWrite(aip, MLA_REQUEST_getpubpmid, &av);
357 break;
358 case MlaRequest_citmatchpmid:
359 writetype = MLA_REQUEST_citmatchpmid;
360 func = (AsnWriteFunc) PubAsnWrite;
361 break;
362 case MlaRequest_getmripmids:
363 av.intvalue = anp->data.intvalue;
364 retval = AsnWrite(aip, MLA_REQUEST_getmripmids, &av);
365 break;
366 case MlaRequest_getaccpmids:
367 writetype = MLA_REQUEST_getaccpmids;
368 func = (AsnWriteFunc) MedlineSiAsnWrite;
369 break;
370 case MlaRequest_citlstpmids:
371 writetype = MLA_REQUEST_citlstpmids;
372 func = (AsnWriteFunc) PubAsnWrite;
373 break;
374 case MlaRequest_getmleuid:
375 av.intvalue = anp->data.intvalue;
376 retval = AsnWrite(aip, MLA_REQUEST_getmleuid, &av);
377 break;
378 case MlaRequest_getmlrpmid:
379 av.intvalue = anp->data.intvalue;
380 retval = AsnWrite(aip, MLA_REQUEST_getmlrpmid, &av);
381 break;
382 case MlaRequest_getmlruid:
383 av.intvalue = anp->data.intvalue;
384 retval = AsnWrite(aip, MLA_REQUEST_getmlruid, &av);
385 break;
386 }
387 if (writetype != NULL) {
388 retval = (* func)(pnt, aip, writetype); /* write it out */
389 }
390 if (!retval) {
391 goto erret;
392 }
393 retval = TRUE;
394
395 erret:
396 AsnUnlinkType(orig); /* unlink local tree */
397 return retval;
398 }
399
400
401 /**************************************************
402 *
403 * TitleMsgNew()
404 *
405 **************************************************/
406 NLM_EXTERN
407 TitleMsgPtr LIBCALL
TitleMsgNew(void)408 TitleMsgNew(void)
409 {
410 TitleMsgPtr ptr = MemNew((size_t) sizeof(TitleMsg));
411
412 return ptr;
413
414 }
415
416
417 /**************************************************
418 *
419 * TitleMsgFree()
420 *
421 **************************************************/
422 NLM_EXTERN
423 TitleMsgPtr LIBCALL
TitleMsgFree(TitleMsgPtr ptr)424 TitleMsgFree(TitleMsgPtr ptr)
425 {
426
427 if(ptr == NULL) {
428 return NULL;
429 }
430 TitleFree(ptr -> title);
431 return MemFree(ptr);
432 }
433
434
435 /**************************************************
436 *
437 * TitleMsgAsnRead()
438 *
439 **************************************************/
440 NLM_EXTERN
441 TitleMsgPtr LIBCALL
TitleMsgAsnRead(AsnIoPtr aip,AsnTypePtr orig)442 TitleMsgAsnRead(AsnIoPtr aip, AsnTypePtr orig)
443 {
444 DataVal av;
445 AsnTypePtr atp;
446 Boolean isError = FALSE;
447 AsnReadFunc func;
448 TitleMsgPtr ptr;
449
450 if (! loaded)
451 {
452 if (! objmlaAsnLoad()) {
453 return NULL;
454 }
455 }
456
457 if (aip == NULL) {
458 return NULL;
459 }
460
461 if (orig == NULL) { /* TitleMsg ::= (self contained) */
462 atp = AsnReadId(aip, amp, TITLE_MSG);
463 } else {
464 atp = AsnLinkType(orig, TITLE_MSG);
465 }
466 /* link in local tree */
467 if (atp == NULL) {
468 return NULL;
469 }
470
471 ptr = TitleMsgNew();
472 if (ptr == NULL) {
473 goto erret;
474 }
475 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
476 goto erret;
477 }
478
479 atp = AsnReadId(aip,amp, atp);
480 func = NULL;
481
482 if (atp == TITLE_MSG_type) {
483 if ( AsnReadVal(aip, atp, &av) <= 0) {
484 goto erret;
485 }
486 ptr -> type = av.intvalue;
487 atp = AsnReadId(aip,amp, atp);
488 }
489 if (atp == TITLE_MSG_title) {
490 ptr -> title = TitleAsnRead(aip, atp);
491 if (aip -> io_failure) {
492 goto erret;
493 }
494 atp = AsnReadId(aip,amp, atp);
495 }
496
497 if (AsnReadVal(aip, atp, &av) <= 0) {
498 goto erret;
499 }
500 /* end struct */
501
502 ret:
503 AsnUnlinkType(orig); /* unlink local tree */
504 return ptr;
505
506 erret:
507 aip -> io_failure = TRUE;
508 ptr = TitleMsgFree(ptr);
509 goto ret;
510 }
511
512
513
514 /**************************************************
515 *
516 * TitleMsgAsnWrite()
517 *
518 **************************************************/
519 NLM_EXTERN Boolean LIBCALL
TitleMsgAsnWrite(TitleMsgPtr ptr,AsnIoPtr aip,AsnTypePtr orig)520 TitleMsgAsnWrite(TitleMsgPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
521 {
522 DataVal av;
523 AsnTypePtr atp;
524 Boolean retval = FALSE;
525
526 if (! loaded)
527 {
528 if (! objmlaAsnLoad()) {
529 return FALSE;
530 }
531 }
532
533 if (aip == NULL) {
534 return FALSE;
535 }
536
537 atp = AsnLinkType(orig, TITLE_MSG); /* link local tree */
538 if (atp == NULL) {
539 return FALSE;
540 }
541
542 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
543 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
544 goto erret;
545 }
546
547 av.intvalue = ptr -> type;
548 retval = AsnWrite(aip, TITLE_MSG_type, &av);
549 if (ptr -> title != NULL) {
550 if ( ! TitleAsnWrite(ptr -> title, aip, TITLE_MSG_title)) {
551 goto erret;
552 }
553 }
554 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
555 goto erret;
556 }
557 retval = TRUE;
558
559 erret:
560 AsnUnlinkType(orig); /* unlink local tree */
561 return retval;
562 }
563
564
565
566 /**************************************************
567 *
568 * TitleMsgListNew()
569 *
570 **************************************************/
571 NLM_EXTERN
572 TitleMsgListPtr LIBCALL
TitleMsgListNew(void)573 TitleMsgListNew(void)
574 {
575 TitleMsgListPtr ptr = MemNew((size_t) sizeof(TitleMsgList));
576
577 return ptr;
578
579 }
580
581
582 /**************************************************
583 *
584 * TitleMsgListFree()
585 *
586 **************************************************/
587 NLM_EXTERN
588 TitleMsgListPtr LIBCALL
TitleMsgListFree(TitleMsgListPtr ptr)589 TitleMsgListFree(TitleMsgListPtr ptr)
590 {
591
592 if(ptr == NULL) {
593 return NULL;
594 }
595 AsnGenericUserSeqOfFree(ptr -> titles, (AsnOptFreeFunc) TitleMsgFree);
596 return MemFree(ptr);
597 }
598
599
600 /**************************************************
601 *
602 * TitleMsgListAsnRead()
603 *
604 **************************************************/
605 NLM_EXTERN
606 TitleMsgListPtr LIBCALL
TitleMsgListAsnRead(AsnIoPtr aip,AsnTypePtr orig)607 TitleMsgListAsnRead(AsnIoPtr aip, AsnTypePtr orig)
608 {
609 DataVal av;
610 AsnTypePtr atp;
611 Boolean isError = FALSE;
612 AsnReadFunc func;
613 TitleMsgListPtr ptr;
614
615 if (! loaded)
616 {
617 if (! objmlaAsnLoad()) {
618 return NULL;
619 }
620 }
621
622 if (aip == NULL) {
623 return NULL;
624 }
625
626 if (orig == NULL) { /* TitleMsgList ::= (self contained) */
627 atp = AsnReadId(aip, amp, TITLE_MSG_LIST);
628 } else {
629 atp = AsnLinkType(orig, TITLE_MSG_LIST);
630 }
631 /* link in local tree */
632 if (atp == NULL) {
633 return NULL;
634 }
635
636 ptr = TitleMsgListNew();
637 if (ptr == NULL) {
638 goto erret;
639 }
640 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
641 goto erret;
642 }
643
644 atp = AsnReadId(aip,amp, atp);
645 func = NULL;
646
647 if (atp == TITLE_MSG_LIST_num) {
648 if ( AsnReadVal(aip, atp, &av) <= 0) {
649 goto erret;
650 }
651 ptr -> num = av.intvalue;
652 atp = AsnReadId(aip,amp, atp);
653 }
654 if (atp == TITLE_MSG_LIST_titles) {
655 ptr -> titles = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) TitleMsgAsnRead, (AsnOptFreeFunc) TitleMsgFree);
656 if (isError && ptr -> titles == NULL) {
657 goto erret;
658 }
659 atp = AsnReadId(aip,amp, atp);
660 }
661
662 if (AsnReadVal(aip, atp, &av) <= 0) {
663 goto erret;
664 }
665 /* end struct */
666
667 ret:
668 AsnUnlinkType(orig); /* unlink local tree */
669 return ptr;
670
671 erret:
672 aip -> io_failure = TRUE;
673 ptr = TitleMsgListFree(ptr);
674 goto ret;
675 }
676
677
678
679 /**************************************************
680 *
681 * TitleMsgListAsnWrite()
682 *
683 **************************************************/
684 NLM_EXTERN Boolean LIBCALL
TitleMsgListAsnWrite(TitleMsgListPtr ptr,AsnIoPtr aip,AsnTypePtr orig)685 TitleMsgListAsnWrite(TitleMsgListPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
686 {
687 DataVal av;
688 AsnTypePtr atp;
689 Boolean retval = FALSE;
690
691 if (! loaded)
692 {
693 if (! objmlaAsnLoad()) {
694 return FALSE;
695 }
696 }
697
698 if (aip == NULL) {
699 return FALSE;
700 }
701
702 atp = AsnLinkType(orig, TITLE_MSG_LIST); /* link local tree */
703 if (atp == NULL) {
704 return FALSE;
705 }
706
707 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
708 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
709 goto erret;
710 }
711
712 av.intvalue = ptr -> num;
713 retval = AsnWrite(aip, TITLE_MSG_LIST_num, &av);
714 AsnGenericUserSeqOfAsnWrite(ptr -> titles, (AsnWriteFunc) TitleMsgAsnWrite, aip, TITLE_MSG_LIST_titles, TITLE_MSG_LIST_titles_E);
715 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
716 goto erret;
717 }
718 retval = TRUE;
719
720 erret:
721 AsnUnlinkType(orig); /* unlink local tree */
722 return retval;
723 }
724
725
726
727 /**************************************************
728 *
729 * MlaBackFree()
730 *
731 **************************************************/
732 NLM_EXTERN
733 MlaBackPtr LIBCALL
MlaBackFree(ValNodePtr anp)734 MlaBackFree(ValNodePtr anp)
735 {
736 Pointer pnt;
737
738 if (anp == NULL) {
739 return NULL;
740 }
741
742 pnt = anp->data.ptrvalue;
743 switch (anp->choice)
744 {
745 default:
746 break;
747 case MlaBack_getmle:
748 MedlineEntryFree(anp -> data.ptrvalue);
749 break;
750 case MlaBack_getpub:
751 PubFree(anp -> data.ptrvalue);
752 break;
753 case MlaBack_gettitle:
754 TitleMsgListFree(anp -> data.ptrvalue);
755 break;
756 case MlaBack_getuids:
757 AsnGenericBaseSeqOfFree((ValNodePtr) pnt,ASNCODE_INTVAL_SLOT);
758 break;
759 case MlaBack_getpmids:
760 AsnGenericBaseSeqOfFree((ValNodePtr) pnt,ASNCODE_INTVAL_SLOT);
761 break;
762 case MlaBack_getpme:
763 PubmedEntryFree(anp -> data.ptrvalue);
764 break;
765 case MlaBack_getmlr:
766 MedlarsEntryFree(anp -> data.ptrvalue);
767 break;
768 }
769 return MemFree(anp);
770 }
771
772
773 /**************************************************
774 *
775 * MlaBackAsnRead()
776 *
777 **************************************************/
778 NLM_EXTERN
779 MlaBackPtr LIBCALL
MlaBackAsnRead(AsnIoPtr aip,AsnTypePtr orig)780 MlaBackAsnRead(AsnIoPtr aip, AsnTypePtr orig)
781 {
782 DataVal av;
783 AsnTypePtr atp;
784 ValNodePtr anp;
785 Uint1 choice;
786 Boolean isError = FALSE;
787 Boolean nullIsError = FALSE;
788 AsnReadFunc func;
789
790 if (! loaded)
791 {
792 if (! objmlaAsnLoad()) {
793 return NULL;
794 }
795 }
796
797 if (aip == NULL) {
798 return NULL;
799 }
800
801 if (orig == NULL) { /* MlaBack ::= (self contained) */
802 atp = AsnReadId(aip, amp, MLA_BACK);
803 } else {
804 atp = AsnLinkType(orig, MLA_BACK); /* link in local tree */
805 }
806 if (atp == NULL) {
807 return NULL;
808 }
809
810 anp = ValNodeNew(NULL);
811 if (anp == NULL) {
812 goto erret;
813 }
814 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
815 goto erret;
816 }
817
818 func = NULL;
819
820 atp = AsnReadId(aip, amp, atp); /* find the choice */
821 if (atp == NULL) {
822 goto erret;
823 }
824 if (atp == MLA_BACK_init) {
825 choice = MlaBack_init;
826 if (AsnReadVal(aip, atp, &av) <= 0) {
827 goto erret;
828 }
829 anp->data.boolvalue = av.boolvalue;
830 }
831 else if (atp == MLA_BACK_error) {
832 choice = MlaBack_error;
833 if (AsnReadVal(aip, atp, &av) <= 0) {
834 goto erret;
835 }
836 anp->data.intvalue = av.intvalue;
837 }
838 else if (atp == MLA_BACK_getmle) {
839 choice = MlaBack_getmle;
840 func = (AsnReadFunc) MedlineEntryAsnRead;
841 }
842 else if (atp == MLA_BACK_getpub) {
843 choice = MlaBack_getpub;
844 func = (AsnReadFunc) PubAsnRead;
845 }
846 else if (atp == MLA_BACK_gettitle) {
847 choice = MlaBack_gettitle;
848 func = (AsnReadFunc) TitleMsgListAsnRead;
849 }
850 else if (atp == MLA_BACK_citmatch) {
851 choice = MlaBack_citmatch;
852 if (AsnReadVal(aip, atp, &av) <= 0) {
853 goto erret;
854 }
855 anp->data.intvalue = av.intvalue;
856 }
857 else if (atp == MLA_BACK_fini) {
858 choice = MlaBack_fini;
859 if (AsnReadVal(aip, atp, &av) <= 0) {
860 goto erret;
861 }
862 anp->data.boolvalue = av.boolvalue;
863 }
864 else if (atp == MLA_BACK_getuids) {
865 choice = MlaBack_getuids;
866 anp -> data.ptrvalue =
867 AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_INTVAL_SLOT, &isError);
868 if (isError && anp -> data.ptrvalue == NULL) {
869 goto erret;
870 }
871 }
872 else if (atp == MLA_BACK_getpmids) {
873 choice = MlaBack_getpmids;
874 anp -> data.ptrvalue =
875 AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_INTVAL_SLOT, &isError);
876 if (isError && anp -> data.ptrvalue == NULL) {
877 goto erret;
878 }
879 }
880 else if (atp == MLA_BACK_outuid) {
881 choice = MlaBack_outuid;
882 if (AsnReadVal(aip, atp, &av) <= 0) {
883 goto erret;
884 }
885 anp->data.intvalue = av.intvalue;
886 }
887 else if (atp == MLA_BACK_outpmid) {
888 choice = MlaBack_outpmid;
889 if (AsnReadVal(aip, atp, &av) <= 0) {
890 goto erret;
891 }
892 anp->data.intvalue = av.intvalue;
893 }
894 else if (atp == MLA_BACK_getpme) {
895 choice = MlaBack_getpme;
896 func = (AsnReadFunc) PubmedEntryAsnRead;
897 }
898 else if (atp == MLA_BACK_getmlr) {
899 choice = MlaBack_getmlr;
900 func = (AsnReadFunc) MedlarsEntryAsnRead;
901 }
902 anp->choice = choice;
903 if (func != NULL)
904 {
905 anp->data.ptrvalue = (* func)(aip, atp);
906 if (aip -> io_failure) goto erret;
907
908 if (nullIsError && anp->data.ptrvalue == NULL) {
909 goto erret;
910 }
911 }
912
913 ret:
914 AsnUnlinkType(orig); /* unlink local tree */
915 return anp;
916
917 erret:
918 anp = MemFree(anp);
919 aip -> io_failure = TRUE;
920 goto ret;
921 }
922
923
924 /**************************************************
925 *
926 * MlaBackAsnWrite()
927 *
928 **************************************************/
929 NLM_EXTERN Boolean LIBCALL
MlaBackAsnWrite(MlaBackPtr anp,AsnIoPtr aip,AsnTypePtr orig)930 MlaBackAsnWrite(MlaBackPtr anp, AsnIoPtr aip, AsnTypePtr orig)
931
932 {
933 DataVal av;
934 AsnTypePtr atp, writetype = NULL;
935 Pointer pnt;
936 AsnWriteFunc func = NULL;
937 Boolean retval = FALSE;
938
939 if (! loaded)
940 {
941 if (! objmlaAsnLoad())
942 return FALSE;
943 }
944
945 if (aip == NULL)
946 return FALSE;
947
948 atp = AsnLinkType(orig, MLA_BACK); /* link local tree */
949 if (atp == NULL) {
950 return FALSE;
951 }
952
953 if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
954
955 av.ptrvalue = (Pointer)anp;
956 if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
957 goto erret;
958 }
959
960 pnt = anp->data.ptrvalue;
961 switch (anp->choice)
962 {
963 case MlaBack_init:
964 av.boolvalue = anp->data.boolvalue;
965 retval = AsnWrite(aip, MLA_BACK_init, &av);
966 break;
967 case MlaBack_error:
968 av.intvalue = anp->data.intvalue;
969 retval = AsnWrite(aip, MLA_BACK_error, &av);
970 break;
971 case MlaBack_getmle:
972 writetype = MLA_BACK_getmle;
973 func = (AsnWriteFunc) MedlineEntryAsnWrite;
974 break;
975 case MlaBack_getpub:
976 writetype = MLA_BACK_getpub;
977 func = (AsnWriteFunc) PubAsnWrite;
978 break;
979 case MlaBack_gettitle:
980 writetype = MLA_BACK_gettitle;
981 func = (AsnWriteFunc) TitleMsgListAsnWrite;
982 break;
983 case MlaBack_citmatch:
984 av.intvalue = anp->data.intvalue;
985 retval = AsnWrite(aip, MLA_BACK_citmatch, &av);
986 break;
987 case MlaBack_fini:
988 av.boolvalue = anp->data.boolvalue;
989 retval = AsnWrite(aip, MLA_BACK_fini, &av);
990 break;
991 case MlaBack_getuids:
992 retval = AsnGenericBaseSeqOfAsnWrite((Pointer) pnt,ASNCODE_INTVAL_SLOT, aip, MLA_BACK_getuids, MLA_BACK_getuids_E); break;
993 case MlaBack_getpmids:
994 retval = AsnGenericBaseSeqOfAsnWrite((Pointer) pnt,ASNCODE_INTVAL_SLOT, aip, MLA_BACK_getpmids, MLA_BACK_getpmids_E); break;
995 case MlaBack_outuid:
996 av.intvalue = anp->data.intvalue;
997 retval = AsnWrite(aip, MLA_BACK_outuid, &av);
998 break;
999 case MlaBack_outpmid:
1000 av.intvalue = anp->data.intvalue;
1001 retval = AsnWrite(aip, MLA_BACK_outpmid, &av);
1002 break;
1003 case MlaBack_getpme:
1004 writetype = MLA_BACK_getpme;
1005 func = (AsnWriteFunc) PubmedEntryAsnWrite;
1006 break;
1007 case MlaBack_getmlr:
1008 writetype = MLA_BACK_getmlr;
1009 func = (AsnWriteFunc) MedlarsEntryAsnWrite;
1010 break;
1011 }
1012 if (writetype != NULL) {
1013 retval = (* func)(pnt, aip, writetype); /* write it out */
1014 }
1015 if (!retval) {
1016 goto erret;
1017 }
1018 retval = TRUE;
1019
1020 erret:
1021 AsnUnlinkType(orig); /* unlink local tree */
1022 return retval;
1023 }
1024