1 #include <asn.h>
2
3 #define NLM_GENERATED_CODE_PROTO
4
5 #include <objmim.h>
6
7 static Boolean loaded = FALSE;
8
9 #include <asnmim.h>
10
11 #ifndef NLM_EXTERN_LOADS
12 #define NLM_EXTERN_LOADS {}
13 #endif
14
15 NLM_EXTERN Boolean LIBCALL
objmimAsnLoad(void)16 objmimAsnLoad(void)
17 {
18
19 if ( ! loaded) {
20 NLM_EXTERN_LOADS
21
22 if ( ! AsnLoad ())
23 return FALSE;
24 loaded = TRUE;
25 }
26
27 return TRUE;
28 }
29
30
31
32 /**************************************************
33 * Generated object loaders for Module NCBI-Mim
34 * Generated using ASNCODE Revision: 6.9 at Aug 16, 2000 6:14 PM
35 *
36 **************************************************/
37
38
39 /**************************************************
40 *
41 * MimSetNew()
42 *
43 **************************************************/
44 NLM_EXTERN
45 MimSetPtr LIBCALL
MimSetNew(void)46 MimSetNew(void)
47 {
48 MimSetPtr ptr = MemNew((size_t) sizeof(MimSet));
49
50 return ptr;
51
52 }
53
54
55 /**************************************************
56 *
57 * MimSetFree()
58 *
59 **************************************************/
60 NLM_EXTERN
61 MimSetPtr LIBCALL
MimSetFree(MimSetPtr ptr)62 MimSetFree(MimSetPtr ptr)
63 {
64
65 if(ptr == NULL) {
66 return NULL;
67 }
68 MimDateFree(ptr -> releaseDate);
69 AsnGenericUserSeqOfFree(ptr -> mimEntries, (AsnOptFreeFunc) MimEntryFree);
70 return MemFree(ptr);
71 }
72
73
74 /**************************************************
75 *
76 * MimSetAsnRead()
77 *
78 **************************************************/
79 NLM_EXTERN
80 MimSetPtr LIBCALL
MimSetAsnRead(AsnIoPtr aip,AsnTypePtr orig)81 MimSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
82 {
83 DataVal av;
84 AsnTypePtr atp;
85 Boolean isError = FALSE;
86 AsnReadFunc func;
87 MimSetPtr ptr;
88
89 if (! loaded)
90 {
91 if (! objmimAsnLoad()) {
92 return NULL;
93 }
94 }
95
96 if (aip == NULL) {
97 return NULL;
98 }
99
100 if (orig == NULL) { /* MimSet ::= (self contained) */
101 atp = AsnReadId(aip, amp, MIM_SET);
102 } else {
103 atp = AsnLinkType(orig, MIM_SET);
104 }
105 /* link in local tree */
106 if (atp == NULL) {
107 return NULL;
108 }
109
110 ptr = MimSetNew();
111 if (ptr == NULL) {
112 goto erret;
113 }
114 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
115 goto erret;
116 }
117
118 atp = AsnReadId(aip,amp, atp);
119 func = NULL;
120
121 if (atp == MIM_SET_releaseDate) {
122 ptr -> releaseDate = MimDateAsnRead(aip, atp);
123 if (aip -> io_failure) {
124 goto erret;
125 }
126 atp = AsnReadId(aip,amp, atp);
127 }
128 if (atp == MIM_SET_mimEntries) {
129 ptr -> mimEntries = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimEntryAsnRead, (AsnOptFreeFunc) MimEntryFree);
130 if (isError && ptr -> mimEntries == NULL) {
131 goto erret;
132 }
133 atp = AsnReadId(aip,amp, atp);
134 }
135
136 if (AsnReadVal(aip, atp, &av) <= 0) {
137 goto erret;
138 }
139 /* end struct */
140
141 ret:
142 AsnUnlinkType(orig); /* unlink local tree */
143 return ptr;
144
145 erret:
146 aip -> io_failure = TRUE;
147 ptr = MimSetFree(ptr);
148 goto ret;
149 }
150
151
152
153 /**************************************************
154 *
155 * MimSetAsnWrite()
156 *
157 **************************************************/
158 NLM_EXTERN Boolean LIBCALL
MimSetAsnWrite(MimSetPtr ptr,AsnIoPtr aip,AsnTypePtr orig)159 MimSetAsnWrite(MimSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
160 {
161 AsnTypePtr atp;
162 Boolean retval = FALSE;
163
164 if (! loaded)
165 {
166 if (! objmimAsnLoad()) {
167 return FALSE;
168 }
169 }
170
171 if (aip == NULL) {
172 return FALSE;
173 }
174
175 atp = AsnLinkType(orig, MIM_SET); /* link local tree */
176 if (atp == NULL) {
177 return FALSE;
178 }
179
180 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
181 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
182 goto erret;
183 }
184
185 if (ptr -> releaseDate != NULL) {
186 if ( ! MimDateAsnWrite(ptr -> releaseDate, aip, MIM_SET_releaseDate)) {
187 goto erret;
188 }
189 }
190 AsnGenericUserSeqOfAsnWrite(ptr -> mimEntries, (AsnWriteFunc) MimEntryAsnWrite, aip, MIM_SET_mimEntries, MIM_SET_mimEntries_E);
191 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
192 goto erret;
193 }
194 retval = TRUE;
195
196 erret:
197 AsnUnlinkType(orig); /* unlink local tree */
198 return retval;
199 }
200
201
202
203 /**************************************************
204 *
205 * MimDateNew()
206 *
207 **************************************************/
208 NLM_EXTERN
209 MimDatePtr LIBCALL
MimDateNew(void)210 MimDateNew(void)
211 {
212 MimDatePtr ptr = MemNew((size_t) sizeof(MimDate));
213
214 return ptr;
215
216 }
217
218
219 /**************************************************
220 *
221 * MimDateFree()
222 *
223 **************************************************/
224 NLM_EXTERN
225 MimDatePtr LIBCALL
MimDateFree(MimDatePtr ptr)226 MimDateFree(MimDatePtr ptr)
227 {
228
229 if(ptr == NULL) {
230 return NULL;
231 }
232 return MemFree(ptr);
233 }
234
235
236 /**************************************************
237 *
238 * MimDateAsnRead()
239 *
240 **************************************************/
241 NLM_EXTERN
242 MimDatePtr LIBCALL
MimDateAsnRead(AsnIoPtr aip,AsnTypePtr orig)243 MimDateAsnRead(AsnIoPtr aip, AsnTypePtr orig)
244 {
245 DataVal av;
246 AsnTypePtr atp;
247 Boolean isError = FALSE;
248 AsnReadFunc func;
249 MimDatePtr ptr;
250
251 if (! loaded)
252 {
253 if (! objmimAsnLoad()) {
254 return NULL;
255 }
256 }
257
258 if (aip == NULL) {
259 return NULL;
260 }
261
262 if (orig == NULL) { /* MimDate ::= (self contained) */
263 atp = AsnReadId(aip, amp, MIM_DATE);
264 } else {
265 atp = AsnLinkType(orig, MIM_DATE);
266 }
267 /* link in local tree */
268 if (atp == NULL) {
269 return NULL;
270 }
271
272 ptr = MimDateNew();
273 if (ptr == NULL) {
274 goto erret;
275 }
276 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
277 goto erret;
278 }
279
280 atp = AsnReadId(aip,amp, atp);
281 func = NULL;
282
283 if (atp == MIM_DATE_year) {
284 if ( AsnReadVal(aip, atp, &av) <= 0) {
285 goto erret;
286 }
287 ptr -> year = av.intvalue;
288 atp = AsnReadId(aip,amp, atp);
289 }
290 if (atp == MIM_DATE_month) {
291 if ( AsnReadVal(aip, atp, &av) <= 0) {
292 goto erret;
293 }
294 ptr -> month = av.intvalue;
295 atp = AsnReadId(aip,amp, atp);
296 }
297 if (atp == MIM_DATE_day) {
298 if ( AsnReadVal(aip, atp, &av) <= 0) {
299 goto erret;
300 }
301 ptr -> day = av.intvalue;
302 atp = AsnReadId(aip,amp, atp);
303 }
304
305 if (AsnReadVal(aip, atp, &av) <= 0) {
306 goto erret;
307 }
308 /* end struct */
309
310 ret:
311 AsnUnlinkType(orig); /* unlink local tree */
312 return ptr;
313
314 erret:
315 aip -> io_failure = TRUE;
316 ptr = MimDateFree(ptr);
317 goto ret;
318 }
319
320
321
322 /**************************************************
323 *
324 * MimDateAsnWrite()
325 *
326 **************************************************/
327 NLM_EXTERN Boolean LIBCALL
MimDateAsnWrite(MimDatePtr ptr,AsnIoPtr aip,AsnTypePtr orig)328 MimDateAsnWrite(MimDatePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
329 {
330 DataVal av;
331 AsnTypePtr atp;
332 Boolean retval = FALSE;
333
334 if (! loaded)
335 {
336 if (! objmimAsnLoad()) {
337 return FALSE;
338 }
339 }
340
341 if (aip == NULL) {
342 return FALSE;
343 }
344
345 atp = AsnLinkType(orig, MIM_DATE); /* link local tree */
346 if (atp == NULL) {
347 return FALSE;
348 }
349
350 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
351 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
352 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
353 goto erret;
354 }
355
356 av.intvalue = ptr -> year;
357 retval = AsnWrite(aip, MIM_DATE_year, &av);
358 av.intvalue = ptr -> month;
359 retval = AsnWrite(aip, MIM_DATE_month, &av);
360 av.intvalue = ptr -> day;
361 retval = AsnWrite(aip, MIM_DATE_day, &av);
362 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
363 goto erret;
364 }
365 retval = TRUE;
366
367 erret:
368 AsnUnlinkType(orig); /* unlink local tree */
369 return retval;
370 }
371
372
373
374 /**************************************************
375 *
376 * MimEntryNew()
377 *
378 **************************************************/
379 NLM_EXTERN
380 MimEntryPtr LIBCALL
MimEntryNew(void)381 MimEntryNew(void)
382 {
383 MimEntryPtr ptr = MemNew((size_t) sizeof(MimEntry));
384
385 return ptr;
386
387 }
388
389
390 /**************************************************
391 *
392 * MimEntryFree()
393 *
394 **************************************************/
395 NLM_EXTERN
396 MimEntryPtr LIBCALL
MimEntryFree(MimEntryPtr ptr)397 MimEntryFree(MimEntryPtr ptr)
398 {
399
400 if(ptr == NULL) {
401 return NULL;
402 }
403 MemFree(ptr -> mimNumber);
404 MemFree(ptr -> title);
405 MemFree(ptr -> copyright);
406 MemFree(ptr -> symbol);
407 MemFree(ptr -> locus);
408 AsnGenericBaseSeqOfFree(ptr -> synonyms ,ASNCODE_PTRVAL_SLOT);
409 AsnGenericBaseSeqOfFree(ptr -> aliases ,ASNCODE_PTRVAL_SLOT);
410 AsnGenericBaseSeqOfFree(ptr -> included ,ASNCODE_PTRVAL_SLOT);
411 AsnGenericUserSeqOfFree(ptr -> seeAlso, (AsnOptFreeFunc) MimCitFree);
412 AsnGenericUserSeqOfFree(ptr -> text, (AsnOptFreeFunc) MimTextFree);
413 AsnGenericUserSeqOfFree(ptr -> textfields, (AsnOptFreeFunc) MimTextFree);
414 AsnGenericUserSeqOfFree(ptr -> summary, (AsnOptFreeFunc) MimTextFree);
415 AsnGenericUserSeqOfFree(ptr -> summaryAttribution, (AsnOptFreeFunc) MimEditItemFree);
416 AsnGenericUserSeqOfFree(ptr -> summaryEditHistory, (AsnOptFreeFunc) MimEditItemFree);
417 MimEditItemFree(ptr -> summaryCreationDate);
418 AsnGenericUserSeqOfFree(ptr -> allelicVariants, (AsnOptFreeFunc) MimAllelicVariantFree);
419 AsnGenericUserSeqOfFree(ptr -> clinicalSynopsis, (AsnOptFreeFunc) MimIndexTermFree);
420 AsnGenericUserSeqOfFree(ptr -> synopsisAttribution, (AsnOptFreeFunc) MimEditItemFree);
421 AsnGenericUserSeqOfFree(ptr -> synopsisEditHistory, (AsnOptFreeFunc) MimEditItemFree);
422 MimEditItemFree(ptr -> synopsisCreationDate);
423 AsnGenericUserSeqOfFree(ptr -> editHistory, (AsnOptFreeFunc) MimEditItemFree);
424 MimEditItemFree(ptr -> creationDate);
425 AsnGenericUserSeqOfFree(ptr -> references, (AsnOptFreeFunc) MimReferenceFree);
426 AsnGenericUserSeqOfFree(ptr -> attribution, (AsnOptFreeFunc) MimEditItemFree);
427 MimLinkFree(ptr -> medlineLinks);
428 MimLinkFree(ptr -> proteinLinks);
429 MimLinkFree(ptr -> nucleotideLinks);
430 MimLinkFree(ptr -> structureLinks);
431 MimLinkFree(ptr -> genomeLinks);
432 return MemFree(ptr);
433 }
434
435
436 /**************************************************
437 *
438 * MimEntryAsnRead()
439 *
440 **************************************************/
441 NLM_EXTERN
442 MimEntryPtr LIBCALL
MimEntryAsnRead(AsnIoPtr aip,AsnTypePtr orig)443 MimEntryAsnRead(AsnIoPtr aip, AsnTypePtr orig)
444 {
445 DataVal av;
446 AsnTypePtr atp;
447 Boolean isError = FALSE;
448 AsnReadFunc func;
449 MimEntryPtr ptr;
450
451 if (! loaded)
452 {
453 if (! objmimAsnLoad()) {
454 return NULL;
455 }
456 }
457
458 if (aip == NULL) {
459 return NULL;
460 }
461
462 if (orig == NULL) { /* MimEntry ::= (self contained) */
463 atp = AsnReadId(aip, amp, MIM_ENTRY);
464 } else {
465 atp = AsnLinkType(orig, MIM_ENTRY);
466 }
467 /* link in local tree */
468 if (atp == NULL) {
469 return NULL;
470 }
471
472 ptr = MimEntryNew();
473 if (ptr == NULL) {
474 goto erret;
475 }
476 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
477 goto erret;
478 }
479
480 atp = AsnReadId(aip,amp, atp);
481 func = NULL;
482
483 if (atp == MIM_ENTRY_mimNumber) {
484 if ( AsnReadVal(aip, atp, &av) <= 0) {
485 goto erret;
486 }
487 ptr -> mimNumber = av.ptrvalue;
488 atp = AsnReadId(aip,amp, atp);
489 }
490 if (atp == MIM_ENTRY_mimType) {
491 if ( AsnReadVal(aip, atp, &av) <= 0) {
492 goto erret;
493 }
494 ptr -> mimType = av.intvalue;
495 atp = AsnReadId(aip,amp, atp);
496 }
497 if (atp == MIM_ENTRY_title) {
498 if ( AsnReadVal(aip, atp, &av) <= 0) {
499 goto erret;
500 }
501 ptr -> title = av.ptrvalue;
502 atp = AsnReadId(aip,amp, atp);
503 }
504 if (atp == MIM_ENTRY_copyright) {
505 if ( AsnReadVal(aip, atp, &av) <= 0) {
506 goto erret;
507 }
508 ptr -> copyright = av.ptrvalue;
509 atp = AsnReadId(aip,amp, atp);
510 }
511 if (atp == MIM_ENTRY_symbol) {
512 if ( AsnReadVal(aip, atp, &av) <= 0) {
513 goto erret;
514 }
515 ptr -> symbol = av.ptrvalue;
516 atp = AsnReadId(aip,amp, atp);
517 }
518 if (atp == MIM_ENTRY_locus) {
519 if ( AsnReadVal(aip, atp, &av) <= 0) {
520 goto erret;
521 }
522 ptr -> locus = av.ptrvalue;
523 atp = AsnReadId(aip,amp, atp);
524 }
525 if (atp == MIM_ENTRY_synonyms) {
526 ptr -> synonyms = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
527 if (isError && ptr -> synonyms == NULL) {
528 goto erret;
529 }
530 atp = AsnReadId(aip,amp, atp);
531 }
532 if (atp == MIM_ENTRY_aliases) {
533 ptr -> aliases = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
534 if (isError && ptr -> aliases == NULL) {
535 goto erret;
536 }
537 atp = AsnReadId(aip,amp, atp);
538 }
539 if (atp == MIM_ENTRY_included) {
540 ptr -> included = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
541 if (isError && ptr -> included == NULL) {
542 goto erret;
543 }
544 atp = AsnReadId(aip,amp, atp);
545 }
546 if (atp == MIM_ENTRY_seeAlso) {
547 ptr -> seeAlso = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimCitAsnRead, (AsnOptFreeFunc) MimCitFree);
548 if (isError && ptr -> seeAlso == NULL) {
549 goto erret;
550 }
551 atp = AsnReadId(aip,amp, atp);
552 }
553 if (atp == MIM_ENTRY_text) {
554 ptr -> text = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimTextAsnRead, (AsnOptFreeFunc) MimTextFree);
555 if (isError && ptr -> text == NULL) {
556 goto erret;
557 }
558 atp = AsnReadId(aip,amp, atp);
559 }
560 if (atp == MIM_ENTRY_textfields) {
561 ptr -> textfields = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimTextAsnRead, (AsnOptFreeFunc) MimTextFree);
562 if (isError && ptr -> textfields == NULL) {
563 goto erret;
564 }
565 atp = AsnReadId(aip,amp, atp);
566 }
567 if (atp == MIM_ENTRY_hasSummary) {
568 if ( AsnReadVal(aip, atp, &av) <= 0) {
569 goto erret;
570 }
571 ptr -> hasSummary = av.boolvalue;
572 atp = AsnReadId(aip,amp, atp);
573 }
574 if (atp == MIM_ENTRY_summary) {
575 ptr -> summary = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimTextAsnRead, (AsnOptFreeFunc) MimTextFree);
576 if (isError && ptr -> summary == NULL) {
577 goto erret;
578 }
579 atp = AsnReadId(aip,amp, atp);
580 }
581 if (atp == MIM_ENTRY_summaryAttribution) {
582 ptr -> summaryAttribution = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimEditItemAsnRead, (AsnOptFreeFunc) MimEditItemFree);
583 if (isError && ptr -> summaryAttribution == NULL) {
584 goto erret;
585 }
586 atp = AsnReadId(aip,amp, atp);
587 }
588 if (atp == MIM_ENTRY_summaryEditHistory) {
589 ptr -> summaryEditHistory = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimEditItemAsnRead, (AsnOptFreeFunc) MimEditItemFree);
590 if (isError && ptr -> summaryEditHistory == NULL) {
591 goto erret;
592 }
593 atp = AsnReadId(aip,amp, atp);
594 }
595 if (atp == MIM_ENTRY_summaryCreationDate) {
596 ptr -> summaryCreationDate = MimEditItemAsnRead(aip, atp);
597 if (aip -> io_failure) {
598 goto erret;
599 }
600 atp = AsnReadId(aip,amp, atp);
601 }
602 if (atp == MIM_ENTRY_allelicVariants) {
603 ptr -> allelicVariants = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimAllelicVariantAsnRead, (AsnOptFreeFunc) MimAllelicVariantFree);
604 if (isError && ptr -> allelicVariants == NULL) {
605 goto erret;
606 }
607 atp = AsnReadId(aip,amp, atp);
608 }
609 if (atp == MIM_ENTRY_hasSynopsis) {
610 if ( AsnReadVal(aip, atp, &av) <= 0) {
611 goto erret;
612 }
613 ptr -> hasSynopsis = av.boolvalue;
614 atp = AsnReadId(aip,amp, atp);
615 }
616 if (atp == MIM_ENTRY_clinicalSynopsis) {
617 ptr -> clinicalSynopsis = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimIndexTermAsnRead, (AsnOptFreeFunc) MimIndexTermFree);
618 if (isError && ptr -> clinicalSynopsis == NULL) {
619 goto erret;
620 }
621 atp = AsnReadId(aip,amp, atp);
622 }
623 if (atp == MIM_ENTRY_synopsisAttribution) {
624 ptr -> synopsisAttribution = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimEditItemAsnRead, (AsnOptFreeFunc) MimEditItemFree);
625 if (isError && ptr -> synopsisAttribution == NULL) {
626 goto erret;
627 }
628 atp = AsnReadId(aip,amp, atp);
629 }
630 if (atp == MIM_ENTRY_synopsisEditHistory) {
631 ptr -> synopsisEditHistory = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimEditItemAsnRead, (AsnOptFreeFunc) MimEditItemFree);
632 if (isError && ptr -> synopsisEditHistory == NULL) {
633 goto erret;
634 }
635 atp = AsnReadId(aip,amp, atp);
636 }
637 if (atp == MIM_ENTRY_synopsisCreationDate) {
638 ptr -> synopsisCreationDate = MimEditItemAsnRead(aip, atp);
639 if (aip -> io_failure) {
640 goto erret;
641 }
642 atp = AsnReadId(aip,amp, atp);
643 }
644 if (atp == MIM_ENTRY_editHistory) {
645 ptr -> editHistory = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimEditItemAsnRead, (AsnOptFreeFunc) MimEditItemFree);
646 if (isError && ptr -> editHistory == NULL) {
647 goto erret;
648 }
649 atp = AsnReadId(aip,amp, atp);
650 }
651 if (atp == MIM_ENTRY_creationDate) {
652 ptr -> creationDate = MimEditItemAsnRead(aip, atp);
653 if (aip -> io_failure) {
654 goto erret;
655 }
656 atp = AsnReadId(aip,amp, atp);
657 }
658 if (atp == MIM_ENTRY_references) {
659 ptr -> references = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimReferenceAsnRead, (AsnOptFreeFunc) MimReferenceFree);
660 if (isError && ptr -> references == NULL) {
661 goto erret;
662 }
663 atp = AsnReadId(aip,amp, atp);
664 }
665 if (atp == MIM_ENTRY_attribution) {
666 ptr -> attribution = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimEditItemAsnRead, (AsnOptFreeFunc) MimEditItemFree);
667 if (isError && ptr -> attribution == NULL) {
668 goto erret;
669 }
670 atp = AsnReadId(aip,amp, atp);
671 }
672 if (atp == MIM_ENTRY_numGeneMaps) {
673 if ( AsnReadVal(aip, atp, &av) <= 0) {
674 goto erret;
675 }
676 ptr -> numGeneMaps = av.intvalue;
677 atp = AsnReadId(aip,amp, atp);
678 }
679 if (atp == MIM_ENTRY_medlineLinks) {
680 ptr -> medlineLinks = MimLinkAsnRead(aip, atp);
681 if (aip -> io_failure) {
682 goto erret;
683 }
684 atp = AsnReadId(aip,amp, atp);
685 }
686 if (atp == MIM_ENTRY_proteinLinks) {
687 ptr -> proteinLinks = MimLinkAsnRead(aip, atp);
688 if (aip -> io_failure) {
689 goto erret;
690 }
691 atp = AsnReadId(aip,amp, atp);
692 }
693 if (atp == MIM_ENTRY_nucleotideLinks) {
694 ptr -> nucleotideLinks = MimLinkAsnRead(aip, atp);
695 if (aip -> io_failure) {
696 goto erret;
697 }
698 atp = AsnReadId(aip,amp, atp);
699 }
700 if (atp == MIM_ENTRY_structureLinks) {
701 ptr -> structureLinks = MimLinkAsnRead(aip, atp);
702 if (aip -> io_failure) {
703 goto erret;
704 }
705 atp = AsnReadId(aip,amp, atp);
706 }
707 if (atp == MIM_ENTRY_genomeLinks) {
708 ptr -> genomeLinks = MimLinkAsnRead(aip, atp);
709 if (aip -> io_failure) {
710 goto erret;
711 }
712 atp = AsnReadId(aip,amp, atp);
713 }
714
715 if (AsnReadVal(aip, atp, &av) <= 0) {
716 goto erret;
717 }
718 /* end struct */
719
720 ret:
721 AsnUnlinkType(orig); /* unlink local tree */
722 return ptr;
723
724 erret:
725 aip -> io_failure = TRUE;
726 ptr = MimEntryFree(ptr);
727 goto ret;
728 }
729
730
731
732 /**************************************************
733 *
734 * MimEntryAsnWrite()
735 *
736 **************************************************/
737 NLM_EXTERN Boolean LIBCALL
MimEntryAsnWrite(MimEntryPtr ptr,AsnIoPtr aip,AsnTypePtr orig)738 MimEntryAsnWrite(MimEntryPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
739 {
740 DataVal av;
741 AsnTypePtr atp;
742 Boolean retval = FALSE;
743
744 if (! loaded)
745 {
746 if (! objmimAsnLoad()) {
747 return FALSE;
748 }
749 }
750
751 if (aip == NULL) {
752 return FALSE;
753 }
754
755 atp = AsnLinkType(orig, MIM_ENTRY); /* link local tree */
756 if (atp == NULL) {
757 return FALSE;
758 }
759
760 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
761 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
762 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
763 goto erret;
764 }
765
766 if (ptr -> mimNumber != NULL) {
767 av.ptrvalue = ptr -> mimNumber;
768 retval = AsnWrite(aip, MIM_ENTRY_mimNumber, &av);
769 }
770 av.intvalue = ptr -> mimType;
771 retval = AsnWrite(aip, MIM_ENTRY_mimType, &av);
772 if (ptr -> title != NULL) {
773 av.ptrvalue = ptr -> title;
774 retval = AsnWrite(aip, MIM_ENTRY_title, &av);
775 }
776 if (ptr -> copyright != NULL) {
777 av.ptrvalue = ptr -> copyright;
778 retval = AsnWrite(aip, MIM_ENTRY_copyright, &av);
779 }
780 if (ptr -> symbol != NULL) {
781 av.ptrvalue = ptr -> symbol;
782 retval = AsnWrite(aip, MIM_ENTRY_symbol, &av);
783 }
784 if (ptr -> locus != NULL) {
785 av.ptrvalue = ptr -> locus;
786 retval = AsnWrite(aip, MIM_ENTRY_locus, &av);
787 }
788 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> synonyms ,ASNCODE_PTRVAL_SLOT, aip, MIM_ENTRY_synonyms, MIM_ENTRY_synonyms_E);
789 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> aliases ,ASNCODE_PTRVAL_SLOT, aip, MIM_ENTRY_aliases, MIM_ENTRY_aliases_E);
790 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> included ,ASNCODE_PTRVAL_SLOT, aip, MIM_ENTRY_included, MIM_ENTRY_included_E);
791 AsnGenericUserSeqOfAsnWrite(ptr -> seeAlso, (AsnWriteFunc) MimCitAsnWrite, aip, MIM_ENTRY_seeAlso, MIM_ENTRY_seeAlso_E);
792 AsnGenericUserSeqOfAsnWrite(ptr -> text, (AsnWriteFunc) MimTextAsnWrite, aip, MIM_ENTRY_text, MIM_ENTRY_text_E);
793 AsnGenericUserSeqOfAsnWrite(ptr -> textfields, (AsnWriteFunc) MimTextAsnWrite, aip, MIM_ENTRY_textfields, MIM_ENTRY_textfields_E);
794 av.boolvalue = ptr -> hasSummary;
795 retval = AsnWrite(aip, MIM_ENTRY_hasSummary, &av);
796 AsnGenericUserSeqOfAsnWrite(ptr -> summary, (AsnWriteFunc) MimTextAsnWrite, aip, MIM_ENTRY_summary, MIM_ENTRY_summary_E);
797 AsnGenericUserSeqOfAsnWrite(ptr -> summaryAttribution, (AsnWriteFunc) MimEditItemAsnWrite, aip, MIM_ENTRY_summaryAttribution, MIM_ENTRY_summaryAttribution_E);
798 AsnGenericUserSeqOfAsnWrite(ptr -> summaryEditHistory, (AsnWriteFunc) MimEditItemAsnWrite, aip, MIM_ENTRY_summaryEditHistory, MIM_ENTRY_summaryEditHistory_E);
799 if (ptr -> summaryCreationDate != NULL) {
800 if ( ! MimEditItemAsnWrite(ptr -> summaryCreationDate, aip, MIM_ENTRY_summaryCreationDate)) {
801 goto erret;
802 }
803 }
804 AsnGenericUserSeqOfAsnWrite(ptr -> allelicVariants, (AsnWriteFunc) MimAllelicVariantAsnWrite, aip, MIM_ENTRY_allelicVariants, MIM_ENTRY_allelicVariants_E);
805 av.boolvalue = ptr -> hasSynopsis;
806 retval = AsnWrite(aip, MIM_ENTRY_hasSynopsis, &av);
807 AsnGenericUserSeqOfAsnWrite(ptr -> clinicalSynopsis, (AsnWriteFunc) MimIndexTermAsnWrite, aip, MIM_ENTRY_clinicalSynopsis, MIM_ENTRY_clinicalSynopsis_E);
808 AsnGenericUserSeqOfAsnWrite(ptr -> synopsisAttribution, (AsnWriteFunc) MimEditItemAsnWrite, aip, MIM_ENTRY_synopsisAttribution, MIM_ENTRY_synopsisAttribution_E);
809 AsnGenericUserSeqOfAsnWrite(ptr -> synopsisEditHistory, (AsnWriteFunc) MimEditItemAsnWrite, aip, MIM_ENTRY_synopsisEditHistory, MIM_ENTRY_synopsisEditHistory_E);
810 if (ptr -> synopsisCreationDate != NULL) {
811 if ( ! MimEditItemAsnWrite(ptr -> synopsisCreationDate, aip, MIM_ENTRY_synopsisCreationDate)) {
812 goto erret;
813 }
814 }
815 AsnGenericUserSeqOfAsnWrite(ptr -> editHistory, (AsnWriteFunc) MimEditItemAsnWrite, aip, MIM_ENTRY_editHistory, MIM_ENTRY_editHistory_E);
816 if (ptr -> creationDate != NULL) {
817 if ( ! MimEditItemAsnWrite(ptr -> creationDate, aip, MIM_ENTRY_creationDate)) {
818 goto erret;
819 }
820 }
821 AsnGenericUserSeqOfAsnWrite(ptr -> references, (AsnWriteFunc) MimReferenceAsnWrite, aip, MIM_ENTRY_references, MIM_ENTRY_references_E);
822 AsnGenericUserSeqOfAsnWrite(ptr -> attribution, (AsnWriteFunc) MimEditItemAsnWrite, aip, MIM_ENTRY_attribution, MIM_ENTRY_attribution_E);
823 av.intvalue = ptr -> numGeneMaps;
824 retval = AsnWrite(aip, MIM_ENTRY_numGeneMaps, &av);
825 if (ptr -> medlineLinks != NULL) {
826 if ( ! MimLinkAsnWrite(ptr -> medlineLinks, aip, MIM_ENTRY_medlineLinks)) {
827 goto erret;
828 }
829 }
830 if (ptr -> proteinLinks != NULL) {
831 if ( ! MimLinkAsnWrite(ptr -> proteinLinks, aip, MIM_ENTRY_proteinLinks)) {
832 goto erret;
833 }
834 }
835 if (ptr -> nucleotideLinks != NULL) {
836 if ( ! MimLinkAsnWrite(ptr -> nucleotideLinks, aip, MIM_ENTRY_nucleotideLinks)) {
837 goto erret;
838 }
839 }
840 if (ptr -> structureLinks != NULL) {
841 if ( ! MimLinkAsnWrite(ptr -> structureLinks, aip, MIM_ENTRY_structureLinks)) {
842 goto erret;
843 }
844 }
845 if (ptr -> genomeLinks != NULL) {
846 if ( ! MimLinkAsnWrite(ptr -> genomeLinks, aip, MIM_ENTRY_genomeLinks)) {
847 goto erret;
848 }
849 }
850 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
851 goto erret;
852 }
853 retval = TRUE;
854
855 erret:
856 AsnUnlinkType(orig); /* unlink local tree */
857 return retval;
858 }
859
860
861
862 /**************************************************
863 *
864 * MimCitNew()
865 *
866 **************************************************/
867 NLM_EXTERN
868 MimCitPtr LIBCALL
MimCitNew(void)869 MimCitNew(void)
870 {
871 MimCitPtr ptr = MemNew((size_t) sizeof(MimCit));
872
873 return ptr;
874
875 }
876
877
878 /**************************************************
879 *
880 * MimCitFree()
881 *
882 **************************************************/
883 NLM_EXTERN
884 MimCitPtr LIBCALL
MimCitFree(MimCitPtr ptr)885 MimCitFree(MimCitPtr ptr)
886 {
887
888 if(ptr == NULL) {
889 return NULL;
890 }
891 MemFree(ptr -> author);
892 MemFree(ptr -> others);
893 return MemFree(ptr);
894 }
895
896
897 /**************************************************
898 *
899 * MimCitAsnRead()
900 *
901 **************************************************/
902 NLM_EXTERN
903 MimCitPtr LIBCALL
MimCitAsnRead(AsnIoPtr aip,AsnTypePtr orig)904 MimCitAsnRead(AsnIoPtr aip, AsnTypePtr orig)
905 {
906 DataVal av;
907 AsnTypePtr atp;
908 Boolean isError = FALSE;
909 AsnReadFunc func;
910 MimCitPtr ptr;
911
912 if (! loaded)
913 {
914 if (! objmimAsnLoad()) {
915 return NULL;
916 }
917 }
918
919 if (aip == NULL) {
920 return NULL;
921 }
922
923 if (orig == NULL) { /* MimCit ::= (self contained) */
924 atp = AsnReadId(aip, amp, MIM_CIT);
925 } else {
926 atp = AsnLinkType(orig, MIM_CIT);
927 }
928 /* link in local tree */
929 if (atp == NULL) {
930 return NULL;
931 }
932
933 ptr = MimCitNew();
934 if (ptr == NULL) {
935 goto erret;
936 }
937 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
938 goto erret;
939 }
940
941 atp = AsnReadId(aip,amp, atp);
942 func = NULL;
943
944 if (atp == MIM_CIT_number) {
945 if ( AsnReadVal(aip, atp, &av) <= 0) {
946 goto erret;
947 }
948 ptr -> number = av.intvalue;
949 atp = AsnReadId(aip,amp, atp);
950 }
951 if (atp == MIM_CIT_author) {
952 if ( AsnReadVal(aip, atp, &av) <= 0) {
953 goto erret;
954 }
955 ptr -> author = av.ptrvalue;
956 atp = AsnReadId(aip,amp, atp);
957 }
958 if (atp == MIM_CIT_others) {
959 if ( AsnReadVal(aip, atp, &av) <= 0) {
960 goto erret;
961 }
962 ptr -> others = av.ptrvalue;
963 atp = AsnReadId(aip,amp, atp);
964 }
965 if (atp == MIM_CIT_year) {
966 if ( AsnReadVal(aip, atp, &av) <= 0) {
967 goto erret;
968 }
969 ptr -> year = av.intvalue;
970 atp = AsnReadId(aip,amp, atp);
971 }
972
973 if (AsnReadVal(aip, atp, &av) <= 0) {
974 goto erret;
975 }
976 /* end struct */
977
978 ret:
979 AsnUnlinkType(orig); /* unlink local tree */
980 return ptr;
981
982 erret:
983 aip -> io_failure = TRUE;
984 ptr = MimCitFree(ptr);
985 goto ret;
986 }
987
988
989
990 /**************************************************
991 *
992 * MimCitAsnWrite()
993 *
994 **************************************************/
995 NLM_EXTERN Boolean LIBCALL
MimCitAsnWrite(MimCitPtr ptr,AsnIoPtr aip,AsnTypePtr orig)996 MimCitAsnWrite(MimCitPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
997 {
998 DataVal av;
999 AsnTypePtr atp;
1000 Boolean retval = FALSE;
1001
1002 if (! loaded)
1003 {
1004 if (! objmimAsnLoad()) {
1005 return FALSE;
1006 }
1007 }
1008
1009 if (aip == NULL) {
1010 return FALSE;
1011 }
1012
1013 atp = AsnLinkType(orig, MIM_CIT); /* link local tree */
1014 if (atp == NULL) {
1015 return FALSE;
1016 }
1017
1018 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1019 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1020 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1021 goto erret;
1022 }
1023
1024 av.intvalue = ptr -> number;
1025 retval = AsnWrite(aip, MIM_CIT_number, &av);
1026 if (ptr -> author != NULL) {
1027 av.ptrvalue = ptr -> author;
1028 retval = AsnWrite(aip, MIM_CIT_author, &av);
1029 }
1030 if (ptr -> others != NULL) {
1031 av.ptrvalue = ptr -> others;
1032 retval = AsnWrite(aip, MIM_CIT_others, &av);
1033 }
1034 av.intvalue = ptr -> year;
1035 retval = AsnWrite(aip, MIM_CIT_year, &av);
1036 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1037 goto erret;
1038 }
1039 retval = TRUE;
1040
1041 erret:
1042 AsnUnlinkType(orig); /* unlink local tree */
1043 return retval;
1044 }
1045
1046
1047
1048 /**************************************************
1049 *
1050 * MimTextNew()
1051 *
1052 **************************************************/
1053 NLM_EXTERN
1054 MimTextPtr LIBCALL
MimTextNew(void)1055 MimTextNew(void)
1056 {
1057 MimTextPtr ptr = MemNew((size_t) sizeof(MimText));
1058
1059 return ptr;
1060
1061 }
1062
1063
1064 /**************************************************
1065 *
1066 * MimTextFree()
1067 *
1068 **************************************************/
1069 NLM_EXTERN
1070 MimTextPtr LIBCALL
MimTextFree(MimTextPtr ptr)1071 MimTextFree(MimTextPtr ptr)
1072 {
1073
1074 if(ptr == NULL) {
1075 return NULL;
1076 }
1077 MemFree(ptr -> label);
1078 MemFree(ptr -> text);
1079 MimLinkFree(ptr -> neighbors);
1080 return MemFree(ptr);
1081 }
1082
1083
1084 /**************************************************
1085 *
1086 * MimTextAsnRead()
1087 *
1088 **************************************************/
1089 NLM_EXTERN
1090 MimTextPtr LIBCALL
MimTextAsnRead(AsnIoPtr aip,AsnTypePtr orig)1091 MimTextAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1092 {
1093 DataVal av;
1094 AsnTypePtr atp;
1095 Boolean isError = FALSE;
1096 AsnReadFunc func;
1097 MimTextPtr ptr;
1098
1099 if (! loaded)
1100 {
1101 if (! objmimAsnLoad()) {
1102 return NULL;
1103 }
1104 }
1105
1106 if (aip == NULL) {
1107 return NULL;
1108 }
1109
1110 if (orig == NULL) { /* MimText ::= (self contained) */
1111 atp = AsnReadId(aip, amp, MIM_TEXT);
1112 } else {
1113 atp = AsnLinkType(orig, MIM_TEXT);
1114 }
1115 /* link in local tree */
1116 if (atp == NULL) {
1117 return NULL;
1118 }
1119
1120 ptr = MimTextNew();
1121 if (ptr == NULL) {
1122 goto erret;
1123 }
1124 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1125 goto erret;
1126 }
1127
1128 atp = AsnReadId(aip,amp, atp);
1129 func = NULL;
1130
1131 if (atp == MIM_TEXT_label) {
1132 if ( AsnReadVal(aip, atp, &av) <= 0) {
1133 goto erret;
1134 }
1135 ptr -> label = av.ptrvalue;
1136 atp = AsnReadId(aip,amp, atp);
1137 }
1138 if (atp == MIM_TEXT_text) {
1139 if ( AsnReadVal(aip, atp, &av) <= 0) {
1140 goto erret;
1141 }
1142 ptr -> text = av.ptrvalue;
1143 atp = AsnReadId(aip,amp, atp);
1144 }
1145 if (atp == MIM_TEXT_neighbors) {
1146 ptr -> neighbors = MimLinkAsnRead(aip, atp);
1147 if (aip -> io_failure) {
1148 goto erret;
1149 }
1150 atp = AsnReadId(aip,amp, atp);
1151 }
1152
1153 if (AsnReadVal(aip, atp, &av) <= 0) {
1154 goto erret;
1155 }
1156 /* end struct */
1157
1158 ret:
1159 AsnUnlinkType(orig); /* unlink local tree */
1160 return ptr;
1161
1162 erret:
1163 aip -> io_failure = TRUE;
1164 ptr = MimTextFree(ptr);
1165 goto ret;
1166 }
1167
1168
1169
1170 /**************************************************
1171 *
1172 * MimTextAsnWrite()
1173 *
1174 **************************************************/
1175 NLM_EXTERN Boolean LIBCALL
MimTextAsnWrite(MimTextPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1176 MimTextAsnWrite(MimTextPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1177 {
1178 DataVal av;
1179 AsnTypePtr atp;
1180 Boolean retval = FALSE;
1181
1182 if (! loaded)
1183 {
1184 if (! objmimAsnLoad()) {
1185 return FALSE;
1186 }
1187 }
1188
1189 if (aip == NULL) {
1190 return FALSE;
1191 }
1192
1193 atp = AsnLinkType(orig, MIM_TEXT); /* link local tree */
1194 if (atp == NULL) {
1195 return FALSE;
1196 }
1197
1198 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1199 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1200 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1201 goto erret;
1202 }
1203
1204 if (ptr -> label != NULL) {
1205 av.ptrvalue = ptr -> label;
1206 retval = AsnWrite(aip, MIM_TEXT_label, &av);
1207 }
1208 if (ptr -> text != NULL) {
1209 av.ptrvalue = ptr -> text;
1210 retval = AsnWrite(aip, MIM_TEXT_text, &av);
1211 }
1212 if (ptr -> neighbors != NULL) {
1213 if ( ! MimLinkAsnWrite(ptr -> neighbors, aip, MIM_TEXT_neighbors)) {
1214 goto erret;
1215 }
1216 }
1217 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1218 goto erret;
1219 }
1220 retval = TRUE;
1221
1222 erret:
1223 AsnUnlinkType(orig); /* unlink local tree */
1224 return retval;
1225 }
1226
1227
1228
1229 /**************************************************
1230 *
1231 * MimEditItemNew()
1232 *
1233 **************************************************/
1234 NLM_EXTERN
1235 MimEditItemPtr LIBCALL
MimEditItemNew(void)1236 MimEditItemNew(void)
1237 {
1238 MimEditItemPtr ptr = MemNew((size_t) sizeof(MimEditItem));
1239
1240 return ptr;
1241
1242 }
1243
1244
1245 /**************************************************
1246 *
1247 * MimEditItemFree()
1248 *
1249 **************************************************/
1250 NLM_EXTERN
1251 MimEditItemPtr LIBCALL
MimEditItemFree(MimEditItemPtr ptr)1252 MimEditItemFree(MimEditItemPtr ptr)
1253 {
1254
1255 if(ptr == NULL) {
1256 return NULL;
1257 }
1258 MemFree(ptr -> author);
1259 MimDateFree(ptr -> modDate);
1260 return MemFree(ptr);
1261 }
1262
1263
1264 /**************************************************
1265 *
1266 * MimEditItemAsnRead()
1267 *
1268 **************************************************/
1269 NLM_EXTERN
1270 MimEditItemPtr LIBCALL
MimEditItemAsnRead(AsnIoPtr aip,AsnTypePtr orig)1271 MimEditItemAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1272 {
1273 DataVal av;
1274 AsnTypePtr atp;
1275 Boolean isError = FALSE;
1276 AsnReadFunc func;
1277 MimEditItemPtr ptr;
1278
1279 if (! loaded)
1280 {
1281 if (! objmimAsnLoad()) {
1282 return NULL;
1283 }
1284 }
1285
1286 if (aip == NULL) {
1287 return NULL;
1288 }
1289
1290 if (orig == NULL) { /* MimEditItem ::= (self contained) */
1291 atp = AsnReadId(aip, amp, MIM_EDIT_ITEM);
1292 } else {
1293 atp = AsnLinkType(orig, MIM_EDIT_ITEM);
1294 }
1295 /* link in local tree */
1296 if (atp == NULL) {
1297 return NULL;
1298 }
1299
1300 ptr = MimEditItemNew();
1301 if (ptr == NULL) {
1302 goto erret;
1303 }
1304 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1305 goto erret;
1306 }
1307
1308 atp = AsnReadId(aip,amp, atp);
1309 func = NULL;
1310
1311 if (atp == MIM_EDIT_ITEM_author) {
1312 if ( AsnReadVal(aip, atp, &av) <= 0) {
1313 goto erret;
1314 }
1315 ptr -> author = av.ptrvalue;
1316 atp = AsnReadId(aip,amp, atp);
1317 }
1318 if (atp == MIM_EDIT_ITEM_modDate) {
1319 ptr -> modDate = MimDateAsnRead(aip, atp);
1320 if (aip -> io_failure) {
1321 goto erret;
1322 }
1323 atp = AsnReadId(aip,amp, atp);
1324 }
1325
1326 if (AsnReadVal(aip, atp, &av) <= 0) {
1327 goto erret;
1328 }
1329 /* end struct */
1330
1331 ret:
1332 AsnUnlinkType(orig); /* unlink local tree */
1333 return ptr;
1334
1335 erret:
1336 aip -> io_failure = TRUE;
1337 ptr = MimEditItemFree(ptr);
1338 goto ret;
1339 }
1340
1341
1342
1343 /**************************************************
1344 *
1345 * MimEditItemAsnWrite()
1346 *
1347 **************************************************/
1348 NLM_EXTERN Boolean LIBCALL
MimEditItemAsnWrite(MimEditItemPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1349 MimEditItemAsnWrite(MimEditItemPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1350 {
1351 DataVal av;
1352 AsnTypePtr atp;
1353 Boolean retval = FALSE;
1354
1355 if (! loaded)
1356 {
1357 if (! objmimAsnLoad()) {
1358 return FALSE;
1359 }
1360 }
1361
1362 if (aip == NULL) {
1363 return FALSE;
1364 }
1365
1366 atp = AsnLinkType(orig, MIM_EDIT_ITEM); /* link local tree */
1367 if (atp == NULL) {
1368 return FALSE;
1369 }
1370
1371 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1372 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1373 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1374 goto erret;
1375 }
1376
1377 if (ptr -> author != NULL) {
1378 av.ptrvalue = ptr -> author;
1379 retval = AsnWrite(aip, MIM_EDIT_ITEM_author, &av);
1380 }
1381 if (ptr -> modDate != NULL) {
1382 if ( ! MimDateAsnWrite(ptr -> modDate, aip, MIM_EDIT_ITEM_modDate)) {
1383 goto erret;
1384 }
1385 }
1386 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1387 goto erret;
1388 }
1389 retval = TRUE;
1390
1391 erret:
1392 AsnUnlinkType(orig); /* unlink local tree */
1393 return retval;
1394 }
1395
1396
1397
1398 /**************************************************
1399 *
1400 * MimAllelicVariantNew()
1401 *
1402 **************************************************/
1403 NLM_EXTERN
1404 MimAllelicVariantPtr LIBCALL
MimAllelicVariantNew(void)1405 MimAllelicVariantNew(void)
1406 {
1407 MimAllelicVariantPtr ptr = MemNew((size_t) sizeof(MimAllelicVariant));
1408
1409 return ptr;
1410
1411 }
1412
1413
1414 /**************************************************
1415 *
1416 * MimAllelicVariantFree()
1417 *
1418 **************************************************/
1419 NLM_EXTERN
1420 MimAllelicVariantPtr LIBCALL
MimAllelicVariantFree(MimAllelicVariantPtr ptr)1421 MimAllelicVariantFree(MimAllelicVariantPtr ptr)
1422 {
1423
1424 if(ptr == NULL) {
1425 return NULL;
1426 }
1427 MemFree(ptr -> number);
1428 MemFree(ptr -> name);
1429 AsnGenericBaseSeqOfFree(ptr -> aliases ,ASNCODE_PTRVAL_SLOT);
1430 AsnGenericUserSeqOfFree(ptr -> mutation, (AsnOptFreeFunc) MimTextFree);
1431 AsnGenericUserSeqOfFree(ptr -> description, (AsnOptFreeFunc) MimTextFree);
1432 return MemFree(ptr);
1433 }
1434
1435
1436 /**************************************************
1437 *
1438 * MimAllelicVariantAsnRead()
1439 *
1440 **************************************************/
1441 NLM_EXTERN
1442 MimAllelicVariantPtr LIBCALL
MimAllelicVariantAsnRead(AsnIoPtr aip,AsnTypePtr orig)1443 MimAllelicVariantAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1444 {
1445 DataVal av;
1446 AsnTypePtr atp;
1447 Boolean isError = FALSE;
1448 AsnReadFunc func;
1449 MimAllelicVariantPtr ptr;
1450
1451 if (! loaded)
1452 {
1453 if (! objmimAsnLoad()) {
1454 return NULL;
1455 }
1456 }
1457
1458 if (aip == NULL) {
1459 return NULL;
1460 }
1461
1462 if (orig == NULL) { /* MimAllelicVariant ::= (self contained) */
1463 atp = AsnReadId(aip, amp, MIM_ALLELIC_VARIANT);
1464 } else {
1465 atp = AsnLinkType(orig, MIM_ALLELIC_VARIANT);
1466 }
1467 /* link in local tree */
1468 if (atp == NULL) {
1469 return NULL;
1470 }
1471
1472 ptr = MimAllelicVariantNew();
1473 if (ptr == NULL) {
1474 goto erret;
1475 }
1476 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1477 goto erret;
1478 }
1479
1480 atp = AsnReadId(aip,amp, atp);
1481 func = NULL;
1482
1483 if (atp == MIM_ALLELIC_VARIANT_number) {
1484 if ( AsnReadVal(aip, atp, &av) <= 0) {
1485 goto erret;
1486 }
1487 ptr -> number = av.ptrvalue;
1488 atp = AsnReadId(aip,amp, atp);
1489 }
1490 if (atp == MIM_ALLELIC_VARIANT_name) {
1491 if ( AsnReadVal(aip, atp, &av) <= 0) {
1492 goto erret;
1493 }
1494 ptr -> name = av.ptrvalue;
1495 atp = AsnReadId(aip,amp, atp);
1496 }
1497 if (atp == MIM_ALLELIC_VARIANT_aliases) {
1498 ptr -> aliases = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
1499 if (isError && ptr -> aliases == NULL) {
1500 goto erret;
1501 }
1502 atp = AsnReadId(aip,amp, atp);
1503 }
1504 if (atp == MIM_ALLELIC_VARIANT_mutation) {
1505 ptr -> mutation = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimTextAsnRead, (AsnOptFreeFunc) MimTextFree);
1506 if (isError && ptr -> mutation == NULL) {
1507 goto erret;
1508 }
1509 atp = AsnReadId(aip,amp, atp);
1510 }
1511 if (atp == MIM_ALLELIC_VARIANT_description) {
1512 ptr -> description = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimTextAsnRead, (AsnOptFreeFunc) MimTextFree);
1513 if (isError && ptr -> description == NULL) {
1514 goto erret;
1515 }
1516 atp = AsnReadId(aip,amp, atp);
1517 }
1518
1519 if (AsnReadVal(aip, atp, &av) <= 0) {
1520 goto erret;
1521 }
1522 /* end struct */
1523
1524 ret:
1525 AsnUnlinkType(orig); /* unlink local tree */
1526 return ptr;
1527
1528 erret:
1529 aip -> io_failure = TRUE;
1530 ptr = MimAllelicVariantFree(ptr);
1531 goto ret;
1532 }
1533
1534
1535
1536 /**************************************************
1537 *
1538 * MimAllelicVariantAsnWrite()
1539 *
1540 **************************************************/
1541 NLM_EXTERN Boolean LIBCALL
MimAllelicVariantAsnWrite(MimAllelicVariantPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1542 MimAllelicVariantAsnWrite(MimAllelicVariantPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1543 {
1544 DataVal av;
1545 AsnTypePtr atp;
1546 Boolean retval = FALSE;
1547
1548 if (! loaded)
1549 {
1550 if (! objmimAsnLoad()) {
1551 return FALSE;
1552 }
1553 }
1554
1555 if (aip == NULL) {
1556 return FALSE;
1557 }
1558
1559 atp = AsnLinkType(orig, MIM_ALLELIC_VARIANT); /* link local tree */
1560 if (atp == NULL) {
1561 return FALSE;
1562 }
1563
1564 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1565 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1566 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1567 goto erret;
1568 }
1569
1570 if (ptr -> number != NULL) {
1571 av.ptrvalue = ptr -> number;
1572 retval = AsnWrite(aip, MIM_ALLELIC_VARIANT_number, &av);
1573 }
1574 if (ptr -> name != NULL) {
1575 av.ptrvalue = ptr -> name;
1576 retval = AsnWrite(aip, MIM_ALLELIC_VARIANT_name, &av);
1577 }
1578 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> aliases ,ASNCODE_PTRVAL_SLOT, aip, MIM_ALLELIC_VARIANT_aliases, MIM_ALLELIC_VARIANT_aliases_E);
1579 AsnGenericUserSeqOfAsnWrite(ptr -> mutation, (AsnWriteFunc) MimTextAsnWrite, aip, MIM_ALLELIC_VARIANT_mutation, MIM_ALLELIC_VARIANT_mutation_E);
1580 AsnGenericUserSeqOfAsnWrite(ptr -> description, (AsnWriteFunc) MimTextAsnWrite, aip, MIM_ALLELIC_VARIANT_description, ALLELIC_VARIANT_description_E);
1581 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1582 goto erret;
1583 }
1584 retval = TRUE;
1585
1586 erret:
1587 AsnUnlinkType(orig); /* unlink local tree */
1588 return retval;
1589 }
1590
1591
1592
1593 /**************************************************
1594 *
1595 * MimIndexTermNew()
1596 *
1597 **************************************************/
1598 NLM_EXTERN
1599 MimIndexTermPtr LIBCALL
MimIndexTermNew(void)1600 MimIndexTermNew(void)
1601 {
1602 MimIndexTermPtr ptr = MemNew((size_t) sizeof(MimIndexTerm));
1603
1604 return ptr;
1605
1606 }
1607
1608
1609 /**************************************************
1610 *
1611 * MimIndexTermFree()
1612 *
1613 **************************************************/
1614 NLM_EXTERN
1615 MimIndexTermPtr LIBCALL
MimIndexTermFree(MimIndexTermPtr ptr)1616 MimIndexTermFree(MimIndexTermPtr ptr)
1617 {
1618
1619 if(ptr == NULL) {
1620 return NULL;
1621 }
1622 MemFree(ptr -> key);
1623 AsnGenericBaseSeqOfFree(ptr -> terms ,ASNCODE_PTRVAL_SLOT);
1624 return MemFree(ptr);
1625 }
1626
1627
1628 /**************************************************
1629 *
1630 * MimIndexTermAsnRead()
1631 *
1632 **************************************************/
1633 NLM_EXTERN
1634 MimIndexTermPtr LIBCALL
MimIndexTermAsnRead(AsnIoPtr aip,AsnTypePtr orig)1635 MimIndexTermAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1636 {
1637 DataVal av;
1638 AsnTypePtr atp;
1639 Boolean isError = FALSE;
1640 AsnReadFunc func;
1641 MimIndexTermPtr ptr;
1642
1643 if (! loaded)
1644 {
1645 if (! objmimAsnLoad()) {
1646 return NULL;
1647 }
1648 }
1649
1650 if (aip == NULL) {
1651 return NULL;
1652 }
1653
1654 if (orig == NULL) { /* MimIndexTerm ::= (self contained) */
1655 atp = AsnReadId(aip, amp, MIM_INDEX_TERM);
1656 } else {
1657 atp = AsnLinkType(orig, MIM_INDEX_TERM);
1658 }
1659 /* link in local tree */
1660 if (atp == NULL) {
1661 return NULL;
1662 }
1663
1664 ptr = MimIndexTermNew();
1665 if (ptr == NULL) {
1666 goto erret;
1667 }
1668 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1669 goto erret;
1670 }
1671
1672 atp = AsnReadId(aip,amp, atp);
1673 func = NULL;
1674
1675 if (atp == MIM_INDEX_TERM_key) {
1676 if ( AsnReadVal(aip, atp, &av) <= 0) {
1677 goto erret;
1678 }
1679 ptr -> key = av.ptrvalue;
1680 atp = AsnReadId(aip,amp, atp);
1681 }
1682 if (atp == MIM_INDEX_TERM_terms) {
1683 ptr -> terms = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
1684 if (isError && ptr -> terms == NULL) {
1685 goto erret;
1686 }
1687 atp = AsnReadId(aip,amp, atp);
1688 }
1689
1690 if (AsnReadVal(aip, atp, &av) <= 0) {
1691 goto erret;
1692 }
1693 /* end struct */
1694
1695 ret:
1696 AsnUnlinkType(orig); /* unlink local tree */
1697 return ptr;
1698
1699 erret:
1700 aip -> io_failure = TRUE;
1701 ptr = MimIndexTermFree(ptr);
1702 goto ret;
1703 }
1704
1705
1706
1707 /**************************************************
1708 *
1709 * MimIndexTermAsnWrite()
1710 *
1711 **************************************************/
1712 NLM_EXTERN Boolean LIBCALL
MimIndexTermAsnWrite(MimIndexTermPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1713 MimIndexTermAsnWrite(MimIndexTermPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1714 {
1715 DataVal av;
1716 AsnTypePtr atp;
1717 Boolean retval = FALSE;
1718
1719 if (! loaded)
1720 {
1721 if (! objmimAsnLoad()) {
1722 return FALSE;
1723 }
1724 }
1725
1726 if (aip == NULL) {
1727 return FALSE;
1728 }
1729
1730 atp = AsnLinkType(orig, MIM_INDEX_TERM); /* link local tree */
1731 if (atp == NULL) {
1732 return FALSE;
1733 }
1734
1735 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1736 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1737 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
1738 goto erret;
1739 }
1740
1741 if (ptr -> key != NULL) {
1742 av.ptrvalue = ptr -> key;
1743 retval = AsnWrite(aip, MIM_INDEX_TERM_key, &av);
1744 }
1745 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> terms ,ASNCODE_PTRVAL_SLOT, aip, MIM_INDEX_TERM_terms, MIM_INDEX_TERM_terms_E);
1746 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
1747 goto erret;
1748 }
1749 retval = TRUE;
1750
1751 erret:
1752 AsnUnlinkType(orig); /* unlink local tree */
1753 return retval;
1754 }
1755
1756
1757
1758 /**************************************************
1759 *
1760 * MimReferenceNew()
1761 *
1762 **************************************************/
1763 NLM_EXTERN
1764 MimReferencePtr LIBCALL
MimReferenceNew(void)1765 MimReferenceNew(void)
1766 {
1767 MimReferencePtr ptr = MemNew((size_t) sizeof(MimReference));
1768
1769 return ptr;
1770
1771 }
1772
1773
1774 /**************************************************
1775 *
1776 * MimReferenceFree()
1777 *
1778 **************************************************/
1779 NLM_EXTERN
1780 MimReferencePtr LIBCALL
MimReferenceFree(MimReferencePtr ptr)1781 MimReferenceFree(MimReferencePtr ptr)
1782 {
1783
1784 if(ptr == NULL) {
1785 return NULL;
1786 }
1787 AsnGenericUserSeqOfFree(ptr -> authors, (AsnOptFreeFunc) MimAuthorFree);
1788 MemFree(ptr -> primaryAuthor);
1789 MemFree(ptr -> otherAuthors);
1790 MemFree(ptr -> citationTitle);
1791 MemFree(ptr -> bookTitle);
1792 AsnGenericUserSeqOfFree(ptr -> editors, (AsnOptFreeFunc) MimAuthorFree);
1793 MemFree(ptr -> volume);
1794 MemFree(ptr -> edition);
1795 MemFree(ptr -> journal);
1796 MemFree(ptr -> series);
1797 MemFree(ptr -> publisher);
1798 MemFree(ptr -> place);
1799 MemFree(ptr -> commNote);
1800 MimDateFree(ptr -> pubDate);
1801 AsnGenericUserSeqOfFree(ptr -> pages, (AsnOptFreeFunc) MimPageFree);
1802 MemFree(ptr -> miscInfo);
1803 return MemFree(ptr);
1804 }
1805
1806
1807 /**************************************************
1808 *
1809 * MimReferenceAsnRead()
1810 *
1811 **************************************************/
1812 NLM_EXTERN
1813 MimReferencePtr LIBCALL
MimReferenceAsnRead(AsnIoPtr aip,AsnTypePtr orig)1814 MimReferenceAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1815 {
1816 DataVal av;
1817 AsnTypePtr atp;
1818 Boolean isError = FALSE;
1819 AsnReadFunc func;
1820 MimReferencePtr ptr;
1821
1822 if (! loaded)
1823 {
1824 if (! objmimAsnLoad()) {
1825 return NULL;
1826 }
1827 }
1828
1829 if (aip == NULL) {
1830 return NULL;
1831 }
1832
1833 if (orig == NULL) { /* MimReference ::= (self contained) */
1834 atp = AsnReadId(aip, amp, MIM_REFERENCE);
1835 } else {
1836 atp = AsnLinkType(orig, MIM_REFERENCE);
1837 }
1838 /* link in local tree */
1839 if (atp == NULL) {
1840 return NULL;
1841 }
1842
1843 ptr = MimReferenceNew();
1844 if (ptr == NULL) {
1845 goto erret;
1846 }
1847 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
1848 goto erret;
1849 }
1850
1851 atp = AsnReadId(aip,amp, atp);
1852 func = NULL;
1853
1854 if (atp == MIM_REFERENCE_number) {
1855 if ( AsnReadVal(aip, atp, &av) <= 0) {
1856 goto erret;
1857 }
1858 ptr -> number = av.intvalue;
1859 atp = AsnReadId(aip,amp, atp);
1860 }
1861 if (atp == MIM_REFERENCE_origNumber) {
1862 if ( AsnReadVal(aip, atp, &av) <= 0) {
1863 goto erret;
1864 }
1865 ptr -> origNumber = av.intvalue;
1866 atp = AsnReadId(aip,amp, atp);
1867 }
1868 if (atp == MIM_REFERENCE_type) {
1869 if ( AsnReadVal(aip, atp, &av) <= 0) {
1870 goto erret;
1871 }
1872 ptr -> type = av.intvalue;
1873 atp = AsnReadId(aip,amp, atp);
1874 }
1875 if (atp == MIM_REFERENCE_authors) {
1876 ptr -> authors = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimAuthorAsnRead, (AsnOptFreeFunc) MimAuthorFree);
1877 if (isError && ptr -> authors == NULL) {
1878 goto erret;
1879 }
1880 atp = AsnReadId(aip,amp, atp);
1881 }
1882 if (atp == MIM_REFERENCE_primaryAuthor) {
1883 if ( AsnReadVal(aip, atp, &av) <= 0) {
1884 goto erret;
1885 }
1886 ptr -> primaryAuthor = av.ptrvalue;
1887 atp = AsnReadId(aip,amp, atp);
1888 }
1889 if (atp == MIM_REFERENCE_otherAuthors) {
1890 if ( AsnReadVal(aip, atp, &av) <= 0) {
1891 goto erret;
1892 }
1893 ptr -> otherAuthors = av.ptrvalue;
1894 atp = AsnReadId(aip,amp, atp);
1895 }
1896 if (atp == MIM_REFERENCE_citationTitle) {
1897 if ( AsnReadVal(aip, atp, &av) <= 0) {
1898 goto erret;
1899 }
1900 ptr -> citationTitle = av.ptrvalue;
1901 atp = AsnReadId(aip,amp, atp);
1902 }
1903 if (atp == MIM_REFERENCE_citationType) {
1904 if ( AsnReadVal(aip, atp, &av) <= 0) {
1905 goto erret;
1906 }
1907 ptr -> citationType = av.intvalue;
1908 atp = AsnReadId(aip,amp, atp);
1909 }
1910 if (atp == MIM_REFERENCE_bookTitle) {
1911 if ( AsnReadVal(aip, atp, &av) <= 0) {
1912 goto erret;
1913 }
1914 ptr -> bookTitle = av.ptrvalue;
1915 atp = AsnReadId(aip,amp, atp);
1916 }
1917 if (atp == MIM_REFERENCE_editors) {
1918 ptr -> editors = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimAuthorAsnRead, (AsnOptFreeFunc) MimAuthorFree);
1919 if (isError && ptr -> editors == NULL) {
1920 goto erret;
1921 }
1922 atp = AsnReadId(aip,amp, atp);
1923 }
1924 if (atp == MIM_REFERENCE_volume) {
1925 if ( AsnReadVal(aip, atp, &av) <= 0) {
1926 goto erret;
1927 }
1928 ptr -> volume = av.ptrvalue;
1929 atp = AsnReadId(aip,amp, atp);
1930 }
1931 if (atp == MIM_REFERENCE_edition) {
1932 if ( AsnReadVal(aip, atp, &av) <= 0) {
1933 goto erret;
1934 }
1935 ptr -> edition = av.ptrvalue;
1936 atp = AsnReadId(aip,amp, atp);
1937 }
1938 if (atp == MIM_REFERENCE_journal) {
1939 if ( AsnReadVal(aip, atp, &av) <= 0) {
1940 goto erret;
1941 }
1942 ptr -> journal = av.ptrvalue;
1943 atp = AsnReadId(aip,amp, atp);
1944 }
1945 if (atp == MIM_REFERENCE_series) {
1946 if ( AsnReadVal(aip, atp, &av) <= 0) {
1947 goto erret;
1948 }
1949 ptr -> series = av.ptrvalue;
1950 atp = AsnReadId(aip,amp, atp);
1951 }
1952 if (atp == MIM_REFERENCE_publisher) {
1953 if ( AsnReadVal(aip, atp, &av) <= 0) {
1954 goto erret;
1955 }
1956 ptr -> publisher = av.ptrvalue;
1957 atp = AsnReadId(aip,amp, atp);
1958 }
1959 if (atp == MIM_REFERENCE_place) {
1960 if ( AsnReadVal(aip, atp, &av) <= 0) {
1961 goto erret;
1962 }
1963 ptr -> place = av.ptrvalue;
1964 atp = AsnReadId(aip,amp, atp);
1965 }
1966 if (atp == MIM_REFERENCE_commNote) {
1967 if ( AsnReadVal(aip, atp, &av) <= 0) {
1968 goto erret;
1969 }
1970 ptr -> commNote = av.ptrvalue;
1971 atp = AsnReadId(aip,amp, atp);
1972 }
1973 if (atp == MIM_REFERENCE_pubDate) {
1974 ptr -> pubDate = MimDateAsnRead(aip, atp);
1975 if (aip -> io_failure) {
1976 goto erret;
1977 }
1978 atp = AsnReadId(aip,amp, atp);
1979 }
1980 if (atp == MIM_REFERENCE_pages) {
1981 ptr -> pages = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) MimPageAsnRead, (AsnOptFreeFunc) MimPageFree);
1982 if (isError && ptr -> pages == NULL) {
1983 goto erret;
1984 }
1985 atp = AsnReadId(aip,amp, atp);
1986 }
1987 if (atp == MIM_REFERENCE_miscInfo) {
1988 if ( AsnReadVal(aip, atp, &av) <= 0) {
1989 goto erret;
1990 }
1991 ptr -> miscInfo = av.ptrvalue;
1992 atp = AsnReadId(aip,amp, atp);
1993 }
1994 if (atp == MIM_REFERENCE_pubmedUID) {
1995 if ( AsnReadVal(aip, atp, &av) <= 0) {
1996 goto erret;
1997 }
1998 ptr -> pubmedUID = av.intvalue;
1999 atp = AsnReadId(aip,amp, atp);
2000 }
2001 if (atp == MIM_REFERENCE_ambiguous) {
2002 if ( AsnReadVal(aip, atp, &av) <= 0) {
2003 goto erret;
2004 }
2005 ptr -> ambiguous = av.boolvalue;
2006 atp = AsnReadId(aip,amp, atp);
2007 }
2008 if (atp == MIM_REFERENCE_noLink) {
2009 if ( AsnReadVal(aip, atp, &av) <= 0) {
2010 goto erret;
2011 }
2012 ptr -> noLink = av.boolvalue;
2013 atp = AsnReadId(aip,amp, atp);
2014 }
2015
2016 if (AsnReadVal(aip, atp, &av) <= 0) {
2017 goto erret;
2018 }
2019 /* end struct */
2020
2021 ret:
2022 AsnUnlinkType(orig); /* unlink local tree */
2023 return ptr;
2024
2025 erret:
2026 aip -> io_failure = TRUE;
2027 ptr = MimReferenceFree(ptr);
2028 goto ret;
2029 }
2030
2031
2032
2033 /**************************************************
2034 *
2035 * MimReferenceAsnWrite()
2036 *
2037 **************************************************/
2038 NLM_EXTERN Boolean LIBCALL
MimReferenceAsnWrite(MimReferencePtr ptr,AsnIoPtr aip,AsnTypePtr orig)2039 MimReferenceAsnWrite(MimReferencePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
2040 {
2041 DataVal av;
2042 AsnTypePtr atp;
2043 Boolean retval = FALSE;
2044
2045 if (! loaded)
2046 {
2047 if (! objmimAsnLoad()) {
2048 return FALSE;
2049 }
2050 }
2051
2052 if (aip == NULL) {
2053 return FALSE;
2054 }
2055
2056 atp = AsnLinkType(orig, MIM_REFERENCE); /* link local tree */
2057 if (atp == NULL) {
2058 return FALSE;
2059 }
2060
2061 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2062 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
2063 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
2064 goto erret;
2065 }
2066
2067 av.intvalue = ptr -> number;
2068 retval = AsnWrite(aip, MIM_REFERENCE_number, &av);
2069 av.intvalue = ptr -> origNumber;
2070 retval = AsnWrite(aip, MIM_REFERENCE_origNumber, &av);
2071 av.intvalue = ptr -> type;
2072 retval = AsnWrite(aip, MIM_REFERENCE_type, &av);
2073 AsnGenericUserSeqOfAsnWrite(ptr -> authors, (AsnWriteFunc) MimAuthorAsnWrite, aip, MIM_REFERENCE_authors, MIM_REFERENCE_authors_E);
2074 if (ptr -> primaryAuthor != NULL) {
2075 av.ptrvalue = ptr -> primaryAuthor;
2076 retval = AsnWrite(aip, MIM_REFERENCE_primaryAuthor, &av);
2077 }
2078 if (ptr -> otherAuthors != NULL) {
2079 av.ptrvalue = ptr -> otherAuthors;
2080 retval = AsnWrite(aip, MIM_REFERENCE_otherAuthors, &av);
2081 }
2082 if (ptr -> citationTitle != NULL) {
2083 av.ptrvalue = ptr -> citationTitle;
2084 retval = AsnWrite(aip, MIM_REFERENCE_citationTitle, &av);
2085 }
2086 av.intvalue = ptr -> citationType;
2087 retval = AsnWrite(aip, MIM_REFERENCE_citationType, &av);
2088 if (ptr -> bookTitle != NULL) {
2089 av.ptrvalue = ptr -> bookTitle;
2090 retval = AsnWrite(aip, MIM_REFERENCE_bookTitle, &av);
2091 }
2092 AsnGenericUserSeqOfAsnWrite(ptr -> editors, (AsnWriteFunc) MimAuthorAsnWrite, aip, MIM_REFERENCE_editors, MIM_REFERENCE_editors_E);
2093 if (ptr -> volume != NULL) {
2094 av.ptrvalue = ptr -> volume;
2095 retval = AsnWrite(aip, MIM_REFERENCE_volume, &av);
2096 }
2097 if (ptr -> edition != NULL) {
2098 av.ptrvalue = ptr -> edition;
2099 retval = AsnWrite(aip, MIM_REFERENCE_edition, &av);
2100 }
2101 if (ptr -> journal != NULL) {
2102 av.ptrvalue = ptr -> journal;
2103 retval = AsnWrite(aip, MIM_REFERENCE_journal, &av);
2104 }
2105 if (ptr -> series != NULL) {
2106 av.ptrvalue = ptr -> series;
2107 retval = AsnWrite(aip, MIM_REFERENCE_series, &av);
2108 }
2109 if (ptr -> publisher != NULL) {
2110 av.ptrvalue = ptr -> publisher;
2111 retval = AsnWrite(aip, MIM_REFERENCE_publisher, &av);
2112 }
2113 if (ptr -> place != NULL) {
2114 av.ptrvalue = ptr -> place;
2115 retval = AsnWrite(aip, MIM_REFERENCE_place, &av);
2116 }
2117 if (ptr -> commNote != NULL) {
2118 av.ptrvalue = ptr -> commNote;
2119 retval = AsnWrite(aip, MIM_REFERENCE_commNote, &av);
2120 }
2121 if (ptr -> pubDate != NULL) {
2122 if ( ! MimDateAsnWrite(ptr -> pubDate, aip, MIM_REFERENCE_pubDate)) {
2123 goto erret;
2124 }
2125 }
2126 AsnGenericUserSeqOfAsnWrite(ptr -> pages, (AsnWriteFunc) MimPageAsnWrite, aip, MIM_REFERENCE_pages, MIM_REFERENCE_pages_E);
2127 if (ptr -> miscInfo != NULL) {
2128 av.ptrvalue = ptr -> miscInfo;
2129 retval = AsnWrite(aip, MIM_REFERENCE_miscInfo, &av);
2130 }
2131 av.intvalue = ptr -> pubmedUID;
2132 retval = AsnWrite(aip, MIM_REFERENCE_pubmedUID, &av);
2133 av.boolvalue = ptr -> ambiguous;
2134 retval = AsnWrite(aip, MIM_REFERENCE_ambiguous, &av);
2135 av.boolvalue = ptr -> noLink;
2136 retval = AsnWrite(aip, MIM_REFERENCE_noLink, &av);
2137 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
2138 goto erret;
2139 }
2140 retval = TRUE;
2141
2142 erret:
2143 AsnUnlinkType(orig); /* unlink local tree */
2144 return retval;
2145 }
2146
2147
2148
2149 /**************************************************
2150 *
2151 * MimLinkNew()
2152 *
2153 **************************************************/
2154 NLM_EXTERN
2155 MimLinkPtr LIBCALL
MimLinkNew(void)2156 MimLinkNew(void)
2157 {
2158 MimLinkPtr ptr = MemNew((size_t) sizeof(MimLink));
2159
2160 return ptr;
2161
2162 }
2163
2164
2165 /**************************************************
2166 *
2167 * MimLinkFree()
2168 *
2169 **************************************************/
2170 NLM_EXTERN
2171 MimLinkPtr LIBCALL
MimLinkFree(MimLinkPtr ptr)2172 MimLinkFree(MimLinkPtr ptr)
2173 {
2174
2175 if(ptr == NULL) {
2176 return NULL;
2177 }
2178 MemFree(ptr -> uids);
2179 return MemFree(ptr);
2180 }
2181
2182
2183 /**************************************************
2184 *
2185 * MimLinkAsnRead()
2186 *
2187 **************************************************/
2188 NLM_EXTERN
2189 MimLinkPtr LIBCALL
MimLinkAsnRead(AsnIoPtr aip,AsnTypePtr orig)2190 MimLinkAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2191 {
2192 DataVal av;
2193 AsnTypePtr atp;
2194 Boolean isError = FALSE;
2195 AsnReadFunc func;
2196 MimLinkPtr ptr;
2197
2198 if (! loaded)
2199 {
2200 if (! objmimAsnLoad()) {
2201 return NULL;
2202 }
2203 }
2204
2205 if (aip == NULL) {
2206 return NULL;
2207 }
2208
2209 if (orig == NULL) { /* MimLink ::= (self contained) */
2210 atp = AsnReadId(aip, amp, MIM_LINK);
2211 } else {
2212 atp = AsnLinkType(orig, MIM_LINK);
2213 }
2214 /* link in local tree */
2215 if (atp == NULL) {
2216 return NULL;
2217 }
2218
2219 ptr = MimLinkNew();
2220 if (ptr == NULL) {
2221 goto erret;
2222 }
2223 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
2224 goto erret;
2225 }
2226
2227 atp = AsnReadId(aip,amp, atp);
2228 func = NULL;
2229
2230 if (atp == MIM_LINK_num) {
2231 if ( AsnReadVal(aip, atp, &av) <= 0) {
2232 goto erret;
2233 }
2234 ptr -> num = av.intvalue;
2235 atp = AsnReadId(aip,amp, atp);
2236 }
2237 if (atp == MIM_LINK_uids) {
2238 if ( AsnReadVal(aip, atp, &av) <= 0) {
2239 goto erret;
2240 }
2241 ptr -> uids = av.ptrvalue;
2242 atp = AsnReadId(aip,amp, atp);
2243 }
2244 if (atp == MIM_LINK_numRelevant) {
2245 if ( AsnReadVal(aip, atp, &av) <= 0) {
2246 goto erret;
2247 }
2248 ptr -> numRelevant = av.intvalue;
2249 atp = AsnReadId(aip,amp, atp);
2250 }
2251
2252 if (AsnReadVal(aip, atp, &av) <= 0) {
2253 goto erret;
2254 }
2255 /* end struct */
2256
2257 ret:
2258 AsnUnlinkType(orig); /* unlink local tree */
2259 return ptr;
2260
2261 erret:
2262 aip -> io_failure = TRUE;
2263 ptr = MimLinkFree(ptr);
2264 goto ret;
2265 }
2266
2267
2268
2269 /**************************************************
2270 *
2271 * MimLinkAsnWrite()
2272 *
2273 **************************************************/
2274 NLM_EXTERN Boolean LIBCALL
MimLinkAsnWrite(MimLinkPtr ptr,AsnIoPtr aip,AsnTypePtr orig)2275 MimLinkAsnWrite(MimLinkPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
2276 {
2277 DataVal av;
2278 AsnTypePtr atp;
2279 Boolean retval = FALSE;
2280
2281 if (! loaded)
2282 {
2283 if (! objmimAsnLoad()) {
2284 return FALSE;
2285 }
2286 }
2287
2288 if (aip == NULL) {
2289 return FALSE;
2290 }
2291
2292 atp = AsnLinkType(orig, MIM_LINK); /* link local tree */
2293 if (atp == NULL) {
2294 return FALSE;
2295 }
2296
2297 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2298 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
2299 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
2300 goto erret;
2301 }
2302
2303 av.intvalue = ptr -> num;
2304 retval = AsnWrite(aip, MIM_LINK_num, &av);
2305 if (ptr -> uids != NULL) {
2306 av.ptrvalue = ptr -> uids;
2307 retval = AsnWrite(aip, MIM_LINK_uids, &av);
2308 }
2309 av.intvalue = ptr -> numRelevant;
2310 retval = AsnWrite(aip, MIM_LINK_numRelevant, &av);
2311 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
2312 goto erret;
2313 }
2314 retval = TRUE;
2315
2316 erret:
2317 AsnUnlinkType(orig); /* unlink local tree */
2318 return retval;
2319 }
2320
2321
2322
2323 /**************************************************
2324 *
2325 * MimAuthorNew()
2326 *
2327 **************************************************/
2328 NLM_EXTERN
2329 MimAuthorPtr LIBCALL
MimAuthorNew(void)2330 MimAuthorNew(void)
2331 {
2332 MimAuthorPtr ptr = MemNew((size_t) sizeof(MimAuthor));
2333
2334 return ptr;
2335
2336 }
2337
2338
2339 /**************************************************
2340 *
2341 * MimAuthorFree()
2342 *
2343 **************************************************/
2344 NLM_EXTERN
2345 MimAuthorPtr LIBCALL
MimAuthorFree(MimAuthorPtr ptr)2346 MimAuthorFree(MimAuthorPtr ptr)
2347 {
2348
2349 if(ptr == NULL) {
2350 return NULL;
2351 }
2352 MemFree(ptr -> name);
2353 return MemFree(ptr);
2354 }
2355
2356
2357 /**************************************************
2358 *
2359 * MimAuthorAsnRead()
2360 *
2361 **************************************************/
2362 NLM_EXTERN
2363 MimAuthorPtr LIBCALL
MimAuthorAsnRead(AsnIoPtr aip,AsnTypePtr orig)2364 MimAuthorAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2365 {
2366 DataVal av;
2367 AsnTypePtr atp;
2368 Boolean isError = FALSE;
2369 AsnReadFunc func;
2370 MimAuthorPtr ptr;
2371
2372 if (! loaded)
2373 {
2374 if (! objmimAsnLoad()) {
2375 return NULL;
2376 }
2377 }
2378
2379 if (aip == NULL) {
2380 return NULL;
2381 }
2382
2383 if (orig == NULL) { /* MimAuthor ::= (self contained) */
2384 atp = AsnReadId(aip, amp, MIM_AUTHOR);
2385 } else {
2386 atp = AsnLinkType(orig, MIM_AUTHOR);
2387 }
2388 /* link in local tree */
2389 if (atp == NULL) {
2390 return NULL;
2391 }
2392
2393 ptr = MimAuthorNew();
2394 if (ptr == NULL) {
2395 goto erret;
2396 }
2397 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
2398 goto erret;
2399 }
2400
2401 atp = AsnReadId(aip,amp, atp);
2402 func = NULL;
2403
2404 if (atp == MIM_AUTHOR_name) {
2405 if ( AsnReadVal(aip, atp, &av) <= 0) {
2406 goto erret;
2407 }
2408 ptr -> name = av.ptrvalue;
2409 atp = AsnReadId(aip,amp, atp);
2410 }
2411 if (atp == MIM_AUTHOR_index) {
2412 if ( AsnReadVal(aip, atp, &av) <= 0) {
2413 goto erret;
2414 }
2415 ptr -> index = av.intvalue;
2416 atp = AsnReadId(aip,amp, atp);
2417 }
2418
2419 if (AsnReadVal(aip, atp, &av) <= 0) {
2420 goto erret;
2421 }
2422 /* end struct */
2423
2424 ret:
2425 AsnUnlinkType(orig); /* unlink local tree */
2426 return ptr;
2427
2428 erret:
2429 aip -> io_failure = TRUE;
2430 ptr = MimAuthorFree(ptr);
2431 goto ret;
2432 }
2433
2434
2435
2436 /**************************************************
2437 *
2438 * MimAuthorAsnWrite()
2439 *
2440 **************************************************/
2441 NLM_EXTERN Boolean LIBCALL
MimAuthorAsnWrite(MimAuthorPtr ptr,AsnIoPtr aip,AsnTypePtr orig)2442 MimAuthorAsnWrite(MimAuthorPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
2443 {
2444 DataVal av;
2445 AsnTypePtr atp;
2446 Boolean retval = FALSE;
2447
2448 if (! loaded)
2449 {
2450 if (! objmimAsnLoad()) {
2451 return FALSE;
2452 }
2453 }
2454
2455 if (aip == NULL) {
2456 return FALSE;
2457 }
2458
2459 atp = AsnLinkType(orig, MIM_AUTHOR); /* link local tree */
2460 if (atp == NULL) {
2461 return FALSE;
2462 }
2463
2464 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2465 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
2466 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
2467 goto erret;
2468 }
2469
2470 if (ptr -> name != NULL) {
2471 av.ptrvalue = ptr -> name;
2472 retval = AsnWrite(aip, MIM_AUTHOR_name, &av);
2473 }
2474 av.intvalue = ptr -> index;
2475 retval = AsnWrite(aip, MIM_AUTHOR_index, &av);
2476 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
2477 goto erret;
2478 }
2479 retval = TRUE;
2480
2481 erret:
2482 AsnUnlinkType(orig); /* unlink local tree */
2483 return retval;
2484 }
2485
2486
2487
2488 /**************************************************
2489 *
2490 * MimPageNew()
2491 *
2492 **************************************************/
2493 NLM_EXTERN
2494 MimPagePtr LIBCALL
MimPageNew(void)2495 MimPageNew(void)
2496 {
2497 MimPagePtr ptr = MemNew((size_t) sizeof(MimPage));
2498
2499 return ptr;
2500
2501 }
2502
2503
2504 /**************************************************
2505 *
2506 * MimPageFree()
2507 *
2508 **************************************************/
2509 NLM_EXTERN
2510 MimPagePtr LIBCALL
MimPageFree(MimPagePtr ptr)2511 MimPageFree(MimPagePtr ptr)
2512 {
2513
2514 if(ptr == NULL) {
2515 return NULL;
2516 }
2517 MemFree(ptr -> from);
2518 MemFree(ptr -> to);
2519 return MemFree(ptr);
2520 }
2521
2522
2523 /**************************************************
2524 *
2525 * MimPageAsnRead()
2526 *
2527 **************************************************/
2528 NLM_EXTERN
2529 MimPagePtr LIBCALL
MimPageAsnRead(AsnIoPtr aip,AsnTypePtr orig)2530 MimPageAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2531 {
2532 DataVal av;
2533 AsnTypePtr atp;
2534 Boolean isError = FALSE;
2535 AsnReadFunc func;
2536 MimPagePtr ptr;
2537
2538 if (! loaded)
2539 {
2540 if (! objmimAsnLoad()) {
2541 return NULL;
2542 }
2543 }
2544
2545 if (aip == NULL) {
2546 return NULL;
2547 }
2548
2549 if (orig == NULL) { /* MimPage ::= (self contained) */
2550 atp = AsnReadId(aip, amp, MIM_PAGE);
2551 } else {
2552 atp = AsnLinkType(orig, MIM_PAGE);
2553 }
2554 /* link in local tree */
2555 if (atp == NULL) {
2556 return NULL;
2557 }
2558
2559 ptr = MimPageNew();
2560 if (ptr == NULL) {
2561 goto erret;
2562 }
2563 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
2564 goto erret;
2565 }
2566
2567 atp = AsnReadId(aip,amp, atp);
2568 func = NULL;
2569
2570 if (atp == MIM_PAGE_from) {
2571 if ( AsnReadVal(aip, atp, &av) <= 0) {
2572 goto erret;
2573 }
2574 ptr -> from = av.ptrvalue;
2575 atp = AsnReadId(aip,amp, atp);
2576 }
2577 if (atp == MIM_PAGE_to) {
2578 if ( AsnReadVal(aip, atp, &av) <= 0) {
2579 goto erret;
2580 }
2581 ptr -> to = av.ptrvalue;
2582 atp = AsnReadId(aip,amp, atp);
2583 }
2584
2585 if (AsnReadVal(aip, atp, &av) <= 0) {
2586 goto erret;
2587 }
2588 /* end struct */
2589
2590 ret:
2591 AsnUnlinkType(orig); /* unlink local tree */
2592 return ptr;
2593
2594 erret:
2595 aip -> io_failure = TRUE;
2596 ptr = MimPageFree(ptr);
2597 goto ret;
2598 }
2599
2600
2601
2602 /**************************************************
2603 *
2604 * MimPageAsnWrite()
2605 *
2606 **************************************************/
2607 NLM_EXTERN Boolean LIBCALL
MimPageAsnWrite(MimPagePtr ptr,AsnIoPtr aip,AsnTypePtr orig)2608 MimPageAsnWrite(MimPagePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
2609 {
2610 DataVal av;
2611 AsnTypePtr atp;
2612 Boolean retval = FALSE;
2613
2614 if (! loaded)
2615 {
2616 if (! objmimAsnLoad()) {
2617 return FALSE;
2618 }
2619 }
2620
2621 if (aip == NULL) {
2622 return FALSE;
2623 }
2624
2625 atp = AsnLinkType(orig, MIM_PAGE); /* link local tree */
2626 if (atp == NULL) {
2627 return FALSE;
2628 }
2629
2630 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2631 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
2632 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
2633 goto erret;
2634 }
2635
2636 if (ptr -> from != NULL) {
2637 av.ptrvalue = ptr -> from;
2638 retval = AsnWrite(aip, MIM_PAGE_from, &av);
2639 }
2640 if (ptr -> to != NULL) {
2641 av.ptrvalue = ptr -> to;
2642 retval = AsnWrite(aip, MIM_PAGE_to, &av);
2643 }
2644 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
2645 goto erret;
2646 }
2647 retval = TRUE;
2648
2649 erret:
2650 AsnUnlinkType(orig); /* unlink local tree */
2651 return retval;
2652 }
2653
2654