1 #include <asn.h>
2
3 #define NLM_GENERATED_CODE_PROTO
4
5 #include <objsset.h>
6 #include <objmmdb1.h>
7 #include <objmmdb3.h>
8 #include <objcn3d.h>
9 #include <objcdd.h>
10 #include <objscoremat.h>
11
12 static Boolean loaded = FALSE;
13
14 #include <cdd.h>
15
16 #ifndef NLM_EXTERN_LOADS
17 #define NLM_EXTERN_LOADS {}
18 #endif
19
20 NLM_EXTERN Boolean LIBCALL
objcddAsnLoad(void)21 objcddAsnLoad(void)
22 {
23
24 if ( ! loaded) {
25 NLM_EXTERN_LOADS
26
27 if ( ! AsnLoad ())
28 return FALSE;
29 loaded = TRUE;
30 }
31
32 return TRUE;
33 }
34
35
36
37 /**************************************************
38 * Generated object loaders for Module NCBI-Cdd
39 * Generated using ASNCODE Revision: 6.16 at Aug 21, 2008 10:43 AM
40 *
41 **************************************************/
42
43
44 /**************************************************
45 *
46 * CddIdFree()
47 *
48 **************************************************/
49 NLM_EXTERN
50 CddIdPtr LIBCALL
CddIdFree(ValNodePtr anp)51 CddIdFree(ValNodePtr anp)
52 {
53 Pointer pnt;
54
55 if (anp == NULL) {
56 return NULL;
57 }
58
59 pnt = anp->data.ptrvalue;
60 switch (anp->choice)
61 {
62 default:
63 break;
64 case CddId_gid:
65 GlobalIdFree(anp -> data.ptrvalue);
66 break;
67 }
68 return MemFree(anp);
69 }
70
71
72 /**************************************************
73 *
74 * CddIdAsnRead()
75 *
76 **************************************************/
77 NLM_EXTERN
78 CddIdPtr LIBCALL
CddIdAsnRead(AsnIoPtr aip,AsnTypePtr orig)79 CddIdAsnRead(AsnIoPtr aip, AsnTypePtr orig)
80 {
81 DataVal av;
82 AsnTypePtr atp;
83 ValNodePtr anp;
84 Uint1 choice;
85 Boolean isError = FALSE;
86 Boolean nullIsError = FALSE;
87 AsnReadFunc func;
88
89 if (! loaded)
90 {
91 if (! objcddAsnLoad()) {
92 return NULL;
93 }
94 }
95
96 if (aip == NULL) {
97 return NULL;
98 }
99
100 if (orig == NULL) { /* CddId ::= (self contained) */
101 atp = AsnReadId(aip, amp, CDD_ID);
102 } else {
103 atp = AsnLinkType(orig, CDD_ID); /* link in local tree */
104 }
105 if (atp == NULL) {
106 return NULL;
107 }
108
109 anp = ValNodeNew(NULL);
110 if (anp == NULL) {
111 goto erret;
112 }
113 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
114 goto erret;
115 }
116
117 func = NULL;
118
119 atp = AsnReadId(aip, amp, atp); /* find the choice */
120 if (atp == NULL) {
121 goto erret;
122 }
123 if (atp == CDD_ID_uid) {
124 choice = CddId_uid;
125 if (AsnReadVal(aip, atp, &av) <= 0) {
126 goto erret;
127 }
128 anp->data.intvalue = av.intvalue;
129 }
130 else if (atp == CDD_ID_gid) {
131 choice = CddId_gid;
132 func = (AsnReadFunc) GlobalIdAsnRead;
133 }
134 anp->choice = choice;
135 if (func != NULL)
136 {
137 anp->data.ptrvalue = (* func)(aip, atp);
138 if (aip -> io_failure) goto erret;
139
140 if (nullIsError && anp->data.ptrvalue == NULL) {
141 goto erret;
142 }
143 }
144
145 ret:
146 AsnUnlinkType(orig); /* unlink local tree */
147 return anp;
148
149 erret:
150 anp = MemFree(anp);
151 aip -> io_failure = TRUE;
152 goto ret;
153 }
154
155
156 /**************************************************
157 *
158 * CddIdAsnWrite()
159 *
160 **************************************************/
161 NLM_EXTERN Boolean LIBCALL
CddIdAsnWrite(CddIdPtr anp,AsnIoPtr aip,AsnTypePtr orig)162 CddIdAsnWrite(CddIdPtr anp, AsnIoPtr aip, AsnTypePtr orig)
163
164 {
165 DataVal av;
166 AsnTypePtr atp, writetype = NULL;
167 Pointer pnt;
168 AsnWriteFunc func = NULL;
169 Boolean retval = FALSE;
170
171 if (! loaded)
172 {
173 if (! objcddAsnLoad())
174 return FALSE;
175 }
176
177 if (aip == NULL)
178 return FALSE;
179
180 atp = AsnLinkType(orig, CDD_ID); /* link local tree */
181 if (atp == NULL) {
182 return FALSE;
183 }
184
185 if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
186 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
187 av.ptrvalue = (Pointer)anp;
188 if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
189 goto erret;
190 }
191
192 pnt = anp->data.ptrvalue;
193 switch (anp->choice)
194 {
195 case CddId_uid:
196 av.intvalue = anp->data.intvalue;
197 retval = AsnWrite(aip, CDD_ID_uid, &av);
198 break;
199 case CddId_gid:
200 writetype = CDD_ID_gid;
201 func = (AsnWriteFunc) GlobalIdAsnWrite;
202 break;
203 }
204 if (writetype != NULL) {
205 retval = (* func)(pnt, aip, writetype); /* write it out */
206 }
207 if (!retval) {
208 goto erret;
209 }
210 retval = TRUE;
211
212 erret:
213 AsnUnlinkType(orig); /* unlink local tree */
214 return retval;
215 }
216
217
218 /**************************************************
219 *
220 * CddIdSetFree()
221 *
222 **************************************************/
223 NLM_EXTERN
224 CddIdSetPtr LIBCALL
CddIdSetFree(CddIdSetPtr ptr)225 CddIdSetFree(CddIdSetPtr ptr)
226 {
227
228 if(ptr == NULL) {
229 return NULL;
230 }
231 AsnGenericChoiceSeqOfFree(ptr, (AsnOptFreeFunc) CddIdFree);
232 return NULL;
233 }
234
235
236 /**************************************************
237 *
238 * CddIdSetAsnRead()
239 *
240 **************************************************/
241 NLM_EXTERN
242 CddIdSetPtr LIBCALL
CddIdSetAsnRead(AsnIoPtr aip,AsnTypePtr orig)243 CddIdSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
244 {
245 DataVal av;
246 AsnTypePtr atp;
247 Boolean isError = FALSE;
248 AsnReadFunc func;
249 CddIdSetPtr ptr;
250
251 if (! loaded)
252 {
253 if (! objcddAsnLoad()) {
254 return NULL;
255 }
256 }
257
258 if (aip == NULL) {
259 return NULL;
260 }
261
262 if (orig == NULL) { /* CddIdSet ::= (self contained) */
263 atp = AsnReadId(aip, amp, CDD_ID_SET);
264 } else {
265 atp = AsnLinkType(orig, CDD_ID_SET);
266 }
267 /* link in local tree */
268 if (atp == NULL) {
269 return NULL;
270 }
271
272 func = NULL;
273
274 ptr = AsnGenericChoiceSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) CddIdAsnRead, (AsnOptFreeFunc) CddIdFree);
275 if (isError && ptr == NULL) {
276 goto erret;
277 }
278
279
280
281 ret:
282 AsnUnlinkType(orig); /* unlink local tree */
283 return ptr;
284
285 erret:
286 aip -> io_failure = TRUE;
287 ptr = CddIdSetFree(ptr);
288 goto ret;
289 }
290
291
292
293 /**************************************************
294 *
295 * CddIdSetAsnWrite()
296 *
297 **************************************************/
298 NLM_EXTERN Boolean LIBCALL
CddIdSetAsnWrite(CddIdSetPtr ptr,AsnIoPtr aip,AsnTypePtr orig)299 CddIdSetAsnWrite(CddIdSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
300 {
301 DataVal av;
302 AsnTypePtr atp;
303 Boolean retval = FALSE;
304
305 if (! loaded)
306 {
307 if (! objcddAsnLoad()) {
308 return FALSE;
309 }
310 }
311
312 if (aip == NULL) {
313 return FALSE;
314 }
315
316 atp = AsnLinkType(orig, CDD_ID_SET); /* link local tree */
317 if (atp == NULL) {
318 return FALSE;
319 }
320
321 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
322 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
323 retval = AsnGenericChoiceSeqOfAsnWrite(ptr , (AsnWriteFunc) CddIdAsnWrite, aip, atp, CDD_ID_SET_E);
324 retval = TRUE;
325
326 erret:
327 AsnUnlinkType(orig); /* unlink local tree */
328 return retval;
329 }
330
331
332
333 /**************************************************
334 *
335 * CddNew()
336 *
337 **************************************************/
338 NLM_EXTERN
339 CddPtr LIBCALL
CddNew(void)340 CddNew(void)
341 {
342 CddPtr ptr = MemNew((size_t) sizeof(Cdd));
343
344 return ptr;
345
346 }
347
348
349 /**************************************************
350 *
351 * CddFree()
352 *
353 **************************************************/
354 NLM_EXTERN
355 CddPtr LIBCALL
CddFree(CddPtr ptr)356 CddFree(CddPtr ptr)
357 {
358
359 if(ptr == NULL) {
360 return NULL;
361 }
362 MemFree(ptr -> name);
363 CddIdSetFree(ptr -> id);
364 CddDescrSetFree(ptr -> description);
365 { SeqAnnotPtr sap, next; sap = ptr -> seqannot; while(sap) { next = sap->next; sap->next = NULL; sap = SeqAnnotFree(sap); sap = next; } }
366 BiostrucAnnotSetFree(ptr -> features);
367 SeqEntryFree(ptr -> sequences);
368 SeqIntFree(ptr -> profile_range);
369 BioseqFree(ptr -> trunc_master);
370 MatrixFree(ptr -> posfreq);
371 MatrixFree(ptr -> scoremat);
372 TriangleFree(ptr -> distance);
373 CddIdFree(ptr -> parent);
374 CddIdSetFree(ptr -> children);
375 CddIdSetFree(ptr -> siblings);
376 CddIdSetFree(ptr -> neighbors);
377 AsnGenericUserSeqOfFree(ptr -> pending, (AsnOptFreeFunc) UpdateAlignFree);
378 AsnGenericUserSeqOfFree(ptr -> rejects, (AsnOptFreeFunc) RejectIdFree);
379 AsnGenericChoiceSeqOfFree(ptr -> master3d, (AsnOptFreeFunc) SeqIdFree);
380 AlignAnnotSetFree(ptr -> alignannot);
381 Cn3dStyleDictionaryFree(ptr -> style_dictionary);
382 Cn3dUserAnnotationsFree(ptr -> user_annotations);
383 AsnGenericUserSeqOfFree(ptr -> ancestors, (AsnOptFreeFunc) DomainParentFree);
384 PssmWithParametersFree(ptr -> scoreparams);
385 SequenceTreeFree(ptr -> seqtree);
386 return MemFree(ptr);
387 }
388
389
390 /**************************************************
391 *
392 * CddAsnRead()
393 *
394 **************************************************/
395 NLM_EXTERN
396 CddPtr LIBCALL
CddAsnRead(AsnIoPtr aip,AsnTypePtr orig)397 CddAsnRead(AsnIoPtr aip, AsnTypePtr orig)
398 {
399 DataVal av;
400 AsnTypePtr atp;
401 Boolean isError = FALSE;
402 AsnReadFunc func;
403 CddPtr ptr;
404
405 if (! loaded)
406 {
407 if (! objcddAsnLoad()) {
408 return NULL;
409 }
410 }
411
412 if (aip == NULL) {
413 return NULL;
414 }
415
416 if (orig == NULL) { /* Cdd ::= (self contained) */
417 atp = AsnReadId(aip, amp, CDD);
418 } else {
419 atp = AsnLinkType(orig, CDD);
420 }
421 /* link in local tree */
422 if (atp == NULL) {
423 return NULL;
424 }
425
426 ptr = CddNew();
427 if (ptr == NULL) {
428 goto erret;
429 }
430 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
431 goto erret;
432 }
433
434 atp = AsnReadId(aip,amp, atp);
435 func = NULL;
436
437 if (atp == CDD_name) {
438 if ( AsnReadVal(aip, atp, &av) <= 0) {
439 goto erret;
440 }
441 ptr -> name = av.ptrvalue;
442 atp = AsnReadId(aip,amp, atp);
443 }
444 if (atp == CDD_id) {
445 ptr -> id = CddIdSetAsnRead(aip, atp);
446 if (aip -> io_failure) {
447 goto erret;
448 }
449 atp = AsnReadId(aip,amp, atp);
450 }
451 if (atp == CDD_description) {
452 ptr -> description = CddDescrSetAsnRead(aip, atp);
453 if (aip -> io_failure) {
454 goto erret;
455 }
456 atp = AsnReadId(aip,amp, atp);
457 }
458 if (atp == CDD_seqannot) {
459 ptr -> seqannot = SeqAnnotSetAsnRead(aip,CDD_seqannot,CDD_seqannot_E);
460 if (isError && ptr -> seqannot == NULL) {
461 goto erret;
462 }
463 atp = AsnReadId(aip,amp, atp);
464 }
465 if (atp == CDD_features) {
466 ptr -> features = BiostrucAnnotSetAsnRead(aip, atp);
467 if (aip -> io_failure) {
468 goto erret;
469 }
470 atp = AsnReadId(aip,amp, atp);
471 }
472 if (atp == CDD_sequences) {
473 ptr -> sequences = SeqEntryAsnRead(aip, atp);
474 if (aip -> io_failure) {
475 goto erret;
476 }
477 atp = AsnReadId(aip,amp, atp);
478 }
479 if (atp == CDD_profile_range) {
480 ptr -> profile_range = SeqIntAsnRead(aip, atp);
481 if (aip -> io_failure) {
482 goto erret;
483 }
484 atp = AsnReadId(aip,amp, atp);
485 }
486 if (atp == CDD_trunc_master) {
487 ptr -> trunc_master = BioseqAsnRead(aip, atp);
488 if (aip -> io_failure) {
489 goto erret;
490 }
491 atp = AsnReadId(aip,amp, atp);
492 }
493 if (atp == CDD_posfreq) {
494 ptr -> posfreq = MatrixAsnRead(aip, atp);
495 if (aip -> io_failure) {
496 goto erret;
497 }
498 atp = AsnReadId(aip,amp, atp);
499 }
500 if (atp == CDD_scoremat) {
501 ptr -> scoremat = MatrixAsnRead(aip, atp);
502 if (aip -> io_failure) {
503 goto erret;
504 }
505 atp = AsnReadId(aip,amp, atp);
506 }
507 if (atp == CDD_distance) {
508 ptr -> distance = TriangleAsnRead(aip, atp);
509 if (aip -> io_failure) {
510 goto erret;
511 }
512 atp = AsnReadId(aip,amp, atp);
513 }
514 if (atp == CDD_parent) {
515 ptr -> parent = CddIdAsnRead(aip, atp);
516 if (aip -> io_failure) {
517 goto erret;
518 }
519 atp = AsnReadId(aip,amp, atp);
520 }
521 if (atp == CDD_children) {
522 ptr -> children = CddIdSetAsnRead(aip, atp);
523 if (aip -> io_failure) {
524 goto erret;
525 }
526 atp = AsnReadId(aip,amp, atp);
527 }
528 if (atp == CDD_siblings) {
529 ptr -> siblings = CddIdSetAsnRead(aip, atp);
530 if (aip -> io_failure) {
531 goto erret;
532 }
533 atp = AsnReadId(aip,amp, atp);
534 }
535 if (atp == CDD_neighbors) {
536 ptr -> neighbors = CddIdSetAsnRead(aip, atp);
537 if (aip -> io_failure) {
538 goto erret;
539 }
540 atp = AsnReadId(aip,amp, atp);
541 }
542 if (atp == CDD_pending) {
543 ptr -> pending = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) UpdateAlignAsnRead, (AsnOptFreeFunc) UpdateAlignFree);
544 if (isError && ptr -> pending == NULL) {
545 goto erret;
546 }
547 atp = AsnReadId(aip,amp, atp);
548 }
549 if (atp == CDD_rejects) {
550 ptr -> rejects = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) RejectIdAsnRead, (AsnOptFreeFunc) RejectIdFree);
551 if (isError && ptr -> rejects == NULL) {
552 goto erret;
553 }
554 atp = AsnReadId(aip,amp, atp);
555 }
556 if (atp == CDD_master3d) {
557 ptr -> master3d = AsnGenericChoiceSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) SeqIdAsnRead, (AsnOptFreeFunc) SeqIdFree);
558 if (isError && ptr -> master3d == NULL) {
559 goto erret;
560 }
561 atp = AsnReadId(aip,amp, atp);
562 }
563 if (atp == CDD_alignannot) {
564 ptr -> alignannot = AlignAnnotSetAsnRead(aip, atp);
565 if (aip -> io_failure) {
566 goto erret;
567 }
568 atp = AsnReadId(aip,amp, atp);
569 }
570 if (atp == CDD_style_dictionary) {
571 ptr -> style_dictionary = Cn3dStyleDictionaryAsnRead(aip, atp);
572 if (aip -> io_failure) {
573 goto erret;
574 }
575 atp = AsnReadId(aip,amp, atp);
576 }
577 if (atp == CDD_user_annotations) {
578 ptr -> user_annotations = Cn3dUserAnnotationsAsnRead(aip, atp);
579 if (aip -> io_failure) {
580 goto erret;
581 }
582 atp = AsnReadId(aip,amp, atp);
583 }
584 if (atp == CDD_ancestors) {
585 ptr -> ancestors = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) DomainParentAsnRead, (AsnOptFreeFunc) DomainParentFree);
586 if (isError && ptr -> ancestors == NULL) {
587 goto erret;
588 }
589 atp = AsnReadId(aip,amp, atp);
590 }
591 if (atp == CDD_scoreparams) {
592 ptr -> scoreparams = PssmWithParametersAsnRead(aip, atp);
593 if (aip -> io_failure) {
594 goto erret;
595 }
596 atp = AsnReadId(aip,amp, atp);
597 }
598 if (atp == CDD_seqtree) {
599 ptr -> seqtree = SequenceTreeAsnRead(aip, atp);
600 if (aip -> io_failure) {
601 goto erret;
602 }
603 atp = AsnReadId(aip,amp, atp);
604 }
605
606 if (AsnReadVal(aip, atp, &av) <= 0) {
607 goto erret;
608 }
609 /* end struct */
610
611 ret:
612 AsnUnlinkType(orig); /* unlink local tree */
613 return ptr;
614
615 erret:
616 aip -> io_failure = TRUE;
617 ptr = CddFree(ptr);
618 goto ret;
619 }
620
621
622
623 /**************************************************
624 *
625 * CddAsnWrite()
626 *
627 **************************************************/
628 NLM_EXTERN Boolean LIBCALL
CddAsnWrite(CddPtr ptr,AsnIoPtr aip,AsnTypePtr orig)629 CddAsnWrite(CddPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
630 {
631 DataVal av;
632 AsnTypePtr atp;
633 Boolean retval = FALSE;
634
635 if (! loaded)
636 {
637 if (! objcddAsnLoad()) {
638 return FALSE;
639 }
640 }
641
642 if (aip == NULL) {
643 return FALSE;
644 }
645
646 atp = AsnLinkType(orig, CDD); /* link local tree */
647 if (atp == NULL) {
648 return FALSE;
649 }
650
651 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
652 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
653 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
654 goto erret;
655 }
656
657 if (ptr -> name != NULL) {
658 av.ptrvalue = ptr -> name;
659 retval = AsnWrite(aip, CDD_name, &av);
660 }
661 if (ptr -> id != NULL) {
662 if ( ! CddIdSetAsnWrite(ptr -> id, aip, CDD_id)) {
663 goto erret;
664 }
665 }
666 if (ptr -> description != NULL) {
667 if ( ! CddDescrSetAsnWrite(ptr -> description, aip, CDD_description)) {
668 goto erret;
669 }
670 }
671 if (ptr->seqannot != NULL) if (SeqAnnotSetAsnWrite(ptr->seqannot,aip,CDD_seqannot,CDD_seqannot_E)==FALSE) goto erret;
672 if (ptr -> features != NULL) {
673 if ( ! BiostrucAnnotSetAsnWrite(ptr -> features, aip, CDD_features)) {
674 goto erret;
675 }
676 }
677 if (ptr -> sequences != NULL) {
678 if ( ! SeqEntryAsnWrite(ptr -> sequences, aip, CDD_sequences)) {
679 goto erret;
680 }
681 }
682 if (ptr -> profile_range != NULL) {
683 if ( ! SeqIntAsnWrite(ptr -> profile_range, aip, CDD_profile_range)) {
684 goto erret;
685 }
686 }
687 if (ptr -> trunc_master != NULL) {
688 if ( ! BioseqAsnWrite(ptr -> trunc_master, aip, CDD_trunc_master)) {
689 goto erret;
690 }
691 }
692 if (ptr -> posfreq != NULL) {
693 if ( ! MatrixAsnWrite(ptr -> posfreq, aip, CDD_posfreq)) {
694 goto erret;
695 }
696 }
697 if (ptr -> scoremat != NULL) {
698 if ( ! MatrixAsnWrite(ptr -> scoremat, aip, CDD_scoremat)) {
699 goto erret;
700 }
701 }
702 if (ptr -> distance != NULL) {
703 if ( ! TriangleAsnWrite(ptr -> distance, aip, CDD_distance)) {
704 goto erret;
705 }
706 }
707 if (ptr -> parent != NULL) {
708 if ( ! CddIdAsnWrite(ptr -> parent, aip, CDD_parent)) {
709 goto erret;
710 }
711 }
712 if (ptr -> children != NULL) {
713 if ( ! CddIdSetAsnWrite(ptr -> children, aip, CDD_children)) {
714 goto erret;
715 }
716 }
717 if (ptr -> siblings != NULL) {
718 if ( ! CddIdSetAsnWrite(ptr -> siblings, aip, CDD_siblings)) {
719 goto erret;
720 }
721 }
722 if (ptr -> neighbors != NULL) {
723 if ( ! CddIdSetAsnWrite(ptr -> neighbors, aip, CDD_neighbors)) {
724 goto erret;
725 }
726 }
727 AsnGenericUserSeqOfAsnWrite(ptr -> pending, (AsnWriteFunc) UpdateAlignAsnWrite, aip, CDD_pending, CDD_pending_E);
728 AsnGenericUserSeqOfAsnWrite(ptr -> rejects, (AsnWriteFunc) RejectIdAsnWrite, aip, CDD_rejects, CDD_rejects_E);
729 AsnGenericChoiceSeqOfAsnWrite(ptr -> master3d, (AsnWriteFunc) SeqIdAsnWrite, aip, CDD_master3d, CDD_master3d_E);
730 if (ptr -> alignannot != NULL) {
731 if ( ! AlignAnnotSetAsnWrite(ptr -> alignannot, aip, CDD_alignannot)) {
732 goto erret;
733 }
734 }
735 if (ptr -> style_dictionary != NULL) {
736 if ( ! Cn3dStyleDictionaryAsnWrite(ptr -> style_dictionary, aip, CDD_style_dictionary)) {
737 goto erret;
738 }
739 }
740 if (ptr -> user_annotations != NULL) {
741 if ( ! Cn3dUserAnnotationsAsnWrite(ptr -> user_annotations, aip, CDD_user_annotations)) {
742 goto erret;
743 }
744 }
745 AsnGenericUserSeqOfAsnWrite(ptr -> ancestors, (AsnWriteFunc) DomainParentAsnWrite, aip, CDD_ancestors, CDD_ancestors_E);
746 if (ptr -> scoreparams != NULL) {
747 if ( ! PssmWithParametersAsnWrite(ptr -> scoreparams, aip, CDD_scoreparams)) {
748 goto erret;
749 }
750 }
751 if (ptr -> seqtree != NULL) {
752 if ( ! SequenceTreeAsnWrite(ptr -> seqtree, aip, CDD_seqtree)) {
753 goto erret;
754 }
755 }
756 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
757 goto erret;
758 }
759 retval = TRUE;
760
761 erret:
762 AsnUnlinkType(orig); /* unlink local tree */
763 return retval;
764 }
765
766
767
768 /**************************************************
769 *
770 * CddSetFree()
771 *
772 **************************************************/
773 NLM_EXTERN
774 CddSetPtr LIBCALL
CddSetFree(CddSetPtr ptr)775 CddSetFree(CddSetPtr ptr)
776 {
777
778 if(ptr == NULL) {
779 return NULL;
780 }
781 AsnGenericUserSeqOfFree(ptr, (AsnOptFreeFunc) CddFree);
782 return NULL;
783 }
784
785
786 /**************************************************
787 *
788 * CddSetAsnRead()
789 *
790 **************************************************/
791 NLM_EXTERN
792 CddSetPtr LIBCALL
CddSetAsnRead(AsnIoPtr aip,AsnTypePtr orig)793 CddSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
794 {
795 DataVal av;
796 AsnTypePtr atp;
797 Boolean isError = FALSE;
798 AsnReadFunc func;
799 CddSetPtr ptr;
800
801 if (! loaded)
802 {
803 if (! objcddAsnLoad()) {
804 return NULL;
805 }
806 }
807
808 if (aip == NULL) {
809 return NULL;
810 }
811
812 if (orig == NULL) { /* CddSet ::= (self contained) */
813 atp = AsnReadId(aip, amp, CDD_SET);
814 } else {
815 atp = AsnLinkType(orig, CDD_SET);
816 }
817 /* link in local tree */
818 if (atp == NULL) {
819 return NULL;
820 }
821
822 func = NULL;
823
824 ptr = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) CddAsnRead, (AsnOptFreeFunc) CddFree);
825 if (isError && ptr == NULL) {
826 goto erret;
827 }
828
829
830
831 ret:
832 AsnUnlinkType(orig); /* unlink local tree */
833 return ptr;
834
835 erret:
836 aip -> io_failure = TRUE;
837 ptr = CddSetFree(ptr);
838 goto ret;
839 }
840
841
842
843 /**************************************************
844 *
845 * CddSetAsnWrite()
846 *
847 **************************************************/
848 NLM_EXTERN Boolean LIBCALL
CddSetAsnWrite(CddSetPtr ptr,AsnIoPtr aip,AsnTypePtr orig)849 CddSetAsnWrite(CddSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
850 {
851 DataVal av;
852 AsnTypePtr atp;
853 Boolean retval = FALSE;
854
855 if (! loaded)
856 {
857 if (! objcddAsnLoad()) {
858 return FALSE;
859 }
860 }
861
862 if (aip == NULL) {
863 return FALSE;
864 }
865
866 atp = AsnLinkType(orig, CDD_SET); /* link local tree */
867 if (atp == NULL) {
868 return FALSE;
869 }
870
871 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
872 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
873 retval = AsnGenericUserSeqOfAsnWrite(ptr , (AsnWriteFunc) CddAsnWrite, aip, atp, CDD_SET_E);
874 retval = TRUE;
875
876 erret:
877 AsnUnlinkType(orig); /* unlink local tree */
878 return retval;
879 }
880
881
882
883 /**************************************************
884 *
885 * CddTreeNew()
886 *
887 **************************************************/
888 NLM_EXTERN
889 CddTreePtr LIBCALL
CddTreeNew(void)890 CddTreeNew(void)
891 {
892 CddTreePtr ptr = MemNew((size_t) sizeof(CddTree));
893
894 return ptr;
895
896 }
897
898
899 /**************************************************
900 *
901 * CddTreeFree()
902 *
903 **************************************************/
904 NLM_EXTERN
905 CddTreePtr LIBCALL
CddTreeFree(CddTreePtr ptr)906 CddTreeFree(CddTreePtr ptr)
907 {
908
909 if(ptr == NULL) {
910 return NULL;
911 }
912 MemFree(ptr -> name);
913 CddIdSetFree(ptr -> id);
914 CddDescrSetFree(ptr -> description);
915 CddIdFree(ptr -> parent);
916 CddIdSetFree(ptr -> children);
917 CddIdSetFree(ptr -> siblings);
918 CddIdSetFree(ptr -> neighbors);
919 return MemFree(ptr);
920 }
921
922
923 /**************************************************
924 *
925 * CddTreeAsnRead()
926 *
927 **************************************************/
928 NLM_EXTERN
929 CddTreePtr LIBCALL
CddTreeAsnRead(AsnIoPtr aip,AsnTypePtr orig)930 CddTreeAsnRead(AsnIoPtr aip, AsnTypePtr orig)
931 {
932 DataVal av;
933 AsnTypePtr atp;
934 Boolean isError = FALSE;
935 AsnReadFunc func;
936 CddTreePtr ptr;
937
938 if (! loaded)
939 {
940 if (! objcddAsnLoad()) {
941 return NULL;
942 }
943 }
944
945 if (aip == NULL) {
946 return NULL;
947 }
948
949 if (orig == NULL) { /* CddTree ::= (self contained) */
950 atp = AsnReadId(aip, amp, CDD_TREE);
951 } else {
952 atp = AsnLinkType(orig, CDD_TREE);
953 }
954 /* link in local tree */
955 if (atp == NULL) {
956 return NULL;
957 }
958
959 ptr = CddTreeNew();
960 if (ptr == NULL) {
961 goto erret;
962 }
963 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
964 goto erret;
965 }
966
967 atp = AsnReadId(aip,amp, atp);
968 func = NULL;
969
970 if (atp == CDD_TREE_name) {
971 if ( AsnReadVal(aip, atp, &av) <= 0) {
972 goto erret;
973 }
974 ptr -> name = av.ptrvalue;
975 atp = AsnReadId(aip,amp, atp);
976 }
977 if (atp == CDD_TREE_id) {
978 ptr -> id = CddIdSetAsnRead(aip, atp);
979 if (aip -> io_failure) {
980 goto erret;
981 }
982 atp = AsnReadId(aip,amp, atp);
983 }
984 if (atp == CDD_TREE_description) {
985 ptr -> description = CddDescrSetAsnRead(aip, atp);
986 if (aip -> io_failure) {
987 goto erret;
988 }
989 atp = AsnReadId(aip,amp, atp);
990 }
991 if (atp == CDD_TREE_parent) {
992 ptr -> parent = CddIdAsnRead(aip, atp);
993 if (aip -> io_failure) {
994 goto erret;
995 }
996 atp = AsnReadId(aip,amp, atp);
997 }
998 if (atp == CDD_TREE_children) {
999 ptr -> children = CddIdSetAsnRead(aip, atp);
1000 if (aip -> io_failure) {
1001 goto erret;
1002 }
1003 atp = AsnReadId(aip,amp, atp);
1004 }
1005 if (atp == CDD_TREE_siblings) {
1006 ptr -> siblings = CddIdSetAsnRead(aip, atp);
1007 if (aip -> io_failure) {
1008 goto erret;
1009 }
1010 atp = AsnReadId(aip,amp, atp);
1011 }
1012 if (atp == CDD_TREE_neighbors) {
1013 ptr -> neighbors = CddIdSetAsnRead(aip, atp);
1014 if (aip -> io_failure) {
1015 goto erret;
1016 }
1017 atp = AsnReadId(aip,amp, atp);
1018 }
1019
1020 if (AsnReadVal(aip, atp, &av) <= 0) {
1021 goto erret;
1022 }
1023 /* end struct */
1024
1025 ret:
1026 AsnUnlinkType(orig); /* unlink local tree */
1027 return ptr;
1028
1029 erret:
1030 aip -> io_failure = TRUE;
1031 ptr = CddTreeFree(ptr);
1032 goto ret;
1033 }
1034
1035
1036
1037 /**************************************************
1038 *
1039 * CddTreeAsnWrite()
1040 *
1041 **************************************************/
1042 NLM_EXTERN Boolean LIBCALL
CddTreeAsnWrite(CddTreePtr ptr,AsnIoPtr aip,AsnTypePtr orig)1043 CddTreeAsnWrite(CddTreePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1044 {
1045 DataVal av;
1046 AsnTypePtr atp;
1047 Boolean retval = FALSE;
1048
1049 if (! loaded)
1050 {
1051 if (! objcddAsnLoad()) {
1052 return FALSE;
1053 }
1054 }
1055
1056 if (aip == NULL) {
1057 return FALSE;
1058 }
1059
1060 atp = AsnLinkType(orig, CDD_TREE); /* link local tree */
1061 if (atp == NULL) {
1062 return FALSE;
1063 }
1064
1065 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1066 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1067 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1068 goto erret;
1069 }
1070
1071 if (ptr -> name != NULL) {
1072 av.ptrvalue = ptr -> name;
1073 retval = AsnWrite(aip, CDD_TREE_name, &av);
1074 }
1075 if (ptr -> id != NULL) {
1076 if ( ! CddIdSetAsnWrite(ptr -> id, aip, CDD_TREE_id)) {
1077 goto erret;
1078 }
1079 }
1080 if (ptr -> description != NULL) {
1081 if ( ! CddDescrSetAsnWrite(ptr -> description, aip, CDD_TREE_description)) {
1082 goto erret;
1083 }
1084 }
1085 if (ptr -> parent != NULL) {
1086 if ( ! CddIdAsnWrite(ptr -> parent, aip, CDD_TREE_parent)) {
1087 goto erret;
1088 }
1089 }
1090 if (ptr -> children != NULL) {
1091 if ( ! CddIdSetAsnWrite(ptr -> children, aip, CDD_TREE_children)) {
1092 goto erret;
1093 }
1094 }
1095 if (ptr -> siblings != NULL) {
1096 if ( ! CddIdSetAsnWrite(ptr -> siblings, aip, CDD_TREE_siblings)) {
1097 goto erret;
1098 }
1099 }
1100 if (ptr -> neighbors != NULL) {
1101 if ( ! CddIdSetAsnWrite(ptr -> neighbors, aip, CDD_TREE_neighbors)) {
1102 goto erret;
1103 }
1104 }
1105 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1106 goto erret;
1107 }
1108 retval = TRUE;
1109
1110 erret:
1111 AsnUnlinkType(orig); /* unlink local tree */
1112 return retval;
1113 }
1114
1115
1116
1117 /**************************************************
1118 *
1119 * CddTreeSetFree()
1120 *
1121 **************************************************/
1122 NLM_EXTERN
1123 CddTreeSetPtr LIBCALL
CddTreeSetFree(CddTreeSetPtr ptr)1124 CddTreeSetFree(CddTreeSetPtr ptr)
1125 {
1126
1127 if(ptr == NULL) {
1128 return NULL;
1129 }
1130 AsnGenericUserSeqOfFree(ptr, (AsnOptFreeFunc) CddTreeFree);
1131 return NULL;
1132 }
1133
1134
1135 /**************************************************
1136 *
1137 * CddTreeSetAsnRead()
1138 *
1139 **************************************************/
1140 NLM_EXTERN
1141 CddTreeSetPtr LIBCALL
CddTreeSetAsnRead(AsnIoPtr aip,AsnTypePtr orig)1142 CddTreeSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1143 {
1144 DataVal av;
1145 AsnTypePtr atp;
1146 Boolean isError = FALSE;
1147 AsnReadFunc func;
1148 CddTreeSetPtr ptr;
1149
1150 if (! loaded)
1151 {
1152 if (! objcddAsnLoad()) {
1153 return NULL;
1154 }
1155 }
1156
1157 if (aip == NULL) {
1158 return NULL;
1159 }
1160
1161 if (orig == NULL) { /* CddTreeSet ::= (self contained) */
1162 atp = AsnReadId(aip, amp, CDD_TREE_SET);
1163 } else {
1164 atp = AsnLinkType(orig, CDD_TREE_SET);
1165 }
1166 /* link in local tree */
1167 if (atp == NULL) {
1168 return NULL;
1169 }
1170
1171 func = NULL;
1172
1173 ptr = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) CddTreeAsnRead, (AsnOptFreeFunc) CddTreeFree);
1174 if (isError && ptr == NULL) {
1175 goto erret;
1176 }
1177
1178
1179
1180 ret:
1181 AsnUnlinkType(orig); /* unlink local tree */
1182 return ptr;
1183
1184 erret:
1185 aip -> io_failure = TRUE;
1186 ptr = CddTreeSetFree(ptr);
1187 goto ret;
1188 }
1189
1190
1191
1192 /**************************************************
1193 *
1194 * CddTreeSetAsnWrite()
1195 *
1196 **************************************************/
1197 NLM_EXTERN Boolean LIBCALL
CddTreeSetAsnWrite(CddTreeSetPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1198 CddTreeSetAsnWrite(CddTreeSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1199 {
1200 DataVal av;
1201 AsnTypePtr atp;
1202 Boolean retval = FALSE;
1203
1204 if (! loaded)
1205 {
1206 if (! objcddAsnLoad()) {
1207 return FALSE;
1208 }
1209 }
1210
1211 if (aip == NULL) {
1212 return FALSE;
1213 }
1214
1215 atp = AsnLinkType(orig, CDD_TREE_SET); /* link local tree */
1216 if (atp == NULL) {
1217 return FALSE;
1218 }
1219
1220 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1221 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1222 retval = AsnGenericUserSeqOfAsnWrite(ptr , (AsnWriteFunc) CddTreeAsnWrite, aip, atp, CDD_TREE_SET_E);
1223 retval = TRUE;
1224
1225 erret:
1226 AsnUnlinkType(orig); /* unlink local tree */
1227 return retval;
1228 }
1229
1230
1231
1232 /**************************************************
1233 *
1234 * CddPrefNodesNew()
1235 *
1236 **************************************************/
1237 NLM_EXTERN
1238 CddPrefNodesPtr LIBCALL
CddPrefNodesNew(void)1239 CddPrefNodesNew(void)
1240 {
1241 CddPrefNodesPtr ptr = MemNew((size_t) sizeof(CddPrefNodes));
1242
1243 return ptr;
1244
1245 }
1246
1247
1248 /**************************************************
1249 *
1250 * CddPrefNodesFree()
1251 *
1252 **************************************************/
1253 NLM_EXTERN
1254 CddPrefNodesPtr LIBCALL
CddPrefNodesFree(CddPrefNodesPtr ptr)1255 CddPrefNodesFree(CddPrefNodesPtr ptr)
1256 {
1257
1258 if(ptr == NULL) {
1259 return NULL;
1260 }
1261 CddOrgRefSetFree(ptr -> preferred_nodes);
1262 CddOrgRefSetFree(ptr -> model_organisms);
1263 CddOrgRefSetFree(ptr -> optional_nodes);
1264 CddPrefNodeDescrSetFree(ptr -> description);
1265 return MemFree(ptr);
1266 }
1267
1268
1269 /**************************************************
1270 *
1271 * CddPrefNodesAsnRead()
1272 *
1273 **************************************************/
1274 NLM_EXTERN
1275 CddPrefNodesPtr LIBCALL
CddPrefNodesAsnRead(AsnIoPtr aip,AsnTypePtr orig)1276 CddPrefNodesAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1277 {
1278 DataVal av;
1279 AsnTypePtr atp;
1280 Boolean isError = FALSE;
1281 AsnReadFunc func;
1282 CddPrefNodesPtr ptr;
1283
1284 if (! loaded)
1285 {
1286 if (! objcddAsnLoad()) {
1287 return NULL;
1288 }
1289 }
1290
1291 if (aip == NULL) {
1292 return NULL;
1293 }
1294
1295 if (orig == NULL) { /* CddPrefNodes ::= (self contained) */
1296 atp = AsnReadId(aip, amp, CDD_PREF_NODES);
1297 } else {
1298 atp = AsnLinkType(orig, CDD_PREF_NODES);
1299 }
1300 /* link in local tree */
1301 if (atp == NULL) {
1302 return NULL;
1303 }
1304
1305 ptr = CddPrefNodesNew();
1306 if (ptr == NULL) {
1307 goto erret;
1308 }
1309 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1310 goto erret;
1311 }
1312
1313 atp = AsnReadId(aip,amp, atp);
1314 func = NULL;
1315
1316 if (atp == CDD_PREF_NODES_preferred_nodes) {
1317 ptr -> preferred_nodes = CddOrgRefSetAsnRead(aip, atp);
1318 if (aip -> io_failure) {
1319 goto erret;
1320 }
1321 atp = AsnReadId(aip,amp, atp);
1322 }
1323 if (atp == CDD_PREF_NODES_model_organisms) {
1324 ptr -> model_organisms = CddOrgRefSetAsnRead(aip, atp);
1325 if (aip -> io_failure) {
1326 goto erret;
1327 }
1328 atp = AsnReadId(aip,amp, atp);
1329 }
1330 if (atp == CDD_PREF_NODES_optional_nodes) {
1331 ptr -> optional_nodes = CddOrgRefSetAsnRead(aip, atp);
1332 if (aip -> io_failure) {
1333 goto erret;
1334 }
1335 atp = AsnReadId(aip,amp, atp);
1336 }
1337 if (atp == CDD_PREF_NODES_description) {
1338 ptr -> description = CddPrefNodeDescrSetAsnRead(aip, atp);
1339 if (aip -> io_failure) {
1340 goto erret;
1341 }
1342 atp = AsnReadId(aip,amp, atp);
1343 }
1344
1345 if (AsnReadVal(aip, atp, &av) <= 0) {
1346 goto erret;
1347 }
1348 /* end struct */
1349
1350 ret:
1351 AsnUnlinkType(orig); /* unlink local tree */
1352 return ptr;
1353
1354 erret:
1355 aip -> io_failure = TRUE;
1356 ptr = CddPrefNodesFree(ptr);
1357 goto ret;
1358 }
1359
1360
1361
1362 /**************************************************
1363 *
1364 * CddPrefNodesAsnWrite()
1365 *
1366 **************************************************/
1367 NLM_EXTERN Boolean LIBCALL
CddPrefNodesAsnWrite(CddPrefNodesPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1368 CddPrefNodesAsnWrite(CddPrefNodesPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1369 {
1370 DataVal av;
1371 AsnTypePtr atp;
1372 Boolean retval = FALSE;
1373
1374 if (! loaded)
1375 {
1376 if (! objcddAsnLoad()) {
1377 return FALSE;
1378 }
1379 }
1380
1381 if (aip == NULL) {
1382 return FALSE;
1383 }
1384
1385 atp = AsnLinkType(orig, CDD_PREF_NODES); /* link local tree */
1386 if (atp == NULL) {
1387 return FALSE;
1388 }
1389
1390 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1391 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1392 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1393 goto erret;
1394 }
1395
1396 if (ptr -> preferred_nodes != NULL) {
1397 if ( ! CddOrgRefSetAsnWrite(ptr -> preferred_nodes, aip, CDD_PREF_NODES_preferred_nodes)) {
1398 goto erret;
1399 }
1400 }
1401 if (ptr -> model_organisms != NULL) {
1402 if ( ! CddOrgRefSetAsnWrite(ptr -> model_organisms, aip, CDD_PREF_NODES_model_organisms)) {
1403 goto erret;
1404 }
1405 }
1406 if (ptr -> optional_nodes != NULL) {
1407 if ( ! CddOrgRefSetAsnWrite(ptr -> optional_nodes, aip, CDD_PREF_NODES_optional_nodes)) {
1408 goto erret;
1409 }
1410 }
1411 if (ptr -> description != NULL) {
1412 if ( ! CddPrefNodeDescrSetAsnWrite(ptr -> description, aip, CDD_PREF_NODES_description)) {
1413 goto erret;
1414 }
1415 }
1416 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1417 goto erret;
1418 }
1419 retval = TRUE;
1420
1421 erret:
1422 AsnUnlinkType(orig); /* unlink local tree */
1423 return retval;
1424 }
1425
1426
1427
1428 /**************************************************
1429 *
1430 * CddProjectNew()
1431 *
1432 **************************************************/
1433 NLM_EXTERN
1434 CddProjectPtr LIBCALL
CddProjectNew(void)1435 CddProjectNew(void)
1436 {
1437 CddProjectPtr ptr = MemNew((size_t) sizeof(CddProject));
1438
1439 return ptr;
1440
1441 }
1442
1443
1444 /**************************************************
1445 *
1446 * CddProjectFree()
1447 *
1448 **************************************************/
1449 NLM_EXTERN
1450 CddProjectPtr LIBCALL
CddProjectFree(CddProjectPtr ptr)1451 CddProjectFree(CddProjectPtr ptr)
1452 {
1453
1454 if(ptr == NULL) {
1455 return NULL;
1456 }
1457 AsnGenericUserSeqOfFree(ptr -> cds, (AsnOptFreeFunc) CddFree);
1458 AsnGenericBaseSeqOfFree(ptr -> cdcolor ,ASNCODE_INTVAL_SLOT);
1459 AsnGenericUserSeqOfFree(ptr -> viewers, (AsnOptFreeFunc) CddViewerFree);
1460 MemFree(ptr -> log);
1461 AsnGenericUserSeqOfFree(ptr -> scripts, (AsnOptFreeFunc) CddScriptFree);
1462 return MemFree(ptr);
1463 }
1464
1465
1466 /**************************************************
1467 *
1468 * CddProjectAsnRead()
1469 *
1470 **************************************************/
1471 NLM_EXTERN
1472 CddProjectPtr LIBCALL
CddProjectAsnRead(AsnIoPtr aip,AsnTypePtr orig)1473 CddProjectAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1474 {
1475 DataVal av;
1476 AsnTypePtr atp;
1477 Boolean isError = FALSE;
1478 AsnReadFunc func;
1479 CddProjectPtr ptr;
1480
1481 if (! loaded)
1482 {
1483 if (! objcddAsnLoad()) {
1484 return NULL;
1485 }
1486 }
1487
1488 if (aip == NULL) {
1489 return NULL;
1490 }
1491
1492 if (orig == NULL) { /* CddProject ::= (self contained) */
1493 atp = AsnReadId(aip, amp, CDD_PROJECT);
1494 } else {
1495 atp = AsnLinkType(orig, CDD_PROJECT);
1496 }
1497 /* link in local tree */
1498 if (atp == NULL) {
1499 return NULL;
1500 }
1501
1502 ptr = CddProjectNew();
1503 if (ptr == NULL) {
1504 goto erret;
1505 }
1506 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1507 goto erret;
1508 }
1509
1510 atp = AsnReadId(aip,amp, atp);
1511 func = NULL;
1512
1513 if (atp == CDD_PROJECT_cds) {
1514 ptr -> cds = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) CddAsnRead, (AsnOptFreeFunc) CddFree);
1515 if (isError && ptr -> cds == NULL) {
1516 goto erret;
1517 }
1518 atp = AsnReadId(aip,amp, atp);
1519 }
1520 if (atp == CDD_PROJECT_cdcolor) {
1521 ptr -> cdcolor = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_INTVAL_SLOT, &isError);
1522 if (isError && ptr -> cdcolor == NULL) {
1523 goto erret;
1524 }
1525 atp = AsnReadId(aip,amp, atp);
1526 }
1527 if (atp == CDD_PROJECT_viewers) {
1528 ptr -> viewers = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) CddViewerAsnRead, (AsnOptFreeFunc) CddViewerFree);
1529 if (isError && ptr -> viewers == NULL) {
1530 goto erret;
1531 }
1532 atp = AsnReadId(aip,amp, atp);
1533 }
1534 if (atp == CDD_PROJECT_log) {
1535 if ( AsnReadVal(aip, atp, &av) <= 0) {
1536 goto erret;
1537 }
1538 ptr -> log = av.ptrvalue;
1539 atp = AsnReadId(aip,amp, atp);
1540 }
1541 if (atp == CDD_PROJECT_scripts) {
1542 ptr -> scripts = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) CddScriptAsnRead, (AsnOptFreeFunc) CddScriptFree);
1543 if (isError && ptr -> scripts == NULL) {
1544 goto erret;
1545 }
1546 atp = AsnReadId(aip,amp, atp);
1547 }
1548
1549 if (AsnReadVal(aip, atp, &av) <= 0) {
1550 goto erret;
1551 }
1552 /* end struct */
1553
1554 ret:
1555 AsnUnlinkType(orig); /* unlink local tree */
1556 return ptr;
1557
1558 erret:
1559 aip -> io_failure = TRUE;
1560 ptr = CddProjectFree(ptr);
1561 goto ret;
1562 }
1563
1564
1565
1566 /**************************************************
1567 *
1568 * CddProjectAsnWrite()
1569 *
1570 **************************************************/
1571 NLM_EXTERN Boolean LIBCALL
CddProjectAsnWrite(CddProjectPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1572 CddProjectAsnWrite(CddProjectPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1573 {
1574 DataVal av;
1575 AsnTypePtr atp;
1576 Boolean retval = FALSE;
1577
1578 if (! loaded)
1579 {
1580 if (! objcddAsnLoad()) {
1581 return FALSE;
1582 }
1583 }
1584
1585 if (aip == NULL) {
1586 return FALSE;
1587 }
1588
1589 atp = AsnLinkType(orig, CDD_PROJECT); /* link local tree */
1590 if (atp == NULL) {
1591 return FALSE;
1592 }
1593
1594 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1595 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1596 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1597 goto erret;
1598 }
1599
1600 AsnGenericUserSeqOfAsnWrite(ptr -> cds, (AsnWriteFunc) CddAsnWrite, aip, CDD_PROJECT_cds, CDD_PROJECT_cds_E);
1601 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> cdcolor ,ASNCODE_INTVAL_SLOT, aip, CDD_PROJECT_cdcolor, CDD_PROJECT_cdcolor_E);
1602 AsnGenericUserSeqOfAsnWrite(ptr -> viewers, (AsnWriteFunc) CddViewerAsnWrite, aip, CDD_PROJECT_viewers, CDD_PROJECT_viewers_E);
1603 if (ptr -> log != NULL) {
1604 av.ptrvalue = ptr -> log;
1605 retval = AsnWrite(aip, CDD_PROJECT_log, &av);
1606 }
1607 AsnGenericUserSeqOfAsnWrite(ptr -> scripts, (AsnWriteFunc) CddScriptAsnWrite, aip, CDD_PROJECT_scripts, CDD_PROJECT_scripts_E);
1608 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1609 goto erret;
1610 }
1611 retval = TRUE;
1612
1613 erret:
1614 AsnUnlinkType(orig); /* unlink local tree */
1615 return retval;
1616 }
1617
1618
1619
1620 /**************************************************
1621 *
1622 * CddOrgRefNew()
1623 *
1624 **************************************************/
1625 NLM_EXTERN
1626 CddOrgRefPtr LIBCALL
CddOrgRefNew(void)1627 CddOrgRefNew(void)
1628 {
1629 CddOrgRefPtr ptr = MemNew((size_t) sizeof(CddOrgRef));
1630
1631 ptr -> active = 1;
1632 return ptr;
1633
1634 }
1635
1636
1637 /**************************************************
1638 *
1639 * CddOrgRefFree()
1640 *
1641 **************************************************/
1642 NLM_EXTERN
1643 CddOrgRefPtr LIBCALL
CddOrgRefFree(CddOrgRefPtr ptr)1644 CddOrgRefFree(CddOrgRefPtr ptr)
1645 {
1646
1647 if(ptr == NULL) {
1648 return NULL;
1649 }
1650 OrgRefFree((OrgRefPtr) ptr -> reference);
1651 MemFree(ptr -> rank);
1652 return MemFree(ptr);
1653 }
1654
1655
1656 /**************************************************
1657 *
1658 * CddOrgRefAsnRead()
1659 *
1660 **************************************************/
1661 NLM_EXTERN
1662 CddOrgRefPtr LIBCALL
CddOrgRefAsnRead(AsnIoPtr aip,AsnTypePtr orig)1663 CddOrgRefAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1664 {
1665 DataVal av;
1666 AsnTypePtr atp;
1667 Boolean isError = FALSE;
1668 AsnReadFunc func;
1669 CddOrgRefPtr ptr;
1670
1671 if (! loaded)
1672 {
1673 if (! objcddAsnLoad()) {
1674 return NULL;
1675 }
1676 }
1677
1678 if (aip == NULL) {
1679 return NULL;
1680 }
1681
1682 if (orig == NULL) { /* CddOrgRef ::= (self contained) */
1683 atp = AsnReadId(aip, amp, CDD_ORG_REF);
1684 } else {
1685 atp = AsnLinkType(orig, CDD_ORG_REF);
1686 }
1687 /* link in local tree */
1688 if (atp == NULL) {
1689 return NULL;
1690 }
1691
1692 ptr = CddOrgRefNew();
1693 if (ptr == NULL) {
1694 goto erret;
1695 }
1696 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1697 goto erret;
1698 }
1699
1700 atp = AsnReadId(aip,amp, atp);
1701 func = NULL;
1702
1703 if (atp == CDD_ORG_REF_reference) {
1704 ptr -> reference = (struct struct_Org_ref PNTR) OrgRefAsnRead(aip, atp);
1705 if (aip -> io_failure) {
1706 goto erret;
1707 }
1708 atp = AsnReadId(aip,amp, atp);
1709 }
1710 if (atp == CDD_ORG_REF_active) {
1711 if ( AsnReadVal(aip, atp, &av) <= 0) {
1712 goto erret;
1713 }
1714 ptr -> active = av.boolvalue;
1715 atp = AsnReadId(aip,amp, atp);
1716 }
1717 if (atp == CDD_ORG_REF_parent_tax_id) {
1718 if ( AsnReadVal(aip, atp, &av) <= 0) {
1719 goto erret;
1720 }
1721 ptr -> parent_tax_id = av.intvalue;
1722 atp = AsnReadId(aip,amp, atp);
1723 }
1724 if (atp == CDD_ORG_REF_rank) {
1725 if ( AsnReadVal(aip, atp, &av) <= 0) {
1726 goto erret;
1727 }
1728 ptr -> rank = av.ptrvalue;
1729 atp = AsnReadId(aip,amp, atp);
1730 }
1731
1732 if (AsnReadVal(aip, atp, &av) <= 0) {
1733 goto erret;
1734 }
1735 /* end struct */
1736
1737 ret:
1738 AsnUnlinkType(orig); /* unlink local tree */
1739 return ptr;
1740
1741 erret:
1742 aip -> io_failure = TRUE;
1743 ptr = CddOrgRefFree(ptr);
1744 goto ret;
1745 }
1746
1747
1748
1749 /**************************************************
1750 *
1751 * CddOrgRefAsnWrite()
1752 *
1753 **************************************************/
1754 NLM_EXTERN Boolean LIBCALL
CddOrgRefAsnWrite(CddOrgRefPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1755 CddOrgRefAsnWrite(CddOrgRefPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1756 {
1757 DataVal av;
1758 AsnTypePtr atp;
1759 Boolean retval = FALSE;
1760
1761 if (! loaded)
1762 {
1763 if (! objcddAsnLoad()) {
1764 return FALSE;
1765 }
1766 }
1767
1768 if (aip == NULL) {
1769 return FALSE;
1770 }
1771
1772 atp = AsnLinkType(orig, CDD_ORG_REF); /* link local tree */
1773 if (atp == NULL) {
1774 return FALSE;
1775 }
1776
1777 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1778 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1779 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1780 goto erret;
1781 }
1782
1783 if (ptr -> reference != NULL) {
1784 if ( ! OrgRefAsnWrite((OrgRefPtr)ptr -> reference, aip, CDD_ORG_REF_reference)) {
1785 goto erret;
1786 }
1787 }
1788 av.boolvalue = ptr -> active;
1789 retval = AsnWrite(aip, CDD_ORG_REF_active, &av);
1790 av.intvalue = ptr -> parent_tax_id;
1791 retval = AsnWrite(aip, CDD_ORG_REF_parent_tax_id, &av);
1792 if (ptr -> rank != NULL) {
1793 av.ptrvalue = ptr -> rank;
1794 retval = AsnWrite(aip, CDD_ORG_REF_rank, &av);
1795 }
1796 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1797 goto erret;
1798 }
1799 retval = TRUE;
1800
1801 erret:
1802 AsnUnlinkType(orig); /* unlink local tree */
1803 return retval;
1804 }
1805
1806
1807
1808 /**************************************************
1809 *
1810 * CddOrgRefSetFree()
1811 *
1812 **************************************************/
1813 NLM_EXTERN
1814 CddOrgRefSetPtr LIBCALL
CddOrgRefSetFree(CddOrgRefSetPtr ptr)1815 CddOrgRefSetFree(CddOrgRefSetPtr ptr)
1816 {
1817
1818 if(ptr == NULL) {
1819 return NULL;
1820 }
1821 AsnGenericUserSeqOfFree(ptr, (AsnOptFreeFunc) CddOrgRefFree);
1822 return NULL;
1823 }
1824
1825
1826 /**************************************************
1827 *
1828 * CddOrgRefSetAsnRead()
1829 *
1830 **************************************************/
1831 NLM_EXTERN
1832 CddOrgRefSetPtr LIBCALL
CddOrgRefSetAsnRead(AsnIoPtr aip,AsnTypePtr orig)1833 CddOrgRefSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1834 {
1835 DataVal av;
1836 AsnTypePtr atp;
1837 Boolean isError = FALSE;
1838 AsnReadFunc func;
1839 CddOrgRefSetPtr ptr;
1840
1841 if (! loaded)
1842 {
1843 if (! objcddAsnLoad()) {
1844 return NULL;
1845 }
1846 }
1847
1848 if (aip == NULL) {
1849 return NULL;
1850 }
1851
1852 if (orig == NULL) { /* CddOrgRefSet ::= (self contained) */
1853 atp = AsnReadId(aip, amp, CDD_ORG_REF_SET);
1854 } else {
1855 atp = AsnLinkType(orig, CDD_ORG_REF_SET);
1856 }
1857 /* link in local tree */
1858 if (atp == NULL) {
1859 return NULL;
1860 }
1861
1862 func = NULL;
1863
1864 ptr = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) CddOrgRefAsnRead, (AsnOptFreeFunc) CddOrgRefFree);
1865 if (isError && ptr == NULL) {
1866 goto erret;
1867 }
1868
1869
1870
1871 ret:
1872 AsnUnlinkType(orig); /* unlink local tree */
1873 return ptr;
1874
1875 erret:
1876 aip -> io_failure = TRUE;
1877 ptr = CddOrgRefSetFree(ptr);
1878 goto ret;
1879 }
1880
1881
1882
1883 /**************************************************
1884 *
1885 * CddOrgRefSetAsnWrite()
1886 *
1887 **************************************************/
1888 NLM_EXTERN Boolean LIBCALL
CddOrgRefSetAsnWrite(CddOrgRefSetPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1889 CddOrgRefSetAsnWrite(CddOrgRefSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1890 {
1891 DataVal av;
1892 AsnTypePtr atp;
1893 Boolean retval = FALSE;
1894
1895 if (! loaded)
1896 {
1897 if (! objcddAsnLoad()) {
1898 return FALSE;
1899 }
1900 }
1901
1902 if (aip == NULL) {
1903 return FALSE;
1904 }
1905
1906 atp = AsnLinkType(orig, CDD_ORG_REF_SET); /* link local tree */
1907 if (atp == NULL) {
1908 return FALSE;
1909 }
1910
1911 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1912 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1913 retval = AsnGenericUserSeqOfAsnWrite(ptr , (AsnWriteFunc) CddOrgRefAsnWrite, aip, atp, CDD_ORG_REF_SET_E);
1914 retval = TRUE;
1915
1916 erret:
1917 AsnUnlinkType(orig); /* unlink local tree */
1918 return retval;
1919 }
1920
1921
1922
1923 /**************************************************
1924 *
1925 * CddPrefNodeDescrFree()
1926 *
1927 **************************************************/
1928 NLM_EXTERN
1929 CddPrefNodeDescrPtr LIBCALL
CddPrefNodeDescrFree(ValNodePtr anp)1930 CddPrefNodeDescrFree(ValNodePtr anp)
1931 {
1932 Pointer pnt;
1933
1934 if (anp == NULL) {
1935 return NULL;
1936 }
1937
1938 pnt = anp->data.ptrvalue;
1939 switch (anp->choice)
1940 {
1941 default:
1942 break;
1943 case CddPrefNodeDescr_create_date:
1944 DateFree(anp -> data.ptrvalue);
1945 break;
1946 case CddPrefNodeDescr_description:
1947 MemFree(anp -> data.ptrvalue);
1948 break;
1949 }
1950 return MemFree(anp);
1951 }
1952
1953
1954 /**************************************************
1955 *
1956 * CddPrefNodeDescrAsnRead()
1957 *
1958 **************************************************/
1959 NLM_EXTERN
1960 CddPrefNodeDescrPtr LIBCALL
CddPrefNodeDescrAsnRead(AsnIoPtr aip,AsnTypePtr orig)1961 CddPrefNodeDescrAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1962 {
1963 DataVal av;
1964 AsnTypePtr atp;
1965 ValNodePtr anp;
1966 Uint1 choice;
1967 Boolean isError = FALSE;
1968 Boolean nullIsError = FALSE;
1969 AsnReadFunc func;
1970
1971 if (! loaded)
1972 {
1973 if (! objcddAsnLoad()) {
1974 return NULL;
1975 }
1976 }
1977
1978 if (aip == NULL) {
1979 return NULL;
1980 }
1981
1982 if (orig == NULL) { /* CddPrefNodeDescr ::= (self contained) */
1983 atp = AsnReadId(aip, amp, CDD_PREF_NODE_DESCR);
1984 } else {
1985 atp = AsnLinkType(orig, CDD_PREF_NODE_DESCR); /* link in local tree */
1986 }
1987 if (atp == NULL) {
1988 return NULL;
1989 }
1990
1991 anp = ValNodeNew(NULL);
1992 if (anp == NULL) {
1993 goto erret;
1994 }
1995 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
1996 goto erret;
1997 }
1998
1999 func = NULL;
2000
2001 atp = AsnReadId(aip, amp, atp); /* find the choice */
2002 if (atp == NULL) {
2003 goto erret;
2004 }
2005 if (atp == CDD_PREF_NODE_DESCR_create_date) {
2006 choice = CddPrefNodeDescr_create_date;
2007 func = (AsnReadFunc) DateAsnRead;
2008 }
2009 else if (atp == CDD_PREF_NODE_DESCR_description) {
2010 choice = CddPrefNodeDescr_description;
2011 if (AsnReadVal(aip, atp, &av) <= 0) {
2012 goto erret;
2013 }
2014 anp->data.ptrvalue = av.ptrvalue;
2015 }
2016 anp->choice = choice;
2017 if (func != NULL)
2018 {
2019 anp->data.ptrvalue = (* func)(aip, atp);
2020 if (aip -> io_failure) goto erret;
2021
2022 if (nullIsError && anp->data.ptrvalue == NULL) {
2023 goto erret;
2024 }
2025 }
2026
2027 ret:
2028 AsnUnlinkType(orig); /* unlink local tree */
2029 return anp;
2030
2031 erret:
2032 anp = MemFree(anp);
2033 aip -> io_failure = TRUE;
2034 goto ret;
2035 }
2036
2037
2038 /**************************************************
2039 *
2040 * CddPrefNodeDescrAsnWrite()
2041 *
2042 **************************************************/
2043 NLM_EXTERN Boolean LIBCALL
CddPrefNodeDescrAsnWrite(CddPrefNodeDescrPtr anp,AsnIoPtr aip,AsnTypePtr orig)2044 CddPrefNodeDescrAsnWrite(CddPrefNodeDescrPtr anp, AsnIoPtr aip, AsnTypePtr orig)
2045
2046 {
2047 DataVal av;
2048 AsnTypePtr atp, writetype = NULL;
2049 Pointer pnt;
2050 AsnWriteFunc func = NULL;
2051 Boolean retval = FALSE;
2052
2053 if (! loaded)
2054 {
2055 if (! objcddAsnLoad())
2056 return FALSE;
2057 }
2058
2059 if (aip == NULL)
2060 return FALSE;
2061
2062 atp = AsnLinkType(orig, CDD_PREF_NODE_DESCR); /* link local tree */
2063 if (atp == NULL) {
2064 return FALSE;
2065 }
2066
2067 if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2068 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
2069 av.ptrvalue = (Pointer)anp;
2070 if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
2071 goto erret;
2072 }
2073
2074 pnt = anp->data.ptrvalue;
2075 switch (anp->choice)
2076 {
2077 case CddPrefNodeDescr_create_date:
2078 writetype = CDD_PREF_NODE_DESCR_create_date;
2079 func = (AsnWriteFunc) DateAsnWrite;
2080 break;
2081 case CddPrefNodeDescr_description:
2082 av.ptrvalue = anp->data.ptrvalue;
2083 retval = AsnWrite(aip, CDD_PREF_NODE_DESCR_description, &av);
2084 break;
2085 }
2086 if (writetype != NULL) {
2087 retval = (* func)(pnt, aip, writetype); /* write it out */
2088 }
2089 if (!retval) {
2090 goto erret;
2091 }
2092 retval = TRUE;
2093
2094 erret:
2095 AsnUnlinkType(orig); /* unlink local tree */
2096 return retval;
2097 }
2098
2099
2100 /**************************************************
2101 *
2102 * CddPrefNodeDescrSetFree()
2103 *
2104 **************************************************/
2105 NLM_EXTERN
2106 CddPrefNodeDescrSetPtr LIBCALL
CddPrefNodeDescrSetFree(CddPrefNodeDescrSetPtr ptr)2107 CddPrefNodeDescrSetFree(CddPrefNodeDescrSetPtr ptr)
2108 {
2109
2110 if(ptr == NULL) {
2111 return NULL;
2112 }
2113 AsnGenericChoiceSeqOfFree(ptr, (AsnOptFreeFunc) CddPrefNodeDescrFree);
2114 return NULL;
2115 }
2116
2117
2118 /**************************************************
2119 *
2120 * CddPrefNodeDescrSetAsnRead()
2121 *
2122 **************************************************/
2123 NLM_EXTERN
2124 CddPrefNodeDescrSetPtr LIBCALL
CddPrefNodeDescrSetAsnRead(AsnIoPtr aip,AsnTypePtr orig)2125 CddPrefNodeDescrSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2126 {
2127 DataVal av;
2128 AsnTypePtr atp;
2129 Boolean isError = FALSE;
2130 AsnReadFunc func;
2131 CddPrefNodeDescrSetPtr ptr;
2132
2133 if (! loaded)
2134 {
2135 if (! objcddAsnLoad()) {
2136 return NULL;
2137 }
2138 }
2139
2140 if (aip == NULL) {
2141 return NULL;
2142 }
2143
2144 if (orig == NULL) { /* CddPrefNodeDescrSet ::= (self contained) */
2145 atp = AsnReadId(aip, amp, CDD_PREF_NODE_DESCR_SET);
2146 } else {
2147 atp = AsnLinkType(orig, CDD_PREF_NODE_DESCR_SET);
2148 }
2149 /* link in local tree */
2150 if (atp == NULL) {
2151 return NULL;
2152 }
2153
2154 func = NULL;
2155
2156 ptr = AsnGenericChoiceSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) CddPrefNodeDescrAsnRead, (AsnOptFreeFunc) CddPrefNodeDescrFree);
2157 if (isError && ptr == NULL) {
2158 goto erret;
2159 }
2160
2161
2162
2163 ret:
2164 AsnUnlinkType(orig); /* unlink local tree */
2165 return ptr;
2166
2167 erret:
2168 aip -> io_failure = TRUE;
2169 ptr = CddPrefNodeDescrSetFree(ptr);
2170 goto ret;
2171 }
2172
2173
2174
2175 /**************************************************
2176 *
2177 * CddPrefNodeDescrSetAsnWrite()
2178 *
2179 **************************************************/
2180 NLM_EXTERN Boolean LIBCALL
CddPrefNodeDescrSetAsnWrite(CddPrefNodeDescrSetPtr ptr,AsnIoPtr aip,AsnTypePtr orig)2181 CddPrefNodeDescrSetAsnWrite(CddPrefNodeDescrSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
2182 {
2183 DataVal av;
2184 AsnTypePtr atp;
2185 Boolean retval = FALSE;
2186
2187 if (! loaded)
2188 {
2189 if (! objcddAsnLoad()) {
2190 return FALSE;
2191 }
2192 }
2193
2194 if (aip == NULL) {
2195 return FALSE;
2196 }
2197
2198 atp = AsnLinkType(orig, CDD_PREF_NODE_DESCR_SET); /* link local tree */
2199 if (atp == NULL) {
2200 return FALSE;
2201 }
2202
2203 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2204 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
2205 retval = AsnGenericChoiceSeqOfAsnWrite(ptr , (AsnWriteFunc) CddPrefNodeDescrAsnWrite, aip, atp, CDD_PREF_NODE_DESCR_SET_E);
2206 retval = TRUE;
2207
2208 erret:
2209 AsnUnlinkType(orig); /* unlink local tree */
2210 return retval;
2211 }
2212
2213
2214
2215 /**************************************************
2216 *
2217 * GlobalIdNew()
2218 *
2219 **************************************************/
2220 NLM_EXTERN
2221 GlobalIdPtr LIBCALL
GlobalIdNew(void)2222 GlobalIdNew(void)
2223 {
2224 GlobalIdPtr ptr = MemNew((size_t) sizeof(GlobalId));
2225
2226 return ptr;
2227
2228 }
2229
2230
2231 /**************************************************
2232 *
2233 * GlobalIdFree()
2234 *
2235 **************************************************/
2236 NLM_EXTERN
2237 GlobalIdPtr LIBCALL
GlobalIdFree(GlobalIdPtr ptr)2238 GlobalIdFree(GlobalIdPtr ptr)
2239 {
2240
2241 if(ptr == NULL) {
2242 return NULL;
2243 }
2244 MemFree(ptr -> accession);
2245 MemFree(ptr -> release);
2246 MemFree(ptr -> database);
2247 return MemFree(ptr);
2248 }
2249
2250
2251 /**************************************************
2252 *
2253 * GlobalIdAsnRead()
2254 *
2255 **************************************************/
2256 NLM_EXTERN
2257 GlobalIdPtr LIBCALL
GlobalIdAsnRead(AsnIoPtr aip,AsnTypePtr orig)2258 GlobalIdAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2259 {
2260 DataVal av;
2261 AsnTypePtr atp;
2262 Boolean isError = FALSE;
2263 AsnReadFunc func;
2264 GlobalIdPtr ptr;
2265
2266 if (! loaded)
2267 {
2268 if (! objcddAsnLoad()) {
2269 return NULL;
2270 }
2271 }
2272
2273 if (aip == NULL) {
2274 return NULL;
2275 }
2276
2277 if (orig == NULL) { /* GlobalId ::= (self contained) */
2278 atp = AsnReadId(aip, amp, GLOBAL_ID);
2279 } else {
2280 atp = AsnLinkType(orig, GLOBAL_ID);
2281 }
2282 /* link in local tree */
2283 if (atp == NULL) {
2284 return NULL;
2285 }
2286
2287 ptr = GlobalIdNew();
2288 if (ptr == NULL) {
2289 goto erret;
2290 }
2291 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
2292 goto erret;
2293 }
2294
2295 atp = AsnReadId(aip,amp, atp);
2296 func = NULL;
2297
2298 if (atp == GLOBAL_ID_accession) {
2299 if ( AsnReadVal(aip, atp, &av) <= 0) {
2300 goto erret;
2301 }
2302 ptr -> accession = av.ptrvalue;
2303 atp = AsnReadId(aip,amp, atp);
2304 }
2305 if (atp == GLOBAL_ID_release) {
2306 if ( AsnReadVal(aip, atp, &av) <= 0) {
2307 goto erret;
2308 }
2309 ptr -> release = av.ptrvalue;
2310 atp = AsnReadId(aip,amp, atp);
2311 }
2312 if (atp == GLOBAL_ID_version) {
2313 if ( AsnReadVal(aip, atp, &av) <= 0) {
2314 goto erret;
2315 }
2316 ptr -> version = av.intvalue;
2317 atp = AsnReadId(aip,amp, atp);
2318 }
2319 if (atp == GLOBAL_ID_database) {
2320 if ( AsnReadVal(aip, atp, &av) <= 0) {
2321 goto erret;
2322 }
2323 ptr -> database = av.ptrvalue;
2324 atp = AsnReadId(aip,amp, atp);
2325 }
2326
2327 if (AsnReadVal(aip, atp, &av) <= 0) {
2328 goto erret;
2329 }
2330 /* end struct */
2331
2332 ret:
2333 AsnUnlinkType(orig); /* unlink local tree */
2334 return ptr;
2335
2336 erret:
2337 aip -> io_failure = TRUE;
2338 ptr = GlobalIdFree(ptr);
2339 goto ret;
2340 }
2341
2342
2343
2344 /**************************************************
2345 *
2346 * GlobalIdAsnWrite()
2347 *
2348 **************************************************/
2349 NLM_EXTERN Boolean LIBCALL
GlobalIdAsnWrite(GlobalIdPtr ptr,AsnIoPtr aip,AsnTypePtr orig)2350 GlobalIdAsnWrite(GlobalIdPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
2351 {
2352 DataVal av;
2353 AsnTypePtr atp;
2354 Boolean retval = FALSE;
2355
2356 if (! loaded)
2357 {
2358 if (! objcddAsnLoad()) {
2359 return FALSE;
2360 }
2361 }
2362
2363 if (aip == NULL) {
2364 return FALSE;
2365 }
2366
2367 atp = AsnLinkType(orig, GLOBAL_ID); /* link local tree */
2368 if (atp == NULL) {
2369 return FALSE;
2370 }
2371
2372 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2373 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
2374 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
2375 goto erret;
2376 }
2377
2378 if (ptr -> accession != NULL) {
2379 av.ptrvalue = ptr -> accession;
2380 retval = AsnWrite(aip, GLOBAL_ID_accession, &av);
2381 }
2382 if (ptr -> release != NULL) {
2383 av.ptrvalue = ptr -> release;
2384 retval = AsnWrite(aip, GLOBAL_ID_release, &av);
2385 }
2386 av.intvalue = ptr -> version;
2387 retval = AsnWrite(aip, GLOBAL_ID_version, &av);
2388 if (ptr -> database != NULL) {
2389 av.ptrvalue = ptr -> database;
2390 retval = AsnWrite(aip, GLOBAL_ID_database, &av);
2391 }
2392 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
2393 goto erret;
2394 }
2395 retval = TRUE;
2396
2397 erret:
2398 AsnUnlinkType(orig); /* unlink local tree */
2399 return retval;
2400 }
2401
2402
2403
2404 /**************************************************
2405 *
2406 * CddRepeatNew()
2407 *
2408 **************************************************/
2409 NLM_EXTERN
2410 CddRepeatPtr LIBCALL
CddRepeatNew(void)2411 CddRepeatNew(void)
2412 {
2413 CddRepeatPtr ptr = MemNew((size_t) sizeof(CddRepeat));
2414
2415 return ptr;
2416
2417 }
2418
2419
2420 /**************************************************
2421 *
2422 * CddRepeatFree()
2423 *
2424 **************************************************/
2425 NLM_EXTERN
2426 CddRepeatPtr LIBCALL
CddRepeatFree(CddRepeatPtr ptr)2427 CddRepeatFree(CddRepeatPtr ptr)
2428 {
2429
2430 if(ptr == NULL) {
2431 return NULL;
2432 }
2433 SeqLocFree(ptr -> location);
2434 return MemFree(ptr);
2435 }
2436
2437
2438 /**************************************************
2439 *
2440 * CddRepeatAsnRead()
2441 *
2442 **************************************************/
2443 NLM_EXTERN
2444 CddRepeatPtr LIBCALL
CddRepeatAsnRead(AsnIoPtr aip,AsnTypePtr orig)2445 CddRepeatAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2446 {
2447 DataVal av;
2448 AsnTypePtr atp;
2449 Boolean isError = FALSE;
2450 AsnReadFunc func;
2451 CddRepeatPtr ptr;
2452
2453 if (! loaded)
2454 {
2455 if (! objcddAsnLoad()) {
2456 return NULL;
2457 }
2458 }
2459
2460 if (aip == NULL) {
2461 return NULL;
2462 }
2463
2464 if (orig == NULL) { /* CddRepeat ::= (self contained) */
2465 atp = AsnReadId(aip, amp, CDD_REPEAT);
2466 } else {
2467 atp = AsnLinkType(orig, CDD_REPEAT);
2468 }
2469 /* link in local tree */
2470 if (atp == NULL) {
2471 return NULL;
2472 }
2473
2474 ptr = CddRepeatNew();
2475 if (ptr == NULL) {
2476 goto erret;
2477 }
2478 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
2479 goto erret;
2480 }
2481
2482 atp = AsnReadId(aip,amp, atp);
2483 func = NULL;
2484
2485 if (atp == CDD_REPEAT_count) {
2486 if ( AsnReadVal(aip, atp, &av) <= 0) {
2487 goto erret;
2488 }
2489 ptr -> count = av.intvalue;
2490 atp = AsnReadId(aip,amp, atp);
2491 }
2492 if (atp == CDD_REPEAT_location) {
2493 ptr -> location = SeqLocAsnRead(aip, atp);
2494 if (aip -> io_failure) {
2495 goto erret;
2496 }
2497 atp = AsnReadId(aip,amp, atp);
2498 }
2499 if (atp == CDD_REPEAT_avglen) {
2500 if ( AsnReadVal(aip, atp, &av) <= 0) {
2501 goto erret;
2502 }
2503 ptr -> avglen = av.intvalue;
2504 atp = AsnReadId(aip,amp, atp);
2505 }
2506
2507 if (AsnReadVal(aip, atp, &av) <= 0) {
2508 goto erret;
2509 }
2510 /* end struct */
2511
2512 ret:
2513 AsnUnlinkType(orig); /* unlink local tree */
2514 return ptr;
2515
2516 erret:
2517 aip -> io_failure = TRUE;
2518 ptr = CddRepeatFree(ptr);
2519 goto ret;
2520 }
2521
2522
2523
2524 /**************************************************
2525 *
2526 * CddRepeatAsnWrite()
2527 *
2528 **************************************************/
2529 NLM_EXTERN Boolean LIBCALL
CddRepeatAsnWrite(CddRepeatPtr ptr,AsnIoPtr aip,AsnTypePtr orig)2530 CddRepeatAsnWrite(CddRepeatPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
2531 {
2532 DataVal av;
2533 AsnTypePtr atp;
2534 Boolean retval = FALSE;
2535
2536 if (! loaded)
2537 {
2538 if (! objcddAsnLoad()) {
2539 return FALSE;
2540 }
2541 }
2542
2543 if (aip == NULL) {
2544 return FALSE;
2545 }
2546
2547 atp = AsnLinkType(orig, CDD_REPEAT); /* link local tree */
2548 if (atp == NULL) {
2549 return FALSE;
2550 }
2551
2552 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2553 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
2554 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
2555 goto erret;
2556 }
2557
2558 av.intvalue = ptr -> count;
2559 retval = AsnWrite(aip, CDD_REPEAT_count, &av);
2560 if (ptr -> location != NULL) {
2561 if ( ! SeqLocAsnWrite(ptr -> location, aip, CDD_REPEAT_location)) {
2562 goto erret;
2563 }
2564 }
2565 av.intvalue = ptr -> avglen;
2566 retval = AsnWrite(aip, CDD_REPEAT_avglen, &av);
2567 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
2568 goto erret;
2569 }
2570 retval = TRUE;
2571
2572 erret:
2573 AsnUnlinkType(orig); /* unlink local tree */
2574 return retval;
2575 }
2576
2577
2578
2579 /**************************************************
2580 *
2581 * CddBookRefNew()
2582 *
2583 **************************************************/
2584 NLM_EXTERN
2585 CddBookRefPtr LIBCALL
CddBookRefNew(void)2586 CddBookRefNew(void)
2587 {
2588 CddBookRefPtr ptr = MemNew((size_t) sizeof(CddBookRef));
2589
2590 return ptr;
2591
2592 }
2593
2594
2595 /**************************************************
2596 *
2597 * CddBookRefFree()
2598 *
2599 **************************************************/
2600 NLM_EXTERN
2601 CddBookRefPtr LIBCALL
CddBookRefFree(CddBookRefPtr ptr)2602 CddBookRefFree(CddBookRefPtr ptr)
2603 {
2604
2605 if(ptr == NULL) {
2606 return NULL;
2607 }
2608 MemFree(ptr -> bookname);
2609 MemFree(ptr -> celementid);
2610 MemFree(ptr -> csubelementid);
2611 return MemFree(ptr);
2612 }
2613
2614
2615 /**************************************************
2616 *
2617 * CddBookRefAsnRead()
2618 *
2619 **************************************************/
2620 NLM_EXTERN
2621 CddBookRefPtr LIBCALL
CddBookRefAsnRead(AsnIoPtr aip,AsnTypePtr orig)2622 CddBookRefAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2623 {
2624 DataVal av;
2625 AsnTypePtr atp;
2626 Boolean isError = FALSE;
2627 AsnReadFunc func;
2628 CddBookRefPtr ptr;
2629
2630 if (! loaded)
2631 {
2632 if (! objcddAsnLoad()) {
2633 return NULL;
2634 }
2635 }
2636
2637 if (aip == NULL) {
2638 return NULL;
2639 }
2640
2641 if (orig == NULL) { /* CddBookRef ::= (self contained) */
2642 atp = AsnReadId(aip, amp, CDD_BOOK_REF);
2643 } else {
2644 atp = AsnLinkType(orig, CDD_BOOK_REF);
2645 }
2646 /* link in local tree */
2647 if (atp == NULL) {
2648 return NULL;
2649 }
2650
2651 ptr = CddBookRefNew();
2652 if (ptr == NULL) {
2653 goto erret;
2654 }
2655 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
2656 goto erret;
2657 }
2658
2659 atp = AsnReadId(aip,amp, atp);
2660 func = NULL;
2661
2662 if (atp == CDD_BOOK_REF_bookname) {
2663 if ( AsnReadVal(aip, atp, &av) <= 0) {
2664 goto erret;
2665 }
2666 ptr -> bookname = av.ptrvalue;
2667 atp = AsnReadId(aip,amp, atp);
2668 }
2669 if (atp == CDD_BOOK_REF_textelement) {
2670 if ( AsnReadVal(aip, atp, &av) <= 0) {
2671 goto erret;
2672 }
2673 ptr -> textelement = av.intvalue;
2674 atp = AsnReadId(aip,amp, atp);
2675 }
2676 if (atp == CDD_BOOK_REF_elementid) {
2677 if ( AsnReadVal(aip, atp, &av) <= 0) {
2678 goto erret;
2679 }
2680 ptr -> elementid = av.intvalue;
2681 atp = AsnReadId(aip,amp, atp);
2682 }
2683 if (atp == CDD_BOOK_REF_subelementid) {
2684 if ( AsnReadVal(aip, atp, &av) <= 0) {
2685 goto erret;
2686 }
2687 ptr -> subelementid = av.intvalue;
2688 atp = AsnReadId(aip,amp, atp);
2689 }
2690 if (atp == CDD_BOOK_REF_celementid) {
2691 if ( AsnReadVal(aip, atp, &av) <= 0) {
2692 goto erret;
2693 }
2694 ptr -> celementid = av.ptrvalue;
2695 atp = AsnReadId(aip,amp, atp);
2696 }
2697 if (atp == CDD_BOOK_REF_csubelementid) {
2698 if ( AsnReadVal(aip, atp, &av) <= 0) {
2699 goto erret;
2700 }
2701 ptr -> csubelementid = av.ptrvalue;
2702 atp = AsnReadId(aip,amp, atp);
2703 }
2704
2705 if (AsnReadVal(aip, atp, &av) <= 0) {
2706 goto erret;
2707 }
2708 /* end struct */
2709
2710 ret:
2711 AsnUnlinkType(orig); /* unlink local tree */
2712 return ptr;
2713
2714 erret:
2715 aip -> io_failure = TRUE;
2716 ptr = CddBookRefFree(ptr);
2717 goto ret;
2718 }
2719
2720
2721
2722 /**************************************************
2723 *
2724 * CddBookRefAsnWrite()
2725 *
2726 **************************************************/
2727 NLM_EXTERN Boolean LIBCALL
CddBookRefAsnWrite(CddBookRefPtr ptr,AsnIoPtr aip,AsnTypePtr orig)2728 CddBookRefAsnWrite(CddBookRefPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
2729 {
2730 DataVal av;
2731 AsnTypePtr atp;
2732 Boolean retval = FALSE;
2733
2734 if (! loaded)
2735 {
2736 if (! objcddAsnLoad()) {
2737 return FALSE;
2738 }
2739 }
2740
2741 if (aip == NULL) {
2742 return FALSE;
2743 }
2744
2745 atp = AsnLinkType(orig, CDD_BOOK_REF); /* link local tree */
2746 if (atp == NULL) {
2747 return FALSE;
2748 }
2749
2750 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2751 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
2752 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
2753 goto erret;
2754 }
2755
2756 if (ptr -> bookname != NULL) {
2757 av.ptrvalue = ptr -> bookname;
2758 retval = AsnWrite(aip, CDD_BOOK_REF_bookname, &av);
2759 }
2760 av.intvalue = ptr -> textelement;
2761 retval = AsnWrite(aip, CDD_BOOK_REF_textelement, &av);
2762 av.intvalue = ptr -> elementid;
2763 retval = AsnWrite(aip, CDD_BOOK_REF_elementid, &av);
2764 av.intvalue = ptr -> subelementid;
2765 retval = AsnWrite(aip, CDD_BOOK_REF_subelementid, &av);
2766 if (ptr -> celementid != NULL) {
2767 av.ptrvalue = ptr -> celementid;
2768 retval = AsnWrite(aip, CDD_BOOK_REF_celementid, &av);
2769 }
2770 if (ptr -> csubelementid != NULL) {
2771 av.ptrvalue = ptr -> csubelementid;
2772 retval = AsnWrite(aip, CDD_BOOK_REF_csubelementid, &av);
2773 }
2774 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
2775 goto erret;
2776 }
2777 retval = TRUE;
2778
2779 erret:
2780 AsnUnlinkType(orig); /* unlink local tree */
2781 return retval;
2782 }
2783
2784
2785
2786 /**************************************************
2787 *
2788 * CddDescrFree()
2789 *
2790 **************************************************/
2791 NLM_EXTERN
2792 CddDescrPtr LIBCALL
CddDescrFree(ValNodePtr anp)2793 CddDescrFree(ValNodePtr anp)
2794 {
2795 Pointer pnt;
2796
2797 if (anp == NULL) {
2798 return NULL;
2799 }
2800
2801 pnt = anp->data.ptrvalue;
2802 switch (anp->choice)
2803 {
2804 default:
2805 break;
2806 case CddDescr_othername:
2807 MemFree(anp -> data.ptrvalue);
2808 break;
2809 case CddDescr_category:
2810 MemFree(anp -> data.ptrvalue);
2811 break;
2812 case CddDescr_comment:
2813 MemFree(anp -> data.ptrvalue);
2814 break;
2815 case CddDescr_reference:
2816 PubFree(anp -> data.ptrvalue);
2817 break;
2818 case CddDescr_create_date:
2819 DateFree(anp -> data.ptrvalue);
2820 break;
2821 case CddDescr_tax_source:
2822 OrgRefFree(anp -> data.ptrvalue);
2823 break;
2824 case CddDescr_source:
2825 MemFree(anp -> data.ptrvalue);
2826 break;
2827 case CddDescr_update_date:
2828 DateFree(anp -> data.ptrvalue);
2829 break;
2830 case CddDescr_scrapbook:
2831 AsnGenericBaseSeqOfFree((ValNodePtr) pnt,ASNCODE_PTRVAL_SLOT);
2832 break;
2833 case CddDescr_source_id:
2834 CddIdSetFree(anp -> data.ptrvalue);
2835 break;
2836 case CddDescr_repeats:
2837 CddRepeatFree(anp -> data.ptrvalue);
2838 break;
2839 case CddDescr_old_root:
2840 CddIdSetFree(anp -> data.ptrvalue);
2841 break;
2842 case CddDescr_book_ref:
2843 CddBookRefFree(anp -> data.ptrvalue);
2844 break;
2845 case CddDescr_attribution:
2846 PubFree(anp -> data.ptrvalue);
2847 break;
2848 case CddDescr_title:
2849 MemFree(anp -> data.ptrvalue);
2850 break;
2851 }
2852 return MemFree(anp);
2853 }
2854
2855
2856 /**************************************************
2857 *
2858 * CddDescrAsnRead()
2859 *
2860 **************************************************/
2861 NLM_EXTERN
2862 CddDescrPtr LIBCALL
CddDescrAsnRead(AsnIoPtr aip,AsnTypePtr orig)2863 CddDescrAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2864 {
2865 DataVal av;
2866 AsnTypePtr atp;
2867 ValNodePtr anp;
2868 Uint1 choice;
2869 Boolean isError = FALSE;
2870 Boolean nullIsError = FALSE;
2871 AsnReadFunc func;
2872
2873 if (! loaded)
2874 {
2875 if (! objcddAsnLoad()) {
2876 return NULL;
2877 }
2878 }
2879
2880 if (aip == NULL) {
2881 return NULL;
2882 }
2883
2884 if (orig == NULL) { /* CddDescr ::= (self contained) */
2885 atp = AsnReadId(aip, amp, CDD_DESCR);
2886 } else {
2887 atp = AsnLinkType(orig, CDD_DESCR); /* link in local tree */
2888 }
2889 if (atp == NULL) {
2890 return NULL;
2891 }
2892
2893 anp = ValNodeNew(NULL);
2894 if (anp == NULL) {
2895 goto erret;
2896 }
2897 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
2898 goto erret;
2899 }
2900
2901 func = NULL;
2902
2903 atp = AsnReadId(aip, amp, atp); /* find the choice */
2904 if (atp == NULL) {
2905 goto erret;
2906 }
2907 if (atp == CDD_DESCR_othername) {
2908 choice = CddDescr_othername;
2909 if (AsnReadVal(aip, atp, &av) <= 0) {
2910 goto erret;
2911 }
2912 anp->data.ptrvalue = av.ptrvalue;
2913 }
2914 else if (atp == CDD_DESCR_category) {
2915 choice = CddDescr_category;
2916 if (AsnReadVal(aip, atp, &av) <= 0) {
2917 goto erret;
2918 }
2919 anp->data.ptrvalue = av.ptrvalue;
2920 }
2921 else if (atp == CDD_DESCR_comment) {
2922 choice = CddDescr_comment;
2923 if (AsnReadVal(aip, atp, &av) <= 0) {
2924 goto erret;
2925 }
2926 anp->data.ptrvalue = av.ptrvalue;
2927 }
2928 else if (atp == CDD_DESCR_reference) {
2929 choice = CddDescr_reference;
2930 func = (AsnReadFunc) PubAsnRead;
2931 }
2932 else if (atp == CDD_DESCR_create_date) {
2933 choice = CddDescr_create_date;
2934 func = (AsnReadFunc) DateAsnRead;
2935 }
2936 else if (atp == CDD_DESCR_tax_source) {
2937 choice = CddDescr_tax_source;
2938 func = (AsnReadFunc) OrgRefAsnRead;
2939 }
2940 else if (atp == CDD_DESCR_source) {
2941 choice = CddDescr_source;
2942 if (AsnReadVal(aip, atp, &av) <= 0) {
2943 goto erret;
2944 }
2945 anp->data.ptrvalue = av.ptrvalue;
2946 }
2947 else if (atp == CDD_DESCR_status) {
2948 choice = CddDescr_status;
2949 if (AsnReadVal(aip, atp, &av) <= 0) {
2950 goto erret;
2951 }
2952 anp->data.intvalue = av.intvalue;
2953 }
2954 else if (atp == CDD_DESCR_update_date) {
2955 choice = CddDescr_update_date;
2956 func = (AsnReadFunc) DateAsnRead;
2957 }
2958 else if (atp == CDD_DESCR_scrapbook) {
2959 choice = CddDescr_scrapbook;
2960 anp -> data.ptrvalue =
2961 AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
2962 if (isError && anp -> data.ptrvalue == NULL) {
2963 goto erret;
2964 }
2965 }
2966 else if (atp == CDD_DESCR_source_id) {
2967 choice = CddDescr_source_id;
2968 func = (AsnReadFunc) CddIdSetAsnRead;
2969 }
2970 else if (atp == CDD_DESCR_repeats) {
2971 choice = CddDescr_repeats;
2972 func = (AsnReadFunc) CddRepeatAsnRead;
2973 }
2974 else if (atp == CDD_DESCR_old_root) {
2975 choice = CddDescr_old_root;
2976 func = (AsnReadFunc) CddIdSetAsnRead;
2977 }
2978 else if (atp == CDD_DESCR_curation_status) {
2979 choice = CddDescr_curation_status;
2980 if (AsnReadVal(aip, atp, &av) <= 0) {
2981 goto erret;
2982 }
2983 anp->data.intvalue = av.intvalue;
2984 }
2985 else if (atp == CDD_DESCR_readonly_status) {
2986 choice = CddDescr_readonly_status;
2987 if (AsnReadVal(aip, atp, &av) <= 0) {
2988 goto erret;
2989 }
2990 anp->data.intvalue = av.intvalue;
2991 }
2992 else if (atp == CDD_DESCR_book_ref) {
2993 choice = CddDescr_book_ref;
2994 func = (AsnReadFunc) CddBookRefAsnRead;
2995 }
2996 else if (atp == CDD_DESCR_attribution) {
2997 choice = CddDescr_attribution;
2998 func = (AsnReadFunc) PubAsnRead;
2999 }
3000 else if (atp == CDD_DESCR_title) {
3001 choice = CddDescr_title;
3002 if (AsnReadVal(aip, atp, &av) <= 0) {
3003 goto erret;
3004 }
3005 anp->data.ptrvalue = av.ptrvalue;
3006 }
3007 anp->choice = choice;
3008 if (func != NULL)
3009 {
3010 anp->data.ptrvalue = (* func)(aip, atp);
3011 if (aip -> io_failure) goto erret;
3012
3013 if (nullIsError && anp->data.ptrvalue == NULL) {
3014 goto erret;
3015 }
3016 }
3017
3018 ret:
3019 AsnUnlinkType(orig); /* unlink local tree */
3020 return anp;
3021
3022 erret:
3023 anp = MemFree(anp);
3024 aip -> io_failure = TRUE;
3025 goto ret;
3026 }
3027
3028
3029 /**************************************************
3030 *
3031 * CddDescrAsnWrite()
3032 *
3033 **************************************************/
3034 NLM_EXTERN Boolean LIBCALL
CddDescrAsnWrite(CddDescrPtr anp,AsnIoPtr aip,AsnTypePtr orig)3035 CddDescrAsnWrite(CddDescrPtr anp, AsnIoPtr aip, AsnTypePtr orig)
3036
3037 {
3038 DataVal av;
3039 AsnTypePtr atp, writetype = NULL;
3040 Pointer pnt;
3041 AsnWriteFunc func = NULL;
3042 Boolean retval = FALSE;
3043
3044 if (! loaded)
3045 {
3046 if (! objcddAsnLoad())
3047 return FALSE;
3048 }
3049
3050 if (aip == NULL)
3051 return FALSE;
3052
3053 atp = AsnLinkType(orig, CDD_DESCR); /* link local tree */
3054 if (atp == NULL) {
3055 return FALSE;
3056 }
3057
3058 if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3059 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
3060 av.ptrvalue = (Pointer)anp;
3061 if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
3062 goto erret;
3063 }
3064
3065 pnt = anp->data.ptrvalue;
3066 switch (anp->choice)
3067 {
3068 case CddDescr_othername:
3069 av.ptrvalue = anp->data.ptrvalue;
3070 retval = AsnWrite(aip, CDD_DESCR_othername, &av);
3071 break;
3072 case CddDescr_category:
3073 av.ptrvalue = anp->data.ptrvalue;
3074 retval = AsnWrite(aip, CDD_DESCR_category, &av);
3075 break;
3076 case CddDescr_comment:
3077 av.ptrvalue = anp->data.ptrvalue;
3078 retval = AsnWrite(aip, CDD_DESCR_comment, &av);
3079 break;
3080 case CddDescr_reference:
3081 writetype = CDD_DESCR_reference;
3082 func = (AsnWriteFunc) PubAsnWrite;
3083 break;
3084 case CddDescr_create_date:
3085 writetype = CDD_DESCR_create_date;
3086 func = (AsnWriteFunc) DateAsnWrite;
3087 break;
3088 case CddDescr_tax_source:
3089 writetype = CDD_DESCR_tax_source;
3090 func = (AsnWriteFunc) OrgRefAsnWrite;
3091 break;
3092 case CddDescr_source:
3093 av.ptrvalue = anp->data.ptrvalue;
3094 retval = AsnWrite(aip, CDD_DESCR_source, &av);
3095 break;
3096 case CddDescr_status:
3097 av.intvalue = anp->data.intvalue;
3098 retval = AsnWrite(aip, CDD_DESCR_status, &av);
3099 break;
3100 case CddDescr_update_date:
3101 writetype = CDD_DESCR_update_date;
3102 func = (AsnWriteFunc) DateAsnWrite;
3103 break;
3104 case CddDescr_scrapbook:
3105 retval = AsnGenericBaseSeqOfAsnWrite((Pointer) pnt,ASNCODE_PTRVAL_SLOT, aip, CDD_DESCR_scrapbook, CDD_DESCR_scrapbook_E); break;
3106 case CddDescr_source_id:
3107 writetype = CDD_DESCR_source_id;
3108 func = (AsnWriteFunc) CddIdSetAsnWrite;
3109 break;
3110 case CddDescr_repeats:
3111 writetype = CDD_DESCR_repeats;
3112 func = (AsnWriteFunc) CddRepeatAsnWrite;
3113 break;
3114 case CddDescr_old_root:
3115 writetype = CDD_DESCR_old_root;
3116 func = (AsnWriteFunc) CddIdSetAsnWrite;
3117 break;
3118 case CddDescr_curation_status:
3119 av.intvalue = anp->data.intvalue;
3120 retval = AsnWrite(aip, CDD_DESCR_curation_status, &av);
3121 break;
3122 case CddDescr_readonly_status:
3123 av.intvalue = anp->data.intvalue;
3124 retval = AsnWrite(aip, CDD_DESCR_readonly_status, &av);
3125 break;
3126 case CddDescr_book_ref:
3127 writetype = CDD_DESCR_book_ref;
3128 func = (AsnWriteFunc) CddBookRefAsnWrite;
3129 break;
3130 case CddDescr_attribution:
3131 writetype = CDD_DESCR_attribution;
3132 func = (AsnWriteFunc) PubAsnWrite;
3133 break;
3134 case CddDescr_title:
3135 av.ptrvalue = anp->data.ptrvalue;
3136 retval = AsnWrite(aip, CDD_DESCR_title, &av);
3137 break;
3138 }
3139 if (writetype != NULL) {
3140 retval = (* func)(pnt, aip, writetype); /* write it out */
3141 }
3142 if (!retval) {
3143 goto erret;
3144 }
3145 retval = TRUE;
3146
3147 erret:
3148 AsnUnlinkType(orig); /* unlink local tree */
3149 return retval;
3150 }
3151
3152
3153 /**************************************************
3154 *
3155 * CddDescrSetFree()
3156 *
3157 **************************************************/
3158 NLM_EXTERN
3159 CddDescrSetPtr LIBCALL
CddDescrSetFree(CddDescrSetPtr ptr)3160 CddDescrSetFree(CddDescrSetPtr ptr)
3161 {
3162
3163 if(ptr == NULL) {
3164 return NULL;
3165 }
3166 AsnGenericChoiceSeqOfFree(ptr, (AsnOptFreeFunc) CddDescrFree);
3167 return NULL;
3168 }
3169
3170
3171 /**************************************************
3172 *
3173 * CddDescrSetAsnRead()
3174 *
3175 **************************************************/
3176 NLM_EXTERN
3177 CddDescrSetPtr LIBCALL
CddDescrSetAsnRead(AsnIoPtr aip,AsnTypePtr orig)3178 CddDescrSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3179 {
3180 DataVal av;
3181 AsnTypePtr atp;
3182 Boolean isError = FALSE;
3183 AsnReadFunc func;
3184 CddDescrSetPtr ptr;
3185
3186 if (! loaded)
3187 {
3188 if (! objcddAsnLoad()) {
3189 return NULL;
3190 }
3191 }
3192
3193 if (aip == NULL) {
3194 return NULL;
3195 }
3196
3197 if (orig == NULL) { /* CddDescrSet ::= (self contained) */
3198 atp = AsnReadId(aip, amp, CDD_DESCR_SET);
3199 } else {
3200 atp = AsnLinkType(orig, CDD_DESCR_SET);
3201 }
3202 /* link in local tree */
3203 if (atp == NULL) {
3204 return NULL;
3205 }
3206
3207 func = NULL;
3208
3209 ptr = AsnGenericChoiceSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) CddDescrAsnRead, (AsnOptFreeFunc) CddDescrFree);
3210 if (isError && ptr == NULL) {
3211 goto erret;
3212 }
3213
3214
3215
3216 ret:
3217 AsnUnlinkType(orig); /* unlink local tree */
3218 return ptr;
3219
3220 erret:
3221 aip -> io_failure = TRUE;
3222 ptr = CddDescrSetFree(ptr);
3223 goto ret;
3224 }
3225
3226
3227
3228 /**************************************************
3229 *
3230 * CddDescrSetAsnWrite()
3231 *
3232 **************************************************/
3233 NLM_EXTERN Boolean LIBCALL
CddDescrSetAsnWrite(CddDescrSetPtr ptr,AsnIoPtr aip,AsnTypePtr orig)3234 CddDescrSetAsnWrite(CddDescrSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
3235 {
3236 DataVal av;
3237 AsnTypePtr atp;
3238 Boolean retval = FALSE;
3239
3240 if (! loaded)
3241 {
3242 if (! objcddAsnLoad()) {
3243 return FALSE;
3244 }
3245 }
3246
3247 if (aip == NULL) {
3248 return FALSE;
3249 }
3250
3251 atp = AsnLinkType(orig, CDD_DESCR_SET); /* link local tree */
3252 if (atp == NULL) {
3253 return FALSE;
3254 }
3255
3256 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3257 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
3258 retval = AsnGenericChoiceSeqOfAsnWrite(ptr , (AsnWriteFunc) CddDescrAsnWrite, aip, atp, CDD_DESCR_SET_E);
3259 retval = TRUE;
3260
3261 erret:
3262 AsnUnlinkType(orig); /* unlink local tree */
3263 return retval;
3264 }
3265
3266
3267
3268 /**************************************************
3269 *
3270 * MatrixNew()
3271 *
3272 **************************************************/
3273 NLM_EXTERN
3274 MatrixPtr LIBCALL
MatrixNew(void)3275 MatrixNew(void)
3276 {
3277 MatrixPtr ptr = MemNew((size_t) sizeof(Matrix));
3278
3279 return ptr;
3280
3281 }
3282
3283
3284 /**************************************************
3285 *
3286 * MatrixFree()
3287 *
3288 **************************************************/
3289 NLM_EXTERN
3290 MatrixPtr LIBCALL
MatrixFree(MatrixPtr ptr)3291 MatrixFree(MatrixPtr ptr)
3292 {
3293
3294 if(ptr == NULL) {
3295 return NULL;
3296 }
3297 AsnGenericBaseSeqOfFree(ptr -> row_labels ,ASNCODE_PTRVAL_SLOT);
3298 AsnGenericBaseSeqOfFree(ptr -> columns ,ASNCODE_INTVAL_SLOT);
3299 return MemFree(ptr);
3300 }
3301
3302
3303 /**************************************************
3304 *
3305 * MatrixAsnRead()
3306 *
3307 **************************************************/
3308 NLM_EXTERN
3309 MatrixPtr LIBCALL
MatrixAsnRead(AsnIoPtr aip,AsnTypePtr orig)3310 MatrixAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3311 {
3312 DataVal av;
3313 AsnTypePtr atp;
3314 Boolean isError = FALSE;
3315 AsnReadFunc func;
3316 MatrixPtr ptr;
3317
3318 if (! loaded)
3319 {
3320 if (! objcddAsnLoad()) {
3321 return NULL;
3322 }
3323 }
3324
3325 if (aip == NULL) {
3326 return NULL;
3327 }
3328
3329 if (orig == NULL) { /* Matrix ::= (self contained) */
3330 atp = AsnReadId(aip, amp, MATRIX);
3331 } else {
3332 atp = AsnLinkType(orig, MATRIX);
3333 }
3334 /* link in local tree */
3335 if (atp == NULL) {
3336 return NULL;
3337 }
3338
3339 ptr = MatrixNew();
3340 if (ptr == NULL) {
3341 goto erret;
3342 }
3343 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
3344 goto erret;
3345 }
3346
3347 atp = AsnReadId(aip,amp, atp);
3348 func = NULL;
3349
3350 if (atp == MATRIX_ncolumns) {
3351 if ( AsnReadVal(aip, atp, &av) <= 0) {
3352 goto erret;
3353 }
3354 ptr -> ncolumns = av.intvalue;
3355 atp = AsnReadId(aip,amp, atp);
3356 }
3357 if (atp == MATRIX_nrows) {
3358 if ( AsnReadVal(aip, atp, &av) <= 0) {
3359 goto erret;
3360 }
3361 ptr -> nrows = av.intvalue;
3362 atp = AsnReadId(aip,amp, atp);
3363 }
3364 if (atp == MATRIX_row_labels) {
3365 ptr -> row_labels = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
3366 if (isError && ptr -> row_labels == NULL) {
3367 goto erret;
3368 }
3369 atp = AsnReadId(aip,amp, atp);
3370 }
3371 if (atp == MATRIX_scale_factor) {
3372 if ( AsnReadVal(aip, atp, &av) <= 0) {
3373 goto erret;
3374 }
3375 ptr -> scale_factor = av.intvalue;
3376 atp = AsnReadId(aip,amp, atp);
3377 }
3378 if (atp == MATRIX_columns) {
3379 ptr -> columns = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_INTVAL_SLOT, &isError);
3380 if (isError && ptr -> columns == NULL) {
3381 goto erret;
3382 }
3383 atp = AsnReadId(aip,amp, atp);
3384 }
3385
3386 if (AsnReadVal(aip, atp, &av) <= 0) {
3387 goto erret;
3388 }
3389 /* end struct */
3390
3391 ret:
3392 AsnUnlinkType(orig); /* unlink local tree */
3393 return ptr;
3394
3395 erret:
3396 aip -> io_failure = TRUE;
3397 ptr = MatrixFree(ptr);
3398 goto ret;
3399 }
3400
3401
3402
3403 /**************************************************
3404 *
3405 * MatrixAsnWrite()
3406 *
3407 **************************************************/
3408 NLM_EXTERN Boolean LIBCALL
MatrixAsnWrite(MatrixPtr ptr,AsnIoPtr aip,AsnTypePtr orig)3409 MatrixAsnWrite(MatrixPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
3410 {
3411 DataVal av;
3412 AsnTypePtr atp;
3413 Boolean retval = FALSE;
3414
3415 if (! loaded)
3416 {
3417 if (! objcddAsnLoad()) {
3418 return FALSE;
3419 }
3420 }
3421
3422 if (aip == NULL) {
3423 return FALSE;
3424 }
3425
3426 atp = AsnLinkType(orig, MATRIX); /* link local tree */
3427 if (atp == NULL) {
3428 return FALSE;
3429 }
3430
3431 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3432 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
3433 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
3434 goto erret;
3435 }
3436
3437 av.intvalue = ptr -> ncolumns;
3438 retval = AsnWrite(aip, MATRIX_ncolumns, &av);
3439 av.intvalue = ptr -> nrows;
3440 retval = AsnWrite(aip, MATRIX_nrows, &av);
3441 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> row_labels ,ASNCODE_PTRVAL_SLOT, aip, MATRIX_row_labels, MATRIX_row_labels_E);
3442 av.intvalue = ptr -> scale_factor;
3443 retval = AsnWrite(aip, MATRIX_scale_factor, &av);
3444 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> columns ,ASNCODE_INTVAL_SLOT, aip, MATRIX_columns, MATRIX_columns_E);
3445 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
3446 goto erret;
3447 }
3448 retval = TRUE;
3449
3450 erret:
3451 AsnUnlinkType(orig); /* unlink local tree */
3452 return retval;
3453 }
3454
3455
3456
3457 /**************************************************
3458 *
3459 * TriangleNew()
3460 *
3461 **************************************************/
3462 NLM_EXTERN
3463 TrianglePtr LIBCALL
TriangleNew(void)3464 TriangleNew(void)
3465 {
3466 TrianglePtr ptr = MemNew((size_t) sizeof(Triangle));
3467
3468 return ptr;
3469
3470 }
3471
3472
3473 /**************************************************
3474 *
3475 * TriangleFree()
3476 *
3477 **************************************************/
3478 NLM_EXTERN
3479 TrianglePtr LIBCALL
TriangleFree(TrianglePtr ptr)3480 TriangleFree(TrianglePtr ptr)
3481 {
3482
3483 if(ptr == NULL) {
3484 return NULL;
3485 }
3486 ScoreSetFree(ptr -> scores);
3487 AsnGenericBaseSeqOfFree(ptr -> div_ranks ,ASNCODE_INTVAL_SLOT);
3488 return MemFree(ptr);
3489 }
3490
3491
3492 /**************************************************
3493 *
3494 * TriangleAsnRead()
3495 *
3496 **************************************************/
3497 NLM_EXTERN
3498 TrianglePtr LIBCALL
TriangleAsnRead(AsnIoPtr aip,AsnTypePtr orig)3499 TriangleAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3500 {
3501 DataVal av;
3502 AsnTypePtr atp;
3503 Boolean isError = FALSE;
3504 AsnReadFunc func;
3505 TrianglePtr ptr;
3506
3507 if (! loaded)
3508 {
3509 if (! objcddAsnLoad()) {
3510 return NULL;
3511 }
3512 }
3513
3514 if (aip == NULL) {
3515 return NULL;
3516 }
3517
3518 if (orig == NULL) { /* Triangle ::= (self contained) */
3519 atp = AsnReadId(aip, amp, TRIANGLE);
3520 } else {
3521 atp = AsnLinkType(orig, TRIANGLE);
3522 }
3523 /* link in local tree */
3524 if (atp == NULL) {
3525 return NULL;
3526 }
3527
3528 ptr = TriangleNew();
3529 if (ptr == NULL) {
3530 goto erret;
3531 }
3532 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
3533 goto erret;
3534 }
3535
3536 atp = AsnReadId(aip,amp, atp);
3537 func = NULL;
3538
3539 if (atp == TRIANGLE_nelements) {
3540 if ( AsnReadVal(aip, atp, &av) <= 0) {
3541 goto erret;
3542 }
3543 ptr -> nelements = av.intvalue;
3544 atp = AsnReadId(aip,amp, atp);
3545 }
3546 if (atp == TRIANGLE_scores) {
3547 ptr -> scores = ScoreSetAsnRead(aip, atp);
3548 if (aip -> io_failure) {
3549 goto erret;
3550 }
3551 atp = AsnReadId(aip,amp, atp);
3552 }
3553 if (atp == TRIANGLE_div_ranks) {
3554 ptr -> div_ranks = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_INTVAL_SLOT, &isError);
3555 if (isError && ptr -> div_ranks == NULL) {
3556 goto erret;
3557 }
3558 atp = AsnReadId(aip,amp, atp);
3559 }
3560
3561 if (AsnReadVal(aip, atp, &av) <= 0) {
3562 goto erret;
3563 }
3564 /* end struct */
3565
3566 ret:
3567 AsnUnlinkType(orig); /* unlink local tree */
3568 return ptr;
3569
3570 erret:
3571 aip -> io_failure = TRUE;
3572 ptr = TriangleFree(ptr);
3573 goto ret;
3574 }
3575
3576
3577
3578 /**************************************************
3579 *
3580 * TriangleAsnWrite()
3581 *
3582 **************************************************/
3583 NLM_EXTERN Boolean LIBCALL
TriangleAsnWrite(TrianglePtr ptr,AsnIoPtr aip,AsnTypePtr orig)3584 TriangleAsnWrite(TrianglePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
3585 {
3586 DataVal av;
3587 AsnTypePtr atp;
3588 Boolean retval = FALSE;
3589
3590 if (! loaded)
3591 {
3592 if (! objcddAsnLoad()) {
3593 return FALSE;
3594 }
3595 }
3596
3597 if (aip == NULL) {
3598 return FALSE;
3599 }
3600
3601 atp = AsnLinkType(orig, TRIANGLE); /* link local tree */
3602 if (atp == NULL) {
3603 return FALSE;
3604 }
3605
3606 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3607 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
3608 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
3609 goto erret;
3610 }
3611
3612 av.intvalue = ptr -> nelements;
3613 retval = AsnWrite(aip, TRIANGLE_nelements, &av);
3614 if (ptr -> scores != NULL) {
3615 if ( ! ScoreSetAsnWrite(ptr -> scores, aip, TRIANGLE_scores)) {
3616 goto erret;
3617 }
3618 }
3619 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> div_ranks ,ASNCODE_INTVAL_SLOT, aip, TRIANGLE_div_ranks, TRIANGLE_div_ranks_E);
3620 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
3621 goto erret;
3622 }
3623 retval = TRUE;
3624
3625 erret:
3626 AsnUnlinkType(orig); /* unlink local tree */
3627 return retval;
3628 }
3629
3630
3631
3632 /**************************************************
3633 *
3634 * UpdateCommentFree()
3635 *
3636 **************************************************/
3637 NLM_EXTERN
3638 UpdateCommentPtr LIBCALL
UpdateCommentFree(ValNodePtr anp)3639 UpdateCommentFree(ValNodePtr anp)
3640 {
3641 Pointer pnt;
3642
3643 if (anp == NULL) {
3644 return NULL;
3645 }
3646
3647 pnt = anp->data.ptrvalue;
3648 switch (anp->choice)
3649 {
3650 default:
3651 break;
3652 case UpdateComment_comment:
3653 MemFree(anp -> data.ptrvalue);
3654 break;
3655 case UpdateComment_addthis:
3656 SeqLocFree(anp -> data.ptrvalue);
3657 break;
3658 case UpdateComment_replaces:
3659 SeqLocFree(anp -> data.ptrvalue);
3660 break;
3661 case UpdateComment_reject_loc:
3662 SeqLocFree(anp -> data.ptrvalue);
3663 break;
3664 case UpdateComment_reference:
3665 PubFree(anp -> data.ptrvalue);
3666 break;
3667 }
3668 return MemFree(anp);
3669 }
3670
3671
3672 /**************************************************
3673 *
3674 * UpdateCommentAsnRead()
3675 *
3676 **************************************************/
3677 NLM_EXTERN
3678 UpdateCommentPtr LIBCALL
UpdateCommentAsnRead(AsnIoPtr aip,AsnTypePtr orig)3679 UpdateCommentAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3680 {
3681 DataVal av;
3682 AsnTypePtr atp;
3683 ValNodePtr anp;
3684 Uint1 choice;
3685 Boolean isError = FALSE;
3686 Boolean nullIsError = FALSE;
3687 AsnReadFunc func;
3688
3689 if (! loaded)
3690 {
3691 if (! objcddAsnLoad()) {
3692 return NULL;
3693 }
3694 }
3695
3696 if (aip == NULL) {
3697 return NULL;
3698 }
3699
3700 if (orig == NULL) { /* UpdateComment ::= (self contained) */
3701 atp = AsnReadId(aip, amp, UPDATE_COMMENT);
3702 } else {
3703 atp = AsnLinkType(orig, UPDATE_COMMENT); /* link in local tree */
3704 }
3705 if (atp == NULL) {
3706 return NULL;
3707 }
3708
3709 anp = ValNodeNew(NULL);
3710 if (anp == NULL) {
3711 goto erret;
3712 }
3713 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
3714 goto erret;
3715 }
3716
3717 func = NULL;
3718
3719 atp = AsnReadId(aip, amp, atp); /* find the choice */
3720 if (atp == NULL) {
3721 goto erret;
3722 }
3723 if (atp == UPDATE_COMMENT_comment) {
3724 choice = UpdateComment_comment;
3725 if (AsnReadVal(aip, atp, &av) <= 0) {
3726 goto erret;
3727 }
3728 anp->data.ptrvalue = av.ptrvalue;
3729 }
3730 else if (atp == UPDATE_COMMENT_addthis) {
3731 choice = UpdateComment_addthis;
3732 func = (AsnReadFunc) SeqLocAsnRead;
3733 }
3734 else if (atp == UPDATE_COMMENT_replaces) {
3735 choice = UpdateComment_replaces;
3736 func = (AsnReadFunc) SeqLocAsnRead;
3737 }
3738 else if (atp == UPDATE_COMMENT_reject_loc) {
3739 choice = UpdateComment_reject_loc;
3740 func = (AsnReadFunc) SeqLocAsnRead;
3741 }
3742 else if (atp == UPDATE_COMMENT_reference) {
3743 choice = UpdateComment_reference;
3744 func = (AsnReadFunc) PubAsnRead;
3745 }
3746 anp->choice = choice;
3747 if (func != NULL)
3748 {
3749 anp->data.ptrvalue = (* func)(aip, atp);
3750 if (aip -> io_failure) goto erret;
3751
3752 if (nullIsError && anp->data.ptrvalue == NULL) {
3753 goto erret;
3754 }
3755 }
3756
3757 ret:
3758 AsnUnlinkType(orig); /* unlink local tree */
3759 return anp;
3760
3761 erret:
3762 anp = MemFree(anp);
3763 aip -> io_failure = TRUE;
3764 goto ret;
3765 }
3766
3767
3768 /**************************************************
3769 *
3770 * UpdateCommentAsnWrite()
3771 *
3772 **************************************************/
3773 NLM_EXTERN Boolean LIBCALL
UpdateCommentAsnWrite(UpdateCommentPtr anp,AsnIoPtr aip,AsnTypePtr orig)3774 UpdateCommentAsnWrite(UpdateCommentPtr anp, AsnIoPtr aip, AsnTypePtr orig)
3775
3776 {
3777 DataVal av;
3778 AsnTypePtr atp, writetype = NULL;
3779 Pointer pnt;
3780 AsnWriteFunc func = NULL;
3781 Boolean retval = FALSE;
3782
3783 if (! loaded)
3784 {
3785 if (! objcddAsnLoad())
3786 return FALSE;
3787 }
3788
3789 if (aip == NULL)
3790 return FALSE;
3791
3792 atp = AsnLinkType(orig, UPDATE_COMMENT); /* link local tree */
3793 if (atp == NULL) {
3794 return FALSE;
3795 }
3796
3797 if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3798 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
3799 av.ptrvalue = (Pointer)anp;
3800 if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
3801 goto erret;
3802 }
3803
3804 pnt = anp->data.ptrvalue;
3805 switch (anp->choice)
3806 {
3807 case UpdateComment_comment:
3808 av.ptrvalue = anp->data.ptrvalue;
3809 retval = AsnWrite(aip, UPDATE_COMMENT_comment, &av);
3810 break;
3811 case UpdateComment_addthis:
3812 writetype = UPDATE_COMMENT_addthis;
3813 func = (AsnWriteFunc) SeqLocAsnWrite;
3814 break;
3815 case UpdateComment_replaces:
3816 writetype = UPDATE_COMMENT_replaces;
3817 func = (AsnWriteFunc) SeqLocAsnWrite;
3818 break;
3819 case UpdateComment_reject_loc:
3820 writetype = UPDATE_COMMENT_reject_loc;
3821 func = (AsnWriteFunc) SeqLocAsnWrite;
3822 break;
3823 case UpdateComment_reference:
3824 writetype = UPDATE_COMMENT_reference;
3825 func = (AsnWriteFunc) PubAsnWrite;
3826 break;
3827 }
3828 if (writetype != NULL) {
3829 retval = (* func)(pnt, aip, writetype); /* write it out */
3830 }
3831 if (!retval) {
3832 goto erret;
3833 }
3834 retval = TRUE;
3835
3836 erret:
3837 AsnUnlinkType(orig); /* unlink local tree */
3838 return retval;
3839 }
3840
3841
3842 /**************************************************
3843 *
3844 * UpdateAlignNew()
3845 *
3846 **************************************************/
3847 NLM_EXTERN
3848 UpdateAlignPtr LIBCALL
UpdateAlignNew(void)3849 UpdateAlignNew(void)
3850 {
3851 UpdateAlignPtr ptr = MemNew((size_t) sizeof(UpdateAlign));
3852
3853 return ptr;
3854
3855 }
3856
3857
3858 /**************************************************
3859 *
3860 * UpdateAlignFree()
3861 *
3862 **************************************************/
3863 NLM_EXTERN
3864 UpdateAlignPtr LIBCALL
UpdateAlignFree(UpdateAlignPtr ptr)3865 UpdateAlignFree(UpdateAlignPtr ptr)
3866 {
3867
3868 if(ptr == NULL) {
3869 return NULL;
3870 }
3871 AsnGenericChoiceSeqOfFree(ptr -> description, (AsnOptFreeFunc) UpdateCommentFree);
3872 SeqAnnotFree(ptr -> seqannot);
3873 return MemFree(ptr);
3874 }
3875
3876
3877 /**************************************************
3878 *
3879 * UpdateAlignAsnRead()
3880 *
3881 **************************************************/
3882 NLM_EXTERN
3883 UpdateAlignPtr LIBCALL
UpdateAlignAsnRead(AsnIoPtr aip,AsnTypePtr orig)3884 UpdateAlignAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3885 {
3886 DataVal av;
3887 AsnTypePtr atp;
3888 Boolean isError = FALSE;
3889 AsnReadFunc func;
3890 UpdateAlignPtr ptr;
3891
3892 if (! loaded)
3893 {
3894 if (! objcddAsnLoad()) {
3895 return NULL;
3896 }
3897 }
3898
3899 if (aip == NULL) {
3900 return NULL;
3901 }
3902
3903 if (orig == NULL) { /* UpdateAlign ::= (self contained) */
3904 atp = AsnReadId(aip, amp, UPDATE_ALIGN);
3905 } else {
3906 atp = AsnLinkType(orig, UPDATE_ALIGN);
3907 }
3908 /* link in local tree */
3909 if (atp == NULL) {
3910 return NULL;
3911 }
3912
3913 ptr = UpdateAlignNew();
3914 if (ptr == NULL) {
3915 goto erret;
3916 }
3917 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
3918 goto erret;
3919 }
3920
3921 atp = AsnReadId(aip,amp, atp);
3922 func = NULL;
3923
3924 if (atp == UPDATE_ALIGN_description) {
3925 ptr -> description = AsnGenericChoiceSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) UpdateCommentAsnRead, (AsnOptFreeFunc) UpdateCommentFree);
3926 if (isError && ptr -> description == NULL) {
3927 goto erret;
3928 }
3929 atp = AsnReadId(aip,amp, atp);
3930 }
3931 if (atp == UPDATE_ALIGN_seqannot) {
3932 ptr -> seqannot = SeqAnnotAsnRead(aip, atp);
3933 if (aip -> io_failure) {
3934 goto erret;
3935 }
3936 atp = AsnReadId(aip,amp, atp);
3937 }
3938 if (atp == UPDATE_ALIGN_type) {
3939 if ( AsnReadVal(aip, atp, &av) <= 0) {
3940 goto erret;
3941 }
3942 ptr -> type = av.intvalue;
3943 atp = AsnReadId(aip,amp, atp);
3944 }
3945
3946 if (AsnReadVal(aip, atp, &av) <= 0) {
3947 goto erret;
3948 }
3949 /* end struct */
3950
3951 ret:
3952 AsnUnlinkType(orig); /* unlink local tree */
3953 return ptr;
3954
3955 erret:
3956 aip -> io_failure = TRUE;
3957 ptr = UpdateAlignFree(ptr);
3958 goto ret;
3959 }
3960
3961
3962
3963 /**************************************************
3964 *
3965 * UpdateAlignAsnWrite()
3966 *
3967 **************************************************/
3968 NLM_EXTERN Boolean LIBCALL
UpdateAlignAsnWrite(UpdateAlignPtr ptr,AsnIoPtr aip,AsnTypePtr orig)3969 UpdateAlignAsnWrite(UpdateAlignPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
3970 {
3971 DataVal av;
3972 AsnTypePtr atp;
3973 Boolean retval = FALSE;
3974
3975 if (! loaded)
3976 {
3977 if (! objcddAsnLoad()) {
3978 return FALSE;
3979 }
3980 }
3981
3982 if (aip == NULL) {
3983 return FALSE;
3984 }
3985
3986 atp = AsnLinkType(orig, UPDATE_ALIGN); /* link local tree */
3987 if (atp == NULL) {
3988 return FALSE;
3989 }
3990
3991 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3992 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
3993 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
3994 goto erret;
3995 }
3996
3997 AsnGenericChoiceSeqOfAsnWrite(ptr -> description, (AsnWriteFunc) UpdateCommentAsnWrite, aip, UPDATE_ALIGN_description, UPDATE_ALIGN_description_E);
3998 if (ptr -> seqannot != NULL) {
3999 if ( ! SeqAnnotAsnWrite(ptr -> seqannot, aip, UPDATE_ALIGN_seqannot)) {
4000 goto erret;
4001 }
4002 }
4003 av.intvalue = ptr -> type;
4004 retval = AsnWrite(aip, UPDATE_ALIGN_type, &av);
4005 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4006 goto erret;
4007 }
4008 retval = TRUE;
4009
4010 erret:
4011 AsnUnlinkType(orig); /* unlink local tree */
4012 return retval;
4013 }
4014
4015
4016
4017 /**************************************************
4018 *
4019 * RejectIdNew()
4020 *
4021 **************************************************/
4022 NLM_EXTERN
4023 RejectIdPtr LIBCALL
RejectIdNew(void)4024 RejectIdNew(void)
4025 {
4026 RejectIdPtr ptr = MemNew((size_t) sizeof(RejectId));
4027
4028 return ptr;
4029
4030 }
4031
4032
4033 /**************************************************
4034 *
4035 * RejectIdFree()
4036 *
4037 **************************************************/
4038 NLM_EXTERN
4039 RejectIdPtr LIBCALL
RejectIdFree(RejectIdPtr ptr)4040 RejectIdFree(RejectIdPtr ptr)
4041 {
4042
4043 if(ptr == NULL) {
4044 return NULL;
4045 }
4046 AsnGenericChoiceSeqOfFree(ptr -> description, (AsnOptFreeFunc) UpdateCommentFree);
4047 AsnGenericChoiceSeqOfFree(ptr -> ids, (AsnOptFreeFunc) SeqIdFree);
4048 return MemFree(ptr);
4049 }
4050
4051
4052 /**************************************************
4053 *
4054 * RejectIdAsnRead()
4055 *
4056 **************************************************/
4057 NLM_EXTERN
4058 RejectIdPtr LIBCALL
RejectIdAsnRead(AsnIoPtr aip,AsnTypePtr orig)4059 RejectIdAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4060 {
4061 DataVal av;
4062 AsnTypePtr atp;
4063 Boolean isError = FALSE;
4064 AsnReadFunc func;
4065 RejectIdPtr ptr;
4066
4067 if (! loaded)
4068 {
4069 if (! objcddAsnLoad()) {
4070 return NULL;
4071 }
4072 }
4073
4074 if (aip == NULL) {
4075 return NULL;
4076 }
4077
4078 if (orig == NULL) { /* RejectId ::= (self contained) */
4079 atp = AsnReadId(aip, amp, REJECT_ID);
4080 } else {
4081 atp = AsnLinkType(orig, REJECT_ID);
4082 }
4083 /* link in local tree */
4084 if (atp == NULL) {
4085 return NULL;
4086 }
4087
4088 ptr = RejectIdNew();
4089 if (ptr == NULL) {
4090 goto erret;
4091 }
4092 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4093 goto erret;
4094 }
4095
4096 atp = AsnReadId(aip,amp, atp);
4097 func = NULL;
4098
4099 if (atp == REJECT_ID_description) {
4100 ptr -> description = AsnGenericChoiceSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) UpdateCommentAsnRead, (AsnOptFreeFunc) UpdateCommentFree);
4101 if (isError && ptr -> description == NULL) {
4102 goto erret;
4103 }
4104 atp = AsnReadId(aip,amp, atp);
4105 }
4106 if (atp == REJECT_ID_ids) {
4107 ptr -> ids = AsnGenericChoiceSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) SeqIdAsnRead, (AsnOptFreeFunc) SeqIdFree);
4108 if (isError && ptr -> ids == NULL) {
4109 goto erret;
4110 }
4111 atp = AsnReadId(aip,amp, atp);
4112 }
4113
4114 if (AsnReadVal(aip, atp, &av) <= 0) {
4115 goto erret;
4116 }
4117 /* end struct */
4118
4119 ret:
4120 AsnUnlinkType(orig); /* unlink local tree */
4121 return ptr;
4122
4123 erret:
4124 aip -> io_failure = TRUE;
4125 ptr = RejectIdFree(ptr);
4126 goto ret;
4127 }
4128
4129
4130
4131 /**************************************************
4132 *
4133 * RejectIdAsnWrite()
4134 *
4135 **************************************************/
4136 NLM_EXTERN Boolean LIBCALL
RejectIdAsnWrite(RejectIdPtr ptr,AsnIoPtr aip,AsnTypePtr orig)4137 RejectIdAsnWrite(RejectIdPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
4138 {
4139 DataVal av;
4140 AsnTypePtr atp;
4141 Boolean retval = FALSE;
4142
4143 if (! loaded)
4144 {
4145 if (! objcddAsnLoad()) {
4146 return FALSE;
4147 }
4148 }
4149
4150 if (aip == NULL) {
4151 return FALSE;
4152 }
4153
4154 atp = AsnLinkType(orig, REJECT_ID); /* link local tree */
4155 if (atp == NULL) {
4156 return FALSE;
4157 }
4158
4159 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4160 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
4161 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
4162 goto erret;
4163 }
4164
4165 AsnGenericChoiceSeqOfAsnWrite(ptr -> description, (AsnWriteFunc) UpdateCommentAsnWrite, aip, REJECT_ID_description, REJECT_ID_description_E);
4166 AsnGenericChoiceSeqOfAsnWrite(ptr -> ids, (AsnWriteFunc) SeqIdAsnWrite, aip, REJECT_ID_ids, REJECT_ID_ids_E);
4167 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4168 goto erret;
4169 }
4170 retval = TRUE;
4171
4172 erret:
4173 AsnUnlinkType(orig); /* unlink local tree */
4174 return retval;
4175 }
4176
4177
4178
4179 /**************************************************
4180 *
4181 * FeatureEvidenceFree()
4182 *
4183 **************************************************/
4184 NLM_EXTERN
4185 FeatureEvidencePtr LIBCALL
FeatureEvidenceFree(ValNodePtr anp)4186 FeatureEvidenceFree(ValNodePtr anp)
4187 {
4188 Pointer pnt;
4189
4190 if (anp == NULL) {
4191 return NULL;
4192 }
4193
4194 pnt = anp->data.ptrvalue;
4195 switch (anp->choice)
4196 {
4197 default:
4198 break;
4199 case FeatureEvidence_comment:
4200 MemFree(anp -> data.ptrvalue);
4201 break;
4202 case FeatureEvidence_reference:
4203 PubFree(anp -> data.ptrvalue);
4204 break;
4205 case FeatureEvidence_bsannot:
4206 BiostrucAnnotSetFree(anp -> data.ptrvalue);
4207 break;
4208 case FeatureEvidence_seqfeat:
4209 SeqFeatFree(anp -> data.ptrvalue);
4210 break;
4211 case FeatureEvidence_book_ref:
4212 CddBookRefFree(anp -> data.ptrvalue);
4213 break;
4214 }
4215 return MemFree(anp);
4216 }
4217
4218
4219 /**************************************************
4220 *
4221 * FeatureEvidenceAsnRead()
4222 *
4223 **************************************************/
4224 NLM_EXTERN
4225 FeatureEvidencePtr LIBCALL
FeatureEvidenceAsnRead(AsnIoPtr aip,AsnTypePtr orig)4226 FeatureEvidenceAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4227 {
4228 DataVal av;
4229 AsnTypePtr atp;
4230 ValNodePtr anp;
4231 Uint1 choice;
4232 Boolean isError = FALSE;
4233 Boolean nullIsError = FALSE;
4234 AsnReadFunc func;
4235
4236 if (! loaded)
4237 {
4238 if (! objcddAsnLoad()) {
4239 return NULL;
4240 }
4241 }
4242
4243 if (aip == NULL) {
4244 return NULL;
4245 }
4246
4247 if (orig == NULL) { /* FeatureEvidence ::= (self contained) */
4248 atp = AsnReadId(aip, amp, FEATURE_EVIDENCE);
4249 } else {
4250 atp = AsnLinkType(orig, FEATURE_EVIDENCE); /* link in local tree */
4251 }
4252 if (atp == NULL) {
4253 return NULL;
4254 }
4255
4256 anp = ValNodeNew(NULL);
4257 if (anp == NULL) {
4258 goto erret;
4259 }
4260 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
4261 goto erret;
4262 }
4263
4264 func = NULL;
4265
4266 atp = AsnReadId(aip, amp, atp); /* find the choice */
4267 if (atp == NULL) {
4268 goto erret;
4269 }
4270 if (atp == FEATURE_EVIDENCE_comment) {
4271 choice = FeatureEvidence_comment;
4272 if (AsnReadVal(aip, atp, &av) <= 0) {
4273 goto erret;
4274 }
4275 anp->data.ptrvalue = av.ptrvalue;
4276 }
4277 else if (atp == FEATURE_EVIDENCE_reference) {
4278 choice = FeatureEvidence_reference;
4279 func = (AsnReadFunc) PubAsnRead;
4280 }
4281 else if (atp == FEATURE_EVIDENCE_bsannot) {
4282 choice = FeatureEvidence_bsannot;
4283 func = (AsnReadFunc) BiostrucAnnotSetAsnRead;
4284 }
4285 else if (atp == FEATURE_EVIDENCE_seqfeat) {
4286 choice = FeatureEvidence_seqfeat;
4287 func = (AsnReadFunc) SeqFeatAsnRead;
4288 }
4289 else if (atp == FEATURE_EVIDENCE_book_ref) {
4290 choice = FeatureEvidence_book_ref;
4291 func = (AsnReadFunc) CddBookRefAsnRead;
4292 }
4293 anp->choice = choice;
4294 if (func != NULL)
4295 {
4296 anp->data.ptrvalue = (* func)(aip, atp);
4297 if (aip -> io_failure) goto erret;
4298
4299 if (nullIsError && anp->data.ptrvalue == NULL) {
4300 goto erret;
4301 }
4302 }
4303
4304 ret:
4305 AsnUnlinkType(orig); /* unlink local tree */
4306 return anp;
4307
4308 erret:
4309 anp = MemFree(anp);
4310 aip -> io_failure = TRUE;
4311 goto ret;
4312 }
4313
4314
4315 /**************************************************
4316 *
4317 * FeatureEvidenceAsnWrite()
4318 *
4319 **************************************************/
4320 NLM_EXTERN Boolean LIBCALL
FeatureEvidenceAsnWrite(FeatureEvidencePtr anp,AsnIoPtr aip,AsnTypePtr orig)4321 FeatureEvidenceAsnWrite(FeatureEvidencePtr anp, AsnIoPtr aip, AsnTypePtr orig)
4322
4323 {
4324 DataVal av;
4325 AsnTypePtr atp, writetype = NULL;
4326 Pointer pnt;
4327 AsnWriteFunc func = NULL;
4328 Boolean retval = FALSE;
4329
4330 if (! loaded)
4331 {
4332 if (! objcddAsnLoad())
4333 return FALSE;
4334 }
4335
4336 if (aip == NULL)
4337 return FALSE;
4338
4339 atp = AsnLinkType(orig, FEATURE_EVIDENCE); /* link local tree */
4340 if (atp == NULL) {
4341 return FALSE;
4342 }
4343
4344 if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4345 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
4346 av.ptrvalue = (Pointer)anp;
4347 if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
4348 goto erret;
4349 }
4350
4351 pnt = anp->data.ptrvalue;
4352 switch (anp->choice)
4353 {
4354 case FeatureEvidence_comment:
4355 av.ptrvalue = anp->data.ptrvalue;
4356 retval = AsnWrite(aip, FEATURE_EVIDENCE_comment, &av);
4357 break;
4358 case FeatureEvidence_reference:
4359 writetype = FEATURE_EVIDENCE_reference;
4360 func = (AsnWriteFunc) PubAsnWrite;
4361 break;
4362 case FeatureEvidence_bsannot:
4363 writetype = FEATURE_EVIDENCE_bsannot;
4364 func = (AsnWriteFunc) BiostrucAnnotSetAsnWrite;
4365 break;
4366 case FeatureEvidence_seqfeat:
4367 writetype = FEATURE_EVIDENCE_seqfeat;
4368 func = (AsnWriteFunc) SeqFeatAsnWrite;
4369 break;
4370 case FeatureEvidence_book_ref:
4371 writetype = FEATURE_EVIDENCE_book_ref;
4372 func = (AsnWriteFunc) CddBookRefAsnWrite;
4373 break;
4374 }
4375 if (writetype != NULL) {
4376 retval = (* func)(pnt, aip, writetype); /* write it out */
4377 }
4378 if (!retval) {
4379 goto erret;
4380 }
4381 retval = TRUE;
4382
4383 erret:
4384 AsnUnlinkType(orig); /* unlink local tree */
4385 return retval;
4386 }
4387
4388
4389 /**************************************************
4390 *
4391 * AlignAnnotNew()
4392 *
4393 **************************************************/
4394 NLM_EXTERN
4395 AlignAnnotPtr LIBCALL
AlignAnnotNew(void)4396 AlignAnnotNew(void)
4397 {
4398 AlignAnnotPtr ptr = MemNew((size_t) sizeof(AlignAnnot));
4399
4400 return ptr;
4401
4402 }
4403
4404
4405 /**************************************************
4406 *
4407 * AlignAnnotFree()
4408 *
4409 **************************************************/
4410 NLM_EXTERN
4411 AlignAnnotPtr LIBCALL
AlignAnnotFree(AlignAnnotPtr ptr)4412 AlignAnnotFree(AlignAnnotPtr ptr)
4413 {
4414
4415 if(ptr == NULL) {
4416 return NULL;
4417 }
4418 SeqLocFree(ptr -> location);
4419 MemFree(ptr -> description);
4420 AsnGenericChoiceSeqOfFree(ptr -> evidence, (AsnOptFreeFunc) FeatureEvidenceFree);
4421 return MemFree(ptr);
4422 }
4423
4424
4425 /**************************************************
4426 *
4427 * AlignAnnotAsnRead()
4428 *
4429 **************************************************/
4430 NLM_EXTERN
4431 AlignAnnotPtr LIBCALL
AlignAnnotAsnRead(AsnIoPtr aip,AsnTypePtr orig)4432 AlignAnnotAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4433 {
4434 DataVal av;
4435 AsnTypePtr atp;
4436 Boolean isError = FALSE;
4437 AsnReadFunc func;
4438 AlignAnnotPtr ptr;
4439
4440 if (! loaded)
4441 {
4442 if (! objcddAsnLoad()) {
4443 return NULL;
4444 }
4445 }
4446
4447 if (aip == NULL) {
4448 return NULL;
4449 }
4450
4451 if (orig == NULL) { /* AlignAnnot ::= (self contained) */
4452 atp = AsnReadId(aip, amp, ALIGN_ANNOT);
4453 } else {
4454 atp = AsnLinkType(orig, ALIGN_ANNOT);
4455 }
4456 /* link in local tree */
4457 if (atp == NULL) {
4458 return NULL;
4459 }
4460
4461 ptr = AlignAnnotNew();
4462 if (ptr == NULL) {
4463 goto erret;
4464 }
4465 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4466 goto erret;
4467 }
4468
4469 atp = AsnReadId(aip,amp, atp);
4470 func = NULL;
4471
4472 if (atp == ALIGN_ANNOT_location) {
4473 ptr -> location = SeqLocAsnRead(aip, atp);
4474 if (aip -> io_failure) {
4475 goto erret;
4476 }
4477 atp = AsnReadId(aip,amp, atp);
4478 }
4479 if (atp == ALIGN_ANNOT_description) {
4480 if ( AsnReadVal(aip, atp, &av) <= 0) {
4481 goto erret;
4482 }
4483 ptr -> description = av.ptrvalue;
4484 atp = AsnReadId(aip,amp, atp);
4485 }
4486 if (atp == ALIGN_ANNOT_evidence) {
4487 ptr -> evidence = AsnGenericChoiceSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) FeatureEvidenceAsnRead, (AsnOptFreeFunc) FeatureEvidenceFree);
4488 if (isError && ptr -> evidence == NULL) {
4489 goto erret;
4490 }
4491 atp = AsnReadId(aip,amp, atp);
4492 }
4493 if (atp == ALIGN_ANNOT_type) {
4494 if ( AsnReadVal(aip, atp, &av) <= 0) {
4495 goto erret;
4496 }
4497 ptr -> type = av.intvalue;
4498 atp = AsnReadId(aip,amp, atp);
4499 }
4500
4501 if (AsnReadVal(aip, atp, &av) <= 0) {
4502 goto erret;
4503 }
4504 /* end struct */
4505
4506 ret:
4507 AsnUnlinkType(orig); /* unlink local tree */
4508 return ptr;
4509
4510 erret:
4511 aip -> io_failure = TRUE;
4512 ptr = AlignAnnotFree(ptr);
4513 goto ret;
4514 }
4515
4516
4517
4518 /**************************************************
4519 *
4520 * AlignAnnotAsnWrite()
4521 *
4522 **************************************************/
4523 NLM_EXTERN Boolean LIBCALL
AlignAnnotAsnWrite(AlignAnnotPtr ptr,AsnIoPtr aip,AsnTypePtr orig)4524 AlignAnnotAsnWrite(AlignAnnotPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
4525 {
4526 DataVal av;
4527 AsnTypePtr atp;
4528 Boolean retval = FALSE;
4529
4530 if (! loaded)
4531 {
4532 if (! objcddAsnLoad()) {
4533 return FALSE;
4534 }
4535 }
4536
4537 if (aip == NULL) {
4538 return FALSE;
4539 }
4540
4541 atp = AsnLinkType(orig, ALIGN_ANNOT); /* link local tree */
4542 if (atp == NULL) {
4543 return FALSE;
4544 }
4545
4546 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4547 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
4548 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
4549 goto erret;
4550 }
4551
4552 if (ptr -> location != NULL) {
4553 if ( ! SeqLocAsnWrite(ptr -> location, aip, ALIGN_ANNOT_location)) {
4554 goto erret;
4555 }
4556 }
4557 if (ptr -> description != NULL) {
4558 av.ptrvalue = ptr -> description;
4559 retval = AsnWrite(aip, ALIGN_ANNOT_description, &av);
4560 }
4561 AsnGenericChoiceSeqOfAsnWrite(ptr -> evidence, (AsnWriteFunc) FeatureEvidenceAsnWrite, aip, ALIGN_ANNOT_evidence, ALIGN_ANNOT_evidence_E);
4562 av.intvalue = ptr -> type;
4563 retval = AsnWrite(aip, ALIGN_ANNOT_type, &av);
4564 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4565 goto erret;
4566 }
4567 retval = TRUE;
4568
4569 erret:
4570 AsnUnlinkType(orig); /* unlink local tree */
4571 return retval;
4572 }
4573
4574
4575
4576 /**************************************************
4577 *
4578 * AlignAnnotSetFree()
4579 *
4580 **************************************************/
4581 NLM_EXTERN
4582 AlignAnnotSetPtr LIBCALL
AlignAnnotSetFree(AlignAnnotSetPtr ptr)4583 AlignAnnotSetFree(AlignAnnotSetPtr ptr)
4584 {
4585
4586 if(ptr == NULL) {
4587 return NULL;
4588 }
4589 AsnGenericUserSeqOfFree(ptr, (AsnOptFreeFunc) AlignAnnotFree);
4590 return NULL;
4591 }
4592
4593
4594 /**************************************************
4595 *
4596 * AlignAnnotSetAsnRead()
4597 *
4598 **************************************************/
4599 NLM_EXTERN
4600 AlignAnnotSetPtr LIBCALL
AlignAnnotSetAsnRead(AsnIoPtr aip,AsnTypePtr orig)4601 AlignAnnotSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4602 {
4603 DataVal av;
4604 AsnTypePtr atp;
4605 Boolean isError = FALSE;
4606 AsnReadFunc func;
4607 AlignAnnotSetPtr ptr;
4608
4609 if (! loaded)
4610 {
4611 if (! objcddAsnLoad()) {
4612 return NULL;
4613 }
4614 }
4615
4616 if (aip == NULL) {
4617 return NULL;
4618 }
4619
4620 if (orig == NULL) { /* AlignAnnotSet ::= (self contained) */
4621 atp = AsnReadId(aip, amp, ALIGN_ANNOT_SET);
4622 } else {
4623 atp = AsnLinkType(orig, ALIGN_ANNOT_SET);
4624 }
4625 /* link in local tree */
4626 if (atp == NULL) {
4627 return NULL;
4628 }
4629
4630 func = NULL;
4631
4632 ptr = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) AlignAnnotAsnRead, (AsnOptFreeFunc) AlignAnnotFree);
4633 if (isError && ptr == NULL) {
4634 goto erret;
4635 }
4636
4637
4638
4639 ret:
4640 AsnUnlinkType(orig); /* unlink local tree */
4641 return ptr;
4642
4643 erret:
4644 aip -> io_failure = TRUE;
4645 ptr = AlignAnnotSetFree(ptr);
4646 goto ret;
4647 }
4648
4649
4650
4651 /**************************************************
4652 *
4653 * AlignAnnotSetAsnWrite()
4654 *
4655 **************************************************/
4656 NLM_EXTERN Boolean LIBCALL
AlignAnnotSetAsnWrite(AlignAnnotSetPtr ptr,AsnIoPtr aip,AsnTypePtr orig)4657 AlignAnnotSetAsnWrite(AlignAnnotSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
4658 {
4659 DataVal av;
4660 AsnTypePtr atp;
4661 Boolean retval = FALSE;
4662
4663 if (! loaded)
4664 {
4665 if (! objcddAsnLoad()) {
4666 return FALSE;
4667 }
4668 }
4669
4670 if (aip == NULL) {
4671 return FALSE;
4672 }
4673
4674 atp = AsnLinkType(orig, ALIGN_ANNOT_SET); /* link local tree */
4675 if (atp == NULL) {
4676 return FALSE;
4677 }
4678
4679 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4680 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
4681 retval = AsnGenericUserSeqOfAsnWrite(ptr , (AsnWriteFunc) AlignAnnotAsnWrite, aip, atp, ALIGN_ANNOT_SET_E);
4682 retval = TRUE;
4683
4684 erret:
4685 AsnUnlinkType(orig); /* unlink local tree */
4686 return retval;
4687 }
4688
4689
4690
4691 /**************************************************
4692 *
4693 * DomainParentNew()
4694 *
4695 **************************************************/
4696 NLM_EXTERN
4697 DomainParentPtr LIBCALL
DomainParentNew(void)4698 DomainParentNew(void)
4699 {
4700 DomainParentPtr ptr = MemNew((size_t) sizeof(DomainParent));
4701
4702 return ptr;
4703
4704 }
4705
4706
4707 /**************************************************
4708 *
4709 * DomainParentFree()
4710 *
4711 **************************************************/
4712 NLM_EXTERN
4713 DomainParentPtr LIBCALL
DomainParentFree(DomainParentPtr ptr)4714 DomainParentFree(DomainParentPtr ptr)
4715 {
4716
4717 if(ptr == NULL) {
4718 return NULL;
4719 }
4720 CddIdFree(ptr -> parentid);
4721 SeqAnnotFree(ptr -> seqannot);
4722 return MemFree(ptr);
4723 }
4724
4725
4726 /**************************************************
4727 *
4728 * DomainParentAsnRead()
4729 *
4730 **************************************************/
4731 NLM_EXTERN
4732 DomainParentPtr LIBCALL
DomainParentAsnRead(AsnIoPtr aip,AsnTypePtr orig)4733 DomainParentAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4734 {
4735 DataVal av;
4736 AsnTypePtr atp;
4737 Boolean isError = FALSE;
4738 AsnReadFunc func;
4739 DomainParentPtr ptr;
4740
4741 if (! loaded)
4742 {
4743 if (! objcddAsnLoad()) {
4744 return NULL;
4745 }
4746 }
4747
4748 if (aip == NULL) {
4749 return NULL;
4750 }
4751
4752 if (orig == NULL) { /* DomainParent ::= (self contained) */
4753 atp = AsnReadId(aip, amp, DOMAIN_PARENT);
4754 } else {
4755 atp = AsnLinkType(orig, DOMAIN_PARENT);
4756 }
4757 /* link in local tree */
4758 if (atp == NULL) {
4759 return NULL;
4760 }
4761
4762 ptr = DomainParentNew();
4763 if (ptr == NULL) {
4764 goto erret;
4765 }
4766 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4767 goto erret;
4768 }
4769
4770 atp = AsnReadId(aip,amp, atp);
4771 func = NULL;
4772
4773 if (atp == DOMAIN_PARENT_parent_type) {
4774 if ( AsnReadVal(aip, atp, &av) <= 0) {
4775 goto erret;
4776 }
4777 ptr -> parent_type = av.intvalue;
4778 atp = AsnReadId(aip,amp, atp);
4779 }
4780 if (atp == DOMAIN_PARENT_parentid) {
4781 ptr -> parentid = CddIdAsnRead(aip, atp);
4782 if (aip -> io_failure) {
4783 goto erret;
4784 }
4785 atp = AsnReadId(aip,amp, atp);
4786 }
4787 if (atp == DOMAIN_PARENT_seqannot) {
4788 ptr -> seqannot = SeqAnnotAsnRead(aip, atp);
4789 if (aip -> io_failure) {
4790 goto erret;
4791 }
4792 atp = AsnReadId(aip,amp, atp);
4793 }
4794
4795 if (AsnReadVal(aip, atp, &av) <= 0) {
4796 goto erret;
4797 }
4798 /* end struct */
4799
4800 ret:
4801 AsnUnlinkType(orig); /* unlink local tree */
4802 return ptr;
4803
4804 erret:
4805 aip -> io_failure = TRUE;
4806 ptr = DomainParentFree(ptr);
4807 goto ret;
4808 }
4809
4810
4811
4812 /**************************************************
4813 *
4814 * DomainParentAsnWrite()
4815 *
4816 **************************************************/
4817 NLM_EXTERN Boolean LIBCALL
DomainParentAsnWrite(DomainParentPtr ptr,AsnIoPtr aip,AsnTypePtr orig)4818 DomainParentAsnWrite(DomainParentPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
4819 {
4820 DataVal av;
4821 AsnTypePtr atp;
4822 Boolean retval = FALSE;
4823
4824 if (! loaded)
4825 {
4826 if (! objcddAsnLoad()) {
4827 return FALSE;
4828 }
4829 }
4830
4831 if (aip == NULL) {
4832 return FALSE;
4833 }
4834
4835 atp = AsnLinkType(orig, DOMAIN_PARENT); /* link local tree */
4836 if (atp == NULL) {
4837 return FALSE;
4838 }
4839
4840 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4841 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
4842 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
4843 goto erret;
4844 }
4845
4846 av.intvalue = ptr -> parent_type;
4847 retval = AsnWrite(aip, DOMAIN_PARENT_parent_type, &av);
4848 if (ptr -> parentid != NULL) {
4849 if ( ! CddIdAsnWrite(ptr -> parentid, aip, DOMAIN_PARENT_parentid)) {
4850 goto erret;
4851 }
4852 }
4853 if (ptr -> seqannot != NULL) {
4854 if ( ! SeqAnnotAsnWrite(ptr -> seqannot, aip, DOMAIN_PARENT_seqannot)) {
4855 goto erret;
4856 }
4857 }
4858 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4859 goto erret;
4860 }
4861 retval = TRUE;
4862
4863 erret:
4864 AsnUnlinkType(orig); /* unlink local tree */
4865 return retval;
4866 }
4867
4868
4869
4870 /**************************************************
4871 *
4872 * SequenceTreeNew()
4873 *
4874 **************************************************/
4875 NLM_EXTERN
4876 SequenceTreePtr LIBCALL
SequenceTreeNew(void)4877 SequenceTreeNew(void)
4878 {
4879 SequenceTreePtr ptr = MemNew((size_t) sizeof(SequenceTree));
4880
4881 ptr -> isAnnotated = 0;
4882 return ptr;
4883
4884 }
4885
4886
4887 /**************************************************
4888 *
4889 * SequenceTreeFree()
4890 *
4891 **************************************************/
4892 NLM_EXTERN
4893 SequenceTreePtr LIBCALL
SequenceTreeFree(SequenceTreePtr ptr)4894 SequenceTreeFree(SequenceTreePtr ptr)
4895 {
4896
4897 if(ptr == NULL) {
4898 return NULL;
4899 }
4900 MemFree(ptr -> cdAccession);
4901 AlgorithmTypeFree(ptr -> algorithm);
4902 SeqTreeNodeFree(ptr -> root);
4903 return MemFree(ptr);
4904 }
4905
4906
4907 /**************************************************
4908 *
4909 * SequenceTreeAsnRead()
4910 *
4911 **************************************************/
4912 NLM_EXTERN
4913 SequenceTreePtr LIBCALL
SequenceTreeAsnRead(AsnIoPtr aip,AsnTypePtr orig)4914 SequenceTreeAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4915 {
4916 DataVal av;
4917 AsnTypePtr atp;
4918 Boolean isError = FALSE;
4919 AsnReadFunc func;
4920 SequenceTreePtr ptr;
4921
4922 if (! loaded)
4923 {
4924 if (! objcddAsnLoad()) {
4925 return NULL;
4926 }
4927 }
4928
4929 if (aip == NULL) {
4930 return NULL;
4931 }
4932
4933 if (orig == NULL) { /* SequenceTree ::= (self contained) */
4934 atp = AsnReadId(aip, amp, SEQUENCE_TREE);
4935 } else {
4936 atp = AsnLinkType(orig, SEQUENCE_TREE);
4937 }
4938 /* link in local tree */
4939 if (atp == NULL) {
4940 return NULL;
4941 }
4942
4943 ptr = SequenceTreeNew();
4944 if (ptr == NULL) {
4945 goto erret;
4946 }
4947 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4948 goto erret;
4949 }
4950
4951 atp = AsnReadId(aip,amp, atp);
4952 func = NULL;
4953
4954 if (atp == SEQUENCE_TREE_cdAccession) {
4955 if ( AsnReadVal(aip, atp, &av) <= 0) {
4956 goto erret;
4957 }
4958 ptr -> cdAccession = av.ptrvalue;
4959 atp = AsnReadId(aip,amp, atp);
4960 }
4961 if (atp == SEQUENCE_TREE_algorithm) {
4962 ptr -> algorithm = AlgorithmTypeAsnRead(aip, atp);
4963 if (aip -> io_failure) {
4964 goto erret;
4965 }
4966 atp = AsnReadId(aip,amp, atp);
4967 }
4968 if (atp == SEQUENCE_TREE_isAnnotated) {
4969 if ( AsnReadVal(aip, atp, &av) <= 0) {
4970 goto erret;
4971 }
4972 ptr -> isAnnotated = av.boolvalue;
4973 atp = AsnReadId(aip,amp, atp);
4974 }
4975 if (atp == SEQUENCE_TREE_root) {
4976 ptr -> root = SeqTreeNodeAsnRead(aip, atp);
4977 if (aip -> io_failure) {
4978 goto erret;
4979 }
4980 atp = AsnReadId(aip,amp, atp);
4981 }
4982
4983 if (AsnReadVal(aip, atp, &av) <= 0) {
4984 goto erret;
4985 }
4986 /* end struct */
4987
4988 ret:
4989 AsnUnlinkType(orig); /* unlink local tree */
4990 return ptr;
4991
4992 erret:
4993 aip -> io_failure = TRUE;
4994 ptr = SequenceTreeFree(ptr);
4995 goto ret;
4996 }
4997
4998
4999
5000 /**************************************************
5001 *
5002 * SequenceTreeAsnWrite()
5003 *
5004 **************************************************/
5005 NLM_EXTERN Boolean LIBCALL
SequenceTreeAsnWrite(SequenceTreePtr ptr,AsnIoPtr aip,AsnTypePtr orig)5006 SequenceTreeAsnWrite(SequenceTreePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
5007 {
5008 DataVal av;
5009 AsnTypePtr atp;
5010 Boolean retval = FALSE;
5011
5012 if (! loaded)
5013 {
5014 if (! objcddAsnLoad()) {
5015 return FALSE;
5016 }
5017 }
5018
5019 if (aip == NULL) {
5020 return FALSE;
5021 }
5022
5023 atp = AsnLinkType(orig, SEQUENCE_TREE); /* link local tree */
5024 if (atp == NULL) {
5025 return FALSE;
5026 }
5027
5028 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5029 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
5030 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
5031 goto erret;
5032 }
5033
5034 if (ptr -> cdAccession != NULL) {
5035 av.ptrvalue = ptr -> cdAccession;
5036 retval = AsnWrite(aip, SEQUENCE_TREE_cdAccession, &av);
5037 }
5038 if (ptr -> algorithm != NULL) {
5039 if ( ! AlgorithmTypeAsnWrite(ptr -> algorithm, aip, SEQUENCE_TREE_algorithm)) {
5040 goto erret;
5041 }
5042 }
5043 av.boolvalue = ptr -> isAnnotated;
5044 retval = AsnWrite(aip, SEQUENCE_TREE_isAnnotated, &av);
5045 if (ptr -> root != NULL) {
5046 if ( ! SeqTreeNodeAsnWrite(ptr -> root, aip, SEQUENCE_TREE_root)) {
5047 goto erret;
5048 }
5049 }
5050 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
5051 goto erret;
5052 }
5053 retval = TRUE;
5054
5055 erret:
5056 AsnUnlinkType(orig); /* unlink local tree */
5057 return retval;
5058 }
5059
5060
5061
5062 /**************************************************
5063 *
5064 * AlgorithmTypeNew()
5065 *
5066 **************************************************/
5067 NLM_EXTERN
5068 AlgorithmTypePtr LIBCALL
AlgorithmTypeNew(void)5069 AlgorithmTypeNew(void)
5070 {
5071 AlgorithmTypePtr ptr = MemNew((size_t) sizeof(AlgorithmType));
5072
5073 return ptr;
5074
5075 }
5076
5077
5078 /**************************************************
5079 *
5080 * AlgorithmTypeFree()
5081 *
5082 **************************************************/
5083 NLM_EXTERN
5084 AlgorithmTypePtr LIBCALL
AlgorithmTypeFree(AlgorithmTypePtr ptr)5085 AlgorithmTypeFree(AlgorithmTypePtr ptr)
5086 {
5087
5088 if(ptr == NULL) {
5089 return NULL;
5090 }
5091 return MemFree(ptr);
5092 }
5093
5094
5095 /**************************************************
5096 *
5097 * AlgorithmTypeAsnRead()
5098 *
5099 **************************************************/
5100 NLM_EXTERN
5101 AlgorithmTypePtr LIBCALL
AlgorithmTypeAsnRead(AsnIoPtr aip,AsnTypePtr orig)5102 AlgorithmTypeAsnRead(AsnIoPtr aip, AsnTypePtr orig)
5103 {
5104 DataVal av;
5105 AsnTypePtr atp;
5106 Boolean isError = FALSE;
5107 AsnReadFunc func;
5108 AlgorithmTypePtr ptr;
5109
5110 if (! loaded)
5111 {
5112 if (! objcddAsnLoad()) {
5113 return NULL;
5114 }
5115 }
5116
5117 if (aip == NULL) {
5118 return NULL;
5119 }
5120
5121 if (orig == NULL) { /* AlgorithmType ::= (self contained) */
5122 atp = AsnReadId(aip, amp, ALGORITHM_TYPE);
5123 } else {
5124 atp = AsnLinkType(orig, ALGORITHM_TYPE);
5125 }
5126 /* link in local tree */
5127 if (atp == NULL) {
5128 return NULL;
5129 }
5130
5131 ptr = AlgorithmTypeNew();
5132 if (ptr == NULL) {
5133 goto erret;
5134 }
5135 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
5136 goto erret;
5137 }
5138
5139 atp = AsnReadId(aip,amp, atp);
5140 func = NULL;
5141
5142 if (atp == ALGORITHM_TYPE_scoring_Scheme) {
5143 if ( AsnReadVal(aip, atp, &av) <= 0) {
5144 goto erret;
5145 }
5146 ptr -> scoring_Scheme = av.intvalue;
5147 atp = AsnReadId(aip,amp, atp);
5148 }
5149 if (atp == ALGORITHM_TYPE_clustering_Method) {
5150 if ( AsnReadVal(aip, atp, &av) <= 0) {
5151 goto erret;
5152 }
5153 ptr -> clustering_Method = av.intvalue;
5154 atp = AsnReadId(aip,amp, atp);
5155 }
5156 if (atp == ALGORITHM_TYPE_score_Matrix) {
5157 if ( AsnReadVal(aip, atp, &av) <= 0) {
5158 goto erret;
5159 }
5160 ptr -> score_Matrix = av.intvalue;
5161 atp = AsnReadId(aip,amp, atp);
5162 }
5163 if (atp == ALGORITHM_TYPE_gapOpen) {
5164 if ( AsnReadVal(aip, atp, &av) <= 0) {
5165 goto erret;
5166 }
5167 ptr -> gapOpen = av.intvalue;
5168 atp = AsnReadId(aip,amp, atp);
5169 }
5170 if (atp == ALGORITHM_TYPE_gapExtend) {
5171 if ( AsnReadVal(aip, atp, &av) <= 0) {
5172 goto erret;
5173 }
5174 ptr -> gapExtend = av.intvalue;
5175 atp = AsnReadId(aip,amp, atp);
5176 }
5177 if (atp == ALGORITHM_TYPE_gapScaleFactor) {
5178 if ( AsnReadVal(aip, atp, &av) <= 0) {
5179 goto erret;
5180 }
5181 ptr -> gapScaleFactor = av.intvalue;
5182 atp = AsnReadId(aip,amp, atp);
5183 }
5184 if (atp == ALGORITHM_TYPE_nTerminalExt) {
5185 if ( AsnReadVal(aip, atp, &av) <= 0) {
5186 goto erret;
5187 }
5188 ptr -> nTerminalExt = av.intvalue;
5189 atp = AsnReadId(aip,amp, atp);
5190 }
5191 if (atp == ALGORITHM_TYPE_cTerminalExt) {
5192 if ( AsnReadVal(aip, atp, &av) <= 0) {
5193 goto erret;
5194 }
5195 ptr -> cTerminalExt = av.intvalue;
5196 atp = AsnReadId(aip,amp, atp);
5197 }
5198 if (atp == ALGORITHM_TYPE_tree_scope) {
5199 if ( AsnReadVal(aip, atp, &av) <= 0) {
5200 goto erret;
5201 }
5202 ptr -> tree_scope = av.intvalue;
5203 atp = AsnReadId(aip,amp, atp);
5204 }
5205 if (atp == ALGORITHM_TYPE_coloring_scope) {
5206 if ( AsnReadVal(aip, atp, &av) <= 0) {
5207 goto erret;
5208 }
5209 ptr -> coloring_scope = av.intvalue;
5210 atp = AsnReadId(aip,amp, atp);
5211 }
5212
5213 if (AsnReadVal(aip, atp, &av) <= 0) {
5214 goto erret;
5215 }
5216 /* end struct */
5217
5218 ret:
5219 AsnUnlinkType(orig); /* unlink local tree */
5220 return ptr;
5221
5222 erret:
5223 aip -> io_failure = TRUE;
5224 ptr = AlgorithmTypeFree(ptr);
5225 goto ret;
5226 }
5227
5228
5229
5230 /**************************************************
5231 *
5232 * AlgorithmTypeAsnWrite()
5233 *
5234 **************************************************/
5235 NLM_EXTERN Boolean LIBCALL
AlgorithmTypeAsnWrite(AlgorithmTypePtr ptr,AsnIoPtr aip,AsnTypePtr orig)5236 AlgorithmTypeAsnWrite(AlgorithmTypePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
5237 {
5238 DataVal av;
5239 AsnTypePtr atp;
5240 Boolean retval = FALSE;
5241
5242 if (! loaded)
5243 {
5244 if (! objcddAsnLoad()) {
5245 return FALSE;
5246 }
5247 }
5248
5249 if (aip == NULL) {
5250 return FALSE;
5251 }
5252
5253 atp = AsnLinkType(orig, ALGORITHM_TYPE); /* link local tree */
5254 if (atp == NULL) {
5255 return FALSE;
5256 }
5257
5258 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5259 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
5260 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
5261 goto erret;
5262 }
5263
5264 av.intvalue = ptr -> scoring_Scheme;
5265 retval = AsnWrite(aip, ALGORITHM_TYPE_scoring_Scheme, &av);
5266 av.intvalue = ptr -> clustering_Method;
5267 retval = AsnWrite(aip, ALGORITHM_TYPE_clustering_Method, &av);
5268 av.intvalue = ptr -> score_Matrix;
5269 retval = AsnWrite(aip, ALGORITHM_TYPE_score_Matrix, &av);
5270 av.intvalue = ptr -> gapOpen;
5271 retval = AsnWrite(aip, ALGORITHM_TYPE_gapOpen, &av);
5272 av.intvalue = ptr -> gapExtend;
5273 retval = AsnWrite(aip, ALGORITHM_TYPE_gapExtend, &av);
5274 av.intvalue = ptr -> gapScaleFactor;
5275 retval = AsnWrite(aip, ALGORITHM_TYPE_gapScaleFactor, &av);
5276 av.intvalue = ptr -> nTerminalExt;
5277 retval = AsnWrite(aip, ALGORITHM_TYPE_nTerminalExt, &av);
5278 av.intvalue = ptr -> cTerminalExt;
5279 retval = AsnWrite(aip, ALGORITHM_TYPE_cTerminalExt, &av);
5280 av.intvalue = ptr -> tree_scope;
5281 retval = AsnWrite(aip, ALGORITHM_TYPE_tree_scope, &av);
5282 av.intvalue = ptr -> coloring_scope;
5283 retval = AsnWrite(aip, ALGORITHM_TYPE_coloring_scope, &av);
5284 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
5285 goto erret;
5286 }
5287 retval = TRUE;
5288
5289 erret:
5290 AsnUnlinkType(orig); /* unlink local tree */
5291 return retval;
5292 }
5293
5294
5295
5296 /**************************************************
5297 *
5298 * SeqTreeNodeNew()
5299 *
5300 **************************************************/
5301 NLM_EXTERN
5302 SeqTreeNodePtr LIBCALL
SeqTreeNodeNew(void)5303 SeqTreeNodeNew(void)
5304 {
5305 SeqTreeNodePtr ptr = MemNew((size_t) sizeof(SeqTreeNode));
5306
5307 ptr -> isAnnotated = 0;
5308 return ptr;
5309
5310 }
5311
5312
5313 /**************************************************
5314 *
5315 * Children_footprintNew()
5316 *
5317 **************************************************/
5318 static
5319 Children_footprintPtr LIBCALL
Children_footprintNew(void)5320 Children_footprintNew(void)
5321 {
5322 Children_footprintPtr ptr = MemNew((size_t) sizeof(Children_footprint));
5323
5324 return ptr;
5325
5326 }
5327
5328
5329 /**************************************************
5330 *
5331 * SeqTreeNodeFree()
5332 *
5333 **************************************************/
5334 NLM_EXTERN
5335 SeqTreeNodePtr LIBCALL
SeqTreeNodeFree(SeqTreeNodePtr ptr)5336 SeqTreeNodeFree(SeqTreeNodePtr ptr)
5337 {
5338
5339 if(ptr == NULL) {
5340 return NULL;
5341 }
5342 MemFree(ptr -> name);
5343 Children_childrenFree(ptr -> Children_children);
5344 NodeAnnotationFree(ptr -> annotation);
5345 return MemFree(ptr);
5346 }
5347
5348
5349 /**************************************************
5350 *
5351 * Children_childrenFree()
5352 *
5353 **************************************************/
5354 static
5355 Children_childrenPtr LIBCALL
Children_childrenFree(ValNodePtr anp)5356 Children_childrenFree(ValNodePtr anp)
5357 {
5358 Pointer pnt;
5359
5360 if (anp == NULL) {
5361 return NULL;
5362 }
5363
5364 pnt = anp->data.ptrvalue;
5365 switch (anp->choice)
5366 {
5367 default:
5368 break;
5369 case Children_children_children:
5370 AsnGenericUserSeqOfFree((Pointer) pnt, (AsnOptFreeFunc) SeqTreeNodeFree);
5371 break;
5372 case Children_children_Children_Footprint:
5373 Children_footprintFree(anp -> data.ptrvalue);
5374 break;
5375 }
5376 return MemFree(anp);
5377 }
5378
5379
5380 /**************************************************
5381 *
5382 * Children_footprintFree()
5383 *
5384 **************************************************/
5385 static
5386 Children_footprintPtr LIBCALL
Children_footprintFree(Children_footprintPtr ptr)5387 Children_footprintFree(Children_footprintPtr ptr)
5388 {
5389
5390 if(ptr == NULL) {
5391 return NULL;
5392 }
5393 SeqIntFree(ptr -> seqRange);
5394 return MemFree(ptr);
5395 }
5396
5397
5398 /**************************************************
5399 *
5400 * SeqTreeNodeAsnRead()
5401 *
5402 **************************************************/
5403 NLM_EXTERN
5404 SeqTreeNodePtr LIBCALL
SeqTreeNodeAsnRead(AsnIoPtr aip,AsnTypePtr orig)5405 SeqTreeNodeAsnRead(AsnIoPtr aip, AsnTypePtr orig)
5406 {
5407 DataVal av;
5408 AsnTypePtr atp;
5409 Boolean isError = FALSE;
5410 AsnReadFunc func;
5411 SeqTreeNodePtr ptr;
5412
5413 if (! loaded)
5414 {
5415 if (! objcddAsnLoad()) {
5416 return NULL;
5417 }
5418 }
5419
5420 if (aip == NULL) {
5421 return NULL;
5422 }
5423
5424 if (orig == NULL) { /* SeqTreeNode ::= (self contained) */
5425 atp = AsnReadId(aip, amp, SEQTREE_NODE);
5426 } else {
5427 atp = AsnLinkType(orig, SEQTREE_NODE);
5428 }
5429 /* link in local tree */
5430 if (atp == NULL) {
5431 return NULL;
5432 }
5433
5434 ptr = SeqTreeNodeNew();
5435 if (ptr == NULL) {
5436 goto erret;
5437 }
5438 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
5439 goto erret;
5440 }
5441
5442 atp = AsnReadId(aip,amp, atp);
5443 func = NULL;
5444
5445 if (atp == SEQTREE_NODE_isAnnotated) {
5446 if ( AsnReadVal(aip, atp, &av) <= 0) {
5447 goto erret;
5448 }
5449 ptr -> isAnnotated = av.boolvalue;
5450 atp = AsnReadId(aip,amp, atp);
5451 }
5452 if (atp == SEQTREE_NODE_name) {
5453 if ( AsnReadVal(aip, atp, &av) <= 0) {
5454 goto erret;
5455 }
5456 ptr -> name = av.ptrvalue;
5457 atp = AsnReadId(aip,amp, atp);
5458 }
5459 if (atp == SEQTREE_NODE_distance) {
5460 if ( AsnReadVal(aip, atp, &av) <= 0) {
5461 goto erret;
5462 }
5463 ptr -> distance = av.realvalue;
5464 atp = AsnReadId(aip,amp, atp);
5465 }
5466 if (atp == SEQTREE_NODE_children) {
5467 ptr -> Children_children = Children_childrenAsnRead(aip, atp);
5468 if (aip -> io_failure) {
5469 goto erret;
5470 }
5471 atp = AsnReadId(aip,amp, atp);
5472 }
5473 if (atp == SEQTREE_NODE_annotation) {
5474 ptr -> annotation = NodeAnnotationAsnRead(aip, atp);
5475 if (aip -> io_failure) {
5476 goto erret;
5477 }
5478 atp = AsnReadId(aip,amp, atp);
5479 }
5480
5481 if (AsnReadVal(aip, atp, &av) <= 0) {
5482 goto erret;
5483 }
5484 /* end struct */
5485
5486 ret:
5487 AsnUnlinkType(orig); /* unlink local tree */
5488 return ptr;
5489
5490 erret:
5491 aip -> io_failure = TRUE;
5492 ptr = SeqTreeNodeFree(ptr);
5493 goto ret;
5494 }
5495
5496
5497
5498 /**************************************************
5499 *
5500 * Children_childrenAsnRead()
5501 *
5502 **************************************************/
5503 static
5504 Children_childrenPtr LIBCALL
Children_childrenAsnRead(AsnIoPtr aip,AsnTypePtr orig)5505 Children_childrenAsnRead(AsnIoPtr aip, AsnTypePtr orig)
5506 {
5507 DataVal av;
5508 AsnTypePtr atp;
5509 ValNodePtr anp;
5510 Uint1 choice;
5511 Boolean isError = FALSE;
5512 Boolean nullIsError = FALSE;
5513 AsnReadFunc func;
5514
5515 if (! loaded)
5516 {
5517 if (! objcddAsnLoad()) {
5518 return NULL;
5519 }
5520 }
5521
5522 if (aip == NULL) {
5523 return NULL;
5524 }
5525
5526 if (orig == NULL) { /* Children_children ::= (self contained) */
5527 atp = AsnReadId(aip, amp, SEQTREE_NODE_children);
5528 } else {
5529 atp = AsnLinkType(orig, SEQTREE_NODE_children); /* link in local tree */
5530 }
5531 if (atp == NULL) {
5532 return NULL;
5533 }
5534
5535 anp = ValNodeNew(NULL);
5536 if (anp == NULL) {
5537 goto erret;
5538 }
5539 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
5540 goto erret;
5541 }
5542
5543 func = NULL;
5544
5545 atp = AsnReadId(aip, amp, atp); /* find the choice */
5546 if (atp == NULL) {
5547 goto erret;
5548 }
5549 if (atp == SEQTREE_NODE_children_children) {
5550 choice = Children_children_children;
5551 anp -> data.ptrvalue =
5552 AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) SeqTreeNodeAsnRead, (AsnOptFreeFunc) SeqTreeNodeFree);
5553 if (isError && anp -> data.ptrvalue == NULL) {
5554 goto erret;
5555 }
5556 }
5557 else if (atp == SEQTREE_NODE_children_footprint) {
5558 choice = Children_children_Children_Footprint;
5559 func = (AsnReadFunc) Children_footprintAsnRead;
5560 }
5561 anp->choice = choice;
5562 if (func != NULL)
5563 {
5564 anp->data.ptrvalue = (* func)(aip, atp);
5565 if (aip -> io_failure) goto erret;
5566
5567 if (nullIsError && anp->data.ptrvalue == NULL) {
5568 goto erret;
5569 }
5570 }
5571
5572 ret:
5573 AsnUnlinkType(orig); /* unlink local tree */
5574 return anp;
5575
5576 erret:
5577 anp = MemFree(anp);
5578 aip -> io_failure = TRUE;
5579 goto ret;
5580 }
5581
5582
5583 /**************************************************
5584 *
5585 * Children_footprintAsnRead()
5586 *
5587 **************************************************/
5588 static
5589 Children_footprintPtr LIBCALL
Children_footprintAsnRead(AsnIoPtr aip,AsnTypePtr orig)5590 Children_footprintAsnRead(AsnIoPtr aip, AsnTypePtr orig)
5591 {
5592 DataVal av;
5593 AsnTypePtr atp;
5594 Boolean isError = FALSE;
5595 AsnReadFunc func;
5596 Children_footprintPtr ptr;
5597
5598 if (! loaded)
5599 {
5600 if (! objcddAsnLoad()) {
5601 return NULL;
5602 }
5603 }
5604
5605 if (aip == NULL) {
5606 return NULL;
5607 }
5608
5609 if (orig == NULL) { /* Children_footprint ::= (self contained) */
5610 atp = AsnReadId(aip, amp, SEQTREE_NODE_children_footprint);
5611 } else {
5612 atp = AsnLinkType(orig, SEQTREE_NODE_children_footprint);
5613 }
5614 /* link in local tree */
5615 if (atp == NULL) {
5616 return NULL;
5617 }
5618
5619 ptr = Children_footprintNew();
5620 if (ptr == NULL) {
5621 goto erret;
5622 }
5623 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
5624 goto erret;
5625 }
5626
5627 atp = AsnReadId(aip,amp, atp);
5628 func = NULL;
5629
5630 if (atp == SEQTREE_NODE_children_footprint_seqRange) {
5631 ptr -> seqRange = SeqIntAsnRead(aip, atp);
5632 if (aip -> io_failure) {
5633 goto erret;
5634 }
5635 atp = AsnReadId(aip,amp, atp);
5636 }
5637 if (atp == SEQTREE_NODE_children_footprint_rowId) {
5638 if ( AsnReadVal(aip, atp, &av) <= 0) {
5639 goto erret;
5640 }
5641 ptr -> rowId = av.intvalue;
5642 atp = AsnReadId(aip,amp, atp);
5643 }
5644
5645 if (AsnReadVal(aip, atp, &av) <= 0) {
5646 goto erret;
5647 }
5648 /* end struct */
5649
5650 ret:
5651 AsnUnlinkType(orig); /* unlink local tree */
5652 return ptr;
5653
5654 erret:
5655 aip -> io_failure = TRUE;
5656 ptr = Children_footprintFree(ptr);
5657 goto ret;
5658 }
5659
5660
5661
5662 /**************************************************
5663 *
5664 * SeqTreeNodeAsnWrite()
5665 *
5666 **************************************************/
5667 NLM_EXTERN Boolean LIBCALL
SeqTreeNodeAsnWrite(SeqTreeNodePtr ptr,AsnIoPtr aip,AsnTypePtr orig)5668 SeqTreeNodeAsnWrite(SeqTreeNodePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
5669 {
5670 DataVal av;
5671 AsnTypePtr atp;
5672 Boolean retval = FALSE;
5673
5674 if (! loaded)
5675 {
5676 if (! objcddAsnLoad()) {
5677 return FALSE;
5678 }
5679 }
5680
5681 if (aip == NULL) {
5682 return FALSE;
5683 }
5684
5685 atp = AsnLinkType(orig, SEQTREE_NODE); /* link local tree */
5686 if (atp == NULL) {
5687 return FALSE;
5688 }
5689
5690 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5691 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
5692 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
5693 goto erret;
5694 }
5695
5696 av.boolvalue = ptr -> isAnnotated;
5697 retval = AsnWrite(aip, SEQTREE_NODE_isAnnotated, &av);
5698 if (ptr -> name != NULL) {
5699 av.ptrvalue = ptr -> name;
5700 retval = AsnWrite(aip, SEQTREE_NODE_name, &av);
5701 }
5702 av.realvalue = ptr -> distance;
5703 retval = AsnWrite(aip, SEQTREE_NODE_distance, &av);
5704 if (ptr -> Children_children != NULL) {
5705 if ( ! Children_childrenAsnWrite(ptr -> Children_children, aip, SEQTREE_NODE_children)) {
5706 goto erret;
5707 }
5708 }
5709 if (ptr -> annotation != NULL) {
5710 if ( ! NodeAnnotationAsnWrite(ptr -> annotation, aip, SEQTREE_NODE_annotation)) {
5711 goto erret;
5712 }
5713 }
5714 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
5715 goto erret;
5716 }
5717 retval = TRUE;
5718
5719 erret:
5720 AsnUnlinkType(orig); /* unlink local tree */
5721 return retval;
5722 }
5723
5724
5725
5726 /**************************************************
5727 *
5728 * Children_childrenAsnWrite()
5729 *
5730 **************************************************/
5731 static Boolean LIBCALL
Children_childrenAsnWrite(Children_childrenPtr anp,AsnIoPtr aip,AsnTypePtr orig)5732 Children_childrenAsnWrite(Children_childrenPtr anp, AsnIoPtr aip, AsnTypePtr orig)
5733
5734 {
5735 DataVal av;
5736 AsnTypePtr atp, writetype = NULL;
5737 Pointer pnt;
5738 AsnWriteFunc func = NULL;
5739 Boolean retval = FALSE;
5740
5741 if (! loaded)
5742 {
5743 if (! objcddAsnLoad())
5744 return FALSE;
5745 }
5746
5747 if (aip == NULL)
5748 return FALSE;
5749
5750 atp = AsnLinkType(orig, SEQTREE_NODE_children); /* link local tree */
5751 if (atp == NULL) {
5752 return FALSE;
5753 }
5754
5755 if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5756 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
5757 av.ptrvalue = (Pointer)anp;
5758 if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
5759 goto erret;
5760 }
5761
5762 pnt = anp->data.ptrvalue;
5763 switch (anp->choice)
5764 {
5765 case Children_children_children:
5766 retval = AsnGenericUserSeqOfAsnWrite((Pointer) pnt, (AsnWriteFunc) SeqTreeNodeAsnWrite, aip, SEQTREE_NODE_children_children, SEQTREE_NODE_children_children_E);
5767 break;
5768 case Children_children_Children_Footprint:
5769 writetype = SEQTREE_NODE_children_footprint;
5770 func = (AsnWriteFunc) Children_footprintAsnWrite;
5771 break;
5772 }
5773 if (writetype != NULL) {
5774 retval = (* func)(pnt, aip, writetype); /* write it out */
5775 }
5776 if (!retval) {
5777 goto erret;
5778 }
5779 retval = TRUE;
5780
5781 erret:
5782 AsnUnlinkType(orig); /* unlink local tree */
5783 return retval;
5784 }
5785
5786
5787 /**************************************************
5788 *
5789 * Children_footprintAsnWrite()
5790 *
5791 **************************************************/
5792 static Boolean LIBCALL
Children_footprintAsnWrite(Children_footprintPtr ptr,AsnIoPtr aip,AsnTypePtr orig)5793 Children_footprintAsnWrite(Children_footprintPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
5794 {
5795 DataVal av;
5796 AsnTypePtr atp;
5797 Boolean retval = FALSE;
5798
5799 if (! loaded)
5800 {
5801 if (! objcddAsnLoad()) {
5802 return FALSE;
5803 }
5804 }
5805
5806 if (aip == NULL) {
5807 return FALSE;
5808 }
5809
5810 atp = AsnLinkType(orig, SEQTREE_NODE_children_footprint); /* link local tree */
5811 if (atp == NULL) {
5812 return FALSE;
5813 }
5814
5815 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5816 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
5817 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
5818 goto erret;
5819 }
5820
5821 if (ptr -> seqRange != NULL) {
5822 if ( ! SeqIntAsnWrite(ptr -> seqRange, aip, SEQTREE_NODE_children_footprint_seqRange)) {
5823 goto erret;
5824 }
5825 }
5826 av.intvalue = ptr -> rowId;
5827 retval = AsnWrite(aip, SEQTREE_NODE_children_footprint_rowId, &av);
5828 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
5829 goto erret;
5830 }
5831 retval = TRUE;
5832
5833 erret:
5834 AsnUnlinkType(orig); /* unlink local tree */
5835 return retval;
5836 }
5837
5838
5839
5840 /**************************************************
5841 *
5842 * NodeAnnotationNew()
5843 *
5844 **************************************************/
5845 NLM_EXTERN
5846 NodeAnnotationPtr LIBCALL
NodeAnnotationNew(void)5847 NodeAnnotationNew(void)
5848 {
5849 NodeAnnotationPtr ptr = MemNew((size_t) sizeof(NodeAnnotation));
5850
5851 return ptr;
5852
5853 }
5854
5855
5856 /**************************************************
5857 *
5858 * NodeAnnotationFree()
5859 *
5860 **************************************************/
5861 NLM_EXTERN
5862 NodeAnnotationPtr LIBCALL
NodeAnnotationFree(NodeAnnotationPtr ptr)5863 NodeAnnotationFree(NodeAnnotationPtr ptr)
5864 {
5865
5866 if(ptr == NULL) {
5867 return NULL;
5868 }
5869 MemFree(ptr -> presentInChildCD);
5870 MemFree(ptr -> note);
5871 return MemFree(ptr);
5872 }
5873
5874
5875 /**************************************************
5876 *
5877 * NodeAnnotationAsnRead()
5878 *
5879 **************************************************/
5880 NLM_EXTERN
5881 NodeAnnotationPtr LIBCALL
NodeAnnotationAsnRead(AsnIoPtr aip,AsnTypePtr orig)5882 NodeAnnotationAsnRead(AsnIoPtr aip, AsnTypePtr orig)
5883 {
5884 DataVal av;
5885 AsnTypePtr atp;
5886 Boolean isError = FALSE;
5887 AsnReadFunc func;
5888 NodeAnnotationPtr ptr;
5889
5890 if (! loaded)
5891 {
5892 if (! objcddAsnLoad()) {
5893 return NULL;
5894 }
5895 }
5896
5897 if (aip == NULL) {
5898 return NULL;
5899 }
5900
5901 if (orig == NULL) { /* NodeAnnotation ::= (self contained) */
5902 atp = AsnReadId(aip, amp, NODE_ANNOTATION);
5903 } else {
5904 atp = AsnLinkType(orig, NODE_ANNOTATION);
5905 }
5906 /* link in local tree */
5907 if (atp == NULL) {
5908 return NULL;
5909 }
5910
5911 ptr = NodeAnnotationNew();
5912 if (ptr == NULL) {
5913 goto erret;
5914 }
5915 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
5916 goto erret;
5917 }
5918
5919 atp = AsnReadId(aip,amp, atp);
5920 func = NULL;
5921
5922 if (atp == NODE_ANNOTATION_presentInChildCD) {
5923 if ( AsnReadVal(aip, atp, &av) <= 0) {
5924 goto erret;
5925 }
5926 ptr -> presentInChildCD = av.ptrvalue;
5927 atp = AsnReadId(aip,amp, atp);
5928 }
5929 if (atp == NODE_ANNOTATION_note) {
5930 if ( AsnReadVal(aip, atp, &av) <= 0) {
5931 goto erret;
5932 }
5933 ptr -> note = av.ptrvalue;
5934 atp = AsnReadId(aip,amp, atp);
5935 }
5936
5937 if (AsnReadVal(aip, atp, &av) <= 0) {
5938 goto erret;
5939 }
5940 /* end struct */
5941
5942 ret:
5943 AsnUnlinkType(orig); /* unlink local tree */
5944 return ptr;
5945
5946 erret:
5947 aip -> io_failure = TRUE;
5948 ptr = NodeAnnotationFree(ptr);
5949 goto ret;
5950 }
5951
5952
5953
5954 /**************************************************
5955 *
5956 * NodeAnnotationAsnWrite()
5957 *
5958 **************************************************/
5959 NLM_EXTERN Boolean LIBCALL
NodeAnnotationAsnWrite(NodeAnnotationPtr ptr,AsnIoPtr aip,AsnTypePtr orig)5960 NodeAnnotationAsnWrite(NodeAnnotationPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
5961 {
5962 DataVal av;
5963 AsnTypePtr atp;
5964 Boolean retval = FALSE;
5965
5966 if (! loaded)
5967 {
5968 if (! objcddAsnLoad()) {
5969 return FALSE;
5970 }
5971 }
5972
5973 if (aip == NULL) {
5974 return FALSE;
5975 }
5976
5977 atp = AsnLinkType(orig, NODE_ANNOTATION); /* link local tree */
5978 if (atp == NULL) {
5979 return FALSE;
5980 }
5981
5982 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5983 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
5984 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
5985 goto erret;
5986 }
5987
5988 if (ptr -> presentInChildCD != NULL) {
5989 av.ptrvalue = ptr -> presentInChildCD;
5990 retval = AsnWrite(aip, NODE_ANNOTATION_presentInChildCD, &av);
5991 }
5992 if (ptr -> note != NULL) {
5993 av.ptrvalue = ptr -> note;
5994 retval = AsnWrite(aip, NODE_ANNOTATION_note, &av);
5995 }
5996 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
5997 goto erret;
5998 }
5999 retval = TRUE;
6000
6001 erret:
6002 AsnUnlinkType(orig); /* unlink local tree */
6003 return retval;
6004 }
6005
6006
6007
6008 /**************************************************
6009 *
6010 * CddViewerRectNew()
6011 *
6012 **************************************************/
6013 NLM_EXTERN
6014 CddViewerRectPtr LIBCALL
CddViewerRectNew(void)6015 CddViewerRectNew(void)
6016 {
6017 CddViewerRectPtr ptr = MemNew((size_t) sizeof(CddViewerRect));
6018
6019 return ptr;
6020
6021 }
6022
6023
6024 /**************************************************
6025 *
6026 * CddViewerRectFree()
6027 *
6028 **************************************************/
6029 NLM_EXTERN
6030 CddViewerRectPtr LIBCALL
CddViewerRectFree(CddViewerRectPtr ptr)6031 CddViewerRectFree(CddViewerRectPtr ptr)
6032 {
6033
6034 if(ptr == NULL) {
6035 return NULL;
6036 }
6037 return MemFree(ptr);
6038 }
6039
6040
6041 /**************************************************
6042 *
6043 * CddViewerRectAsnRead()
6044 *
6045 **************************************************/
6046 NLM_EXTERN
6047 CddViewerRectPtr LIBCALL
CddViewerRectAsnRead(AsnIoPtr aip,AsnTypePtr orig)6048 CddViewerRectAsnRead(AsnIoPtr aip, AsnTypePtr orig)
6049 {
6050 DataVal av;
6051 AsnTypePtr atp;
6052 Boolean isError = FALSE;
6053 AsnReadFunc func;
6054 CddViewerRectPtr ptr;
6055
6056 if (! loaded)
6057 {
6058 if (! objcddAsnLoad()) {
6059 return NULL;
6060 }
6061 }
6062
6063 if (aip == NULL) {
6064 return NULL;
6065 }
6066
6067 if (orig == NULL) { /* CddViewerRect ::= (self contained) */
6068 atp = AsnReadId(aip, amp, CDD_VIEWER_RECT);
6069 } else {
6070 atp = AsnLinkType(orig, CDD_VIEWER_RECT);
6071 }
6072 /* link in local tree */
6073 if (atp == NULL) {
6074 return NULL;
6075 }
6076
6077 ptr = CddViewerRectNew();
6078 if (ptr == NULL) {
6079 goto erret;
6080 }
6081 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
6082 goto erret;
6083 }
6084
6085 atp = AsnReadId(aip,amp, atp);
6086 func = NULL;
6087
6088 if (atp == CDD_VIEWER_RECT_top) {
6089 if ( AsnReadVal(aip, atp, &av) <= 0) {
6090 goto erret;
6091 }
6092 ptr -> top = av.intvalue;
6093 atp = AsnReadId(aip,amp, atp);
6094 }
6095 if (atp == CDD_VIEWER_RECT_left) {
6096 if ( AsnReadVal(aip, atp, &av) <= 0) {
6097 goto erret;
6098 }
6099 ptr -> left = av.intvalue;
6100 atp = AsnReadId(aip,amp, atp);
6101 }
6102 if (atp == CDD_VIEWER_RECT_width) {
6103 if ( AsnReadVal(aip, atp, &av) <= 0) {
6104 goto erret;
6105 }
6106 ptr -> width = av.intvalue;
6107 atp = AsnReadId(aip,amp, atp);
6108 }
6109 if (atp == CDD_VIEWER_RECT_height) {
6110 if ( AsnReadVal(aip, atp, &av) <= 0) {
6111 goto erret;
6112 }
6113 ptr -> height = av.intvalue;
6114 atp = AsnReadId(aip,amp, atp);
6115 }
6116
6117 if (AsnReadVal(aip, atp, &av) <= 0) {
6118 goto erret;
6119 }
6120 /* end struct */
6121
6122 ret:
6123 AsnUnlinkType(orig); /* unlink local tree */
6124 return ptr;
6125
6126 erret:
6127 aip -> io_failure = TRUE;
6128 ptr = CddViewerRectFree(ptr);
6129 goto ret;
6130 }
6131
6132
6133
6134 /**************************************************
6135 *
6136 * CddViewerRectAsnWrite()
6137 *
6138 **************************************************/
6139 NLM_EXTERN Boolean LIBCALL
CddViewerRectAsnWrite(CddViewerRectPtr ptr,AsnIoPtr aip,AsnTypePtr orig)6140 CddViewerRectAsnWrite(CddViewerRectPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
6141 {
6142 DataVal av;
6143 AsnTypePtr atp;
6144 Boolean retval = FALSE;
6145
6146 if (! loaded)
6147 {
6148 if (! objcddAsnLoad()) {
6149 return FALSE;
6150 }
6151 }
6152
6153 if (aip == NULL) {
6154 return FALSE;
6155 }
6156
6157 atp = AsnLinkType(orig, CDD_VIEWER_RECT); /* link local tree */
6158 if (atp == NULL) {
6159 return FALSE;
6160 }
6161
6162 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
6163 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
6164 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
6165 goto erret;
6166 }
6167
6168 av.intvalue = ptr -> top;
6169 retval = AsnWrite(aip, CDD_VIEWER_RECT_top, &av);
6170 av.intvalue = ptr -> left;
6171 retval = AsnWrite(aip, CDD_VIEWER_RECT_left, &av);
6172 av.intvalue = ptr -> width;
6173 retval = AsnWrite(aip, CDD_VIEWER_RECT_width, &av);
6174 av.intvalue = ptr -> height;
6175 retval = AsnWrite(aip, CDD_VIEWER_RECT_height, &av);
6176 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
6177 goto erret;
6178 }
6179 retval = TRUE;
6180
6181 erret:
6182 AsnUnlinkType(orig); /* unlink local tree */
6183 return retval;
6184 }
6185
6186
6187
6188 /**************************************************
6189 *
6190 * CddViewerNew()
6191 *
6192 **************************************************/
6193 NLM_EXTERN
6194 CddViewerPtr LIBCALL
CddViewerNew(void)6195 CddViewerNew(void)
6196 {
6197 CddViewerPtr ptr = MemNew((size_t) sizeof(CddViewer));
6198
6199 return ptr;
6200
6201 }
6202
6203
6204 /**************************************************
6205 *
6206 * CddViewerFree()
6207 *
6208 **************************************************/
6209 NLM_EXTERN
6210 CddViewerPtr LIBCALL
CddViewerFree(CddViewerPtr ptr)6211 CddViewerFree(CddViewerPtr ptr)
6212 {
6213
6214 if(ptr == NULL) {
6215 return NULL;
6216 }
6217 CddViewerRectFree(ptr -> rect);
6218 AsnGenericBaseSeqOfFree(ptr -> accessions ,ASNCODE_PTRVAL_SLOT);
6219 return MemFree(ptr);
6220 }
6221
6222
6223 /**************************************************
6224 *
6225 * CddViewerAsnRead()
6226 *
6227 **************************************************/
6228 NLM_EXTERN
6229 CddViewerPtr LIBCALL
CddViewerAsnRead(AsnIoPtr aip,AsnTypePtr orig)6230 CddViewerAsnRead(AsnIoPtr aip, AsnTypePtr orig)
6231 {
6232 DataVal av;
6233 AsnTypePtr atp;
6234 Boolean isError = FALSE;
6235 AsnReadFunc func;
6236 CddViewerPtr ptr;
6237
6238 if (! loaded)
6239 {
6240 if (! objcddAsnLoad()) {
6241 return NULL;
6242 }
6243 }
6244
6245 if (aip == NULL) {
6246 return NULL;
6247 }
6248
6249 if (orig == NULL) { /* CddViewer ::= (self contained) */
6250 atp = AsnReadId(aip, amp, CDD_VIEWER);
6251 } else {
6252 atp = AsnLinkType(orig, CDD_VIEWER);
6253 }
6254 /* link in local tree */
6255 if (atp == NULL) {
6256 return NULL;
6257 }
6258
6259 ptr = CddViewerNew();
6260 if (ptr == NULL) {
6261 goto erret;
6262 }
6263 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
6264 goto erret;
6265 }
6266
6267 atp = AsnReadId(aip,amp, atp);
6268 func = NULL;
6269
6270 if (atp == CDD_VIEWER_ctrl) {
6271 if ( AsnReadVal(aip, atp, &av) <= 0) {
6272 goto erret;
6273 }
6274 ptr -> ctrl = av.intvalue;
6275 atp = AsnReadId(aip,amp, atp);
6276 }
6277 if (atp == CDD_VIEWER_rect) {
6278 ptr -> rect = CddViewerRectAsnRead(aip, atp);
6279 if (aip -> io_failure) {
6280 goto erret;
6281 }
6282 atp = AsnReadId(aip,amp, atp);
6283 }
6284 if (atp == CDD_VIEWER_accessions) {
6285 ptr -> accessions = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
6286 if (isError && ptr -> accessions == NULL) {
6287 goto erret;
6288 }
6289 atp = AsnReadId(aip,amp, atp);
6290 }
6291
6292 if (AsnReadVal(aip, atp, &av) <= 0) {
6293 goto erret;
6294 }
6295 /* end struct */
6296
6297 ret:
6298 AsnUnlinkType(orig); /* unlink local tree */
6299 return ptr;
6300
6301 erret:
6302 aip -> io_failure = TRUE;
6303 ptr = CddViewerFree(ptr);
6304 goto ret;
6305 }
6306
6307
6308
6309 /**************************************************
6310 *
6311 * CddViewerAsnWrite()
6312 *
6313 **************************************************/
6314 NLM_EXTERN Boolean LIBCALL
CddViewerAsnWrite(CddViewerPtr ptr,AsnIoPtr aip,AsnTypePtr orig)6315 CddViewerAsnWrite(CddViewerPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
6316 {
6317 DataVal av;
6318 AsnTypePtr atp;
6319 Boolean retval = FALSE;
6320
6321 if (! loaded)
6322 {
6323 if (! objcddAsnLoad()) {
6324 return FALSE;
6325 }
6326 }
6327
6328 if (aip == NULL) {
6329 return FALSE;
6330 }
6331
6332 atp = AsnLinkType(orig, CDD_VIEWER); /* link local tree */
6333 if (atp == NULL) {
6334 return FALSE;
6335 }
6336
6337 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
6338 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
6339 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
6340 goto erret;
6341 }
6342
6343 av.intvalue = ptr -> ctrl;
6344 retval = AsnWrite(aip, CDD_VIEWER_ctrl, &av);
6345 if (ptr -> rect != NULL) {
6346 if ( ! CddViewerRectAsnWrite(ptr -> rect, aip, CDD_VIEWER_rect)) {
6347 goto erret;
6348 }
6349 }
6350 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> accessions ,ASNCODE_PTRVAL_SLOT, aip, CDD_VIEWER_accessions, CDD_VIEWER_accessions_E);
6351 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
6352 goto erret;
6353 }
6354 retval = TRUE;
6355
6356 erret:
6357 AsnUnlinkType(orig); /* unlink local tree */
6358 return retval;
6359 }
6360
6361
6362
6363 /**************************************************
6364 *
6365 * CddScriptNew()
6366 *
6367 **************************************************/
6368 NLM_EXTERN
6369 CddScriptPtr LIBCALL
CddScriptNew(void)6370 CddScriptNew(void)
6371 {
6372 CddScriptPtr ptr = MemNew((size_t) sizeof(CddScript));
6373
6374 return ptr;
6375
6376 }
6377
6378
6379 /**************************************************
6380 *
6381 * CddScriptFree()
6382 *
6383 **************************************************/
6384 NLM_EXTERN
6385 CddScriptPtr LIBCALL
CddScriptFree(CddScriptPtr ptr)6386 CddScriptFree(CddScriptPtr ptr)
6387 {
6388
6389 if(ptr == NULL) {
6390 return NULL;
6391 }
6392 MemFree(ptr -> name);
6393 MemFree(ptr -> commands);
6394 return MemFree(ptr);
6395 }
6396
6397
6398 /**************************************************
6399 *
6400 * CddScriptAsnRead()
6401 *
6402 **************************************************/
6403 NLM_EXTERN
6404 CddScriptPtr LIBCALL
CddScriptAsnRead(AsnIoPtr aip,AsnTypePtr orig)6405 CddScriptAsnRead(AsnIoPtr aip, AsnTypePtr orig)
6406 {
6407 DataVal av;
6408 AsnTypePtr atp;
6409 Boolean isError = FALSE;
6410 AsnReadFunc func;
6411 CddScriptPtr ptr;
6412
6413 if (! loaded)
6414 {
6415 if (! objcddAsnLoad()) {
6416 return NULL;
6417 }
6418 }
6419
6420 if (aip == NULL) {
6421 return NULL;
6422 }
6423
6424 if (orig == NULL) { /* CddScript ::= (self contained) */
6425 atp = AsnReadId(aip, amp, CDD_SCRIPT);
6426 } else {
6427 atp = AsnLinkType(orig, CDD_SCRIPT);
6428 }
6429 /* link in local tree */
6430 if (atp == NULL) {
6431 return NULL;
6432 }
6433
6434 ptr = CddScriptNew();
6435 if (ptr == NULL) {
6436 goto erret;
6437 }
6438 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
6439 goto erret;
6440 }
6441
6442 atp = AsnReadId(aip,amp, atp);
6443 func = NULL;
6444
6445 if (atp == CDD_SCRIPT_type) {
6446 if ( AsnReadVal(aip, atp, &av) <= 0) {
6447 goto erret;
6448 }
6449 ptr -> type = av.intvalue;
6450 atp = AsnReadId(aip,amp, atp);
6451 }
6452 if (atp == CDD_SCRIPT_name) {
6453 if ( AsnReadVal(aip, atp, &av) <= 0) {
6454 goto erret;
6455 }
6456 ptr -> name = av.ptrvalue;
6457 atp = AsnReadId(aip,amp, atp);
6458 }
6459 if (atp == CDD_SCRIPT_commands) {
6460 if ( AsnReadVal(aip, atp, &av) <= 0) {
6461 goto erret;
6462 }
6463 ptr -> commands = av.ptrvalue;
6464 atp = AsnReadId(aip,amp, atp);
6465 }
6466
6467 if (AsnReadVal(aip, atp, &av) <= 0) {
6468 goto erret;
6469 }
6470 /* end struct */
6471
6472 ret:
6473 AsnUnlinkType(orig); /* unlink local tree */
6474 return ptr;
6475
6476 erret:
6477 aip -> io_failure = TRUE;
6478 ptr = CddScriptFree(ptr);
6479 goto ret;
6480 }
6481
6482
6483
6484 /**************************************************
6485 *
6486 * CddScriptAsnWrite()
6487 *
6488 **************************************************/
6489 NLM_EXTERN Boolean LIBCALL
CddScriptAsnWrite(CddScriptPtr ptr,AsnIoPtr aip,AsnTypePtr orig)6490 CddScriptAsnWrite(CddScriptPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
6491 {
6492 DataVal av;
6493 AsnTypePtr atp;
6494 Boolean retval = FALSE;
6495
6496 if (! loaded)
6497 {
6498 if (! objcddAsnLoad()) {
6499 return FALSE;
6500 }
6501 }
6502
6503 if (aip == NULL) {
6504 return FALSE;
6505 }
6506
6507 atp = AsnLinkType(orig, CDD_SCRIPT); /* link local tree */
6508 if (atp == NULL) {
6509 return FALSE;
6510 }
6511
6512 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
6513 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
6514 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
6515 goto erret;
6516 }
6517
6518 av.intvalue = ptr -> type;
6519 retval = AsnWrite(aip, CDD_SCRIPT_type, &av);
6520 if (ptr -> name != NULL) {
6521 av.ptrvalue = ptr -> name;
6522 retval = AsnWrite(aip, CDD_SCRIPT_name, &av);
6523 }
6524 if (ptr -> commands != NULL) {
6525 av.ptrvalue = ptr -> commands;
6526 retval = AsnWrite(aip, CDD_SCRIPT_commands, &av);
6527 }
6528 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
6529 goto erret;
6530 }
6531 retval = TRUE;
6532
6533 erret:
6534 AsnUnlinkType(orig); /* unlink local tree */
6535 return retval;
6536 }
6537
6538