1 #include <asn.h>
2 
3 #define NLM_GENERATED_CODE_PROTO
4 
5 #include <tax1map.h>
6 #include <objtax1.h>
7 
8 static Boolean loaded = FALSE;
9 
10 #include <asntax1.h>
11 
12 #ifndef NLM_EXTERN_LOADS
13 #define NLM_EXTERN_LOADS {}
14 #endif
15 
16 NLM_EXTERN Boolean LIBCALL
objtax1AsnLoad(void)17 objtax1AsnLoad(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-Taxon1
35 *    Generated using ASNCODE Revision: 6.12 at Sep 28, 2001 11:31 AM
36 *
37 **************************************************/
38 
39 
40 /**************************************************
41 *
42 *    Taxon1ReqFree()
43 *
44 **************************************************/
45 NLM_EXTERN
46 Taxon1ReqPtr LIBCALL
Taxon1ReqFree(ValNodePtr anp)47 Taxon1ReqFree(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 Taxon1Req_findname:
61    case Taxon1Req_getdesignator:
62    case Taxon1Req_getunique:
63       MemFree(anp -> data.ptrvalue);
64       break;
65    case Taxon1Req_getidbyorg:
66    case Taxon1Req_lookup:
67       OrgRefFree(anp -> data.ptrvalue);
68       break;
69    case Taxon1Req_getorgmod:
70    case Taxon1Req_getorgprop:
71    case Taxon1Req_searchname:
72       Taxon1InfoFree(anp -> data.ptrvalue);
73       break;
74    }
75    return MemFree(anp);
76 }
77 
78 
79 /**************************************************
80 *
81 *    Taxon1ReqAsnRead()
82 *
83 **************************************************/
84 NLM_EXTERN
85 Taxon1ReqPtr LIBCALL
Taxon1ReqAsnRead(AsnIoPtr aip,AsnTypePtr orig)86 Taxon1ReqAsnRead(AsnIoPtr aip, AsnTypePtr orig)
87 {
88    DataVal av;
89    AsnTypePtr atp;
90    ValNodePtr anp;
91    Uint1 choice;
92    Boolean isError = FALSE;
93    Boolean nullIsError = FALSE;
94    AsnReadFunc func;
95 
96    if (! loaded)
97    {
98       if (! objtax1AsnLoad()) {
99          return NULL;
100       }
101    }
102 
103    if (aip == NULL) {
104       return NULL;
105    }
106 
107    if (orig == NULL) {         /* Taxon1Req ::= (self contained) */
108       atp = AsnReadId(aip, amp, TAXON1_REQ);
109    } else {
110       atp = AsnLinkType(orig, TAXON1_REQ);    /* link in local tree */
111    }
112    if (atp == NULL) {
113       return NULL;
114    }
115 
116    anp = ValNodeNew(NULL);
117    if (anp == NULL) {
118       goto erret;
119    }
120    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
121       goto erret;
122    }
123 
124    func = NULL;
125 
126    atp = AsnReadId(aip, amp, atp);  /* find the choice */
127    if (atp == NULL) {
128       goto erret;
129    }
130    if (atp == TAXON1_REQ_init) {
131       choice = Taxon1Req_init;
132       if (AsnReadVal(aip, atp, &av) <= 0) {
133          goto erret;
134       }
135       anp->data.boolvalue = av.boolvalue;
136    }
137    else if (atp == TAXON1_REQ_findname) {
138       choice = Taxon1Req_findname;
139       if (AsnReadVal(aip, atp, &av) <= 0) {
140          goto erret;
141       }
142       anp->data.ptrvalue = av.ptrvalue;
143    }
144    else if (atp == TAXON1_REQ_getdesignator) {
145       choice = Taxon1Req_getdesignator;
146       if (AsnReadVal(aip, atp, &av) <= 0) {
147          goto erret;
148       }
149       anp->data.ptrvalue = av.ptrvalue;
150    }
151    else if (atp == TAXON1_REQ_getunique) {
152       choice = Taxon1Req_getunique;
153       if (AsnReadVal(aip, atp, &av) <= 0) {
154          goto erret;
155       }
156       anp->data.ptrvalue = av.ptrvalue;
157    }
158    else if (atp == TAXON1_REQ_getidbyorg) {
159       choice = Taxon1Req_getidbyorg;
160       func = (AsnReadFunc) OrgRefAsnRead;
161    }
162    else if (atp == TAXON1_REQ_getorgnames) {
163       choice = Taxon1Req_getorgnames;
164       if (AsnReadVal(aip, atp, &av) <= 0) {
165          goto erret;
166       }
167       anp->data.intvalue = av.intvalue;
168    }
169    else if (atp == TAXON1_REQ_getcde) {
170       choice = Taxon1Req_getcde;
171       if (AsnReadVal(aip, atp, &av) <= 0) {
172          goto erret;
173       }
174       anp->data.boolvalue = av.boolvalue;
175    }
176    else if (atp == TAXON1_REQ_getranks) {
177       choice = Taxon1Req_getranks;
178       if (AsnReadVal(aip, atp, &av) <= 0) {
179          goto erret;
180       }
181       anp->data.boolvalue = av.boolvalue;
182    }
183    else if (atp == TAXON1_REQ_getdivs) {
184       choice = Taxon1Req_getdivs;
185       if (AsnReadVal(aip, atp, &av) <= 0) {
186          goto erret;
187       }
188       anp->data.boolvalue = av.boolvalue;
189    }
190    else if (atp == TAXON1_REQ_getgcs) {
191       choice = Taxon1Req_getgcs;
192       if (AsnReadVal(aip, atp, &av) <= 0) {
193          goto erret;
194       }
195       anp->data.boolvalue = av.boolvalue;
196    }
197    else if (atp == TAXON1_REQ_getlineage) {
198       choice = Taxon1Req_getlineage;
199       if (AsnReadVal(aip, atp, &av) <= 0) {
200          goto erret;
201       }
202       anp->data.intvalue = av.intvalue;
203    }
204    else if (atp == TAXON1_REQ_getchildren) {
205       choice = Taxon1Req_getchildren;
206       if (AsnReadVal(aip, atp, &av) <= 0) {
207          goto erret;
208       }
209       anp->data.intvalue = av.intvalue;
210    }
211    else if (atp == TAXON1_REQ_getbyid) {
212       choice = Taxon1Req_getbyid;
213       if (AsnReadVal(aip, atp, &av) <= 0) {
214          goto erret;
215       }
216       anp->data.intvalue = av.intvalue;
217    }
218    else if (atp == TAXON1_REQ_lookup) {
219       choice = Taxon1Req_lookup;
220       func = (AsnReadFunc) OrgRefAsnRead;
221    }
222    else if (atp == TAXON1_REQ_getorgmod) {
223       choice = Taxon1Req_getorgmod;
224       func = (AsnReadFunc) Taxon1InfoAsnRead;
225    }
226    else if (atp == TAXON1_REQ_fini) {
227       choice = Taxon1Req_fini;
228       if (AsnReadVal(aip, atp, &av) <= 0) {
229          goto erret;
230       }
231       anp->data.boolvalue = av.boolvalue;
232    }
233    else if (atp == TAXON1_REQ_id4gi) {
234       choice = Taxon1Req_id4gi;
235       if (AsnReadVal(aip, atp, &av) <= 0) {
236          goto erret;
237       }
238       anp->data.intvalue = av.intvalue;
239    }
240    else if (atp == TAXON1_REQ_taxachildren) {
241       choice = Taxon1Req_taxachildren;
242       if (AsnReadVal(aip, atp, &av) <= 0) {
243          goto erret;
244       }
245       anp->data.intvalue = av.intvalue;
246    }
247    else if (atp == TAXON1_REQ_taxalineage) {
248       choice = Taxon1Req_taxalineage;
249       if (AsnReadVal(aip, atp, &av) <= 0) {
250          goto erret;
251       }
252       anp->data.intvalue = av.intvalue;
253    }
254    else if (atp == TAXON1_REQ_maxtaxid) {
255       choice = Taxon1Req_maxtaxid;
256       if (AsnReadVal(aip, atp, &av) <= 0) {
257          goto erret;
258       }
259       anp->data.boolvalue = av.boolvalue;
260    }
261    else if (atp == TAXON1_REQ_getproptypes) {
262       choice = Taxon1Req_getproptypes;
263       if (AsnReadVal(aip, atp, &av) <= 0) {
264          goto erret;
265       }
266       anp->data.boolvalue = av.boolvalue;
267    }
268    else if (atp == TAXON1_REQ_getorgprop) {
269       choice = Taxon1Req_getorgprop;
270       func = (AsnReadFunc) Taxon1InfoAsnRead;
271    }
272    else if (atp == TAXON1_REQ_searchname) {
273       choice = Taxon1Req_searchname;
274       func = (AsnReadFunc) Taxon1InfoAsnRead;
275    }
276    else if (atp == TAXON1_REQ_dumpnames4class) {
277       choice = Taxon1Req_dumpnames4class;
278       if (AsnReadVal(aip, atp, &av) <= 0) {
279          goto erret;
280       }
281       anp->data.intvalue = av.intvalue;
282    }
283 
284    anp->choice = choice;
285    if (func != NULL)
286    {
287       anp->data.ptrvalue = (* func)(aip, atp);
288       if (aip -> io_failure) goto erret;
289 
290       if (nullIsError && anp->data.ptrvalue == NULL) {
291          goto erret;
292       }
293    }
294 
295 ret:
296    AsnUnlinkType(orig);       /* unlink local tree */
297    return anp;
298 
299 erret:
300    anp = MemFree(anp);
301    aip -> io_failure = TRUE;
302    goto ret;
303 }
304 
305 
306 /**************************************************
307 *
308 *    Taxon1ReqAsnWrite()
309 *
310 **************************************************/
311 NLM_EXTERN Boolean LIBCALL
Taxon1ReqAsnWrite(Taxon1ReqPtr anp,AsnIoPtr aip,AsnTypePtr orig)312 Taxon1ReqAsnWrite(Taxon1ReqPtr anp, AsnIoPtr aip, AsnTypePtr orig)
313 
314 {
315    DataVal av;
316    AsnTypePtr atp, writetype = NULL;
317    Pointer pnt;
318    AsnWriteFunc func = NULL;
319    Boolean retval = FALSE;
320 
321    if (! loaded)
322    {
323       if (! objtax1AsnLoad())
324       return FALSE;
325    }
326 
327    if (aip == NULL)
328    return FALSE;
329 
330    atp = AsnLinkType(orig, TAXON1_REQ);   /* link local tree */
331    if (atp == NULL) {
332       return FALSE;
333    }
334 
335    if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
336 
337    av.ptrvalue = (Pointer)anp;
338    if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
339       goto erret;
340    }
341 
342    pnt = anp->data.ptrvalue;
343    switch (anp->choice)
344    {
345    case Taxon1Req_init:
346       av.boolvalue = anp->data.boolvalue;
347       retval = AsnWrite(aip, TAXON1_REQ_init, &av);
348       break;
349    case Taxon1Req_findname:
350       av.ptrvalue = anp->data.ptrvalue;
351       retval = AsnWrite(aip, TAXON1_REQ_findname, &av);
352       break;
353    case Taxon1Req_getdesignator:
354       av.ptrvalue = anp->data.ptrvalue;
355       retval = AsnWrite(aip, TAXON1_REQ_getdesignator, &av);
356       break;
357    case Taxon1Req_getunique:
358       av.ptrvalue = anp->data.ptrvalue;
359       retval = AsnWrite(aip, TAXON1_REQ_getunique, &av);
360       break;
361    case Taxon1Req_getidbyorg:
362       writetype = TAXON1_REQ_getidbyorg;
363       func = (AsnWriteFunc) OrgRefAsnWrite;
364       break;
365    case Taxon1Req_getorgnames:
366       av.intvalue = anp->data.intvalue;
367       retval = AsnWrite(aip, TAXON1_REQ_getorgnames, &av);
368       break;
369    case Taxon1Req_getcde:
370       av.boolvalue = anp->data.boolvalue;
371       retval = AsnWrite(aip, TAXON1_REQ_getcde, &av);
372       break;
373    case Taxon1Req_getranks:
374       av.boolvalue = anp->data.boolvalue;
375       retval = AsnWrite(aip, TAXON1_REQ_getranks, &av);
376       break;
377    case Taxon1Req_getdivs:
378       av.boolvalue = anp->data.boolvalue;
379       retval = AsnWrite(aip, TAXON1_REQ_getdivs, &av);
380       break;
381    case Taxon1Req_getgcs:
382       av.boolvalue = anp->data.boolvalue;
383       retval = AsnWrite(aip, TAXON1_REQ_getgcs, &av);
384       break;
385    case Taxon1Req_getlineage:
386       av.intvalue = anp->data.intvalue;
387       retval = AsnWrite(aip, TAXON1_REQ_getlineage, &av);
388       break;
389    case Taxon1Req_getchildren:
390       av.intvalue = anp->data.intvalue;
391       retval = AsnWrite(aip, TAXON1_REQ_getchildren, &av);
392       break;
393    case Taxon1Req_getbyid:
394       av.intvalue = anp->data.intvalue;
395       retval = AsnWrite(aip, TAXON1_REQ_getbyid, &av);
396       break;
397    case Taxon1Req_lookup:
398       writetype = TAXON1_REQ_lookup;
399       func = (AsnWriteFunc) OrgRefAsnWrite;
400       break;
401    case Taxon1Req_getorgmod:
402       writetype = TAXON1_REQ_getorgmod;
403       func = (AsnWriteFunc) Taxon1InfoAsnWrite;
404       break;
405    case Taxon1Req_fini:
406       av.boolvalue = anp->data.boolvalue;
407       retval = AsnWrite(aip, TAXON1_REQ_fini, &av);
408       break;
409    case Taxon1Req_id4gi:
410       av.intvalue = anp->data.intvalue;
411       retval = AsnWrite(aip, TAXON1_REQ_id4gi, &av);
412       break;
413    case Taxon1Req_taxachildren:
414       av.intvalue = anp->data.intvalue;
415       retval = AsnWrite(aip, TAXON1_REQ_taxachildren, &av);
416       break;
417    case Taxon1Req_taxalineage:
418       av.intvalue = anp->data.intvalue;
419       retval = AsnWrite(aip, TAXON1_REQ_taxalineage, &av);
420       break;
421    case Taxon1Req_maxtaxid:
422       av.boolvalue = anp->data.boolvalue;
423       retval = AsnWrite(aip, TAXON1_REQ_maxtaxid, &av);
424       break;
425    case Taxon1Req_getproptypes:
426       av.boolvalue = anp->data.boolvalue;
427       retval = AsnWrite(aip, TAXON1_REQ_getproptypes, &av);
428       break;
429    case Taxon1Req_getorgprop:
430       writetype = TAXON1_REQ_getorgprop;
431       func = (AsnWriteFunc) Taxon1InfoAsnWrite;
432       break;
433    case Taxon1Req_searchname:
434       writetype = TAXON1_REQ_searchname;
435       func = (AsnWriteFunc) Taxon1InfoAsnWrite;
436       break;
437    case Taxon1Req_dumpnames4class:
438       av.intvalue = anp->data.intvalue;
439       retval = AsnWrite(aip, TAXON1_REQ_dumpnames4class, &av);
440       break;
441    }
442    if (writetype != NULL) {
443       retval = (* func)(pnt, aip, writetype);   /* write it out */
444    }
445    if (!retval) {
446       goto erret;
447    }
448    retval = TRUE;
449 
450 erret:
451    AsnUnlinkType(orig);       /* unlink local tree */
452    return retval;
453 }
454 
455 
456 /**************************************************
457 *
458 *    Taxon1InfoNew()
459 *
460 **************************************************/
461 NLM_EXTERN
462 Taxon1InfoPtr LIBCALL
Taxon1InfoNew(void)463 Taxon1InfoNew(void)
464 {
465    Taxon1InfoPtr ptr = MemNew((size_t) sizeof(Taxon1Info));
466 
467    return ptr;
468 
469 }
470 
471 
472 /**************************************************
473 *
474 *    Taxon1InfoFree()
475 *
476 **************************************************/
477 NLM_EXTERN
478 Taxon1InfoPtr LIBCALL
Taxon1InfoFree(Taxon1InfoPtr ptr)479 Taxon1InfoFree(Taxon1InfoPtr ptr)
480 {
481 
482    if(ptr == NULL) {
483       return NULL;
484    }
485    MemFree(ptr -> sval);
486    return MemFree(ptr);
487 }
488 
489 
490 /**************************************************
491 *
492 *    Taxon1InfoAsnRead()
493 *
494 **************************************************/
495 NLM_EXTERN
496 Taxon1InfoPtr LIBCALL
Taxon1InfoAsnRead(AsnIoPtr aip,AsnTypePtr orig)497 Taxon1InfoAsnRead(AsnIoPtr aip, AsnTypePtr orig)
498 {
499    DataVal av;
500    AsnTypePtr atp;
501    Boolean isError = FALSE;
502    AsnReadFunc func;
503    Taxon1InfoPtr ptr;
504 
505    if (! loaded)
506    {
507       if (! objtax1AsnLoad()) {
508          return NULL;
509       }
510    }
511 
512    if (aip == NULL) {
513       return NULL;
514    }
515 
516    if (orig == NULL) {         /* Taxon1Info ::= (self contained) */
517       atp = AsnReadId(aip, amp, TAXON1_INFO);
518    } else {
519       atp = AsnLinkType(orig, TAXON1_INFO);
520    }
521    /* link in local tree */
522    if (atp == NULL) {
523       return NULL;
524    }
525 
526    ptr = Taxon1InfoNew();
527    if (ptr == NULL) {
528       goto erret;
529    }
530    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
531       goto erret;
532    }
533 
534    atp = AsnReadId(aip,amp, atp);
535    func = NULL;
536 
537    if (atp == TAXON1_INFO_ival1) {
538       if ( AsnReadVal(aip, atp, &av) <= 0) {
539          goto erret;
540       }
541       ptr -> ival1 = av.intvalue;
542       atp = AsnReadId(aip,amp, atp);
543    }
544    if (atp == TAXON1_INFO_ival2) {
545       if ( AsnReadVal(aip, atp, &av) <= 0) {
546          goto erret;
547       }
548       ptr -> ival2 = av.intvalue;
549       atp = AsnReadId(aip,amp, atp);
550    }
551    if (atp == TAXON1_INFO_sval) {
552       if ( AsnReadVal(aip, atp, &av) <= 0) {
553          goto erret;
554       }
555       ptr -> sval = av.ptrvalue;
556       atp = AsnReadId(aip,amp, atp);
557    }
558 
559    if (AsnReadVal(aip, atp, &av) <= 0) {
560       goto erret;
561    }
562    /* end struct */
563 
564 ret:
565    AsnUnlinkType(orig);       /* unlink local tree */
566    return ptr;
567 
568 erret:
569    aip -> io_failure = TRUE;
570    ptr = Taxon1InfoFree(ptr);
571    goto ret;
572 }
573 
574 
575 
576 /**************************************************
577 *
578 *    Taxon1InfoAsnWrite()
579 *
580 **************************************************/
581 NLM_EXTERN Boolean LIBCALL
Taxon1InfoAsnWrite(Taxon1InfoPtr ptr,AsnIoPtr aip,AsnTypePtr orig)582 Taxon1InfoAsnWrite(Taxon1InfoPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
583 {
584    DataVal av;
585    AsnTypePtr atp;
586    Boolean retval = FALSE;
587 
588    if (! loaded)
589    {
590       if (! objtax1AsnLoad()) {
591          return FALSE;
592       }
593    }
594 
595    if (aip == NULL) {
596       return FALSE;
597    }
598 
599    atp = AsnLinkType(orig, TAXON1_INFO);   /* link local tree */
600    if (atp == NULL) {
601       return FALSE;
602    }
603 
604    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
605    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
606       goto erret;
607    }
608 
609    av.intvalue = ptr -> ival1;
610    retval = AsnWrite(aip, TAXON1_INFO_ival1,  &av);
611    av.intvalue = ptr -> ival2;
612    retval = AsnWrite(aip, TAXON1_INFO_ival2,  &av);
613    if (ptr -> sval != NULL) {
614       av.ptrvalue = ptr -> sval;
615       retval = AsnWrite(aip, TAXON1_INFO_sval,  &av);
616    }
617    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
618       goto erret;
619    }
620    retval = TRUE;
621 
622 erret:
623    AsnUnlinkType(orig);       /* unlink local tree */
624    return retval;
625 }
626 
627 
628 
629 /**************************************************
630 *
631 *    Taxon1RespFree()
632 *
633 **************************************************/
634 NLM_EXTERN
635 Taxon1RespPtr LIBCALL
Taxon1RespFree(ValNodePtr anp)636 Taxon1RespFree(ValNodePtr anp)
637 {
638    Pointer pnt;
639 
640    if (anp == NULL) {
641       return NULL;
642    }
643 
644    pnt = anp->data.ptrvalue;
645    switch (anp->choice)
646    {
647    default:
648       break;
649    case Taxon1Resp_error:
650       Taxon1ErrorFree(anp -> data.ptrvalue);
651       break;
652    case Taxon1Resp_getcde:
653    case Taxon1Resp_getranks:
654    case Taxon1Resp_getdivs:
655    case Taxon1Resp_getgcs:
656    case Taxon1Resp_getlineage:
657    case Taxon1Resp_getchildren:
658    case Taxon1Resp_getorgmod:
659    case Taxon1Resp_getproptypes:
660    case Taxon1Resp_getorgprop:
661       AsnGenericUserSeqOfFree((Pointer) pnt, (AsnOptFreeFunc) Taxon1InfoFree);
662       break;
663    case Taxon1Resp_getbyid:
664    case Taxon1Resp_lookup:
665       Taxon1DataFree(anp -> data.ptrvalue);
666       break;
667    case Taxon1Resp_taxabyid:
668       Taxon2DataFree(anp -> data.ptrvalue);
669       break;
670    case Taxon1Resp_findname:
671    case Taxon1Resp_getorgnames:
672    case Taxon1Resp_taxachildren:
673    case Taxon1Resp_taxalineage:
674    case Taxon1Resp_searchname:
675    case Taxon1Resp_dumpnames4class:
676       AsnGenericUserSeqOfFree((Pointer) pnt, (AsnOptFreeFunc) Taxon1NameFree);
677       break;
678    }
679    return MemFree(anp);
680 }
681 
682 
683 /**************************************************
684 *
685 *    Taxon1RespAsnRead()
686 *
687 **************************************************/
688 NLM_EXTERN
689 Taxon1RespPtr LIBCALL
Taxon1RespAsnRead(AsnIoPtr aip,AsnTypePtr orig)690 Taxon1RespAsnRead(AsnIoPtr aip, AsnTypePtr orig)
691 {
692    DataVal av;
693    AsnTypePtr atp;
694    ValNodePtr anp;
695    Uint1 choice;
696    Boolean isError = FALSE;
697    Boolean nullIsError = FALSE;
698    AsnReadFunc func;
699 
700    if (! loaded)
701    {
702       if (! objtax1AsnLoad()) {
703          return NULL;
704       }
705    }
706 
707    if (aip == NULL) {
708       return NULL;
709    }
710 
711    if (orig == NULL) {         /* Taxon1Resp ::= (self contained) */
712       atp = AsnReadId(aip, amp, TAXON1_RESP);
713    } else {
714       atp = AsnLinkType(orig, TAXON1_RESP);    /* link in local tree */
715    }
716    if (atp == NULL) {
717       return NULL;
718    }
719 
720    anp = ValNodeNew(NULL);
721    if (anp == NULL) {
722       goto erret;
723    }
724    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
725       goto erret;
726    }
727 
728    func = NULL;
729 
730    atp = AsnReadId(aip, amp, atp);  /* find the choice */
731    if (atp == NULL) {
732       goto erret;
733    }
734    if (atp == TAXON1_RESP_error) {
735       choice = Taxon1Resp_error;
736       func = (AsnReadFunc) Taxon1ErrorAsnRead;
737    }
738    else if (atp == TAXON1_RESP_init) {
739       choice = Taxon1Resp_init;
740       if (AsnReadVal(aip, atp, &av) <= 0) {
741          goto erret;
742       }
743       anp->data.boolvalue = av.boolvalue;
744    }
745    else if (atp == TAXON1_RESP_findname) {
746       choice = Taxon1Resp_findname;
747       anp -> data.ptrvalue =
748       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1NameAsnRead,             (AsnOptFreeFunc) Taxon1NameFree);
749       if (isError && anp -> data.ptrvalue == NULL) {
750          goto erret;
751       }
752    }
753    else if (atp == TAXON1_RESP_getdesignator) {
754       choice = Taxon1Resp_getdesignator;
755       if (AsnReadVal(aip, atp, &av) <= 0) {
756          goto erret;
757       }
758       anp->data.intvalue = av.intvalue;
759    }
760    else if (atp == TAXON1_RESP_getunique) {
761       choice = Taxon1Resp_getunique;
762       if (AsnReadVal(aip, atp, &av) <= 0) {
763          goto erret;
764       }
765       anp->data.intvalue = av.intvalue;
766    }
767    else if (atp == TAXON1_RESP_getidbyorg) {
768       choice = Taxon1Resp_getidbyorg;
769       if (AsnReadVal(aip, atp, &av) <= 0) {
770          goto erret;
771       }
772       anp->data.intvalue = av.intvalue;
773    }
774    else if (atp == TAXON1_RESP_getorgnames) {
775       choice = Taxon1Resp_getorgnames;
776       anp -> data.ptrvalue =
777       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1NameAsnRead,             (AsnOptFreeFunc) Taxon1NameFree);
778       if (isError && anp -> data.ptrvalue == NULL) {
779          goto erret;
780       }
781    }
782    else if (atp == TAXON1_RESP_getcde) {
783       choice = Taxon1Resp_getcde;
784       anp -> data.ptrvalue =
785       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1InfoAsnRead,             (AsnOptFreeFunc) Taxon1InfoFree);
786       if (isError && anp -> data.ptrvalue == NULL) {
787          goto erret;
788       }
789    }
790    else if (atp == TAXON1_RESP_getranks) {
791       choice = Taxon1Resp_getranks;
792       anp -> data.ptrvalue =
793       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1InfoAsnRead,             (AsnOptFreeFunc) Taxon1InfoFree);
794       if (isError && anp -> data.ptrvalue == NULL) {
795          goto erret;
796       }
797    }
798    else if (atp == TAXON1_RESP_getdivs) {
799       choice = Taxon1Resp_getdivs;
800       anp -> data.ptrvalue =
801       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1InfoAsnRead,             (AsnOptFreeFunc) Taxon1InfoFree);
802       if (isError && anp -> data.ptrvalue == NULL) {
803          goto erret;
804       }
805    }
806    else if (atp == TAXON1_RESP_getgcs) {
807       choice = Taxon1Resp_getgcs;
808       anp -> data.ptrvalue =
809       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1InfoAsnRead,             (AsnOptFreeFunc) Taxon1InfoFree);
810       if (isError && anp -> data.ptrvalue == NULL) {
811          goto erret;
812       }
813    }
814    else if (atp == TAXON1_RESP_getlineage) {
815       choice = Taxon1Resp_getlineage;
816       anp -> data.ptrvalue =
817       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1InfoAsnRead,             (AsnOptFreeFunc) Taxon1InfoFree);
818       if (isError && anp -> data.ptrvalue == NULL) {
819          goto erret;
820       }
821    }
822    else if (atp == TAXON1_RESP_getchildren) {
823       choice = Taxon1Resp_getchildren;
824       anp -> data.ptrvalue =
825       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1InfoAsnRead,             (AsnOptFreeFunc) Taxon1InfoFree);
826       if (isError && anp -> data.ptrvalue == NULL) {
827          goto erret;
828       }
829    }
830    else if (atp == TAXON1_RESP_getbyid) {
831       choice = Taxon1Resp_getbyid;
832       func = (AsnReadFunc) Taxon1DataAsnRead;
833    }
834    else if (atp == TAXON1_RESP_lookup) {
835       choice = Taxon1Resp_lookup;
836       func = (AsnReadFunc) Taxon1DataAsnRead;
837    }
838    else if (atp == TAXON1_RESP_getorgmod) {
839       choice = Taxon1Resp_getorgmod;
840       anp -> data.ptrvalue =
841       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1InfoAsnRead,             (AsnOptFreeFunc) Taxon1InfoFree);
842       if (isError && anp -> data.ptrvalue == NULL) {
843          goto erret;
844       }
845    }
846    else if (atp == TAXON1_RESP_fini) {
847       choice = Taxon1Resp_fini;
848       if (AsnReadVal(aip, atp, &av) <= 0) {
849          goto erret;
850       }
851       anp->data.boolvalue = av.boolvalue;
852    }
853    else if (atp == TAXON1_RESP_id4gi) {
854       choice = Taxon1Resp_id4gi;
855       if (AsnReadVal(aip, atp, &av) <= 0) {
856          goto erret;
857       }
858       anp->data.intvalue = av.intvalue;
859    }
860    else if (atp == TAXON1_RESP_taxabyid) {
861       choice = Taxon1Resp_taxabyid;
862       func = (AsnReadFunc) Taxon2DataAsnRead;
863    }
864    else if (atp == TAXON1_RESP_taxachildren) {
865       choice = Taxon1Resp_taxachildren;
866       anp -> data.ptrvalue =
867       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1NameAsnRead,             (AsnOptFreeFunc) Taxon1NameFree);
868       if (isError && anp -> data.ptrvalue == NULL) {
869          goto erret;
870       }
871    }
872    else if (atp == TAXON1_RESP_taxalineage) {
873       choice = Taxon1Resp_taxalineage;
874       anp -> data.ptrvalue =
875       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1NameAsnRead,             (AsnOptFreeFunc) Taxon1NameFree);
876       if (isError && anp -> data.ptrvalue == NULL) {
877          goto erret;
878       }
879    }
880    else if (atp == TAXON1_RESP_maxtaxid) {
881       choice = Taxon1Resp_maxtaxid;
882       if (AsnReadVal(aip, atp, &av) <= 0) {
883          goto erret;
884       }
885       anp->data.intvalue = av.intvalue;
886    }
887    else if (atp == TAXON1_RESP_getproptypes) {
888       choice = Taxon1Resp_getproptypes;
889       anp -> data.ptrvalue =
890       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1InfoAsnRead,             (AsnOptFreeFunc) Taxon1InfoFree);
891       if (isError && anp -> data.ptrvalue == NULL) {
892          goto erret;
893       }
894    }
895    else if (atp == TAXON1_RESP_getorgprop) {
896       choice = Taxon1Resp_getorgprop;
897       anp -> data.ptrvalue =
898       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1InfoAsnRead,             (AsnOptFreeFunc) Taxon1InfoFree);
899       if (isError && anp -> data.ptrvalue == NULL) {
900          goto erret;
901       }
902    }
903    else if (atp == TAXON1_RESP_searchname) {
904       choice = Taxon1Resp_searchname;
905       anp -> data.ptrvalue =
906       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1NameAsnRead,             (AsnOptFreeFunc) Taxon1NameFree);
907       if (isError && anp -> data.ptrvalue == NULL) {
908          goto erret;
909       }
910    }
911    else if (atp == TAXON1_RESP_dumpnames4class) {
912       choice = Taxon1Resp_dumpnames4class;
913       anp -> data.ptrvalue =
914       AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) Taxon1NameAsnRead,             (AsnOptFreeFunc) Taxon1NameFree);
915       if (isError && anp -> data.ptrvalue == NULL) {
916          goto erret;
917       }
918    }
919 
920    anp->choice = choice;
921    if (func != NULL)
922    {
923       anp->data.ptrvalue = (* func)(aip, atp);
924       if (aip -> io_failure) goto erret;
925 
926       if (nullIsError && anp->data.ptrvalue == NULL) {
927          goto erret;
928       }
929    }
930 
931 ret:
932    AsnUnlinkType(orig);       /* unlink local tree */
933    return anp;
934 
935 erret:
936    anp = MemFree(anp);
937    aip -> io_failure = TRUE;
938    goto ret;
939 }
940 
941 
942 /**************************************************
943 *
944 *    Taxon1RespAsnWrite()
945 *
946 **************************************************/
947 NLM_EXTERN Boolean LIBCALL
Taxon1RespAsnWrite(Taxon1RespPtr anp,AsnIoPtr aip,AsnTypePtr orig)948 Taxon1RespAsnWrite(Taxon1RespPtr anp, AsnIoPtr aip, AsnTypePtr orig)
949 
950 {
951    DataVal av;
952    AsnTypePtr atp, writetype = NULL;
953    Pointer pnt;
954    AsnWriteFunc func = NULL;
955    Boolean retval = FALSE;
956 
957    if (! loaded)
958    {
959       if (! objtax1AsnLoad())
960       return FALSE;
961    }
962 
963    if (aip == NULL)
964    return FALSE;
965 
966    atp = AsnLinkType(orig, TAXON1_RESP);   /* link local tree */
967    if (atp == NULL) {
968       return FALSE;
969    }
970 
971    if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
972 
973    av.ptrvalue = (Pointer)anp;
974    if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
975       goto erret;
976    }
977 
978    pnt = anp->data.ptrvalue;
979    switch (anp->choice)
980    {
981    case Taxon1Resp_error:
982       writetype = TAXON1_RESP_error;
983       func = (AsnWriteFunc) Taxon1ErrorAsnWrite;
984       break;
985    case Taxon1Resp_init:
986       av.boolvalue = anp->data.boolvalue;
987       retval = AsnWrite(aip, TAXON1_RESP_init, &av);
988       break;
989    case Taxon1Resp_findname:
990       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1NameAsnWrite, aip, TAXON1_RESP_findname, TAXON1_RESP_findname_E);
991       break;
992    case Taxon1Resp_getdesignator:
993       av.intvalue = anp->data.intvalue;
994       retval = AsnWrite(aip, TAXON1_RESP_getdesignator, &av);
995       break;
996    case Taxon1Resp_getunique:
997       av.intvalue = anp->data.intvalue;
998       retval = AsnWrite(aip, TAXON1_RESP_getunique, &av);
999       break;
1000    case Taxon1Resp_getidbyorg:
1001       av.intvalue = anp->data.intvalue;
1002       retval = AsnWrite(aip, TAXON1_RESP_getidbyorg, &av);
1003       break;
1004    case Taxon1Resp_getorgnames:
1005       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1NameAsnWrite, aip, TAXON1_RESP_getorgnames, TAXON1_RESP_getorgnames_E);
1006       break;
1007    case Taxon1Resp_getcde:
1008       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1InfoAsnWrite, aip, TAXON1_RESP_getcde, TAXON1_RESP_getcde_E);
1009       break;
1010    case Taxon1Resp_getranks:
1011       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1InfoAsnWrite, aip, TAXON1_RESP_getranks, TAXON1_RESP_getranks_E);
1012       break;
1013    case Taxon1Resp_getdivs:
1014       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1InfoAsnWrite, aip, TAXON1_RESP_getdivs, TAXON1_RESP_getdivs_E);
1015       break;
1016    case Taxon1Resp_getgcs:
1017       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1InfoAsnWrite, aip, TAXON1_RESP_getgcs, TAXON1_RESP_getgcs_E);
1018       break;
1019    case Taxon1Resp_getlineage:
1020       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1InfoAsnWrite, aip, TAXON1_RESP_getlineage, TAXON1_RESP_getlineage_E);
1021       break;
1022    case Taxon1Resp_getchildren:
1023       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1InfoAsnWrite, aip, TAXON1_RESP_getchildren, TAXON1_RESP_getchildren_E);
1024       break;
1025    case Taxon1Resp_getbyid:
1026       writetype = TAXON1_RESP_getbyid;
1027       func = (AsnWriteFunc) Taxon1DataAsnWrite;
1028       break;
1029    case Taxon1Resp_lookup:
1030       writetype = TAXON1_RESP_lookup;
1031       func = (AsnWriteFunc) Taxon1DataAsnWrite;
1032       break;
1033    case Taxon1Resp_getorgmod:
1034       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1InfoAsnWrite, aip, TAXON1_RESP_getorgmod, TAXON1_RESP_getorgmod_E);
1035       break;
1036    case Taxon1Resp_fini:
1037       av.boolvalue = anp->data.boolvalue;
1038       retval = AsnWrite(aip, TAXON1_RESP_fini, &av);
1039       break;
1040    case Taxon1Resp_id4gi:
1041       av.intvalue = anp->data.intvalue;
1042       retval = AsnWrite(aip, TAXON1_RESP_id4gi, &av);
1043       break;
1044    case Taxon1Resp_taxabyid:
1045       writetype = TAXON1_RESP_taxabyid;
1046       func = (AsnWriteFunc) Taxon2DataAsnWrite;
1047       break;
1048    case Taxon1Resp_taxachildren:
1049       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1NameAsnWrite, aip, TAXON1_RESP_taxachildren, TAXON1_RESP_taxachildren_E);
1050       break;
1051    case Taxon1Resp_taxalineage:
1052       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1NameAsnWrite, aip, TAXON1_RESP_taxalineage, TAXON1_RESP_taxalineage_E);
1053       break;
1054    case Taxon1Resp_maxtaxid:
1055       av.intvalue = anp->data.intvalue;
1056       retval = AsnWrite(aip, TAXON1_RESP_maxtaxid, &av);
1057       break;
1058    case Taxon1Resp_getproptypes:
1059       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1InfoAsnWrite, aip, TAXON1_RESP_getproptypes, TAXON1_RESP_getproptypes_E);
1060       break;
1061    case Taxon1Resp_getorgprop:
1062       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1InfoAsnWrite, aip, TAXON1_RESP_getorgprop, TAXON1_RESP_getorgprop_E);
1063       break;
1064    case Taxon1Resp_searchname:
1065       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1NameAsnWrite, aip, TAXON1_RESP_searchname, TAXON1_RESP_searchname_E);
1066       break;
1067    case Taxon1Resp_dumpnames4class:
1068       retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) Taxon1NameAsnWrite, aip, TAXON1_RESP_dumpnames4class, TAXON1_RESP_dumpnames4class_E);
1069       break;
1070    }
1071    if (writetype != NULL) {
1072       retval = (* func)(pnt, aip, writetype);   /* write it out */
1073    }
1074    if (!retval) {
1075       goto erret;
1076    }
1077    retval = TRUE;
1078 
1079 erret:
1080    AsnUnlinkType(orig);       /* unlink local tree */
1081    return retval;
1082 }
1083 
1084 
1085 /**************************************************
1086 *
1087 *    Taxon1ErrorNew()
1088 *
1089 **************************************************/
1090 NLM_EXTERN
1091 Taxon1ErrorPtr LIBCALL
Taxon1ErrorNew(void)1092 Taxon1ErrorNew(void)
1093 {
1094    Taxon1ErrorPtr ptr = MemNew((size_t) sizeof(Taxon1Error));
1095 
1096    return ptr;
1097 
1098 }
1099 
1100 
1101 /**************************************************
1102 *
1103 *    Taxon1ErrorFree()
1104 *
1105 **************************************************/
1106 NLM_EXTERN
1107 Taxon1ErrorPtr LIBCALL
Taxon1ErrorFree(Taxon1ErrorPtr ptr)1108 Taxon1ErrorFree(Taxon1ErrorPtr ptr)
1109 {
1110 
1111    if(ptr == NULL) {
1112       return NULL;
1113    }
1114    MemFree(ptr -> msg);
1115    return MemFree(ptr);
1116 }
1117 
1118 
1119 /**************************************************
1120 *
1121 *    Taxon1ErrorAsnRead()
1122 *
1123 **************************************************/
1124 NLM_EXTERN
1125 Taxon1ErrorPtr LIBCALL
Taxon1ErrorAsnRead(AsnIoPtr aip,AsnTypePtr orig)1126 Taxon1ErrorAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1127 {
1128    DataVal av;
1129    AsnTypePtr atp;
1130    Boolean isError = FALSE;
1131    AsnReadFunc func;
1132    Taxon1ErrorPtr ptr;
1133 
1134    if (! loaded)
1135    {
1136       if (! objtax1AsnLoad()) {
1137          return NULL;
1138       }
1139    }
1140 
1141    if (aip == NULL) {
1142       return NULL;
1143    }
1144 
1145    if (orig == NULL) {         /* Taxon1Error ::= (self contained) */
1146       atp = AsnReadId(aip, amp, TAXON1_ERROR);
1147    } else {
1148       atp = AsnLinkType(orig, TAXON1_ERROR);
1149    }
1150    /* link in local tree */
1151    if (atp == NULL) {
1152       return NULL;
1153    }
1154 
1155    ptr = Taxon1ErrorNew();
1156    if (ptr == NULL) {
1157       goto erret;
1158    }
1159    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1160       goto erret;
1161    }
1162 
1163    atp = AsnReadId(aip,amp, atp);
1164    func = NULL;
1165 
1166    if (atp == TAXON1_ERROR_level) {
1167       if ( AsnReadVal(aip, atp, &av) <= 0) {
1168          goto erret;
1169       }
1170       ptr -> level = av.intvalue;
1171       atp = AsnReadId(aip,amp, atp);
1172    }
1173    if (atp == TAXON1_ERROR_msg) {
1174       if ( AsnReadVal(aip, atp, &av) <= 0) {
1175          goto erret;
1176       }
1177       ptr -> msg = av.ptrvalue;
1178       atp = AsnReadId(aip,amp, atp);
1179    }
1180 
1181    if (AsnReadVal(aip, atp, &av) <= 0) {
1182       goto erret;
1183    }
1184    /* end struct */
1185 
1186 ret:
1187    AsnUnlinkType(orig);       /* unlink local tree */
1188    return ptr;
1189 
1190 erret:
1191    aip -> io_failure = TRUE;
1192    ptr = Taxon1ErrorFree(ptr);
1193    goto ret;
1194 }
1195 
1196 
1197 
1198 /**************************************************
1199 *
1200 *    Taxon1ErrorAsnWrite()
1201 *
1202 **************************************************/
1203 NLM_EXTERN Boolean LIBCALL
Taxon1ErrorAsnWrite(Taxon1ErrorPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1204 Taxon1ErrorAsnWrite(Taxon1ErrorPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1205 {
1206    DataVal av;
1207    AsnTypePtr atp;
1208    Boolean retval = FALSE;
1209 
1210    if (! loaded)
1211    {
1212       if (! objtax1AsnLoad()) {
1213          return FALSE;
1214       }
1215    }
1216 
1217    if (aip == NULL) {
1218       return FALSE;
1219    }
1220 
1221    atp = AsnLinkType(orig, TAXON1_ERROR);   /* link local tree */
1222    if (atp == NULL) {
1223       return FALSE;
1224    }
1225 
1226    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1227    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1228       goto erret;
1229    }
1230 
1231    av.intvalue = ptr -> level;
1232    retval = AsnWrite(aip, TAXON1_ERROR_level,  &av);
1233    if (ptr -> msg != NULL) {
1234       av.ptrvalue = ptr -> msg;
1235       retval = AsnWrite(aip, TAXON1_ERROR_msg,  &av);
1236    }
1237    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1238       goto erret;
1239    }
1240    retval = TRUE;
1241 
1242 erret:
1243    AsnUnlinkType(orig);       /* unlink local tree */
1244    return retval;
1245 }
1246 
1247 
1248 
1249 /**************************************************
1250 *
1251 *    Taxon1NameNew()
1252 *
1253 **************************************************/
1254 NLM_EXTERN
1255 Taxon1NamePtr LIBCALL
Taxon1NameNew(void)1256 Taxon1NameNew(void)
1257 {
1258    Taxon1NamePtr ptr = MemNew((size_t) sizeof(Taxon1Name));
1259 
1260    return ptr;
1261 
1262 }
1263 
1264 
1265 /**************************************************
1266 *
1267 *    Taxon1NameFree()
1268 *
1269 **************************************************/
1270 NLM_EXTERN
1271 Taxon1NamePtr LIBCALL
Taxon1NameFree(Taxon1NamePtr ptr)1272 Taxon1NameFree(Taxon1NamePtr ptr)
1273 {
1274 
1275    if(ptr == NULL) {
1276       return NULL;
1277    }
1278    MemFree(ptr -> oname);
1279    MemFree(ptr -> uname);
1280    return MemFree(ptr);
1281 }
1282 
1283 
1284 /**************************************************
1285 *
1286 *    Taxon1NameAsnRead()
1287 *
1288 **************************************************/
1289 NLM_EXTERN
1290 Taxon1NamePtr LIBCALL
Taxon1NameAsnRead(AsnIoPtr aip,AsnTypePtr orig)1291 Taxon1NameAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1292 {
1293    DataVal av;
1294    AsnTypePtr atp;
1295    Boolean isError = FALSE;
1296    AsnReadFunc func;
1297    Taxon1NamePtr ptr;
1298 
1299    if (! loaded)
1300    {
1301       if (! objtax1AsnLoad()) {
1302          return NULL;
1303       }
1304    }
1305 
1306    if (aip == NULL) {
1307       return NULL;
1308    }
1309 
1310    if (orig == NULL) {         /* Taxon1Name ::= (self contained) */
1311       atp = AsnReadId(aip, amp, TAXON1_NAME);
1312    } else {
1313       atp = AsnLinkType(orig, TAXON1_NAME);
1314    }
1315    /* link in local tree */
1316    if (atp == NULL) {
1317       return NULL;
1318    }
1319 
1320    ptr = Taxon1NameNew();
1321    if (ptr == NULL) {
1322       goto erret;
1323    }
1324    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1325       goto erret;
1326    }
1327 
1328    atp = AsnReadId(aip,amp, atp);
1329    func = NULL;
1330 
1331    if (atp == TAXON1_NAME_taxid) {
1332       if ( AsnReadVal(aip, atp, &av) <= 0) {
1333          goto erret;
1334       }
1335       ptr -> taxid = av.intvalue;
1336       atp = AsnReadId(aip,amp, atp);
1337    }
1338    if (atp == TAXON1_NAME_cde) {
1339       if ( AsnReadVal(aip, atp, &av) <= 0) {
1340          goto erret;
1341       }
1342       ptr -> cde = av.intvalue;
1343       atp = AsnReadId(aip,amp, atp);
1344    }
1345    if (atp == TAXON1_NAME_oname) {
1346       if ( AsnReadVal(aip, atp, &av) <= 0) {
1347          goto erret;
1348       }
1349       ptr -> oname = av.ptrvalue;
1350       atp = AsnReadId(aip,amp, atp);
1351    }
1352    if (atp == TAXON1_NAME_uname) {
1353       if ( AsnReadVal(aip, atp, &av) <= 0) {
1354          goto erret;
1355       }
1356       ptr -> uname = av.ptrvalue;
1357       atp = AsnReadId(aip,amp, atp);
1358    }
1359 
1360    if (AsnReadVal(aip, atp, &av) <= 0) {
1361       goto erret;
1362    }
1363    /* end struct */
1364 
1365 ret:
1366    AsnUnlinkType(orig);       /* unlink local tree */
1367    return ptr;
1368 
1369 erret:
1370    aip -> io_failure = TRUE;
1371    ptr = Taxon1NameFree(ptr);
1372    goto ret;
1373 }
1374 
1375 
1376 
1377 /**************************************************
1378 *
1379 *    Taxon1NameAsnWrite()
1380 *
1381 **************************************************/
1382 NLM_EXTERN Boolean LIBCALL
Taxon1NameAsnWrite(Taxon1NamePtr ptr,AsnIoPtr aip,AsnTypePtr orig)1383 Taxon1NameAsnWrite(Taxon1NamePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1384 {
1385    DataVal av;
1386    AsnTypePtr atp;
1387    Boolean retval = FALSE;
1388 
1389    if (! loaded)
1390    {
1391       if (! objtax1AsnLoad()) {
1392          return FALSE;
1393       }
1394    }
1395 
1396    if (aip == NULL) {
1397       return FALSE;
1398    }
1399 
1400    atp = AsnLinkType(orig, TAXON1_NAME);   /* link local tree */
1401    if (atp == NULL) {
1402       return FALSE;
1403    }
1404 
1405    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1406    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1407       goto erret;
1408    }
1409 
1410    av.intvalue = ptr -> taxid;
1411    retval = AsnWrite(aip, TAXON1_NAME_taxid,  &av);
1412    av.intvalue = ptr -> cde;
1413    retval = AsnWrite(aip, TAXON1_NAME_cde,  &av);
1414    if (ptr -> oname != NULL) {
1415       av.ptrvalue = ptr -> oname;
1416       retval = AsnWrite(aip, TAXON1_NAME_oname,  &av);
1417    }
1418    if (ptr -> uname != NULL) {
1419       av.ptrvalue = ptr -> uname;
1420       retval = AsnWrite(aip, TAXON1_NAME_uname,  &av);
1421    }
1422    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1423       goto erret;
1424    }
1425    retval = TRUE;
1426 
1427 erret:
1428    AsnUnlinkType(orig);       /* unlink local tree */
1429    return retval;
1430 }
1431 
1432 
1433 
1434 /**************************************************
1435 *
1436 *    Taxon1DataNew()
1437 *
1438 **************************************************/
1439 NLM_EXTERN
1440 Taxon1DataPtr LIBCALL
Taxon1DataNew(void)1441 Taxon1DataNew(void)
1442 {
1443    Taxon1DataPtr ptr = MemNew((size_t) sizeof(Taxon1Data));
1444 
1445    return ptr;
1446 
1447 }
1448 
1449 
1450 /**************************************************
1451 *
1452 *    Taxon1DataFree()
1453 *
1454 **************************************************/
1455 NLM_EXTERN
1456 Taxon1DataPtr LIBCALL
Taxon1DataFree(Taxon1DataPtr ptr)1457 Taxon1DataFree(Taxon1DataPtr ptr)
1458 {
1459 
1460    if(ptr == NULL) {
1461       return NULL;
1462    }
1463    OrgRefFree(ptr -> org);
1464    MemFree(ptr -> div);
1465    MemFree(ptr -> embl_code);
1466    return MemFree(ptr);
1467 }
1468 
1469 
1470 /**************************************************
1471 *
1472 *    Taxon1DataAsnRead()
1473 *
1474 **************************************************/
1475 NLM_EXTERN
1476 Taxon1DataPtr LIBCALL
Taxon1DataAsnRead(AsnIoPtr aip,AsnTypePtr orig)1477 Taxon1DataAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1478 {
1479    DataVal av;
1480    AsnTypePtr atp;
1481    Boolean isError = FALSE;
1482    AsnReadFunc func;
1483    Taxon1DataPtr ptr;
1484 
1485    if (! loaded)
1486    {
1487       if (! objtax1AsnLoad()) {
1488          return NULL;
1489       }
1490    }
1491 
1492    if (aip == NULL) {
1493       return NULL;
1494    }
1495 
1496    if (orig == NULL) {         /* Taxon1Data ::= (self contained) */
1497       atp = AsnReadId(aip, amp, TAXON1_DATA);
1498    } else {
1499       atp = AsnLinkType(orig, TAXON1_DATA);
1500    }
1501    /* link in local tree */
1502    if (atp == NULL) {
1503       return NULL;
1504    }
1505 
1506    ptr = Taxon1DataNew();
1507    if (ptr == NULL) {
1508       goto erret;
1509    }
1510    if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1511       goto erret;
1512    }
1513 
1514    atp = AsnReadId(aip,amp, atp);
1515    func = NULL;
1516 
1517    if (atp == TAXON1_DATA_org) {
1518       ptr -> org = OrgRefAsnRead(aip, atp);
1519       if (aip -> io_failure) {
1520          goto erret;
1521       }
1522       atp = AsnReadId(aip,amp, atp);
1523    }
1524    if (atp == TAXON1_DATA_div) {
1525       if ( AsnReadVal(aip, atp, &av) <= 0) {
1526          goto erret;
1527       }
1528       ptr -> div = av.ptrvalue;
1529       atp = AsnReadId(aip,amp, atp);
1530    }
1531    if (atp == TAXON1_DATA_embl_code) {
1532       if ( AsnReadVal(aip, atp, &av) <= 0) {
1533          goto erret;
1534       }
1535       ptr -> embl_code = av.ptrvalue;
1536       atp = AsnReadId(aip,amp, atp);
1537    }
1538    if (atp == TAXON1_DATA_is_species_level) {
1539       if ( AsnReadVal(aip, atp, &av) <= 0) {
1540          goto erret;
1541       }
1542       ptr -> is_species_level = av.boolvalue;
1543       atp = AsnReadId(aip,amp, atp);
1544    }
1545 
1546    if (AsnReadVal(aip, atp, &av) <= 0) {
1547       goto erret;
1548    }
1549    /* end struct */
1550 
1551 ret:
1552    AsnUnlinkType(orig);       /* unlink local tree */
1553    return ptr;
1554 
1555 erret:
1556    aip -> io_failure = TRUE;
1557    ptr = Taxon1DataFree(ptr);
1558    goto ret;
1559 }
1560 
1561 
1562 
1563 /**************************************************
1564 *
1565 *    Taxon1DataAsnWrite()
1566 *
1567 **************************************************/
1568 NLM_EXTERN Boolean LIBCALL
Taxon1DataAsnWrite(Taxon1DataPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1569 Taxon1DataAsnWrite(Taxon1DataPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1570 {
1571    DataVal av;
1572    AsnTypePtr atp;
1573    Boolean retval = FALSE;
1574 
1575    if (! loaded)
1576    {
1577       if (! objtax1AsnLoad()) {
1578          return FALSE;
1579       }
1580    }
1581 
1582    if (aip == NULL) {
1583       return FALSE;
1584    }
1585 
1586    atp = AsnLinkType(orig, TAXON1_DATA);   /* link local tree */
1587    if (atp == NULL) {
1588       return FALSE;
1589    }
1590 
1591    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1592    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1593       goto erret;
1594    }
1595 
1596    if (ptr -> org != NULL) {
1597       if ( ! OrgRefAsnWrite(ptr -> org, aip, TAXON1_DATA_org)) {
1598          goto erret;
1599       }
1600    }
1601    if (ptr -> div != NULL) {
1602       av.ptrvalue = ptr -> div;
1603       retval = AsnWrite(aip, TAXON1_DATA_div,  &av);
1604    }
1605    if (ptr -> embl_code != NULL) {
1606       av.ptrvalue = ptr -> embl_code;
1607       retval = AsnWrite(aip, TAXON1_DATA_embl_code,  &av);
1608    }
1609    av.boolvalue = ptr -> is_species_level;
1610    retval = AsnWrite(aip, TAXON1_DATA_is_species_level,  &av);
1611    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1612       goto erret;
1613    }
1614    retval = TRUE;
1615 
1616 erret:
1617    AsnUnlinkType(orig);       /* unlink local tree */
1618    return retval;
1619 }
1620 
1621 
1622 
1623 /**************************************************
1624 *
1625 *    Taxon2DataNew()
1626 *
1627 **************************************************/
1628 NLM_EXTERN
1629 Taxon2DataPtr LIBCALL
Taxon2DataNew(void)1630 Taxon2DataNew(void)
1631 {
1632    Taxon2DataPtr ptr = MemNew((size_t) sizeof(Taxon2Data));
1633 
1634    return ptr;
1635 
1636 }
1637 
1638 
1639 /**************************************************
1640 *
1641 *    Taxon2DataFree()
1642 *
1643 **************************************************/
1644 NLM_EXTERN
1645 Taxon2DataPtr LIBCALL
Taxon2DataFree(Taxon2DataPtr ptr)1646 Taxon2DataFree(Taxon2DataPtr ptr)
1647 {
1648 
1649    if(ptr == NULL) {
1650       return NULL;
1651    }
1652    OrgRefFree(ptr -> org);
1653    AsnGenericBaseSeqOfFree(ptr -> blast_name ,ASNCODE_PTRVAL_SLOT);
1654    return MemFree(ptr);
1655 }
1656 
1657 
1658 /**************************************************
1659 *
1660 *    Taxon2DataAsnRead()
1661 *
1662 **************************************************/
1663 NLM_EXTERN
1664 Taxon2DataPtr LIBCALL
Taxon2DataAsnRead(AsnIoPtr aip,AsnTypePtr orig)1665 Taxon2DataAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1666 {
1667    DataVal av;
1668    AsnTypePtr atp;
1669    Boolean isError = FALSE;
1670    AsnReadFunc func;
1671    Taxon2DataPtr ptr;
1672 
1673    if (! loaded)
1674    {
1675       if (! objtax1AsnLoad()) {
1676          return NULL;
1677       }
1678    }
1679 
1680    if (aip == NULL) {
1681       return NULL;
1682    }
1683 
1684    if (orig == NULL) {         /* Taxon2Data ::= (self contained) */
1685       atp = AsnReadId(aip, amp, TAXON2_DATA);
1686    } else {
1687       atp = AsnLinkType(orig, TAXON2_DATA);
1688    }
1689    /* link in local tree */
1690    if (atp == NULL) {
1691       return NULL;
1692    }
1693 
1694    ptr = Taxon2DataNew();
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 == TAXON2_DATA_org) {
1706       ptr -> org = OrgRefAsnRead(aip, atp);
1707       if (aip -> io_failure) {
1708          goto erret;
1709       }
1710       atp = AsnReadId(aip,amp, atp);
1711    }
1712    if (atp == TAXON2_DATA_blast_name) {
1713       ptr -> blast_name = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
1714       if (isError && ptr -> blast_name == NULL) {
1715          goto erret;
1716       }
1717       atp = AsnReadId(aip,amp, atp);
1718    }
1719    if (atp == TAXON2_DATA_is_uncultured) {
1720       if ( AsnReadVal(aip, atp, &av) <= 0) {
1721          goto erret;
1722       }
1723       ptr -> is_uncultured = av.boolvalue;
1724       atp = AsnReadId(aip,amp, atp);
1725    }
1726    if (atp == TAXON2_DATA_is_species_level) {
1727       if ( AsnReadVal(aip, atp, &av) <= 0) {
1728          goto erret;
1729       }
1730       ptr -> is_species_level = av.boolvalue;
1731       atp = AsnReadId(aip,amp, atp);
1732    }
1733 
1734    if (AsnReadVal(aip, atp, &av) <= 0) {
1735       goto erret;
1736    }
1737    /* end struct */
1738 
1739 ret:
1740    AsnUnlinkType(orig);       /* unlink local tree */
1741    return ptr;
1742 
1743 erret:
1744    aip -> io_failure = TRUE;
1745    ptr = Taxon2DataFree(ptr);
1746    goto ret;
1747 }
1748 
1749 
1750 
1751 /**************************************************
1752 *
1753 *    Taxon2DataAsnWrite()
1754 *
1755 **************************************************/
1756 NLM_EXTERN Boolean LIBCALL
Taxon2DataAsnWrite(Taxon2DataPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1757 Taxon2DataAsnWrite(Taxon2DataPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1758 {
1759    DataVal av;
1760    AsnTypePtr atp;
1761    Boolean retval = FALSE;
1762 
1763    if (! loaded)
1764    {
1765       if (! objtax1AsnLoad()) {
1766          return FALSE;
1767       }
1768    }
1769 
1770    if (aip == NULL) {
1771       return FALSE;
1772    }
1773 
1774    atp = AsnLinkType(orig, TAXON2_DATA);   /* link local tree */
1775    if (atp == NULL) {
1776       return FALSE;
1777    }
1778 
1779    if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1780    if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1781       goto erret;
1782    }
1783 
1784    if (ptr -> org != NULL) {
1785       if ( ! OrgRefAsnWrite(ptr -> org, aip, TAXON2_DATA_org)) {
1786          goto erret;
1787       }
1788    }
1789    retval = AsnGenericBaseSeqOfAsnWrite(ptr -> blast_name ,ASNCODE_PTRVAL_SLOT, aip, TAXON2_DATA_blast_name, TAXON2_DATA_blast_name_E);
1790    av.boolvalue = ptr -> is_uncultured;
1791    retval = AsnWrite(aip, TAXON2_DATA_is_uncultured,  &av);
1792    av.boolvalue = ptr -> is_species_level;
1793    retval = AsnWrite(aip, TAXON2_DATA_is_species_level,  &av);
1794    if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1795       goto erret;
1796    }
1797    retval = TRUE;
1798 
1799 erret:
1800    AsnUnlinkType(orig);       /* unlink local tree */
1801    return retval;
1802 }
1803 
1804