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