1 #include <asn.h>
2
3 #define NLM_GENERATED_CODE_PROTO
4
5 #include <objvalid.h>
6
7 static Boolean loaded = FALSE;
8
9 #include <asnvalid.h>
10
11 #ifndef NLM_EXTERN_LOADS
12 #define NLM_EXTERN_LOADS {}
13 #endif
14
15 NLM_EXTERN Boolean LIBCALL
objvalidAsnLoad(void)16 objvalidAsnLoad(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 //LCOV_EXCL_START
31
32 /**************************************************
33 * Generated object loaders for Module NCBI-Structured-comment-validation
34 * Generated using ASNCODE Revision: 6.19 at Jul 22, 2013 2:43 PM
35 *
36 **************************************************/
37
38
39 /**************************************************
40 *
41 * FieldRuleNew()
42 *
43 **************************************************/
44 NLM_EXTERN
45 FieldRulePtr LIBCALL
FieldRuleNew(void)46 FieldRuleNew(void)
47 {
48 FieldRulePtr ptr = MemNew((size_t) sizeof(FieldRule));
49
50 ptr -> required = 0;
51 ptr -> severity = 2;
52 return ptr;
53
54 }
55
56
57 /**************************************************
58 *
59 * FieldRuleFree()
60 *
61 **************************************************/
62 NLM_EXTERN
63 FieldRulePtr LIBCALL
FieldRuleFree(FieldRulePtr ptr)64 FieldRuleFree(FieldRulePtr ptr)
65 {
66
67 if(ptr == NULL) {
68 return NULL;
69 }
70 MemFree(ptr -> field_name);
71 MemFree(ptr -> match_expression);
72 return MemFree(ptr);
73 }
74
75
76 /**************************************************
77 *
78 * FieldRuleAsnRead()
79 *
80 **************************************************/
81 NLM_EXTERN
82 FieldRulePtr LIBCALL
FieldRuleAsnRead(AsnIoPtr aip,AsnTypePtr orig)83 FieldRuleAsnRead(AsnIoPtr aip, AsnTypePtr orig)
84 {
85 DataVal av;
86 AsnTypePtr atp;
87 Boolean isError = FALSE;
88 AsnReadFunc func;
89 FieldRulePtr ptr;
90
91 if (! loaded)
92 {
93 if (! objvalidAsnLoad()) {
94 return NULL;
95 }
96 }
97
98 if (aip == NULL) {
99 return NULL;
100 }
101
102 if (orig == NULL) { /* FieldRule ::= (self contained) */
103 atp = AsnReadId(aip, amp, FIELD_RULE);
104 } else {
105 atp = AsnLinkType(orig, FIELD_RULE);
106 }
107 /* link in local tree */
108 if (atp == NULL) {
109 return NULL;
110 }
111
112 ptr = FieldRuleNew();
113 if (ptr == NULL) {
114 goto erret;
115 }
116 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
117 goto erret;
118 }
119
120 atp = AsnReadId(aip,amp, atp);
121 func = NULL;
122
123 if (atp == FIELD_RULE_field_name) {
124 if ( AsnReadVal(aip, atp, &av) <= 0) {
125 goto erret;
126 }
127 ptr -> field_name = av.ptrvalue;
128 atp = AsnReadId(aip,amp, atp);
129 }
130 if (atp == FIELD_RULE_match_expression) {
131 if ( AsnReadVal(aip, atp, &av) <= 0) {
132 goto erret;
133 }
134 ptr -> match_expression = av.ptrvalue;
135 atp = AsnReadId(aip,amp, atp);
136 }
137 if (atp == FIELD_RULE_required) {
138 if ( AsnReadVal(aip, atp, &av) <= 0) {
139 goto erret;
140 }
141 ptr -> required = av.boolvalue;
142 atp = AsnReadId(aip,amp, atp);
143 }
144 if (atp == FIELD_RULE_severity) {
145 if ( AsnReadVal(aip, atp, &av) <= 0) {
146 goto erret;
147 }
148 ptr -> severity = av.intvalue;
149 atp = AsnReadId(aip,amp, atp);
150 }
151
152 if (AsnReadVal(aip, atp, &av) <= 0) {
153 goto erret;
154 }
155 /* end struct */
156
157 ret:
158 AsnUnlinkType(orig); /* unlink local tree */
159 return ptr;
160
161 erret:
162 aip -> io_failure = TRUE;
163 ptr = FieldRuleFree(ptr);
164 goto ret;
165 }
166
167
168
169 /**************************************************
170 *
171 * FieldRuleAsnWrite()
172 *
173 **************************************************/
174 NLM_EXTERN Boolean LIBCALL
FieldRuleAsnWrite(FieldRulePtr ptr,AsnIoPtr aip,AsnTypePtr orig)175 FieldRuleAsnWrite(FieldRulePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
176 {
177 DataVal av;
178 AsnTypePtr atp;
179 Boolean retval = FALSE;
180
181 if (! loaded)
182 {
183 if (! objvalidAsnLoad()) {
184 return FALSE;
185 }
186 }
187
188 if (aip == NULL) {
189 return FALSE;
190 }
191
192 atp = AsnLinkType(orig, FIELD_RULE); /* link local tree */
193 if (atp == NULL) {
194 return FALSE;
195 }
196
197 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
198
199 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
200
201 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
202 goto erret;
203 }
204
205 if (ptr -> field_name != NULL) {
206 av.ptrvalue = ptr -> field_name;
207 retval = AsnWrite(aip, FIELD_RULE_field_name, &av);
208 }
209 if (ptr -> match_expression != NULL) {
210 av.ptrvalue = ptr -> match_expression;
211 retval = AsnWrite(aip, FIELD_RULE_match_expression, &av);
212 }
213 av.boolvalue = ptr -> required;
214 retval = AsnWrite(aip, FIELD_RULE_required, &av);
215 av.intvalue = ptr -> severity;
216 retval = AsnWrite(aip, FIELD_RULE_severity, &av);
217 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
218 goto erret;
219 }
220 retval = TRUE;
221
222 erret:
223 AsnUnlinkType(orig); /* unlink local tree */
224 return retval;
225 }
226
227
228
229 /**************************************************
230 *
231 * FieldSetFree()
232 *
233 **************************************************/
234 NLM_EXTERN
235 FieldSetPtr LIBCALL
FieldSetFree(FieldSetPtr ptr)236 FieldSetFree(FieldSetPtr ptr)
237 {
238
239 if(ptr == NULL) {
240 return NULL;
241 }
242 AsnGenericUserSeqOfFree(ptr, (AsnOptFreeFunc) FieldRuleFree);
243 return NULL;
244 }
245
246
247 /**************************************************
248 *
249 * FieldSetAsnRead()
250 *
251 **************************************************/
252 NLM_EXTERN
253 FieldSetPtr LIBCALL
FieldSetAsnRead(AsnIoPtr aip,AsnTypePtr orig)254 FieldSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
255 {
256 DataVal av;
257 AsnTypePtr atp;
258 Boolean isError = FALSE;
259 AsnReadFunc func;
260 FieldSetPtr ptr;
261
262 if (! loaded)
263 {
264 if (! objvalidAsnLoad()) {
265 return NULL;
266 }
267 }
268
269 if (aip == NULL) {
270 return NULL;
271 }
272
273 if (orig == NULL) { /* FieldSet ::= (self contained) */
274 atp = AsnReadId(aip, amp, FIELD_SET);
275 } else {
276 atp = AsnLinkType(orig, FIELD_SET);
277 }
278 /* link in local tree */
279 if (atp == NULL) {
280 return NULL;
281 }
282
283 func = NULL;
284
285 ptr = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) FieldRuleAsnRead, (AsnOptFreeFunc) FieldRuleFree);
286 if (isError && ptr == NULL) {
287 goto erret;
288 }
289
290
291
292 ret:
293 AsnUnlinkType(orig); /* unlink local tree */
294 return ptr;
295
296 erret:
297 aip -> io_failure = TRUE;
298 ptr = FieldSetFree(ptr);
299 goto ret;
300 }
301
302
303
304 /**************************************************
305 *
306 * FieldSetAsnWrite()
307 *
308 **************************************************/
309 NLM_EXTERN Boolean LIBCALL
FieldSetAsnWrite(FieldSetPtr ptr,AsnIoPtr aip,AsnTypePtr orig)310 FieldSetAsnWrite(FieldSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
311 {
312 DataVal av;
313 AsnTypePtr atp;
314 Boolean retval = FALSE;
315
316 if (! loaded)
317 {
318 if (! objvalidAsnLoad()) {
319 return FALSE;
320 }
321 }
322
323 if (aip == NULL) {
324 return FALSE;
325 }
326
327 atp = AsnLinkType(orig, FIELD_SET); /* link local tree */
328 if (atp == NULL) {
329 return FALSE;
330 }
331
332 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
333
334 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
335
336 retval = AsnGenericUserSeqOfAsnWrite(ptr , (AsnWriteFunc) FieldRuleAsnWrite, aip, atp, FIELD_SET_E);
337 retval = TRUE;
338
339 erret:
340 AsnUnlinkType(orig); /* unlink local tree */
341 return retval;
342 }
343
344
345
346 /**************************************************
347 *
348 * DependentFieldRuleNew()
349 *
350 **************************************************/
351 NLM_EXTERN
352 DependentFieldRulePtr LIBCALL
DependentFieldRuleNew(void)353 DependentFieldRuleNew(void)
354 {
355 DependentFieldRulePtr ptr = MemNew((size_t) sizeof(DependentFieldRule));
356
357 ptr -> invert_match = 0;
358 return ptr;
359
360 }
361
362
363 /**************************************************
364 *
365 * DependentFieldRuleFree()
366 *
367 **************************************************/
368 NLM_EXTERN
369 DependentFieldRulePtr LIBCALL
DependentFieldRuleFree(DependentFieldRulePtr ptr)370 DependentFieldRuleFree(DependentFieldRulePtr ptr)
371 {
372
373 if(ptr == NULL) {
374 return NULL;
375 }
376 MemFree(ptr -> match_name);
377 MemFree(ptr -> value_constraint);
378 FieldSetFree(ptr -> other_fields);
379 FieldSetFree(ptr -> disallowed_fields);
380 return MemFree(ptr);
381 }
382
383
384 /**************************************************
385 *
386 * DependentFieldRuleAsnRead()
387 *
388 **************************************************/
389 NLM_EXTERN
390 DependentFieldRulePtr LIBCALL
DependentFieldRuleAsnRead(AsnIoPtr aip,AsnTypePtr orig)391 DependentFieldRuleAsnRead(AsnIoPtr aip, AsnTypePtr orig)
392 {
393 DataVal av;
394 AsnTypePtr atp;
395 Boolean isError = FALSE;
396 AsnReadFunc func;
397 DependentFieldRulePtr ptr;
398
399 if (! loaded)
400 {
401 if (! objvalidAsnLoad()) {
402 return NULL;
403 }
404 }
405
406 if (aip == NULL) {
407 return NULL;
408 }
409
410 if (orig == NULL) { /* DependentFieldRule ::= (self contained) */
411 atp = AsnReadId(aip, amp, DEPENDENT_FIELD_RULE);
412 } else {
413 atp = AsnLinkType(orig, DEPENDENT_FIELD_RULE);
414 }
415 /* link in local tree */
416 if (atp == NULL) {
417 return NULL;
418 }
419
420 ptr = DependentFieldRuleNew();
421 if (ptr == NULL) {
422 goto erret;
423 }
424 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
425 goto erret;
426 }
427
428 atp = AsnReadId(aip,amp, atp);
429 func = NULL;
430
431 if (atp == DEPENDENT_FIELD_RULE_match_name) {
432 if ( AsnReadVal(aip, atp, &av) <= 0) {
433 goto erret;
434 }
435 ptr -> match_name = av.ptrvalue;
436 atp = AsnReadId(aip,amp, atp);
437 }
438 if (atp == FIELD_RULE_value_constraint) {
439 if ( AsnReadVal(aip, atp, &av) <= 0) {
440 goto erret;
441 }
442 ptr -> value_constraint = av.ptrvalue;
443 atp = AsnReadId(aip,amp, atp);
444 }
445 if (atp == FIELD_RULE_invert_match) {
446 if ( AsnReadVal(aip, atp, &av) <= 0) {
447 goto erret;
448 }
449 ptr -> invert_match = av.boolvalue;
450 atp = AsnReadId(aip,amp, atp);
451 }
452 if (atp == FIELD_RULE_other_fields) {
453 ptr -> other_fields = FieldSetAsnRead(aip, atp);
454 if (aip -> io_failure) {
455 goto erret;
456 }
457 atp = AsnReadId(aip,amp, atp);
458 }
459 if (atp == FIELD_RULE_disallowed_fields) {
460 ptr -> disallowed_fields = FieldSetAsnRead(aip, atp);
461 if (aip -> io_failure) {
462 goto erret;
463 }
464 atp = AsnReadId(aip,amp, atp);
465 }
466
467 if (AsnReadVal(aip, atp, &av) <= 0) {
468 goto erret;
469 }
470 /* end struct */
471
472 ret:
473 AsnUnlinkType(orig); /* unlink local tree */
474 return ptr;
475
476 erret:
477 aip -> io_failure = TRUE;
478 ptr = DependentFieldRuleFree(ptr);
479 goto ret;
480 }
481
482
483
484 /**************************************************
485 *
486 * DependentFieldRuleAsnWrite()
487 *
488 **************************************************/
489 NLM_EXTERN Boolean LIBCALL
DependentFieldRuleAsnWrite(DependentFieldRulePtr ptr,AsnIoPtr aip,AsnTypePtr orig)490 DependentFieldRuleAsnWrite(DependentFieldRulePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
491 {
492 DataVal av;
493 AsnTypePtr atp;
494 Boolean retval = FALSE;
495
496 if (! loaded)
497 {
498 if (! objvalidAsnLoad()) {
499 return FALSE;
500 }
501 }
502
503 if (aip == NULL) {
504 return FALSE;
505 }
506
507 atp = AsnLinkType(orig, DEPENDENT_FIELD_RULE); /* link local tree */
508 if (atp == NULL) {
509 return FALSE;
510 }
511
512 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
513
514 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
515
516 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
517 goto erret;
518 }
519
520 if (ptr -> match_name != NULL) {
521 av.ptrvalue = ptr -> match_name;
522 retval = AsnWrite(aip, DEPENDENT_FIELD_RULE_match_name, &av);
523 }
524 if (ptr -> value_constraint != NULL) {
525 av.ptrvalue = ptr -> value_constraint;
526 retval = AsnWrite(aip, FIELD_RULE_value_constraint, &av);
527 }
528 av.boolvalue = ptr -> invert_match;
529 retval = AsnWrite(aip, FIELD_RULE_invert_match, &av);
530 if (ptr -> other_fields != NULL) {
531 if ( ! FieldSetAsnWrite(ptr -> other_fields, aip, FIELD_RULE_other_fields)) {
532 goto erret;
533 }
534 }
535 if (ptr -> disallowed_fields != NULL) {
536 if ( ! FieldSetAsnWrite(ptr -> disallowed_fields, aip, FIELD_RULE_disallowed_fields)) {
537 goto erret;
538 }
539 }
540 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
541 goto erret;
542 }
543 retval = TRUE;
544
545 erret:
546 AsnUnlinkType(orig); /* unlink local tree */
547 return retval;
548 }
549
550
551
552 /**************************************************
553 *
554 * DependentFieldSetFree()
555 *
556 **************************************************/
557 NLM_EXTERN
558 DependentFieldSetPtr LIBCALL
DependentFieldSetFree(DependentFieldSetPtr ptr)559 DependentFieldSetFree(DependentFieldSetPtr ptr)
560 {
561
562 if(ptr == NULL) {
563 return NULL;
564 }
565 AsnGenericUserSeqOfFree(ptr, (AsnOptFreeFunc) DependentFieldRuleFree);
566 return NULL;
567 }
568
569
570 /**************************************************
571 *
572 * DependentFieldSetAsnRead()
573 *
574 **************************************************/
575 NLM_EXTERN
576 DependentFieldSetPtr LIBCALL
DependentFieldSetAsnRead(AsnIoPtr aip,AsnTypePtr orig)577 DependentFieldSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
578 {
579 DataVal av;
580 AsnTypePtr atp;
581 Boolean isError = FALSE;
582 AsnReadFunc func;
583 DependentFieldSetPtr ptr;
584
585 if (! loaded)
586 {
587 if (! objvalidAsnLoad()) {
588 return NULL;
589 }
590 }
591
592 if (aip == NULL) {
593 return NULL;
594 }
595
596 if (orig == NULL) { /* DependentFieldSet ::= (self contained) */
597 atp = AsnReadId(aip, amp, DEPENDENT_FIELD_SET);
598 } else {
599 atp = AsnLinkType(orig, DEPENDENT_FIELD_SET);
600 }
601 /* link in local tree */
602 if (atp == NULL) {
603 return NULL;
604 }
605
606 func = NULL;
607
608 ptr = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) DependentFieldRuleAsnRead, (AsnOptFreeFunc) DependentFieldRuleFree);
609 if (isError && ptr == NULL) {
610 goto erret;
611 }
612
613
614
615 ret:
616 AsnUnlinkType(orig); /* unlink local tree */
617 return ptr;
618
619 erret:
620 aip -> io_failure = TRUE;
621 ptr = DependentFieldSetFree(ptr);
622 goto ret;
623 }
624
625
626
627 /**************************************************
628 *
629 * DependentFieldSetAsnWrite()
630 *
631 **************************************************/
632 NLM_EXTERN Boolean LIBCALL
DependentFieldSetAsnWrite(DependentFieldSetPtr ptr,AsnIoPtr aip,AsnTypePtr orig)633 DependentFieldSetAsnWrite(DependentFieldSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
634 {
635 DataVal av;
636 AsnTypePtr atp;
637 Boolean retval = FALSE;
638
639 if (! loaded)
640 {
641 if (! objvalidAsnLoad()) {
642 return FALSE;
643 }
644 }
645
646 if (aip == NULL) {
647 return FALSE;
648 }
649
650 atp = AsnLinkType(orig, DEPENDENT_FIELD_SET); /* link local tree */
651 if (atp == NULL) {
652 return FALSE;
653 }
654
655 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
656
657 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
658
659 retval = AsnGenericUserSeqOfAsnWrite(ptr , (AsnWriteFunc) DependentFieldRuleAsnWrite, aip, atp, DEPENDENT_FIELD_SET_E);
660 retval = TRUE;
661
662 erret:
663 AsnUnlinkType(orig); /* unlink local tree */
664 return retval;
665 }
666
667
668
669 /**************************************************
670 *
671 * CommentRuleNew()
672 *
673 **************************************************/
674 NLM_EXTERN
675 CommentRulePtr LIBCALL
CommentRuleNew(void)676 CommentRuleNew(void)
677 {
678 CommentRulePtr ptr = MemNew((size_t) sizeof(CommentRule));
679
680 ptr -> updated = 0;
681 ptr -> require_order = 1;
682 ptr -> allow_unlisted = 0;
683 return ptr;
684
685 }
686
687
688 /**************************************************
689 *
690 * CommentRuleFree()
691 *
692 **************************************************/
693 NLM_EXTERN
694 CommentRulePtr LIBCALL
CommentRuleFree(CommentRulePtr ptr)695 CommentRuleFree(CommentRulePtr ptr)
696 {
697
698 if(ptr == NULL) {
699 return NULL;
700 }
701 MemFree(ptr -> prefix);
702 FieldSetFree(ptr -> fields);
703 DependentFieldSetFree(ptr -> dependent_rules);
704 PhraseListFree(ptr -> forbidden_phrases);
705 return MemFree(ptr);
706 }
707
708
709 /**************************************************
710 *
711 * CommentRuleAsnRead()
712 *
713 **************************************************/
714 NLM_EXTERN
715 CommentRulePtr LIBCALL
CommentRuleAsnRead(AsnIoPtr aip,AsnTypePtr orig)716 CommentRuleAsnRead(AsnIoPtr aip, AsnTypePtr orig)
717 {
718 DataVal av;
719 AsnTypePtr atp;
720 Boolean isError = FALSE;
721 AsnReadFunc func;
722 CommentRulePtr ptr;
723
724 if (! loaded)
725 {
726 if (! objvalidAsnLoad()) {
727 return NULL;
728 }
729 }
730
731 if (aip == NULL) {
732 return NULL;
733 }
734
735 if (orig == NULL) { /* CommentRule ::= (self contained) */
736 atp = AsnReadId(aip, amp, COMMENT_RULE);
737 } else {
738 atp = AsnLinkType(orig, COMMENT_RULE);
739 }
740 /* link in local tree */
741 if (atp == NULL) {
742 return NULL;
743 }
744
745 ptr = CommentRuleNew();
746 if (ptr == NULL) {
747 goto erret;
748 }
749 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
750 goto erret;
751 }
752
753 atp = AsnReadId(aip,amp, atp);
754 func = NULL;
755
756 if (atp == COMMENT_RULE_prefix) {
757 if ( AsnReadVal(aip, atp, &av) <= 0) {
758 goto erret;
759 }
760 ptr -> prefix = av.ptrvalue;
761 atp = AsnReadId(aip,amp, atp);
762 }
763 if (atp == COMMENT_RULE_updated) {
764 if ( AsnReadVal(aip, atp, &av) <= 0) {
765 goto erret;
766 }
767 ptr -> updated = av.boolvalue;
768 atp = AsnReadId(aip,amp, atp);
769 }
770 if (atp == COMMENT_RULE_fields) {
771 ptr -> fields = FieldSetAsnRead(aip, atp);
772 if (aip -> io_failure) {
773 goto erret;
774 }
775 atp = AsnReadId(aip,amp, atp);
776 }
777 if (atp == COMMENT_RULE_require_order) {
778 if ( AsnReadVal(aip, atp, &av) <= 0) {
779 goto erret;
780 }
781 ptr -> require_order = av.boolvalue;
782 atp = AsnReadId(aip,amp, atp);
783 }
784 if (atp == COMMENT_RULE_allow_unlisted) {
785 if ( AsnReadVal(aip, atp, &av) <= 0) {
786 goto erret;
787 }
788 ptr -> allow_unlisted = av.boolvalue;
789 atp = AsnReadId(aip,amp, atp);
790 }
791 if (atp == COMMENT_RULE_dependent_rules) {
792 ptr -> dependent_rules = DependentFieldSetAsnRead(aip, atp);
793 if (aip -> io_failure) {
794 goto erret;
795 }
796 atp = AsnReadId(aip,amp, atp);
797 }
798 if (atp == COMMENT_RULE_forbidden_phrases) {
799 ptr -> forbidden_phrases = PhraseListAsnRead(aip, atp);
800 if (aip -> io_failure) {
801 goto erret;
802 }
803 atp = AsnReadId(aip,amp, atp);
804 }
805
806 if (AsnReadVal(aip, atp, &av) <= 0) {
807 goto erret;
808 }
809 /* end struct */
810
811 ret:
812 AsnUnlinkType(orig); /* unlink local tree */
813 return ptr;
814
815 erret:
816 aip -> io_failure = TRUE;
817 ptr = CommentRuleFree(ptr);
818 goto ret;
819 }
820
821
822
823 /**************************************************
824 *
825 * CommentRuleAsnWrite()
826 *
827 **************************************************/
828 NLM_EXTERN Boolean LIBCALL
CommentRuleAsnWrite(CommentRulePtr ptr,AsnIoPtr aip,AsnTypePtr orig)829 CommentRuleAsnWrite(CommentRulePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
830 {
831 DataVal av;
832 AsnTypePtr atp;
833 Boolean retval = FALSE;
834
835 if (! loaded)
836 {
837 if (! objvalidAsnLoad()) {
838 return FALSE;
839 }
840 }
841
842 if (aip == NULL) {
843 return FALSE;
844 }
845
846 atp = AsnLinkType(orig, COMMENT_RULE); /* link local tree */
847 if (atp == NULL) {
848 return FALSE;
849 }
850
851 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
852
853 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
854
855 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
856 goto erret;
857 }
858
859 if (ptr -> prefix != NULL) {
860 av.ptrvalue = ptr -> prefix;
861 retval = AsnWrite(aip, COMMENT_RULE_prefix, &av);
862 }
863 av.boolvalue = ptr -> updated;
864 retval = AsnWrite(aip, COMMENT_RULE_updated, &av);
865 if (ptr -> fields != NULL) {
866 if ( ! FieldSetAsnWrite(ptr -> fields, aip, COMMENT_RULE_fields)) {
867 goto erret;
868 }
869 }
870 av.boolvalue = ptr -> require_order;
871 retval = AsnWrite(aip, COMMENT_RULE_require_order, &av);
872 av.boolvalue = ptr -> allow_unlisted;
873 retval = AsnWrite(aip, COMMENT_RULE_allow_unlisted, &av);
874 if (ptr -> dependent_rules != NULL) {
875 if ( ! DependentFieldSetAsnWrite(ptr -> dependent_rules, aip, COMMENT_RULE_dependent_rules)) {
876 goto erret;
877 }
878 }
879 if (ptr -> forbidden_phrases != NULL) {
880 if ( ! PhraseListAsnWrite(ptr -> forbidden_phrases, aip, COMMENT_RULE_forbidden_phrases)) {
881 goto erret;
882 }
883 }
884 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
885 goto erret;
886 }
887 retval = TRUE;
888
889 erret:
890 AsnUnlinkType(orig); /* unlink local tree */
891 return retval;
892 }
893
894
895
896 /**************************************************
897 *
898 * CommentSetFree()
899 *
900 **************************************************/
901 NLM_EXTERN
902 CommentSetPtr LIBCALL
CommentSetFree(CommentSetPtr ptr)903 CommentSetFree(CommentSetPtr ptr)
904 {
905
906 if(ptr == NULL) {
907 return NULL;
908 }
909 AsnGenericUserSeqOfFree(ptr, (AsnOptFreeFunc) CommentRuleFree);
910 return NULL;
911 }
912
913
914 /**************************************************
915 *
916 * CommentSetAsnRead()
917 *
918 **************************************************/
919 NLM_EXTERN
920 CommentSetPtr LIBCALL
CommentSetAsnRead(AsnIoPtr aip,AsnTypePtr orig)921 CommentSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
922 {
923 DataVal av;
924 AsnTypePtr atp;
925 Boolean isError = FALSE;
926 AsnReadFunc func;
927 CommentSetPtr ptr;
928
929 if (! loaded)
930 {
931 if (! objvalidAsnLoad()) {
932 return NULL;
933 }
934 }
935
936 if (aip == NULL) {
937 return NULL;
938 }
939
940 if (orig == NULL) { /* CommentSet ::= (self contained) */
941 atp = AsnReadId(aip, amp, COMMENT_SET);
942 } else {
943 atp = AsnLinkType(orig, COMMENT_SET);
944 }
945 /* link in local tree */
946 if (atp == NULL) {
947 return NULL;
948 }
949
950 func = NULL;
951
952 ptr = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) CommentRuleAsnRead, (AsnOptFreeFunc) CommentRuleFree);
953 if (isError && ptr == NULL) {
954 goto erret;
955 }
956
957
958
959 ret:
960 AsnUnlinkType(orig); /* unlink local tree */
961 return ptr;
962
963 erret:
964 aip -> io_failure = TRUE;
965 ptr = CommentSetFree(ptr);
966 goto ret;
967 }
968
969
970
971 /**************************************************
972 *
973 * CommentSetAsnWrite()
974 *
975 **************************************************/
976 NLM_EXTERN Boolean LIBCALL
CommentSetAsnWrite(CommentSetPtr ptr,AsnIoPtr aip,AsnTypePtr orig)977 CommentSetAsnWrite(CommentSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
978 {
979 DataVal av;
980 AsnTypePtr atp;
981 Boolean retval = FALSE;
982
983 if (! loaded)
984 {
985 if (! objvalidAsnLoad()) {
986 return FALSE;
987 }
988 }
989
990 if (aip == NULL) {
991 return FALSE;
992 }
993
994 atp = AsnLinkType(orig, COMMENT_SET); /* link local tree */
995 if (atp == NULL) {
996 return FALSE;
997 }
998
999 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1000
1001 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1002
1003 retval = AsnGenericUserSeqOfAsnWrite(ptr , (AsnWriteFunc) CommentRuleAsnWrite, aip, atp, COMMENT_SET_E);
1004 retval = TRUE;
1005
1006 erret:
1007 AsnUnlinkType(orig); /* unlink local tree */
1008 return retval;
1009 }
1010
1011
1012
1013 /**************************************************
1014 *
1015 * PhraseListFree()
1016 *
1017 **************************************************/
1018 NLM_EXTERN
1019 PhraseListPtr LIBCALL
PhraseListFree(PhraseListPtr ptr)1020 PhraseListFree(PhraseListPtr ptr)
1021 {
1022
1023 if(ptr == NULL) {
1024 return NULL;
1025 }
1026 AsnGenericBaseSeqOfFree(ptr,ASNCODE_PTRVAL_SLOT);
1027 return NULL;
1028 }
1029
1030
1031 /**************************************************
1032 *
1033 * PhraseListAsnRead()
1034 *
1035 **************************************************/
1036 NLM_EXTERN
1037 PhraseListPtr LIBCALL
PhraseListAsnRead(AsnIoPtr aip,AsnTypePtr orig)1038 PhraseListAsnRead(AsnIoPtr aip, AsnTypePtr orig)
1039 {
1040 DataVal av;
1041 AsnTypePtr atp;
1042 Boolean isError = FALSE;
1043 AsnReadFunc func;
1044 PhraseListPtr ptr;
1045
1046 if (! loaded)
1047 {
1048 if (! objvalidAsnLoad()) {
1049 return NULL;
1050 }
1051 }
1052
1053 if (aip == NULL) {
1054 return NULL;
1055 }
1056
1057 if (orig == NULL) { /* PhraseList ::= (self contained) */
1058 atp = AsnReadId(aip, amp, PHRASE_LIST);
1059 } else {
1060 atp = AsnLinkType(orig, PHRASE_LIST);
1061 }
1062 /* link in local tree */
1063 if (atp == NULL) {
1064 return NULL;
1065 }
1066
1067 func = NULL;
1068
1069 ptr = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
1070 if (isError && ptr == NULL) {
1071 goto erret;
1072 }
1073
1074
1075
1076 ret:
1077 AsnUnlinkType(orig); /* unlink local tree */
1078 return ptr;
1079
1080 erret:
1081 aip -> io_failure = TRUE;
1082 ptr = PhraseListFree(ptr);
1083 goto ret;
1084 }
1085
1086
1087
1088 /**************************************************
1089 *
1090 * PhraseListAsnWrite()
1091 *
1092 **************************************************/
1093 NLM_EXTERN Boolean LIBCALL
PhraseListAsnWrite(PhraseListPtr ptr,AsnIoPtr aip,AsnTypePtr orig)1094 PhraseListAsnWrite(PhraseListPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
1095 {
1096 DataVal av;
1097 AsnTypePtr atp;
1098 Boolean retval = FALSE;
1099
1100 if (! loaded)
1101 {
1102 if (! objvalidAsnLoad()) {
1103 return FALSE;
1104 }
1105 }
1106
1107 if (aip == NULL) {
1108 return FALSE;
1109 }
1110
1111 atp = AsnLinkType(orig, PHRASE_LIST); /* link local tree */
1112 if (atp == NULL) {
1113 return FALSE;
1114 }
1115
1116 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1117
1118 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1119
1120 retval = AsnGenericBaseSeqOfAsnWrite(ptr, ASNCODE_PTRVAL_SLOT, aip, atp, PHRASE_LIST_E);
1121 retval = TRUE;
1122
1123 erret:
1124 AsnUnlinkType(orig); /* unlink local tree */
1125 return retval;
1126 }
1127
1128 //LCOV_EXCL_STOP