1 #include <asn.h>
2
3 #define NLM_GENERATED_CODE_PROTO
4
5 #include <objtseq.h>
6
7 static Boolean loaded = FALSE;
8
9 #include <asntseq.h>
10
11 #ifndef NLM_EXTERN_LOADS
12 #define NLM_EXTERN_LOADS {}
13 #endif
14
15 NLM_EXTERN Boolean LIBCALL
objtseqAsnLoad(void)16 objtseqAsnLoad(void)
17 {
18
19 if ( ! loaded) {
20 NLM_EXTERN_LOADS
21
22 if ( ! AsnLoad ())
23 return FALSE;
24 loaded = TRUE;
25 }
26
27 return TRUE;
28 }
29
30
31
32 /**************************************************
33 * Generated object loaders for Module NCBI-TSeq
34 * Generated using ASNCODE Revision: 6.14 at Jun 28, 2002 12:46 PM
35 *
36 **************************************************/
37
38
39 /**************************************************
40 *
41 * TSeqNew()
42 *
43 **************************************************/
44 NLM_EXTERN
45 TSeqPtr LIBCALL
TSeqNew(void)46 TSeqNew(void)
47 {
48 TSeqPtr ptr = MemNew((size_t) sizeof(TSeq));
49
50 return ptr;
51
52 }
53
54
55 /**************************************************
56 *
57 * TSeqFree()
58 *
59 **************************************************/
60 NLM_EXTERN
61 TSeqPtr LIBCALL
TSeqFree(TSeqPtr ptr)62 TSeqFree(TSeqPtr ptr)
63 {
64
65 if(ptr == NULL) {
66 return NULL;
67 }
68 MemFree(ptr -> accver);
69 MemFree(ptr -> sid);
70 MemFree(ptr -> local);
71 MemFree(ptr -> orgname);
72 MemFree(ptr -> defline);
73 MemFree(ptr -> sequence);
74 return MemFree(ptr);
75 }
76
77
78 /**************************************************
79 *
80 * TSeqAsnRead()
81 *
82 **************************************************/
83 NLM_EXTERN
84 TSeqPtr LIBCALL
TSeqAsnRead(AsnIoPtr aip,AsnTypePtr orig)85 TSeqAsnRead(AsnIoPtr aip, AsnTypePtr orig)
86 {
87 DataVal av;
88 AsnTypePtr atp;
89 AsnReadFunc func;
90 TSeqPtr ptr;
91
92 if (! loaded)
93 {
94 if (! objtseqAsnLoad()) {
95 return NULL;
96 }
97 }
98
99 if (aip == NULL) {
100 return NULL;
101 }
102
103 if (orig == NULL) { /* TSeq ::= (self contained) */
104 atp = AsnReadId(aip, amp, TSEQ);
105 } else {
106 atp = AsnLinkType(orig, TSEQ);
107 }
108 /* link in local tree */
109 if (atp == NULL) {
110 return NULL;
111 }
112
113 ptr = TSeqNew();
114 if (ptr == NULL) {
115 goto erret;
116 }
117 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
118 goto erret;
119 }
120
121 atp = AsnReadId(aip,amp, atp);
122 func = NULL;
123
124 if (atp == TSEQ_seqtype) {
125 if ( AsnReadVal(aip, atp, &av) <= 0) {
126 goto erret;
127 }
128 ptr -> seqtype = av.intvalue;
129 atp = AsnReadId(aip,amp, atp);
130 }
131 if (atp == TSEQ_gi) {
132 if ( AsnReadVal(aip, atp, &av) <= 0) {
133 goto erret;
134 }
135 ptr -> gi = av.intvalue;
136 ptr -> OBbits__ |= 1<<0;
137 atp = AsnReadId(aip,amp, atp);
138 }
139 if (atp == TSEQ_accver) {
140 if ( AsnReadVal(aip, atp, &av) <= 0) {
141 goto erret;
142 }
143 ptr -> accver = av.ptrvalue;
144 atp = AsnReadId(aip,amp, atp);
145 }
146 if (atp == TSEQ_sid) {
147 if ( AsnReadVal(aip, atp, &av) <= 0) {
148 goto erret;
149 }
150 ptr -> sid = av.ptrvalue;
151 atp = AsnReadId(aip,amp, atp);
152 }
153 if (atp == TSEQ_local) {
154 if ( AsnReadVal(aip, atp, &av) <= 0) {
155 goto erret;
156 }
157 ptr -> local = av.ptrvalue;
158 atp = AsnReadId(aip,amp, atp);
159 }
160 if (atp == TSEQ_taxid) {
161 if ( AsnReadVal(aip, atp, &av) <= 0) {
162 goto erret;
163 }
164 ptr -> taxid = av.intvalue;
165 ptr -> OBbits__ |= 1<<1;
166 atp = AsnReadId(aip,amp, atp);
167 }
168 if (atp == TSEQ_orgname) {
169 if ( AsnReadVal(aip, atp, &av) <= 0) {
170 goto erret;
171 }
172 ptr -> orgname = av.ptrvalue;
173 atp = AsnReadId(aip,amp, atp);
174 }
175 if (atp == TSEQ_defline) {
176 if ( AsnReadVal(aip, atp, &av) <= 0) {
177 goto erret;
178 }
179 ptr -> defline = av.ptrvalue;
180 atp = AsnReadId(aip,amp, atp);
181 }
182 if (atp == TSEQ_length) {
183 if ( AsnReadVal(aip, atp, &av) <= 0) {
184 goto erret;
185 }
186 ptr -> length = av.intvalue;
187 atp = AsnReadId(aip,amp, atp);
188 }
189 if (atp == TSEQ_sequence) {
190 if ( AsnReadVal(aip, atp, &av) <= 0) {
191 goto erret;
192 }
193 ptr -> sequence = av.ptrvalue;
194 atp = AsnReadId(aip,amp, atp);
195 }
196
197 if (AsnReadVal(aip, atp, &av) <= 0) {
198 goto erret;
199 }
200 /* end struct */
201
202 ret:
203 AsnUnlinkType(orig); /* unlink local tree */
204 return ptr;
205
206 erret:
207 aip -> io_failure = TRUE;
208 ptr = TSeqFree(ptr);
209 goto ret;
210 }
211
212
213
214 /**************************************************
215 *
216 * TSeqAsnWrite()
217 *
218 **************************************************/
219 NLM_EXTERN Boolean LIBCALL
TSeqAsnWrite(TSeqPtr ptr,AsnIoPtr aip,AsnTypePtr orig)220 TSeqAsnWrite(TSeqPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
221 {
222 DataVal av;
223 AsnTypePtr atp;
224 Boolean retval = FALSE;
225
226 if (! loaded)
227 {
228 if (! objtseqAsnLoad()) {
229 return FALSE;
230 }
231 }
232
233 if (aip == NULL) {
234 return FALSE;
235 }
236
237 atp = AsnLinkType(orig, TSEQ); /* link local tree */
238 if (atp == NULL) {
239 return FALSE;
240 }
241
242 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
243
244 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
245
246 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
247 goto erret;
248 }
249
250 av.intvalue = ptr -> seqtype;
251 retval = AsnWrite(aip, TSEQ_seqtype, &av);
252 if (ptr -> gi || (ptr -> OBbits__ & (1<<0) )){ av.intvalue = ptr -> gi;
253 retval = AsnWrite(aip, TSEQ_gi, &av);
254 }
255 if (ptr -> accver != NULL) {
256 av.ptrvalue = ptr -> accver;
257 retval = AsnWrite(aip, TSEQ_accver, &av);
258 }
259 if (ptr -> sid != NULL) {
260 av.ptrvalue = ptr -> sid;
261 retval = AsnWrite(aip, TSEQ_sid, &av);
262 }
263 if (ptr -> local != NULL) {
264 av.ptrvalue = ptr -> local;
265 retval = AsnWrite(aip, TSEQ_local, &av);
266 }
267 if (ptr -> taxid || (ptr -> OBbits__ & (1<<1) )){ av.intvalue = ptr -> taxid;
268 retval = AsnWrite(aip, TSEQ_taxid, &av);
269 }
270 if (ptr -> orgname != NULL) {
271 av.ptrvalue = ptr -> orgname;
272 retval = AsnWrite(aip, TSEQ_orgname, &av);
273 }
274 if (ptr -> defline != NULL) {
275 av.ptrvalue = ptr -> defline;
276 retval = AsnWrite(aip, TSEQ_defline, &av);
277 }
278 av.intvalue = ptr -> length;
279 retval = AsnWrite(aip, TSEQ_length, &av);
280 if (ptr -> sequence != NULL) {
281 av.ptrvalue = ptr -> sequence;
282 retval = AsnWrite(aip, TSEQ_sequence, &av);
283 }
284 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
285 goto erret;
286 }
287 retval = TRUE;
288
289 erret:
290 AsnUnlinkType(orig); /* unlink local tree */
291 return retval;
292 }
293
294
295
296 /**************************************************
297 *
298 * TSeqSetFree()
299 *
300 **************************************************/
301 NLM_EXTERN
302 TSeqSetPtr LIBCALL
TSeqSetFree(TSeqSetPtr ptr)303 TSeqSetFree(TSeqSetPtr ptr)
304 {
305
306 if(ptr == NULL) {
307 return NULL;
308 }
309 AsnGenericUserSeqOfFree(ptr, (AsnOptFreeFunc) TSeqFree);
310 return NULL;
311 }
312
313
314 /**************************************************
315 *
316 * TSeqSetAsnRead()
317 *
318 **************************************************/
319 NLM_EXTERN
320 TSeqSetPtr LIBCALL
TSeqSetAsnRead(AsnIoPtr aip,AsnTypePtr orig)321 TSeqSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
322 {
323 AsnTypePtr atp;
324 Boolean isError = FALSE;
325 AsnReadFunc func;
326 TSeqSetPtr ptr;
327
328 if (! loaded)
329 {
330 if (! objtseqAsnLoad()) {
331 return NULL;
332 }
333 }
334
335 if (aip == NULL) {
336 return NULL;
337 }
338
339 if (orig == NULL) { /* TSeqSet ::= (self contained) */
340 atp = AsnReadId(aip, amp, TSEQSET);
341 } else {
342 atp = AsnLinkType(orig, TSEQSET);
343 }
344 /* link in local tree */
345 if (atp == NULL) {
346 return NULL;
347 }
348
349 func = NULL;
350
351 ptr = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) TSeqAsnRead, (AsnOptFreeFunc) TSeqFree);
352 if (isError && ptr == NULL) {
353 goto erret;
354 }
355
356
357
358 ret:
359 AsnUnlinkType(orig); /* unlink local tree */
360 return ptr;
361
362 erret:
363 aip -> io_failure = TRUE;
364 ptr = TSeqSetFree(ptr);
365 goto ret;
366 }
367
368
369
370 /**************************************************
371 *
372 * TSeqSetAsnWrite()
373 *
374 **************************************************/
375 NLM_EXTERN Boolean LIBCALL
TSeqSetAsnWrite(TSeqSetPtr ptr,AsnIoPtr aip,AsnTypePtr orig)376 TSeqSetAsnWrite(TSeqSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
377 {
378 AsnTypePtr atp;
379 Boolean retval = FALSE;
380
381 if (! loaded)
382 {
383 if (! objtseqAsnLoad()) {
384 return FALSE;
385 }
386 }
387
388 if (aip == NULL) {
389 return FALSE;
390 }
391
392 atp = AsnLinkType(orig, TSEQSET); /* link local tree */
393 if (atp == NULL) {
394 return FALSE;
395 }
396
397 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
398
399 retval = AsnGenericUserSeqOfAsnWrite(ptr , (AsnWriteFunc) TSeqAsnWrite, aip, atp, TSEQSET_E);
400 retval = TRUE;
401
402 erret:
403 AsnUnlinkType(orig); /* unlink local tree */
404 return retval;
405 }
406
407 /* manually added */
408
409 #include <seqport.h>
410 #include <gather.h>
411 #include <tofasta.h>
412
SaveTseqSequence(CharPtr sequence,Pointer userdata)413 static void LIBCALLBACK SaveTseqSequence (
414 CharPtr sequence,
415 Pointer userdata
416 )
417
418 {
419 Char ch;
420 CharPtr str;
421 CharPtr tmp;
422 CharPtr PNTR tmpp;
423
424 tmpp = (CharPtr PNTR) userdata;
425 tmp = *tmpp;
426
427 str = sequence;
428 if (sequence == NULL) return;
429 ch = *str;
430 while (ch != '\0') {
431 if (ch == '\n' || ch == '\r' || ch == '\t') {
432 *str = ' ';
433 }
434 str++;
435 ch = *str;
436 }
437 TrimSpacesAroundString (sequence);
438
439 tmp = StringMove (tmp, sequence);
440
441 *tmpp = tmp;
442 }
443
BioseqToTSeq(BioseqPtr bsp)444 NLM_EXTERN TSeqPtr BioseqToTSeq (BioseqPtr bsp)
445
446 {
447 TSeqPtr tsp;
448 SeqIdPtr sip;
449 Char buf[255];
450 CharPtr accession = NULL, organism = NULL;
451 CharPtr seq;
452 Uint1 seqcode;
453 ValNodePtr vnp;
454 BioSourcePtr biosp;
455 OrgRefPtr orp;
456 DbtagPtr dbp;
457 ObjectIdPtr oip;
458
459 if (bsp == NULL) return NULL;
460 tsp = TSeqNew ();
461 if (ISA_aa(bsp->mol))
462 tsp->seqtype = TSeq_seqtype_protein;
463 else
464 tsp->seqtype = TSeq_seqtype_nucleotide;
465
466 for (sip = bsp->id; sip != NULL; sip = sip->next)
467 {
468 switch (sip->choice)
469 {
470 case SEQID_GI:
471 tsp->gi = sip->data.intvalue;
472 break;
473 case SEQID_GENBANK:
474 case SEQID_DDBJ:
475 case SEQID_EMBL:
476 case SEQID_SWISSPROT:
477 case SEQID_OTHER:
478 case SEQID_TPG:
479 case SEQID_TPE:
480 case SEQID_TPD:
481 case SEQID_GPIPE:
482 SeqIdWrite(sip, buf, PRINTID_TEXTID_ACC_VER, 250);
483 tsp->accver = StringSave(buf);
484 break;
485 default:
486 SeqIdWrite(sip, buf, PRINTID_FASTA_SHORT, 250);
487 tsp->sid = StringSave(buf);
488 break;
489 }
490 }
491
492 CreateDefLine(NULL, bsp, buf, 250, 0, accession, organism);
493 tsp->defline = StringSave(buf);
494
495 vnp = GetNextDescriptorUnindexed (bsp, Seq_descr_source, NULL);
496 if (vnp != NULL && vnp->data.ptrvalue != NULL) {
497 biosp = (BioSourcePtr)(vnp->data.ptrvalue);
498 orp = biosp->org;
499 if (orp != NULL) {
500 if (orp->taxname != NULL)
501 tsp->orgname = StringSave(orp->taxname);
502 else if (orp->common != NULL)
503 tsp->orgname = StringSave(orp->common);
504
505 for (vnp = orp->db; vnp != NULL; vnp = vnp->next)
506 {
507 dbp = (DbtagPtr)(vnp->data.ptrvalue);
508 if (! StringICmp("taxon", dbp->db))
509 {
510 oip = dbp->tag;
511 tsp->taxid = oip->id;
512 break;
513 }
514 }
515 }
516 }
517
518 tsp->length = bsp->length;
519
520 if (ISA_aa(bsp->mol))
521 {
522 seqcode = Seq_code_ncbieaa;
523 }
524 else
525 {
526 seqcode = Seq_code_iupacna;
527 }
528
529 seq = MemNew(bsp->length + 1);
530 if (seq != NULL) {
531 tsp->sequence = seq;
532 SeqPortStream (bsp, STREAM_EXPAND_GAPS | STREAM_CORRECT_INVAL, (Pointer) &seq, SaveTseqSequence);
533 }
534
535 return tsp;
536 }
537
538 NLM_EXTERN Boolean AsnPrintString (CharPtr the_string, AsnIoPtr aip);
539
TSeqStreamProc(CharPtr sequence,Pointer userdata)540 static void LIBCALLBACK TSeqStreamProc (CharPtr sequence, Pointer userdata)
541
542 {
543 AsnIoPtr aip;
544
545 aip = (AsnIoPtr) userdata;
546
547 AsnPrintString (sequence, aip);
548 }
549
StreamTSeq(Pointer object,AsnIoPtr aip)550 static Boolean LIBCALL StreamTSeq (Pointer object, AsnIoPtr aip)
551
552 {
553 SeqPortStream ((BioseqPtr) object, STREAM_EXPAND_GAPS | STREAM_CORRECT_INVAL, (Pointer) aip, TSeqStreamProc);
554 return TRUE;
555 }
556
BioseqToMiniTSeq(BioseqPtr bsp)557 static TSeqPtr BioseqToMiniTSeq (BioseqPtr bsp)
558
559 {
560 TSeqPtr tsp;
561 SeqIdPtr sip;
562 Char buf[255];
563 CharPtr accession = NULL, organism = NULL, gpipe = NULL;
564 Uint1 seqcode;
565 ValNodePtr vnp;
566 BioSourcePtr biosp;
567 OrgRefPtr orp;
568 DbtagPtr dbp;
569 ObjectIdPtr oip;
570
571 if (bsp == NULL) return NULL;
572 tsp = TSeqNew ();
573 if (ISA_aa (bsp->mol)) {
574 tsp->seqtype = TSeq_seqtype_protein;
575 } else {
576 tsp->seqtype = TSeq_seqtype_nucleotide;
577 }
578
579 for (sip = bsp->id; sip != NULL; sip = sip->next) {
580 switch (sip->choice) {
581 case SEQID_GI:
582 tsp->gi = sip->data.intvalue;
583 break;
584 case SEQID_GENBANK:
585 case SEQID_DDBJ:
586 case SEQID_EMBL:
587 case SEQID_SWISSPROT:
588 case SEQID_OTHER:
589 case SEQID_TPG:
590 case SEQID_TPE:
591 case SEQID_TPD:
592 SeqIdWrite (sip, buf, PRINTID_TEXTID_ACC_VER, 250);
593 tsp->accver = StringSave (buf);
594 break;
595 case SEQID_GPIPE:
596 SeqIdWrite (sip, buf, PRINTID_TEXTID_ACC_VER, 250);
597 gpipe = StringSave (buf);
598 break;
599 default:
600 SeqIdWrite (sip, buf, PRINTID_FASTA_SHORT, 250);
601 tsp->sid = StringSave (buf);
602 break;
603 }
604 }
605 if (gpipe != NULL) {
606 if (tsp->accver == NULL) {
607 tsp->accver = gpipe;
608 } else if (tsp->sid == NULL) {
609 tsp->sid = gpipe;
610 }
611 }
612
613 CreateDefLine (NULL, bsp, buf, 250, 0, accession, organism);
614 tsp->defline = StringSave (buf);
615
616 vnp = GetNextDescriptorUnindexed (bsp, Seq_descr_source, NULL);
617 if (vnp != NULL && vnp->data.ptrvalue != NULL) {
618 biosp = (BioSourcePtr)(vnp->data.ptrvalue);
619 orp = biosp->org;
620 if (orp != NULL) {
621 if (orp->taxname != NULL) {
622 tsp->orgname = StringSave (orp->taxname);
623 } else if (orp->common != NULL) {
624 tsp->orgname = StringSave (orp->common);
625 }
626
627 for (vnp = orp->db; vnp != NULL; vnp = vnp->next) {
628 dbp = (DbtagPtr)(vnp->data.ptrvalue);
629 if (! StringICmp ("taxon", dbp->db)) {
630 oip = dbp->tag;
631 tsp->taxid = oip->id;
632 break;
633 }
634 }
635 }
636 }
637
638 tsp->length = bsp->length;
639
640 if (ISA_aa (bsp->mol)) {
641 seqcode = Seq_code_ncbieaa;
642 } else {
643 seqcode = Seq_code_iupacna;
644 }
645
646 /*
647 seq = MemNew(bsp->length + 1);
648 if (seq != NULL) {
649 tsp->sequence = seq;
650 SeqPortStream (bsp, STREAM_EXPAND_GAPS | STREAM_CORRECT_INVAL, (Pointer) &seq, SaveTseqSequence);
651 }
652 */
653
654 return tsp;
655 }
656
BioseqAsnWriteAsTSeq(BioseqPtr bsp,AsnIoPtr aip,AsnTypePtr orig)657 NLM_EXTERN Boolean BioseqAsnWriteAsTSeq (BioseqPtr bsp, AsnIoPtr aip, AsnTypePtr orig)
658 {
659 DataVal av;
660 AsnTypePtr atp;
661 Boolean retval = FALSE;
662 TSeqPtr ptr = NULL;
663
664 if (! loaded)
665 {
666 if (! objtseqAsnLoad()) {
667 return FALSE;
668 }
669 }
670
671 if (aip == NULL) {
672 return FALSE;
673 }
674
675 atp = AsnLinkType(orig, TSEQ); /* link local tree */
676 if (atp == NULL) {
677 return FALSE;
678 }
679
680 ptr = BioseqToMiniTSeq (bsp);
681
682 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
683
684 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
685
686 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
687 goto erret;
688 }
689
690 av.intvalue = ptr -> seqtype;
691 retval = AsnWrite(aip, TSEQ_seqtype, &av);
692 if (ptr -> gi || (ptr -> OBbits__ & (1<<0) )){ av.intvalue = ptr -> gi;
693 retval = AsnWrite(aip, TSEQ_gi, &av);
694 }
695 if (ptr -> accver != NULL) {
696 av.ptrvalue = ptr -> accver;
697 retval = AsnWrite(aip, TSEQ_accver, &av);
698 }
699 if (ptr -> sid != NULL) {
700 av.ptrvalue = ptr -> sid;
701 retval = AsnWrite(aip, TSEQ_sid, &av);
702 }
703 if (ptr -> local != NULL) {
704 av.ptrvalue = ptr -> local;
705 retval = AsnWrite(aip, TSEQ_local, &av);
706 }
707 if (ptr -> taxid || (ptr -> OBbits__ & (1<<1) )){ av.intvalue = ptr -> taxid;
708 retval = AsnWrite(aip, TSEQ_taxid, &av);
709 }
710 if (ptr -> orgname != NULL) {
711 av.ptrvalue = ptr -> orgname;
712 retval = AsnWrite(aip, TSEQ_orgname, &av);
713 }
714 if (ptr -> defline != NULL) {
715 av.ptrvalue = ptr -> defline;
716 retval = AsnWrite(aip, TSEQ_defline, &av);
717 }
718 av.intvalue = ptr -> length;
719 retval = AsnWrite(aip, TSEQ_length, &av);
720 if (bsp != NULL) {
721 av.ptrvalue = bsp; /* pass bsp to SeqPortStream */
722 retval = AsnWriteEx(aip, TSEQ_sequence, &av, StreamTSeq);
723 }
724 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
725 goto erret;
726 }
727 retval = TRUE;
728
729 erret:
730 AsnUnlinkType(orig); /* unlink local tree */
731 TSeqFree (ptr);
732 return retval;
733 }
734
735