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