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