1 #include <asn.h>
2
3 #define NLM_GENERATED_CODE_PROTO
4
5 #include <objgen.h>
6 #include <objsset.h>
7 #include <objscoremat.h>
8
9 static Boolean loaded = FALSE;
10
11 #include <scoremat.h>
12
13 #ifndef NLM_EXTERN_LOADS
14 #define NLM_EXTERN_LOADS {}
15 #endif
16
17 NLM_EXTERN Boolean LIBCALL
objscorematAsnLoad(void)18 objscorematAsnLoad(void)
19 {
20
21 if ( ! loaded) {
22 NLM_EXTERN_LOADS
23
24 if ( ! AsnLoad ())
25 return FALSE;
26 loaded = TRUE;
27 }
28
29 return TRUE;
30 }
31
32
33
34 /**************************************************
35 * Generated object loaders for Module NCBI-ScoreMat
36 * Generated using ASNCODE Revision: 6.16 at Jun 2, 2008 11:45 AM
37 *
38 **************************************************/
39
40
41 /**************************************************
42 *
43 * PssmNew()
44 *
45 **************************************************/
46 NLM_EXTERN
47 PssmPtr LIBCALL
PssmNew(void)48 PssmNew(void)
49 {
50 PssmPtr ptr = MemNew((size_t) sizeof(Pssm));
51
52 ptr -> isProtein = 1;
53 ptr -> byRow = 0;
54 return ptr;
55
56 }
57
58
59 /**************************************************
60 *
61 * PssmFree()
62 *
63 **************************************************/
64 NLM_EXTERN
65 PssmPtr LIBCALL
PssmFree(PssmPtr ptr)66 PssmFree(PssmPtr ptr)
67 {
68
69 if(ptr == NULL) {
70 return NULL;
71 }
72 ObjectIdFree(ptr -> identifier);
73 AsnGenericBaseSeqOfFree(ptr -> rowLabels ,ASNCODE_PTRVAL_SLOT);
74 SeqEntryFree(ptr -> query);
75 PssmIntermediateDataFree(ptr -> intermediateData);
76 PssmFinalDataFree(ptr -> finalData);
77 return MemFree(ptr);
78 }
79
80
81 /**************************************************
82 *
83 * PssmAsnRead()
84 *
85 **************************************************/
86 NLM_EXTERN
87 PssmPtr LIBCALL
PssmAsnRead(AsnIoPtr aip,AsnTypePtr orig)88 PssmAsnRead(AsnIoPtr aip, AsnTypePtr orig)
89 {
90 DataVal av;
91 AsnTypePtr atp;
92 Boolean isError = FALSE;
93 AsnReadFunc func;
94 PssmPtr ptr;
95
96 if (! loaded)
97 {
98 if (! objscorematAsnLoad()) {
99 return NULL;
100 }
101 }
102
103 if (aip == NULL) {
104 return NULL;
105 }
106
107 if (orig == NULL) { /* Pssm ::= (self contained) */
108 atp = AsnReadId(aip, amp, PSSM);
109 } else {
110 atp = AsnLinkType(orig, PSSM);
111 }
112 /* link in local tree */
113 if (atp == NULL) {
114 return NULL;
115 }
116
117 ptr = PssmNew();
118 if (ptr == NULL) {
119 goto erret;
120 }
121 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
122 goto erret;
123 }
124
125 atp = AsnReadId(aip,amp, atp);
126 func = NULL;
127
128 if (atp == PSSM_isProtein) {
129 if ( AsnReadVal(aip, atp, &av) <= 0) {
130 goto erret;
131 }
132 ptr -> isProtein = av.boolvalue;
133 atp = AsnReadId(aip,amp, atp);
134 }
135 if (atp == PSSM_identifier) {
136 ptr -> identifier = ObjectIdAsnRead(aip, atp);
137 if (aip -> io_failure) {
138 goto erret;
139 }
140 atp = AsnReadId(aip,amp, atp);
141 }
142 if (atp == PSSM_numRows) {
143 if ( AsnReadVal(aip, atp, &av) <= 0) {
144 goto erret;
145 }
146 ptr -> numRows = av.intvalue;
147 atp = AsnReadId(aip,amp, atp);
148 }
149 if (atp == PSSM_numColumns) {
150 if ( AsnReadVal(aip, atp, &av) <= 0) {
151 goto erret;
152 }
153 ptr -> numColumns = av.intvalue;
154 atp = AsnReadId(aip,amp, atp);
155 }
156 if (atp == PSSM_rowLabels) {
157 ptr -> rowLabels = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
158 if (isError && ptr -> rowLabels == NULL) {
159 goto erret;
160 }
161 atp = AsnReadId(aip,amp, atp);
162 }
163 if (atp == PSSM_byRow) {
164 if ( AsnReadVal(aip, atp, &av) <= 0) {
165 goto erret;
166 }
167 ptr -> byRow = av.boolvalue;
168 atp = AsnReadId(aip,amp, atp);
169 }
170 if (atp == PSSM_query) {
171 ptr -> query = SeqEntryAsnRead(aip, atp);
172 if (aip -> io_failure) {
173 goto erret;
174 }
175 atp = AsnReadId(aip,amp, atp);
176 }
177 if (atp == PSSM_intermediateData) {
178 ptr -> intermediateData = PssmIntermediateDataAsnRead(aip, atp);
179 if (aip -> io_failure) {
180 goto erret;
181 }
182 atp = AsnReadId(aip,amp, atp);
183 }
184 if (atp == PSSM_finalData) {
185 ptr -> finalData = PssmFinalDataAsnRead(aip, atp);
186 if (aip -> io_failure) {
187 goto erret;
188 }
189 atp = AsnReadId(aip,amp, atp);
190 }
191
192 if (AsnReadVal(aip, atp, &av) <= 0) {
193 goto erret;
194 }
195 /* end struct */
196
197 ret:
198 AsnUnlinkType(orig); /* unlink local tree */
199 return ptr;
200
201 erret:
202 aip -> io_failure = TRUE;
203 ptr = PssmFree(ptr);
204 goto ret;
205 }
206
207
208
209 /**************************************************
210 *
211 * PssmAsnWrite()
212 *
213 **************************************************/
214 NLM_EXTERN Boolean LIBCALL
PssmAsnWrite(PssmPtr ptr,AsnIoPtr aip,AsnTypePtr orig)215 PssmAsnWrite(PssmPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
216 {
217 DataVal av;
218 AsnTypePtr atp;
219 Boolean retval = FALSE;
220
221 if (! loaded)
222 {
223 if (! objscorematAsnLoad()) {
224 return FALSE;
225 }
226 }
227
228 if (aip == NULL) {
229 return FALSE;
230 }
231
232 atp = AsnLinkType(orig, PSSM); /* link local tree */
233 if (atp == NULL) {
234 return FALSE;
235 }
236
237 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
238
239 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
240
241 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
242 goto erret;
243 }
244
245 av.boolvalue = ptr -> isProtein;
246 retval = AsnWrite(aip, PSSM_isProtein, &av);
247 if (ptr -> identifier != NULL) {
248 if ( ! ObjectIdAsnWrite(ptr -> identifier, aip, PSSM_identifier)) {
249 goto erret;
250 }
251 }
252 av.intvalue = ptr -> numRows;
253 retval = AsnWrite(aip, PSSM_numRows, &av);
254 av.intvalue = ptr -> numColumns;
255 retval = AsnWrite(aip, PSSM_numColumns, &av);
256 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> rowLabels ,ASNCODE_PTRVAL_SLOT, aip, PSSM_rowLabels, PSSM_rowLabels_E);
257 av.boolvalue = ptr -> byRow;
258 retval = AsnWrite(aip, PSSM_byRow, &av);
259 if (ptr -> query != NULL) {
260 if ( ! SeqEntryAsnWrite(ptr -> query, aip, PSSM_query)) {
261 goto erret;
262 }
263 }
264 if (ptr -> intermediateData != NULL) {
265 if ( ! PssmIntermediateDataAsnWrite(ptr -> intermediateData, aip, PSSM_intermediateData)) {
266 goto erret;
267 }
268 }
269 if (ptr -> finalData != NULL) {
270 if ( ! PssmFinalDataAsnWrite(ptr -> finalData, aip, PSSM_finalData)) {
271 goto erret;
272 }
273 }
274 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
275 goto erret;
276 }
277 retval = TRUE;
278
279 erret:
280 AsnUnlinkType(orig); /* unlink local tree */
281 return retval;
282 }
283
284
285
286 /**************************************************
287 *
288 * PssmIntermediateDataNew()
289 *
290 **************************************************/
291 NLM_EXTERN
292 PssmIntermediateDataPtr LIBCALL
PssmIntermediateDataNew(void)293 PssmIntermediateDataNew(void)
294 {
295 PssmIntermediateDataPtr ptr = MemNew((size_t) sizeof(PssmIntermediateData));
296
297 return ptr;
298
299 }
300
301
302 /**************************************************
303 *
304 * PssmIntermediateDataFree()
305 *
306 **************************************************/
307 NLM_EXTERN
308 PssmIntermediateDataPtr LIBCALL
PssmIntermediateDataFree(PssmIntermediateDataPtr ptr)309 PssmIntermediateDataFree(PssmIntermediateDataPtr ptr)
310 {
311
312 if(ptr == NULL) {
313 return NULL;
314 }
315 AsnGenericBaseSeqOfFree(ptr -> resFreqsPerPos ,ASNCODE_INTVAL_SLOT);
316 AsnGenericBaseSeqOfFree(ptr -> weightedResFreqsPerPos ,ASNCODE_REALVAL_SLOT);
317 AsnGenericBaseSeqOfFree(ptr -> freqRatios ,ASNCODE_REALVAL_SLOT);
318 AsnGenericBaseSeqOfFree(ptr -> informationContent ,ASNCODE_REALVAL_SLOT);
319 AsnGenericBaseSeqOfFree(ptr -> gaplessColumnWeights ,ASNCODE_REALVAL_SLOT);
320 AsnGenericBaseSeqOfFree(ptr -> sigma ,ASNCODE_REALVAL_SLOT);
321 AsnGenericBaseSeqOfFree(ptr -> intervalSizes ,ASNCODE_INTVAL_SLOT);
322 AsnGenericBaseSeqOfFree(ptr -> numMatchingSeqs ,ASNCODE_INTVAL_SLOT);
323 return MemFree(ptr);
324 }
325
326
327 /**************************************************
328 *
329 * PssmIntermediateDataAsnRead()
330 *
331 **************************************************/
332 NLM_EXTERN
333 PssmIntermediateDataPtr LIBCALL
PssmIntermediateDataAsnRead(AsnIoPtr aip,AsnTypePtr orig)334 PssmIntermediateDataAsnRead(AsnIoPtr aip, AsnTypePtr orig)
335 {
336 DataVal av;
337 AsnTypePtr atp;
338 Boolean isError = FALSE;
339 AsnReadFunc func;
340 PssmIntermediateDataPtr ptr;
341
342 if (! loaded)
343 {
344 if (! objscorematAsnLoad()) {
345 return NULL;
346 }
347 }
348
349 if (aip == NULL) {
350 return NULL;
351 }
352
353 if (orig == NULL) { /* PssmIntermediateData ::= (self contained) */
354 atp = AsnReadId(aip, amp, PSSMINTERMEDIATEDATA);
355 } else {
356 atp = AsnLinkType(orig, PSSMINTERMEDIATEDATA);
357 }
358 /* link in local tree */
359 if (atp == NULL) {
360 return NULL;
361 }
362
363 ptr = PssmIntermediateDataNew();
364 if (ptr == NULL) {
365 goto erret;
366 }
367 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
368 goto erret;
369 }
370
371 atp = AsnReadId(aip,amp, atp);
372 func = NULL;
373
374 if (atp == PSSMINTERMEDIATEDATA_resFreqsPerPos) {
375 ptr -> resFreqsPerPos = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_INTVAL_SLOT, &isError);
376 if (isError && ptr -> resFreqsPerPos == NULL) {
377 goto erret;
378 }
379 atp = AsnReadId(aip,amp, atp);
380 }
381 if (atp == PSSMINTERMEDIATEDATA_weightedResFreqsPerPos) {
382 ptr -> weightedResFreqsPerPos = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_REALVAL_SLOT, &isError);
383 if (isError && ptr -> weightedResFreqsPerPos == NULL) {
384 goto erret;
385 }
386 atp = AsnReadId(aip,amp, atp);
387 }
388 if (atp == PSSMINTERMEDIATEDATA_freqRatios) {
389 ptr -> freqRatios = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_REALVAL_SLOT, &isError);
390 if (isError && ptr -> freqRatios == NULL) {
391 goto erret;
392 }
393 atp = AsnReadId(aip,amp, atp);
394 }
395 if (atp == PSSMINTERMEDIATEDATA_informationContent) {
396 ptr -> informationContent = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_REALVAL_SLOT, &isError);
397 if (isError && ptr -> informationContent == NULL) {
398 goto erret;
399 }
400 atp = AsnReadId(aip,amp, atp);
401 }
402 if (atp == PSSMINTERMEDIATEDATA_gaplessColumnWeights) {
403 ptr -> gaplessColumnWeights = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_REALVAL_SLOT, &isError);
404 if (isError && ptr -> gaplessColumnWeights == NULL) {
405 goto erret;
406 }
407 atp = AsnReadId(aip,amp, atp);
408 }
409 if (atp == PSSMINTERMEDIATEDATA_sigma) {
410 ptr -> sigma = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_REALVAL_SLOT, &isError);
411 if (isError && ptr -> sigma == NULL) {
412 goto erret;
413 }
414 atp = AsnReadId(aip,amp, atp);
415 }
416 if (atp == PSSMINTERMEDIATEDATA_intervalSizes) {
417 ptr -> intervalSizes = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_INTVAL_SLOT, &isError);
418 if (isError && ptr -> intervalSizes == NULL) {
419 goto erret;
420 }
421 atp = AsnReadId(aip,amp, atp);
422 }
423 if (atp == PSSMINTERMEDIATEDATA_numMatchingSeqs) {
424 ptr -> numMatchingSeqs = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_INTVAL_SLOT, &isError);
425 if (isError && ptr -> numMatchingSeqs == NULL) {
426 goto erret;
427 }
428 atp = AsnReadId(aip,amp, atp);
429 }
430
431 if (AsnReadVal(aip, atp, &av) <= 0) {
432 goto erret;
433 }
434 /* end struct */
435
436 ret:
437 AsnUnlinkType(orig); /* unlink local tree */
438 return ptr;
439
440 erret:
441 aip -> io_failure = TRUE;
442 ptr = PssmIntermediateDataFree(ptr);
443 goto ret;
444 }
445
446
447
448 /**************************************************
449 *
450 * PssmIntermediateDataAsnWrite()
451 *
452 **************************************************/
453 NLM_EXTERN Boolean LIBCALL
PssmIntermediateDataAsnWrite(PssmIntermediateDataPtr ptr,AsnIoPtr aip,AsnTypePtr orig)454 PssmIntermediateDataAsnWrite(PssmIntermediateDataPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
455 {
456 AsnTypePtr atp;
457 Boolean retval = FALSE;
458
459 if (! loaded)
460 {
461 if (! objscorematAsnLoad()) {
462 return FALSE;
463 }
464 }
465
466 if (aip == NULL) {
467 return FALSE;
468 }
469
470 atp = AsnLinkType(orig, PSSMINTERMEDIATEDATA); /* link local tree */
471 if (atp == NULL) {
472 return FALSE;
473 }
474
475 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
476
477 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
478 goto erret;
479 }
480
481 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> resFreqsPerPos ,ASNCODE_INTVAL_SLOT, aip, PSSMINTERMEDIATEDATA_resFreqsPerPos, PSSMINTERMEDIATEDATA_resFreqsPerPos_E);
482 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> weightedResFreqsPerPos ,ASNCODE_REALVAL_SLOT, aip, PSSMINTERMEDIATEDATA_weightedResFreqsPerPos, PSSMINTERMEDIATEDATA_weightedResFreqsPerPos_E);
483 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> freqRatios ,ASNCODE_REALVAL_SLOT, aip, PSSMINTERMEDIATEDATA_freqRatios, PSSMINTERMEDIATEDATA_freqRatios_E);
484 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> informationContent ,ASNCODE_REALVAL_SLOT, aip, PSSMINTERMEDIATEDATA_informationContent, PSSMINTERMEDIATEDATA_informationContent_E);
485 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> gaplessColumnWeights ,ASNCODE_REALVAL_SLOT, aip, PSSMINTERMEDIATEDATA_gaplessColumnWeights, PSSMINTERMEDIATEDATA_gaplessColumnWeights_E);
486 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> sigma ,ASNCODE_REALVAL_SLOT, aip, PSSMINTERMEDIATEDATA_sigma, PSSMINTERMEDIATEDATA_sigma_E);
487 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> intervalSizes ,ASNCODE_INTVAL_SLOT, aip, PSSMINTERMEDIATEDATA_intervalSizes, PSSMINTERMEDIATEDATA_intervalSizes_E);
488 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> numMatchingSeqs ,ASNCODE_INTVAL_SLOT, aip, PSSMINTERMEDIATEDATA_numMatchingSeqs, PSSMINTERMEDIATEDATA_numMatchingSeqs_E);
489 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
490 goto erret;
491 }
492 retval = TRUE;
493
494 erret:
495 AsnUnlinkType(orig); /* unlink local tree */
496 return retval;
497 }
498
499
500
501 /**************************************************
502 *
503 * PssmFinalDataNew()
504 *
505 **************************************************/
506 NLM_EXTERN
507 PssmFinalDataPtr LIBCALL
PssmFinalDataNew(void)508 PssmFinalDataNew(void)
509 {
510 PssmFinalDataPtr ptr = MemNew((size_t) sizeof(PssmFinalData));
511
512 ptr -> scalingFactor = 1;
513 return ptr;
514
515 }
516
517
518 /**************************************************
519 *
520 * PssmFinalDataFree()
521 *
522 **************************************************/
523 NLM_EXTERN
524 PssmFinalDataPtr LIBCALL
PssmFinalDataFree(PssmFinalDataPtr ptr)525 PssmFinalDataFree(PssmFinalDataPtr ptr)
526 {
527
528 if(ptr == NULL) {
529 return NULL;
530 }
531 AsnGenericBaseSeqOfFree(ptr -> scores ,ASNCODE_INTVAL_SLOT);
532 return MemFree(ptr);
533 }
534
535
536 /**************************************************
537 *
538 * PssmFinalDataAsnRead()
539 *
540 **************************************************/
541 NLM_EXTERN
542 PssmFinalDataPtr LIBCALL
PssmFinalDataAsnRead(AsnIoPtr aip,AsnTypePtr orig)543 PssmFinalDataAsnRead(AsnIoPtr aip, AsnTypePtr orig)
544 {
545 DataVal av;
546 AsnTypePtr atp;
547 Boolean isError = FALSE;
548 AsnReadFunc func;
549 PssmFinalDataPtr ptr;
550
551 if (! loaded)
552 {
553 if (! objscorematAsnLoad()) {
554 return NULL;
555 }
556 }
557
558 if (aip == NULL) {
559 return NULL;
560 }
561
562 if (orig == NULL) { /* PssmFinalData ::= (self contained) */
563 atp = AsnReadId(aip, amp, PSSMFINALDATA);
564 } else {
565 atp = AsnLinkType(orig, PSSMFINALDATA);
566 }
567 /* link in local tree */
568 if (atp == NULL) {
569 return NULL;
570 }
571
572 ptr = PssmFinalDataNew();
573 if (ptr == NULL) {
574 goto erret;
575 }
576 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
577 goto erret;
578 }
579
580 atp = AsnReadId(aip,amp, atp);
581 func = NULL;
582
583 if (atp == PSSMFINALDATA_scores) {
584 ptr -> scores = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_INTVAL_SLOT, &isError);
585 if (isError && ptr -> scores == NULL) {
586 goto erret;
587 }
588 atp = AsnReadId(aip,amp, atp);
589 }
590 if (atp == PSSMFINALDATA_lambda) {
591 if ( AsnReadVal(aip, atp, &av) <= 0) {
592 goto erret;
593 }
594 ptr -> lambda = av.realvalue;
595 atp = AsnReadId(aip,amp, atp);
596 }
597 if (atp == PSSMFINALDATA_kappa) {
598 if ( AsnReadVal(aip, atp, &av) <= 0) {
599 goto erret;
600 }
601 ptr -> kappa = av.realvalue;
602 atp = AsnReadId(aip,amp, atp);
603 }
604 if (atp == PSSMFINALDATA_h) {
605 if ( AsnReadVal(aip, atp, &av) <= 0) {
606 goto erret;
607 }
608 ptr -> h = av.realvalue;
609 atp = AsnReadId(aip,amp, atp);
610 }
611 if (atp == PSSMFINALDATA_scalingFactor) {
612 if ( AsnReadVal(aip, atp, &av) <= 0) {
613 goto erret;
614 }
615 ptr -> scalingFactor = av.intvalue;
616 atp = AsnReadId(aip,amp, atp);
617 }
618 if (atp == PSSMFINALDATA_lambdaUngapped) {
619 if ( AsnReadVal(aip, atp, &av) <= 0) {
620 goto erret;
621 }
622 ptr -> lambdaUngapped = av.realvalue;
623 atp = AsnReadId(aip,amp, atp);
624 }
625 if (atp == PSSMFINALDATA_kappaUngapped) {
626 if ( AsnReadVal(aip, atp, &av) <= 0) {
627 goto erret;
628 }
629 ptr -> kappaUngapped = av.realvalue;
630 atp = AsnReadId(aip,amp, atp);
631 }
632 if (atp == PSSMFINALDATA_hUngapped) {
633 if ( AsnReadVal(aip, atp, &av) <= 0) {
634 goto erret;
635 }
636 ptr -> hUngapped = av.realvalue;
637 atp = AsnReadId(aip,amp, atp);
638 }
639
640 if (AsnReadVal(aip, atp, &av) <= 0) {
641 goto erret;
642 }
643 /* end struct */
644
645 ret:
646 AsnUnlinkType(orig); /* unlink local tree */
647 return ptr;
648
649 erret:
650 aip -> io_failure = TRUE;
651 ptr = PssmFinalDataFree(ptr);
652 goto ret;
653 }
654
655
656
657 /**************************************************
658 *
659 * PssmFinalDataAsnWrite()
660 *
661 **************************************************/
662 NLM_EXTERN Boolean LIBCALL
PssmFinalDataAsnWrite(PssmFinalDataPtr ptr,AsnIoPtr aip,AsnTypePtr orig)663 PssmFinalDataAsnWrite(PssmFinalDataPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
664 {
665 DataVal av;
666 AsnTypePtr atp;
667 Boolean retval = FALSE;
668
669 if (! loaded)
670 {
671 if (! objscorematAsnLoad()) {
672 return FALSE;
673 }
674 }
675
676 if (aip == NULL) {
677 return FALSE;
678 }
679
680 atp = AsnLinkType(orig, PSSMFINALDATA); /* link local tree */
681 if (atp == NULL) {
682 return FALSE;
683 }
684
685 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
686
687 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
688
689 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
690 goto erret;
691 }
692
693 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> scores ,ASNCODE_INTVAL_SLOT, aip, PSSMFINALDATA_scores, PSSMFINALDATA_scores_E);
694 av.realvalue = ptr -> lambda;
695 retval = AsnWrite(aip, PSSMFINALDATA_lambda, &av);
696 av.realvalue = ptr -> kappa;
697 retval = AsnWrite(aip, PSSMFINALDATA_kappa, &av);
698 av.realvalue = ptr -> h;
699 retval = AsnWrite(aip, PSSMFINALDATA_h, &av);
700 av.intvalue = ptr -> scalingFactor;
701 retval = AsnWrite(aip, PSSMFINALDATA_scalingFactor, &av);
702 av.realvalue = ptr -> lambdaUngapped;
703 retval = AsnWrite(aip, PSSMFINALDATA_lambdaUngapped, &av);
704 av.realvalue = ptr -> kappaUngapped;
705 retval = AsnWrite(aip, PSSMFINALDATA_kappaUngapped, &av);
706 av.realvalue = ptr -> hUngapped;
707 retval = AsnWrite(aip, PSSMFINALDATA_hUngapped, &av);
708 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
709 goto erret;
710 }
711 retval = TRUE;
712
713 erret:
714 AsnUnlinkType(orig); /* unlink local tree */
715 return retval;
716 }
717
718
719
720 /**************************************************
721 *
722 * PssmParametersNew()
723 *
724 **************************************************/
725 NLM_EXTERN
726 PssmParametersPtr LIBCALL
PssmParametersNew(void)727 PssmParametersNew(void)
728 {
729 PssmParametersPtr ptr = MemNew((size_t) sizeof(PssmParameters));
730
731 return ptr;
732
733 }
734
735
736 /**************************************************
737 *
738 * PssmParametersFree()
739 *
740 **************************************************/
741 NLM_EXTERN
742 PssmParametersPtr LIBCALL
PssmParametersFree(PssmParametersPtr ptr)743 PssmParametersFree(PssmParametersPtr ptr)
744 {
745
746 if(ptr == NULL) {
747 return NULL;
748 }
749 FormatRpsDbParametersFree(ptr -> rpsdbparams);
750 CoreDefFree(ptr -> constraints);
751 return MemFree(ptr);
752 }
753
754
755 /**************************************************
756 *
757 * PssmParametersAsnRead()
758 *
759 **************************************************/
760 NLM_EXTERN
761 PssmParametersPtr LIBCALL
PssmParametersAsnRead(AsnIoPtr aip,AsnTypePtr orig)762 PssmParametersAsnRead(AsnIoPtr aip, AsnTypePtr orig)
763 {
764 DataVal av;
765 AsnTypePtr atp;
766 AsnReadFunc func;
767 PssmParametersPtr ptr;
768
769 if (! loaded)
770 {
771 if (! objscorematAsnLoad()) {
772 return NULL;
773 }
774 }
775
776 if (aip == NULL) {
777 return NULL;
778 }
779
780 if (orig == NULL) { /* PssmParameters ::= (self contained) */
781 atp = AsnReadId(aip, amp, PSSMPARAMETERS);
782 } else {
783 atp = AsnLinkType(orig, PSSMPARAMETERS);
784 }
785 /* link in local tree */
786 if (atp == NULL) {
787 return NULL;
788 }
789
790 ptr = PssmParametersNew();
791 if (ptr == NULL) {
792 goto erret;
793 }
794 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
795 goto erret;
796 }
797
798 atp = AsnReadId(aip,amp, atp);
799 func = NULL;
800
801 if (atp == PSSMPARAMETERS_pseudocount) {
802 if ( AsnReadVal(aip, atp, &av) <= 0) {
803 goto erret;
804 }
805 ptr -> pseudocount = av.intvalue;
806 atp = AsnReadId(aip,amp, atp);
807 }
808 if (atp == PSSMPARAMETERS_rpsdbparams) {
809 ptr -> rpsdbparams = FormatRpsDbParametersAsnRead(aip, atp);
810 if (aip -> io_failure) {
811 goto erret;
812 }
813 atp = AsnReadId(aip,amp, atp);
814 }
815 if (atp == PSSMPARAMETERS_constraints) {
816 ptr -> constraints = CoreDefAsnRead(aip, atp);
817 if (aip -> io_failure) {
818 goto erret;
819 }
820 atp = AsnReadId(aip,amp, atp);
821 }
822
823 if (AsnReadVal(aip, atp, &av) <= 0) {
824 goto erret;
825 }
826 /* end struct */
827
828 ret:
829 AsnUnlinkType(orig); /* unlink local tree */
830 return ptr;
831
832 erret:
833 aip -> io_failure = TRUE;
834 ptr = PssmParametersFree(ptr);
835 goto ret;
836 }
837
838
839
840 /**************************************************
841 *
842 * PssmParametersAsnWrite()
843 *
844 **************************************************/
845 NLM_EXTERN Boolean LIBCALL
PssmParametersAsnWrite(PssmParametersPtr ptr,AsnIoPtr aip,AsnTypePtr orig)846 PssmParametersAsnWrite(PssmParametersPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
847 {
848 DataVal av;
849 AsnTypePtr atp;
850 Boolean retval = FALSE;
851
852 if (! loaded)
853 {
854 if (! objscorematAsnLoad()) {
855 return FALSE;
856 }
857 }
858
859 if (aip == NULL) {
860 return FALSE;
861 }
862
863 atp = AsnLinkType(orig, PSSMPARAMETERS); /* link local tree */
864 if (atp == NULL) {
865 return FALSE;
866 }
867
868 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
869
870 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
871
872 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
873 goto erret;
874 }
875
876 av.intvalue = ptr -> pseudocount;
877 retval = AsnWrite(aip, PSSMPARAMETERS_pseudocount, &av);
878 if (ptr -> rpsdbparams != NULL) {
879 if ( ! FormatRpsDbParametersAsnWrite(ptr -> rpsdbparams, aip, PSSMPARAMETERS_rpsdbparams)) {
880 goto erret;
881 }
882 }
883 if (ptr -> constraints != NULL) {
884 if ( ! CoreDefAsnWrite(ptr -> constraints, aip, PSSMPARAMETERS_constraints)) {
885 goto erret;
886 }
887 }
888 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
889 goto erret;
890 }
891 retval = TRUE;
892
893 erret:
894 AsnUnlinkType(orig); /* unlink local tree */
895 return retval;
896 }
897
898
899
900 /**************************************************
901 *
902 * PssmWithParametersNew()
903 *
904 **************************************************/
905 NLM_EXTERN
906 PssmWithParametersPtr LIBCALL
PssmWithParametersNew(void)907 PssmWithParametersNew(void)
908 {
909 PssmWithParametersPtr ptr = MemNew((size_t) sizeof(PssmWithParameters));
910
911 return ptr;
912
913 }
914
915
916 /**************************************************
917 *
918 * PssmWithParametersFree()
919 *
920 **************************************************/
921 NLM_EXTERN
922 PssmWithParametersPtr LIBCALL
PssmWithParametersFree(PssmWithParametersPtr ptr)923 PssmWithParametersFree(PssmWithParametersPtr ptr)
924 {
925
926 if(ptr == NULL) {
927 return NULL;
928 }
929 PssmFree(ptr -> pssm);
930 PssmParametersFree(ptr -> params);
931 return MemFree(ptr);
932 }
933
934
935 /**************************************************
936 *
937 * PssmWithParametersAsnRead()
938 *
939 **************************************************/
940 NLM_EXTERN
941 PssmWithParametersPtr LIBCALL
PssmWithParametersAsnRead(AsnIoPtr aip,AsnTypePtr orig)942 PssmWithParametersAsnRead(AsnIoPtr aip, AsnTypePtr orig)
943 {
944 DataVal av;
945 AsnTypePtr atp;
946 AsnReadFunc func;
947 PssmWithParametersPtr ptr;
948
949 if (! loaded)
950 {
951 if (! objscorematAsnLoad()) {
952 return NULL;
953 }
954 }
955
956 if (aip == NULL) {
957 return NULL;
958 }
959
960 if (orig == NULL) { /* PssmWithParameters ::= (self contained) */
961 atp = AsnReadId(aip, amp, PSSMWITHPARAMETERS);
962 } else {
963 atp = AsnLinkType(orig, PSSMWITHPARAMETERS);
964 }
965 /* link in local tree */
966 if (atp == NULL) {
967 return NULL;
968 }
969
970 ptr = PssmWithParametersNew();
971 if (ptr == NULL) {
972 goto erret;
973 }
974 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
975 goto erret;
976 }
977
978 atp = AsnReadId(aip,amp, atp);
979 func = NULL;
980
981 if (atp == PSSMWITHPARAMETERS_pssm) {
982 ptr -> pssm = PssmAsnRead(aip, atp);
983 if (aip -> io_failure) {
984 goto erret;
985 }
986 atp = AsnReadId(aip,amp, atp);
987 }
988 if (atp == PSSMWITHPARAMETERS_params) {
989 ptr -> params = PssmParametersAsnRead(aip, atp);
990 if (aip -> io_failure) {
991 goto erret;
992 }
993 atp = AsnReadId(aip,amp, atp);
994 }
995
996 if (AsnReadVal(aip, atp, &av) <= 0) {
997 goto erret;
998 }
999 /* end struct */
1000
1001 ret:
1002 AsnUnlinkType(orig); /* unlink local tree */
1003 return ptr;
1004
1005 erret:
1006 aip -> io_failure = TRUE;
1007 ptr = PssmWithParametersFree(ptr);
1008 goto ret;
1009 }
1010
1011
1012
1013 /**************************************************
1014 *
1015 * PssmWithParametersAsnWrite()
1016 *
1017 **************************************************/
1018 NLM_EXTERN Boolean LIBCALL
PssmWithParametersAsnWrite(PssmWithParametersPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1019 PssmWithParametersAsnWrite(PssmWithParametersPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1020 {
1021 AsnTypePtr atp;
1022 Boolean retval = FALSE;
1023
1024 if (! loaded)
1025 {
1026 if (! objscorematAsnLoad()) {
1027 return FALSE;
1028 }
1029 }
1030
1031 if (aip == NULL) {
1032 return FALSE;
1033 }
1034
1035 atp = AsnLinkType(orig, PSSMWITHPARAMETERS); /* link local tree */
1036 if (atp == NULL) {
1037 return FALSE;
1038 }
1039
1040 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1041
1042 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1043 goto erret;
1044 }
1045
1046 if (ptr -> pssm != NULL) {
1047 if ( ! PssmAsnWrite(ptr -> pssm, aip, PSSMWITHPARAMETERS_pssm)) {
1048 goto erret;
1049 }
1050 }
1051 if (ptr -> params != NULL) {
1052 if ( ! PssmParametersAsnWrite(ptr -> params, aip, PSSMWITHPARAMETERS_params)) {
1053 goto erret;
1054 }
1055 }
1056 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1057 goto erret;
1058 }
1059 retval = TRUE;
1060
1061 erret:
1062 AsnUnlinkType(orig); /* unlink local tree */
1063 return retval;
1064 }
1065
1066
1067
1068 /**************************************************
1069 *
1070 * BlockPropertyNew()
1071 *
1072 **************************************************/
1073 NLM_EXTERN
1074 BlockPropertyPtr LIBCALL
BlockPropertyNew(void)1075 BlockPropertyNew(void)
1076 {
1077 BlockPropertyPtr ptr = MemNew((size_t) sizeof(BlockProperty));
1078
1079 return ptr;
1080
1081 }
1082
1083
1084 /**************************************************
1085 *
1086 * BlockPropertyFree()
1087 *
1088 **************************************************/
1089 NLM_EXTERN
1090 BlockPropertyPtr LIBCALL
BlockPropertyFree(BlockPropertyPtr ptr)1091 BlockPropertyFree(BlockPropertyPtr ptr)
1092 {
1093
1094 if(ptr == NULL) {
1095 return NULL;
1096 }
1097 MemFree(ptr -> textvalue);
1098 return MemFree(ptr);
1099 }
1100
1101
1102 /**************************************************
1103 *
1104 * BlockPropertyAsnRead()
1105 *
1106 **************************************************/
1107 NLM_EXTERN
1108 BlockPropertyPtr LIBCALL
BlockPropertyAsnRead(AsnIoPtr aip,AsnTypePtr orig)1109 BlockPropertyAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1110 {
1111 DataVal av;
1112 AsnTypePtr atp;
1113 AsnReadFunc func;
1114 BlockPropertyPtr ptr;
1115
1116 if (! loaded)
1117 {
1118 if (! objscorematAsnLoad()) {
1119 return NULL;
1120 }
1121 }
1122
1123 if (aip == NULL) {
1124 return NULL;
1125 }
1126
1127 if (orig == NULL) { /* BlockProperty ::= (self contained) */
1128 atp = AsnReadId(aip, amp, BLOCKPROPERTY);
1129 } else {
1130 atp = AsnLinkType(orig, BLOCKPROPERTY);
1131 }
1132 /* link in local tree */
1133 if (atp == NULL) {
1134 return NULL;
1135 }
1136
1137 ptr = BlockPropertyNew();
1138 if (ptr == NULL) {
1139 goto erret;
1140 }
1141 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1142 goto erret;
1143 }
1144
1145 atp = AsnReadId(aip,amp, atp);
1146 func = NULL;
1147
1148 if (atp == BLOCKPROPERTY_type) {
1149 if ( AsnReadVal(aip, atp, &av) <= 0) {
1150 goto erret;
1151 }
1152 ptr -> type = av.intvalue;
1153 atp = AsnReadId(aip,amp, atp);
1154 }
1155 if (atp == BLOCKPROPERTY_intvalue) {
1156 if ( AsnReadVal(aip, atp, &av) <= 0) {
1157 goto erret;
1158 }
1159 ptr -> intvalue = av.intvalue;
1160 atp = AsnReadId(aip,amp, atp);
1161 }
1162 if (atp == BLOCKPROPERTY_textvalue) {
1163 if ( AsnReadVal(aip, atp, &av) <= 0) {
1164 goto erret;
1165 }
1166 ptr -> textvalue = av.ptrvalue;
1167 atp = AsnReadId(aip,amp, atp);
1168 }
1169
1170 if (AsnReadVal(aip, atp, &av) <= 0) {
1171 goto erret;
1172 }
1173 /* end struct */
1174
1175 ret:
1176 AsnUnlinkType(orig); /* unlink local tree */
1177 return ptr;
1178
1179 erret:
1180 aip -> io_failure = TRUE;
1181 ptr = BlockPropertyFree(ptr);
1182 goto ret;
1183 }
1184
1185
1186
1187 /**************************************************
1188 *
1189 * BlockPropertyAsnWrite()
1190 *
1191 **************************************************/
1192 NLM_EXTERN Boolean LIBCALL
BlockPropertyAsnWrite(BlockPropertyPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1193 BlockPropertyAsnWrite(BlockPropertyPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1194 {
1195 DataVal av;
1196 AsnTypePtr atp;
1197 Boolean retval = FALSE;
1198
1199 if (! loaded)
1200 {
1201 if (! objscorematAsnLoad()) {
1202 return FALSE;
1203 }
1204 }
1205
1206 if (aip == NULL) {
1207 return FALSE;
1208 }
1209
1210 atp = AsnLinkType(orig, BLOCKPROPERTY); /* link local tree */
1211 if (atp == NULL) {
1212 return FALSE;
1213 }
1214
1215 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1216
1217 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1218
1219 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1220 goto erret;
1221 }
1222
1223 av.intvalue = ptr -> type;
1224 retval = AsnWrite(aip, BLOCKPROPERTY_type, &av);
1225 av.intvalue = ptr -> intvalue;
1226 retval = AsnWrite(aip, BLOCKPROPERTY_intvalue, &av);
1227 if (ptr -> textvalue != NULL) {
1228 av.ptrvalue = ptr -> textvalue;
1229 retval = AsnWrite(aip, BLOCKPROPERTY_textvalue, &av);
1230 }
1231 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1232 goto erret;
1233 }
1234 retval = TRUE;
1235
1236 erret:
1237 AsnUnlinkType(orig); /* unlink local tree */
1238 return retval;
1239 }
1240
1241
1242
1243 /**************************************************
1244 *
1245 * CoreBlockNew()
1246 *
1247 **************************************************/
1248 NLM_EXTERN
1249 CoreBlockPtr LIBCALL
CoreBlockNew(void)1250 CoreBlockNew(void)
1251 {
1252 CoreBlockPtr ptr = MemNew((size_t) sizeof(CoreBlock));
1253
1254 return ptr;
1255
1256 }
1257
1258
1259 /**************************************************
1260 *
1261 * CoreBlockFree()
1262 *
1263 **************************************************/
1264 NLM_EXTERN
1265 CoreBlockPtr LIBCALL
CoreBlockFree(CoreBlockPtr ptr)1266 CoreBlockFree(CoreBlockPtr ptr)
1267 {
1268
1269 if(ptr == NULL) {
1270 return NULL;
1271 }
1272 AsnGenericUserSeqOfFree(ptr -> property, (AsnOptFreeFunc) BlockPropertyFree);
1273 return MemFree(ptr);
1274 }
1275
1276
1277 /**************************************************
1278 *
1279 * CoreBlockAsnRead()
1280 *
1281 **************************************************/
1282 NLM_EXTERN
1283 CoreBlockPtr LIBCALL
CoreBlockAsnRead(AsnIoPtr aip,AsnTypePtr orig)1284 CoreBlockAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1285 {
1286 DataVal av;
1287 AsnTypePtr atp;
1288 Boolean isError = FALSE;
1289 AsnReadFunc func;
1290 CoreBlockPtr ptr;
1291
1292 if (! loaded)
1293 {
1294 if (! objscorematAsnLoad()) {
1295 return NULL;
1296 }
1297 }
1298
1299 if (aip == NULL) {
1300 return NULL;
1301 }
1302
1303 if (orig == NULL) { /* CoreBlock ::= (self contained) */
1304 atp = AsnReadId(aip, amp, COREBLOCK);
1305 } else {
1306 atp = AsnLinkType(orig, COREBLOCK);
1307 }
1308 /* link in local tree */
1309 if (atp == NULL) {
1310 return NULL;
1311 }
1312
1313 ptr = CoreBlockNew();
1314 if (ptr == NULL) {
1315 goto erret;
1316 }
1317 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1318 goto erret;
1319 }
1320
1321 atp = AsnReadId(aip,amp, atp);
1322 func = NULL;
1323
1324 if (atp == COREBLOCK_start) {
1325 if ( AsnReadVal(aip, atp, &av) <= 0) {
1326 goto erret;
1327 }
1328 ptr -> start = av.intvalue;
1329 atp = AsnReadId(aip,amp, atp);
1330 }
1331 if (atp == COREBLOCK_stop) {
1332 if ( AsnReadVal(aip, atp, &av) <= 0) {
1333 goto erret;
1334 }
1335 ptr -> stop = av.intvalue;
1336 atp = AsnReadId(aip,amp, atp);
1337 }
1338 if (atp == COREBLOCK_minstart) {
1339 if ( AsnReadVal(aip, atp, &av) <= 0) {
1340 goto erret;
1341 }
1342 ptr -> minstart = av.intvalue;
1343 atp = AsnReadId(aip,amp, atp);
1344 }
1345 if (atp == COREBLOCK_maxstop) {
1346 if ( AsnReadVal(aip, atp, &av) <= 0) {
1347 goto erret;
1348 }
1349 ptr -> maxstop = av.intvalue;
1350 atp = AsnReadId(aip,amp, atp);
1351 }
1352 if (atp == COREBLOCK_property) {
1353 ptr -> property = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) BlockPropertyAsnRead, (AsnOptFreeFunc) BlockPropertyFree);
1354 if (isError && ptr -> property == NULL) {
1355 goto erret;
1356 }
1357 atp = AsnReadId(aip,amp, atp);
1358 }
1359
1360 if (AsnReadVal(aip, atp, &av) <= 0) {
1361 goto erret;
1362 }
1363 /* end struct */
1364
1365 ret:
1366 AsnUnlinkType(orig); /* unlink local tree */
1367 return ptr;
1368
1369 erret:
1370 aip -> io_failure = TRUE;
1371 ptr = CoreBlockFree(ptr);
1372 goto ret;
1373 }
1374
1375
1376
1377 /**************************************************
1378 *
1379 * CoreBlockAsnWrite()
1380 *
1381 **************************************************/
1382 NLM_EXTERN Boolean LIBCALL
CoreBlockAsnWrite(CoreBlockPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1383 CoreBlockAsnWrite(CoreBlockPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1384 {
1385 DataVal av;
1386 AsnTypePtr atp;
1387 Boolean retval = FALSE;
1388
1389 if (! loaded)
1390 {
1391 if (! objscorematAsnLoad()) {
1392 return FALSE;
1393 }
1394 }
1395
1396 if (aip == NULL) {
1397 return FALSE;
1398 }
1399
1400 atp = AsnLinkType(orig, COREBLOCK); /* link local tree */
1401 if (atp == NULL) {
1402 return FALSE;
1403 }
1404
1405 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1406
1407 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1408
1409 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1410 goto erret;
1411 }
1412
1413 av.intvalue = ptr -> start;
1414 retval = AsnWrite(aip, COREBLOCK_start, &av);
1415 av.intvalue = ptr -> stop;
1416 retval = AsnWrite(aip, COREBLOCK_stop, &av);
1417 av.intvalue = ptr -> minstart;
1418 retval = AsnWrite(aip, COREBLOCK_minstart, &av);
1419 av.intvalue = ptr -> maxstop;
1420 retval = AsnWrite(aip, COREBLOCK_maxstop, &av);
1421 AsnGenericUserSeqOfAsnWrite(ptr -> property, (AsnWriteFunc) BlockPropertyAsnWrite, aip, COREBLOCK_property, COREBLOCK_property_E);
1422 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1423 goto erret;
1424 }
1425 retval = TRUE;
1426
1427 erret:
1428 AsnUnlinkType(orig); /* unlink local tree */
1429 return retval;
1430 }
1431
1432
1433
1434 /**************************************************
1435 *
1436 * LoopConstraintNew()
1437 *
1438 **************************************************/
1439 NLM_EXTERN
1440 LoopConstraintPtr LIBCALL
LoopConstraintNew(void)1441 LoopConstraintNew(void)
1442 {
1443 LoopConstraintPtr ptr = MemNew((size_t) sizeof(LoopConstraint));
1444
1445 ptr -> minlength = 0;
1446 ptr -> maxlength = 100000;
1447 return ptr;
1448
1449 }
1450
1451
1452 /**************************************************
1453 *
1454 * LoopConstraintFree()
1455 *
1456 **************************************************/
1457 NLM_EXTERN
1458 LoopConstraintPtr LIBCALL
LoopConstraintFree(LoopConstraintPtr ptr)1459 LoopConstraintFree(LoopConstraintPtr ptr)
1460 {
1461
1462 if(ptr == NULL) {
1463 return NULL;
1464 }
1465 return MemFree(ptr);
1466 }
1467
1468
1469 /**************************************************
1470 *
1471 * LoopConstraintAsnRead()
1472 *
1473 **************************************************/
1474 NLM_EXTERN
1475 LoopConstraintPtr LIBCALL
LoopConstraintAsnRead(AsnIoPtr aip,AsnTypePtr orig)1476 LoopConstraintAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1477 {
1478 DataVal av;
1479 AsnTypePtr atp;
1480 AsnReadFunc func;
1481 LoopConstraintPtr ptr;
1482
1483 if (! loaded)
1484 {
1485 if (! objscorematAsnLoad()) {
1486 return NULL;
1487 }
1488 }
1489
1490 if (aip == NULL) {
1491 return NULL;
1492 }
1493
1494 if (orig == NULL) { /* LoopConstraint ::= (self contained) */
1495 atp = AsnReadId(aip, amp, LOOPCONSTRAINT);
1496 } else {
1497 atp = AsnLinkType(orig, LOOPCONSTRAINT);
1498 }
1499 /* link in local tree */
1500 if (atp == NULL) {
1501 return NULL;
1502 }
1503
1504 ptr = LoopConstraintNew();
1505 if (ptr == NULL) {
1506 goto erret;
1507 }
1508 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1509 goto erret;
1510 }
1511
1512 atp = AsnReadId(aip,amp, atp);
1513 func = NULL;
1514
1515 if (atp == LOOPCONSTRAINT_minlength) {
1516 if ( AsnReadVal(aip, atp, &av) <= 0) {
1517 goto erret;
1518 }
1519 ptr -> minlength = av.intvalue;
1520 atp = AsnReadId(aip,amp, atp);
1521 }
1522 if (atp == LOOPCONSTRAINT_maxlength) {
1523 if ( AsnReadVal(aip, atp, &av) <= 0) {
1524 goto erret;
1525 }
1526 ptr -> maxlength = av.intvalue;
1527 atp = AsnReadId(aip,amp, atp);
1528 }
1529
1530 if (AsnReadVal(aip, atp, &av) <= 0) {
1531 goto erret;
1532 }
1533 /* end struct */
1534
1535 ret:
1536 AsnUnlinkType(orig); /* unlink local tree */
1537 return ptr;
1538
1539 erret:
1540 aip -> io_failure = TRUE;
1541 ptr = LoopConstraintFree(ptr);
1542 goto ret;
1543 }
1544
1545
1546
1547 /**************************************************
1548 *
1549 * LoopConstraintAsnWrite()
1550 *
1551 **************************************************/
1552 NLM_EXTERN Boolean LIBCALL
LoopConstraintAsnWrite(LoopConstraintPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1553 LoopConstraintAsnWrite(LoopConstraintPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1554 {
1555 DataVal av;
1556 AsnTypePtr atp;
1557 Boolean retval = FALSE;
1558
1559 if (! loaded)
1560 {
1561 if (! objscorematAsnLoad()) {
1562 return FALSE;
1563 }
1564 }
1565
1566 if (aip == NULL) {
1567 return FALSE;
1568 }
1569
1570 atp = AsnLinkType(orig, LOOPCONSTRAINT); /* link local tree */
1571 if (atp == NULL) {
1572 return FALSE;
1573 }
1574
1575 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1576
1577 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1578
1579 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1580 goto erret;
1581 }
1582
1583 av.intvalue = ptr -> minlength;
1584 retval = AsnWrite(aip, LOOPCONSTRAINT_minlength, &av);
1585 av.intvalue = ptr -> maxlength;
1586 retval = AsnWrite(aip, LOOPCONSTRAINT_maxlength, &av);
1587 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1588 goto erret;
1589 }
1590 retval = TRUE;
1591
1592 erret:
1593 AsnUnlinkType(orig); /* unlink local tree */
1594 return retval;
1595 }
1596
1597
1598
1599 /**************************************************
1600 *
1601 * CoreDefNew()
1602 *
1603 **************************************************/
1604 NLM_EXTERN
1605 CoreDefPtr LIBCALL
CoreDefNew(void)1606 CoreDefNew(void)
1607 {
1608 CoreDefPtr ptr = MemNew((size_t) sizeof(CoreDef));
1609
1610 return ptr;
1611
1612 }
1613
1614
1615 /**************************************************
1616 *
1617 * CoreDefFree()
1618 *
1619 **************************************************/
1620 NLM_EXTERN
1621 CoreDefPtr LIBCALL
CoreDefFree(CoreDefPtr ptr)1622 CoreDefFree(CoreDefPtr ptr)
1623 {
1624
1625 if(ptr == NULL) {
1626 return NULL;
1627 }
1628 AsnGenericUserSeqOfFree(ptr -> blocks, (AsnOptFreeFunc) CoreBlockFree);
1629 AsnGenericUserSeqOfFree(ptr -> loops, (AsnOptFreeFunc) LoopConstraintFree);
1630 return MemFree(ptr);
1631 }
1632
1633
1634 /**************************************************
1635 *
1636 * CoreDefAsnRead()
1637 *
1638 **************************************************/
1639 NLM_EXTERN
1640 CoreDefPtr LIBCALL
CoreDefAsnRead(AsnIoPtr aip,AsnTypePtr orig)1641 CoreDefAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1642 {
1643 DataVal av;
1644 AsnTypePtr atp;
1645 Boolean isError = FALSE;
1646 AsnReadFunc func;
1647 CoreDefPtr ptr;
1648
1649 if (! loaded)
1650 {
1651 if (! objscorematAsnLoad()) {
1652 return NULL;
1653 }
1654 }
1655
1656 if (aip == NULL) {
1657 return NULL;
1658 }
1659
1660 if (orig == NULL) { /* CoreDef ::= (self contained) */
1661 atp = AsnReadId(aip, amp, COREDEF);
1662 } else {
1663 atp = AsnLinkType(orig, COREDEF);
1664 }
1665 /* link in local tree */
1666 if (atp == NULL) {
1667 return NULL;
1668 }
1669
1670 ptr = CoreDefNew();
1671 if (ptr == NULL) {
1672 goto erret;
1673 }
1674 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1675 goto erret;
1676 }
1677
1678 atp = AsnReadId(aip,amp, atp);
1679 func = NULL;
1680
1681 if (atp == COREDEF_nblocks) {
1682 if ( AsnReadVal(aip, atp, &av) <= 0) {
1683 goto erret;
1684 }
1685 ptr -> nblocks = av.intvalue;
1686 atp = AsnReadId(aip,amp, atp);
1687 }
1688 if (atp == COREDEF_blocks) {
1689 ptr -> blocks = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) CoreBlockAsnRead, (AsnOptFreeFunc) CoreBlockFree);
1690 if (isError && ptr -> blocks == NULL) {
1691 goto erret;
1692 }
1693 atp = AsnReadId(aip,amp, atp);
1694 }
1695 if (atp == COREDEF_loops) {
1696 ptr -> loops = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) LoopConstraintAsnRead, (AsnOptFreeFunc) LoopConstraintFree);
1697 if (isError && ptr -> loops == NULL) {
1698 goto erret;
1699 }
1700 atp = AsnReadId(aip,amp, atp);
1701 }
1702
1703 if (AsnReadVal(aip, atp, &av) <= 0) {
1704 goto erret;
1705 }
1706 /* end struct */
1707
1708 ret:
1709 AsnUnlinkType(orig); /* unlink local tree */
1710 return ptr;
1711
1712 erret:
1713 aip -> io_failure = TRUE;
1714 ptr = CoreDefFree(ptr);
1715 goto ret;
1716 }
1717
1718
1719
1720 /**************************************************
1721 *
1722 * CoreDefAsnWrite()
1723 *
1724 **************************************************/
1725 NLM_EXTERN Boolean LIBCALL
CoreDefAsnWrite(CoreDefPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1726 CoreDefAsnWrite(CoreDefPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1727 {
1728 DataVal av;
1729 AsnTypePtr atp;
1730 Boolean retval = FALSE;
1731
1732 if (! loaded)
1733 {
1734 if (! objscorematAsnLoad()) {
1735 return FALSE;
1736 }
1737 }
1738
1739 if (aip == NULL) {
1740 return FALSE;
1741 }
1742
1743 atp = AsnLinkType(orig, COREDEF); /* link local tree */
1744 if (atp == NULL) {
1745 return FALSE;
1746 }
1747
1748 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1749
1750 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1751
1752 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1753 goto erret;
1754 }
1755
1756 av.intvalue = ptr -> nblocks;
1757 retval = AsnWrite(aip, COREDEF_nblocks, &av);
1758 AsnGenericUserSeqOfAsnWrite(ptr -> blocks, (AsnWriteFunc) CoreBlockAsnWrite, aip, COREDEF_blocks, COREDEF_blocks_E);
1759 AsnGenericUserSeqOfAsnWrite(ptr -> loops, (AsnWriteFunc) LoopConstraintAsnWrite, aip, COREDEF_loops, COREDEF_loops_E);
1760 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1761 goto erret;
1762 }
1763 retval = TRUE;
1764
1765 erret:
1766 AsnUnlinkType(orig); /* unlink local tree */
1767 return retval;
1768 }
1769
1770
1771
1772 /**************************************************
1773 *
1774 * FormatRpsDbParametersNew()
1775 *
1776 **************************************************/
1777 NLM_EXTERN
1778 FormatRpsDbParametersPtr LIBCALL
FormatRpsDbParametersNew(void)1779 FormatRpsDbParametersNew(void)
1780 {
1781 FormatRpsDbParametersPtr ptr = MemNew((size_t) sizeof(FormatRpsDbParameters));
1782
1783 return ptr;
1784
1785 }
1786
1787
1788 /**************************************************
1789 *
1790 * FormatRpsDbParametersFree()
1791 *
1792 **************************************************/
1793 NLM_EXTERN
1794 FormatRpsDbParametersPtr LIBCALL
FormatRpsDbParametersFree(FormatRpsDbParametersPtr ptr)1795 FormatRpsDbParametersFree(FormatRpsDbParametersPtr ptr)
1796 {
1797
1798 if(ptr == NULL) {
1799 return NULL;
1800 }
1801 MemFree(ptr -> matrixName);
1802 return MemFree(ptr);
1803 }
1804
1805
1806 /**************************************************
1807 *
1808 * FormatRpsDbParametersAsnRead()
1809 *
1810 **************************************************/
1811 NLM_EXTERN
1812 FormatRpsDbParametersPtr LIBCALL
FormatRpsDbParametersAsnRead(AsnIoPtr aip,AsnTypePtr orig)1813 FormatRpsDbParametersAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1814 {
1815 DataVal av;
1816 AsnTypePtr atp;
1817 AsnReadFunc func;
1818 FormatRpsDbParametersPtr ptr;
1819
1820 if (! loaded)
1821 {
1822 if (! objscorematAsnLoad()) {
1823 return NULL;
1824 }
1825 }
1826
1827 if (aip == NULL) {
1828 return NULL;
1829 }
1830
1831 if (orig == NULL) { /* FormatRpsDbParameters ::= (self contained) */
1832 atp = AsnReadId(aip, amp, FORMATRPSDBPARAMETERS);
1833 } else {
1834 atp = AsnLinkType(orig, FORMATRPSDBPARAMETERS);
1835 }
1836 /* link in local tree */
1837 if (atp == NULL) {
1838 return NULL;
1839 }
1840
1841 ptr = FormatRpsDbParametersNew();
1842 if (ptr == NULL) {
1843 goto erret;
1844 }
1845 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1846 goto erret;
1847 }
1848
1849 atp = AsnReadId(aip,amp, atp);
1850 func = NULL;
1851
1852 if (atp == FORMATRPSDBPARAMETERS_matrixName) {
1853 if ( AsnReadVal(aip, atp, &av) <= 0) {
1854 goto erret;
1855 }
1856 ptr -> matrixName = av.ptrvalue;
1857 atp = AsnReadId(aip,amp, atp);
1858 }
1859 if (atp == FORMATRPSDBPARAMETERS_gapOpen) {
1860 if ( AsnReadVal(aip, atp, &av) <= 0) {
1861 goto erret;
1862 }
1863 ptr -> gapOpen = av.intvalue;
1864 atp = AsnReadId(aip,amp, atp);
1865 }
1866 if (atp == FORMATRPSDBPARAMETERS_gapExtend) {
1867 if ( AsnReadVal(aip, atp, &av) <= 0) {
1868 goto erret;
1869 }
1870 ptr -> gapExtend = av.intvalue;
1871 atp = AsnReadId(aip,amp, atp);
1872 }
1873
1874 if (AsnReadVal(aip, atp, &av) <= 0) {
1875 goto erret;
1876 }
1877 /* end struct */
1878
1879 ret:
1880 AsnUnlinkType(orig); /* unlink local tree */
1881 return ptr;
1882
1883 erret:
1884 aip -> io_failure = TRUE;
1885 ptr = FormatRpsDbParametersFree(ptr);
1886 goto ret;
1887 }
1888
1889
1890
1891 /**************************************************
1892 *
1893 * FormatRpsDbParametersAsnWrite()
1894 *
1895 **************************************************/
1896 NLM_EXTERN Boolean LIBCALL
FormatRpsDbParametersAsnWrite(FormatRpsDbParametersPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1897 FormatRpsDbParametersAsnWrite(FormatRpsDbParametersPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1898 {
1899 DataVal av;
1900 AsnTypePtr atp;
1901 Boolean retval = FALSE;
1902
1903 if (! loaded)
1904 {
1905 if (! objscorematAsnLoad()) {
1906 return FALSE;
1907 }
1908 }
1909
1910 if (aip == NULL) {
1911 return FALSE;
1912 }
1913
1914 atp = AsnLinkType(orig, FORMATRPSDBPARAMETERS); /* link local tree */
1915 if (atp == NULL) {
1916 return FALSE;
1917 }
1918
1919 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1920
1921 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1922
1923 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1924 goto erret;
1925 }
1926
1927 if (ptr -> matrixName != NULL) {
1928 av.ptrvalue = ptr -> matrixName;
1929 retval = AsnWrite(aip, FORMATRPSDBPARAMETERS_matrixName, &av);
1930 }
1931 av.intvalue = ptr -> gapOpen;
1932 retval = AsnWrite(aip, FORMATRPSDBPARAMETERS_gapOpen, &av);
1933 av.intvalue = ptr -> gapExtend;
1934 retval = AsnWrite(aip, FORMATRPSDBPARAMETERS_gapExtend, &av);
1935 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1936 goto erret;
1937 }
1938 retval = TRUE;
1939
1940 erret:
1941 AsnUnlinkType(orig); /* unlink local tree */
1942 return retval;
1943 }
1944
1945