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