1 /* objneten.c
2 * ===========================================================================
3 *
4 * PUBLIC DOMAIN NOTICE
5 * National Center for Biotechnology Information
6 *
7 * This software/database is a "United States Government Work" under the
8 * terms of the United States Copyright Act. It was written as part of
9 * the author's official duties as a United States Government employee and
10 * thus cannot be copyrighted. This software/database is freely available
11 * to the public for use. The National Library of Medicine and the U.S.
12 * Government have not placed any restriction on its use or reproduction.
13 *
14 * Although all reasonable efforts have been taken to ensure the accuracy
15 * and reliability of the software and data, the NLM and the U.S.
16 * Government do not and cannot warrant the performance or results that
17 * may be obtained by using this software or data. The NLM and the U.S.
18 * Government disclaim all warranties, express or implied, including
19 * warranties of performance, merchantability or fitness for any particular
20 * purpose.
21 *
22 * Please cite the author in any work or product based on this material.
23 *
24 * ===========================================================================
25 *
26 * File Name: objneten.c
27 *
28 * Author: Epstein
29 *
30 * Version Creation Date: 06/02/92
31 *
32 * $Revision: 6.1 $
33 *
34 * File Description:
35 * object loaders for Network Entrez
36 *
37 * Modifications:
38 * --------------------------------------------------------------------------
39 * Date Name Description of modification
40 * ------- ---------- -----------------------------------------------------
41 * 8-16-94 Brylawski Added loaders for on-the-fly text neighboring
42 (EntrezNeighborText) and EntrezHierarchy
43 * ==========================================================================
44 *
45 *
46 * RCS Modification History:
47 * $Log: objneten.c,v $
48 * Revision 6.1 2001/04/12 22:42:26 juran
49 * Remove unused variable.
50 *
51 * Revision 6.0 1997/08/25 18:35:08 madden
52 * Revision changed to 6.0
53 *
54 * Revision 5.2 1997/07/29 21:24:21 vakatov
55 * [WIN32,DLL] DLL'zation of "netentr.lib"
56 *
57 * Revision 5.1 1996/08/14 19:43:25 epstein
58 * add annot get by feat ids, and also add date filtering support
59 *
60 * Revision 5.0 1996/05/28 14:10:21 ostell
61 * Set to revision 5.0
62 *
63 * Revision 4.2 1995/08/29 15:40:45 epstein
64 * remove obselete ResidueGraphDictionaryLoad reference
65 *
66 * Revision 4.1 1995/08/22 19:35:11 epstein
67 * add clustering support
68 *
69 * Revision 4.0 1995/07/26 13:54:59 ostell
70 * force revision to 4.0
71 *
72 * Revision 1.14 1995/07/11 12:30:36 epstein
73 * change CDECLs to LIBCALLs
74 *
75 * Revision 1.13 1995/07/10 19:38:23 epstein
76 * implement docsumX
77 *
78 * Revision 1.12 1995/06/23 15:58:49 kans
79 * added ResidueGraphDictionaryLoad to initialization
80 *
81 * Revision 1.11 1995/05/17 17:53:30 epstein
82 * add RCS log revision history
83 *
84 */
85
86 #include <asnneten.h> /* the AsnTool header */
87 #include <objacces.h>
88 #include <accentr.h>
89 #include <objmedli.h> /* the Medline interface */
90 #include <objloc.h> /* the 'Seqloc' interface */
91 #include <objsset.h> /* the 'SeqSet' interface */
92 #include <objneten.h> /* the Entrez objects interface */
93 #include <objall.h>
94
95
96 static Boolean loaded = FALSE;
97
98 /*****************************************************************************
99 *
100 * NetEntAsnLoad()
101 *
102 *****************************************************************************/
103 NLM_EXTERN Boolean LIBCALL
NetEntAsnLoad(void)104 NetEntAsnLoad(void)
105 {
106 if (loaded)
107 return TRUE;
108 loaded = TRUE;
109
110 if (! AllObjLoad()) {
111 loaded = FALSE;
112 return FALSE;
113 }
114
115 #ifdef Biostruc_supported
116 objmmdb1AsnLoad ();
117 objmmdb2AsnLoad ();
118 objmmdb3AsnLoad ();
119 #endif
120
121 if (! AsnLoad()) {
122 loaded = FALSE;
123 return FALSE;
124 }
125
126 return TRUE;
127 }
128
129
130 /************************** EntrezIds ****************************************/
131
132 NLM_EXTERN EntrezIdsPtr LIBCALL
EntrezIdsNew(void)133 EntrezIdsNew(void)
134 {
135 EntrezIdsPtr p;
136
137 p = MemNew(sizeof(EntrezIds));
138 if (p != NULL)
139 {
140 p->numid = 0;
141 p->ids = NULL;
142 }
143 return p;
144 }
145
146 NLM_EXTERN EntrezIdsPtr LIBCALL
EntrezIdsFree(EntrezIdsPtr p)147 EntrezIdsFree(EntrezIdsPtr p)
148 {
149 if (p == NULL)
150 return NULL;
151 MemFree (p->ids);
152 return MemFree(p);
153 }
154
155 NLM_EXTERN EntrezIdsPtr LIBCALL
EntrezIdsAsnRead(AsnIoPtr aip,AsnTypePtr orig)156 EntrezIdsAsnRead (AsnIoPtr aip, AsnTypePtr orig)
157 {
158 DataVal av;
159 EntrezIdsPtr p;
160 AsnTypePtr atp;
161 Int4 num;
162
163 if (!NetEntAsnLoad())
164 return NULL;
165
166 if (aip == NULL)
167 return NULL;
168
169 if (orig == NULL)
170 atp = AsnReadId(aip, amp, ENTREZ_IDS);
171 else
172 atp = AsnLinkType(orig, ENTREZ_IDS); /* link in local tree */
173
174 if (atp == NULL)
175 return NULL;
176
177 p = EntrezIdsNew();
178 if (p == NULL)
179 goto erret;
180
181 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
182 goto erret;
183 atp = AsnReadId(aip, amp, atp); /* find the num */
184 if (atp == NULL)
185 goto erret;
186 if (AsnReadVal(aip, atp, &av) <= 0) /* get the num */
187 goto erret;
188 p->numid = av.intvalue;
189
190 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_IDS_ids)
191 goto erret;
192
193 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
194 goto erret;
195
196 p->ids = (DocUidPtr) MemNew(sizeof(DocUid) * (size_t) p->numid);
197 atp = AsnReadId(aip, amp, atp);
198
199 for (num = 0; num < p->numid && atp == ENTREZ_IDS_ids_E; num++)
200 {
201 if (AsnReadVal(aip, atp, &av) <= 0)
202 goto erret;
203 p->ids[num] = av.intvalue;
204 atp = AsnReadId(aip, amp, atp);
205 }
206
207 /* check for count mis-match */
208 if (num != p->numid || atp != ENTREZ_IDS_ids)
209 goto erret;
210
211 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
212 goto erret;
213
214 atp = AsnReadId(aip, amp, atp);
215 if (orig == NULL)
216 {
217 if (atp != ENTREZ_IDS)
218 goto erret;
219 }
220 else { /* check for "close struct" associated with "orig" */
221 if (atp != orig)
222 goto erret;
223 }
224 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
225 goto erret;
226
227 ret:
228 AsnUnlinkType(orig);
229 return p;
230
231 erret:
232 p = EntrezIdsFree(p);
233 goto ret;
234 }
235
236
237 NLM_EXTERN Boolean LIBCALL
EntrezIdsAsnWrite(EntrezIdsPtr p,AsnIoPtr aip,AsnTypePtr orig)238 EntrezIdsAsnWrite (EntrezIdsPtr p, AsnIoPtr aip, AsnTypePtr orig)
239 {
240 DataVal av;
241 Int4 i;
242 AsnTypePtr atp;
243 Boolean retval = FALSE;
244
245 if (! NetEntAsnLoad() )
246 return FALSE;
247
248 if (aip == NULL)
249 return FALSE;
250
251 atp = AsnLinkType(orig, ENTREZ_IDS); /* link local tree */
252
253 if (atp == NULL)
254 return FALSE;
255
256 if (p == NULL)
257 {
258 AsnNullValueMsg(aip, atp);
259 goto erret;
260 }
261
262
263 if (! AsnStartStruct(aip, atp))
264 goto erret;
265 av.intvalue = p->numid;
266 AsnWrite (aip, ENTREZ_IDS_numid, &av);
267
268 AsnStartStruct (aip, ENTREZ_IDS_ids);
269 for (i = 0; i < p->numid; i++)
270 {
271 av.intvalue = p->ids[i];
272 AsnWrite (aip, ENTREZ_IDS_ids_E, &av);
273 }
274 AsnEndStruct (aip, ENTREZ_IDS_ids);
275
276 if (! AsnEndStruct(aip, atp) )
277 goto erret;
278
279 retval = TRUE;
280
281 erret:
282 AsnUnlinkType(orig); /* unlink local tree */
283 return retval;
284 }
285
286 /************************** Marked-link-set **********************************/
287
288 NLM_EXTERN MarkedLinkSetPtr LIBCALL
MarkedLinkSetNew(void)289 MarkedLinkSetNew(void)
290 {
291 MarkedLinkSetPtr p;
292
293 p = MemNew(sizeof(MarkedLinkSet));
294 if (p != NULL)
295 {
296 p->link_set = NULL;
297 p->marked_missing = NULL;
298 }
299 return p;
300 }
301
302 NLM_EXTERN MarkedLinkSetPtr LIBCALL
MarkedLinkSetFree(MarkedLinkSetPtr p)303 MarkedLinkSetFree(MarkedLinkSetPtr p)
304 {
305 if (p == NULL)
306 return NULL;
307 LinkSetFree (p->link_set);
308 EntrezIdsFree (p->marked_missing);
309
310 return MemFree(p);
311 }
312
313 NLM_EXTERN MarkedLinkSetPtr LIBCALL
MarkedLinkSetAsnRead(AsnIoPtr aip,AsnTypePtr orig)314 MarkedLinkSetAsnRead (AsnIoPtr aip, AsnTypePtr orig)
315 {
316 DataVal av;
317 MarkedLinkSetPtr p;
318 EntrezIdsPtr eip;
319 LinkSetPtr lsp;
320 AsnTypePtr atp;
321
322 if (!NetEntAsnLoad())
323 return NULL;
324
325 if (aip == NULL)
326 return NULL;
327
328 if (orig == NULL)
329 atp = AsnReadId(aip, amp, MARKED_LINK_SET);
330 else
331 atp = AsnLinkType(orig, MARKED_LINK_SET); /* link in local tree */
332
333 if (atp == NULL)
334 return NULL;
335
336 p = MarkedLinkSetNew();
337 if (p == NULL)
338 goto erret;
339
340 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
341 goto erret;
342
343 if ((atp = AsnReadId(aip, amp, atp)) != MARKED_LINK_SET_link_set)
344 goto erret;
345
346 lsp = LinkSetAsnRead(aip, atp);
347 if (lsp == NULL)
348 goto erret;
349 p->link_set = lsp;
350
351 if ((atp = AsnReadId(aip, amp, atp)) != MARKED_LINK_SET_uids_processed)
352 goto erret;
353 if (AsnReadVal(aip, atp, &av) <= 0)
354 goto erret;
355 p->uids_processed = av.intvalue;
356
357 if ((atp = AsnReadId(aip, amp, atp)) == MARKED_LINK_SET_marked_missing)
358 { /* optional */
359 eip = EntrezIdsAsnRead(aip, atp);
360 if (eip == NULL)
361 goto erret;
362 p->marked_missing = eip;
363 atp = AsnReadId(aip, amp, atp);
364 }
365
366 if (orig == NULL)
367 {
368 if (atp != MARKED_LINK_SET)
369 goto erret;
370 }
371 else { /* check for "close struct" associated with "orig" */
372 if (atp != orig)
373 goto erret;
374 }
375
376 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
377 goto erret;
378
379 ret:
380 AsnUnlinkType(orig);
381 return p;
382
383 erret:
384 p = MarkedLinkSetFree(p);
385 goto ret;
386 }
387
388 NLM_EXTERN Boolean LIBCALL
MarkedLinkSetAsnWrite(MarkedLinkSetPtr p,AsnIoPtr aip,AsnTypePtr orig)389 MarkedLinkSetAsnWrite (MarkedLinkSetPtr p, AsnIoPtr aip, AsnTypePtr orig)
390 {
391 DataVal av;
392 Boolean retval = FALSE;
393 AsnTypePtr atp;
394
395 if (! NetEntAsnLoad() )
396 return FALSE;
397
398 if (aip == NULL)
399 return FALSE;
400
401 atp = AsnLinkType(orig, MARKED_LINK_SET); /* link local tree */
402
403 if (atp == NULL)
404 return FALSE;
405
406 if (p == NULL)
407 {
408 AsnNullValueMsg(aip, atp);
409 goto erret;
410 }
411
412 if (! AsnStartStruct (aip, atp))
413 goto erret;
414
415 if (! LinkSetAsnWrite(p->link_set, aip, MARKED_LINK_SET_link_set) )
416 goto erret;
417
418 av.intvalue = p->uids_processed;
419 AsnWrite(aip, MARKED_LINK_SET_uids_processed, &av);
420
421 if (p->marked_missing != NULL) /* optional */
422 {
423 if (! EntrezIdsAsnWrite(p->marked_missing, aip, MARKED_LINK_SET_marked_missing) )
424 goto erret;
425 }
426
427 if (! AsnEndStruct(aip, atp))
428 goto erret;
429
430 retval = TRUE;
431
432 erret:
433 AsnUnlinkType(orig); /* unlink local tree */
434 return retval;
435 }
436
437 /************************** Named-List **********************************/
438
439 NLM_EXTERN NamedListPtr LIBCALL
NamedListNew(void)440 NamedListNew(void)
441 {
442 NamedListPtr p;
443
444 p = MemNew(sizeof(NamedList));
445 p->uids = NULL;
446 return p;
447 }
448
449 NLM_EXTERN NamedListPtr LIBCALL
NamedListFree(NamedListPtr p)450 NamedListFree(NamedListPtr p)
451 {
452 if (p == NULL)
453 return NULL;
454 EntrezIdsFree(p->uids);
455
456 return MemFree(p);
457 }
458
459 NLM_EXTERN NamedListPtr LIBCALL
NamedListAsnRead(AsnIoPtr aip,AsnTypePtr orig)460 NamedListAsnRead (AsnIoPtr aip, AsnTypePtr orig)
461 {
462 DataVal av;
463 NamedListPtr p;
464 AsnTypePtr atp;
465
466 if (!NetEntAsnLoad())
467 return NULL;
468
469 if (aip == NULL)
470 return NULL;
471
472 if (orig == NULL)
473 atp = AsnReadId(aip, amp, ENTREZ_NAMED_LIST);
474 else
475 atp = AsnLinkType(orig, ENTREZ_NAMED_LIST); /* link in local tree */
476
477 if (atp == NULL)
478 return NULL;
479
480 p = NamedListNew();
481 if (p == NULL)
482 goto erret;
483
484 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
485 goto erret;
486
487 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_NAMED_LIST_term)
488 goto erret;
489 if (AsnReadVal(aip, atp, &av) <= 0)
490 goto erret;
491 p->term = av.ptrvalue;
492
493 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_NAMED_LIST_type)
494 goto erret;
495 if (AsnReadVal(aip, atp, &av) <= 0)
496 goto erret;
497 p->type = av.intvalue;
498
499 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_NAMED_LIST_fld)
500 goto erret;
501 if (AsnReadVal(aip, atp, &av) <= 0)
502 goto erret;
503 p->fld = av.intvalue;
504
505 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_NAMED_LIST_uids)
506 goto erret;
507 p->uids = EntrezIdsAsnRead(aip, atp);
508 if (p->uids == NULL)
509 goto erret;
510
511 atp = AsnReadId(aip, amp, atp);
512 if (orig == NULL)
513 {
514 if (atp != ENTREZ_NAMED_LIST)
515 goto erret;
516 }
517 else { /* check for "close struct" associated with "orig" */
518 if (atp != orig)
519 goto erret;
520 }
521
522 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
523 goto erret;
524
525 ret:
526 AsnUnlinkType(orig);
527 return p;
528
529 erret:
530 p = NamedListFree(p);
531 goto ret;
532 }
533
534 NLM_EXTERN Boolean LIBCALL
NamedListAsnWrite(NamedListPtr p,AsnIoPtr aip,AsnTypePtr orig)535 NamedListAsnWrite (NamedListPtr p, AsnIoPtr aip, AsnTypePtr orig)
536 {
537 DataVal av;
538 Boolean retval = FALSE;
539 AsnTypePtr atp;
540
541 if (! NetEntAsnLoad() )
542 return FALSE;
543
544 if (aip == NULL)
545 return FALSE;
546
547 atp = AsnLinkType(orig, ENTREZ_NAMED_LIST); /* link local tree */
548
549 if (atp == NULL)
550 return FALSE;
551
552 if (p == NULL)
553 {
554 AsnNullValueMsg(aip, atp);
555 goto erret;
556 }
557
558 if (! AsnStartStruct(aip, atp))
559 goto erret;
560
561 av.ptrvalue = p->term;
562 AsnWrite (aip, ENTREZ_NAMED_LIST_term, &av);
563 av.intvalue = p->type;
564 AsnWrite (aip, ENTREZ_NAMED_LIST_type, &av);
565 av.intvalue = p->fld;
566 AsnWrite (aip, ENTREZ_NAMED_LIST_fld, &av);
567 if (! EntrezIdsAsnWrite(p->uids, aip, ENTREZ_NAMED_LIST_uids) )
568 goto erret;
569
570 if (! AsnEndStruct(aip, atp))
571 goto erret;
572
573 retval = TRUE;
574
575 erret:
576 AsnUnlinkType(orig); /* unlink local tree */
577 return retval;
578 }
579
580 /************************** Term-by-page **********************************/
581
582 NLM_EXTERN TermByPagePtr LIBCALL
TermByPageNew(void)583 TermByPageNew(void)
584 {
585 TermByPagePtr p;
586
587 p = MemNew(sizeof(TermByPage));
588 return p;
589 }
590
591 NLM_EXTERN TermByPagePtr LIBCALL
TermByPageFree(TermByPagePtr p)592 TermByPageFree(TermByPagePtr p)
593 {
594 if (p == NULL)
595 return NULL;
596
597 return MemFree(p);
598 }
599
600 NLM_EXTERN TermByPagePtr LIBCALL
TermByPageAsnRead(AsnIoPtr aip,AsnTypePtr orig)601 TermByPageAsnRead (AsnIoPtr aip, AsnTypePtr orig)
602 {
603 DataVal av;
604 TermByPagePtr p;
605 AsnTypePtr atp;
606
607 if (!NetEntAsnLoad())
608 return NULL;
609
610 if (aip == NULL)
611 return NULL;
612
613 if (orig == NULL)
614 atp = AsnReadId(aip, amp, ENTREZ_TERM_BY_PAGE);
615 else
616 atp = AsnLinkType(orig, ENTREZ_TERM_BY_PAGE); /* link in local tree */
617
618 if (atp == NULL)
619 return NULL;
620
621 p = TermByPageNew();
622 if (p == NULL)
623 goto erret;
624
625 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
626 goto erret;
627
628 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_TERM_BY_PAGE_type)
629 goto erret;
630 if (AsnReadVal(aip, atp, &av) <= 0)
631 goto erret;
632 p->type = av.intvalue;
633
634 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_TERM_BY_PAGE_fld)
635 goto erret;
636 if (AsnReadVal(aip, atp, &av) <= 0)
637 goto erret;
638 p->fld = av.intvalue;
639
640 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_TERM_BY_PAGE_page)
641 goto erret;
642 if (AsnReadVal(aip, atp, &av) <= 0)
643 goto erret;
644 p->page = av.intvalue;
645
646 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_TERM_BY_PAGE_num_pages)
647 goto erret;
648 if (AsnReadVal(aip, atp, &av) <= 0)
649 goto erret;
650 p->num_pages = av.intvalue;
651
652 atp = AsnReadId(aip, amp, atp);
653 if (orig == NULL)
654 {
655 if (atp != ENTREZ_TERM_BY_PAGE)
656 goto erret;
657 }
658 else { /* check for "close struct" associated with "orig" */
659 if (atp != orig)
660 goto erret;
661 }
662
663 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
664 goto erret;
665
666 ret:
667 AsnUnlinkType(orig);
668 return p;
669
670 erret:
671 p = TermByPageFree(p);
672 goto ret;
673 }
674
675 NLM_EXTERN Boolean LIBCALL
TermByPageAsnWrite(TermByPagePtr p,AsnIoPtr aip,AsnTypePtr orig)676 TermByPageAsnWrite (TermByPagePtr p, AsnIoPtr aip, AsnTypePtr orig)
677 {
678 DataVal av;
679 Boolean retval = FALSE;
680 AsnTypePtr atp;
681
682 if (! NetEntAsnLoad() )
683 return FALSE;
684
685 if (aip == NULL)
686 return FALSE;
687
688 atp = AsnLinkType(orig, ENTREZ_TERM_BY_PAGE); /* link local tree */
689
690 if (atp == NULL)
691 return FALSE;
692
693 if (p == NULL)
694 {
695 AsnNullValueMsg(aip, atp);
696 goto erret;
697 }
698
699 if (! AsnStartStruct(aip, atp))
700 goto erret;
701
702 av.intvalue = p->type;
703 AsnWrite (aip, ENTREZ_TERM_BY_PAGE_type, &av);
704 av.intvalue = p->fld;
705 AsnWrite (aip, ENTREZ_TERM_BY_PAGE_fld, &av);
706 av.intvalue = p->page;
707 AsnWrite (aip, ENTREZ_TERM_BY_PAGE_page, &av);
708 av.intvalue = p->num_pages;
709 AsnWrite (aip, ENTREZ_TERM_BY_PAGE_num_pages, &av);
710
711 if (! AsnEndStruct(aip, atp))
712 goto erret;
713
714 retval = TRUE;
715
716 erret:
717 AsnUnlinkType(orig); /* unlink local tree */
718 return retval;
719 }
720
721 /************************** Term-by-term **********************************/
722
723 NLM_EXTERN TermByTermPtr LIBCALL
TermByTermNew(void)724 TermByTermNew(void)
725 {
726 TermByTermPtr p;
727
728 p = MemNew(sizeof(TermByTerm));
729 p->term = NULL;
730 return p;
731 }
732
733 NLM_EXTERN TermByTermPtr LIBCALL
TermByTermFree(TermByTermPtr p)734 TermByTermFree(TermByTermPtr p)
735 {
736 if (p == NULL)
737 return NULL;
738 MemFree (p->term);
739
740 return MemFree(p);
741 }
742
743 NLM_EXTERN TermByTermPtr LIBCALL
TermByTermAsnRead(AsnIoPtr aip,AsnTypePtr orig)744 TermByTermAsnRead (AsnIoPtr aip, AsnTypePtr orig)
745 {
746 DataVal av;
747 TermByTermPtr p;
748 AsnTypePtr atp;
749
750 if (!NetEntAsnLoad())
751 return NULL;
752
753 if (aip == NULL)
754 return NULL;
755
756 if (orig == NULL)
757 atp = AsnReadId(aip, amp, ENTREZ_TERM_BY_TERM);
758 else
759 atp = AsnLinkType(orig, ENTREZ_TERM_BY_TERM); /* link in local tree */
760
761 if (atp == NULL)
762 return NULL;
763
764 p = TermByTermNew();
765 if (p == NULL)
766 goto erret;
767
768 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
769 goto erret;
770
771 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_TERM_BY_TERM_type)
772 goto erret;
773 if (AsnReadVal(aip, atp, &av) <= 0)
774 goto erret;
775 p->type = av.intvalue;
776
777 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_TERM_BY_TERM_fld)
778 goto erret;
779 if (AsnReadVal(aip, atp, &av) <= 0)
780 goto erret;
781 p->fld = av.intvalue;
782
783 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_TERM_BY_TERM_term)
784 goto erret;
785 if (AsnReadVal(aip, atp, &av) <= 0)
786 goto erret;
787 p->term = av.ptrvalue;
788
789 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_TERM_BY_TERM_num_terms)
790 goto erret;
791 if (AsnReadVal(aip, atp, &av) <= 0)
792 goto erret;
793 p->num_terms = av.intvalue;
794
795 atp = AsnReadId(aip, amp, atp);
796 if (orig == NULL)
797 {
798 if (atp != ENTREZ_TERM_BY_TERM)
799 goto erret;
800 }
801 else { /* check for "close struct" associated with "orig" */
802 if (atp != orig)
803 goto erret;
804 }
805
806 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
807 goto erret;
808
809 ret:
810 AsnUnlinkType(orig);
811 return p;
812
813 erret:
814 p = TermByTermFree(p);
815 goto ret;
816 }
817
818 NLM_EXTERN Boolean LIBCALL
TermByTermAsnWrite(TermByTermPtr p,AsnIoPtr aip,AsnTypePtr orig)819 TermByTermAsnWrite (TermByTermPtr p, AsnIoPtr aip, AsnTypePtr orig)
820 {
821 DataVal av;
822 Boolean retval = FALSE;
823 AsnTypePtr atp;
824
825 if (! NetEntAsnLoad() )
826 return FALSE;
827
828 if (aip == NULL)
829 return FALSE;
830
831 atp = AsnLinkType(orig, ENTREZ_TERM_BY_TERM); /* link local tree */
832
833 if (atp == NULL)
834 return FALSE;
835
836 if (p == NULL)
837 {
838 AsnNullValueMsg(aip, atp);
839 goto erret;
840 }
841
842 if (! AsnStartStruct(aip, atp))
843 goto erret;
844
845 av.intvalue = p->type;
846 AsnWrite (aip, ENTREZ_TERM_BY_TERM_type, &av);
847 av.intvalue = p->fld;
848 AsnWrite (aip, ENTREZ_TERM_BY_TERM_fld, &av);
849 av.ptrvalue = p->term;
850 AsnWrite (aip, ENTREZ_TERM_BY_TERM_term, &av);
851 av.intvalue = p->num_terms;
852 AsnWrite (aip, ENTREZ_TERM_BY_TERM_num_terms, &av);
853
854 if (! AsnEndStruct(aip, atp))
855 goto erret;
856
857 retval = TRUE;
858
859 erret:
860 AsnUnlinkType(orig); /* unlink local tree */
861 return retval;
862 }
863
864 /************************** Term-Lookup **********************************/
865
866 NLM_EXTERN TermLookupPtr LIBCALL
TermLookupNew(void)867 TermLookupNew(void)
868 {
869 TermLookupPtr p;
870
871 p = MemNew(sizeof(TermLookup));
872 p->term = NULL;
873 return p;
874 }
875
876 NLM_EXTERN TermLookupPtr LIBCALL
TermLookupFree(TermLookupPtr p)877 TermLookupFree(TermLookupPtr p)
878 {
879 if (p == NULL)
880 return NULL;
881 MemFree (p->term);
882
883 return MemFree(p);
884 }
885
886 NLM_EXTERN TermLookupPtr LIBCALL
TermLookupAsnRead(AsnIoPtr aip,AsnTypePtr orig)887 TermLookupAsnRead (AsnIoPtr aip, AsnTypePtr orig)
888 {
889 DataVal av;
890 TermLookupPtr p;
891 AsnTypePtr atp;
892
893 if (!NetEntAsnLoad())
894 return NULL;
895
896 if (aip == NULL)
897 return NULL;
898
899 if (orig == NULL)
900 atp = AsnReadId(aip, amp, TERM_LOOKUP);
901 else
902 atp = AsnLinkType(orig, TERM_LOOKUP); /* link in local tree */
903
904 if (atp == NULL)
905 return NULL;
906
907 p = TermLookupNew();
908 if (p == NULL)
909 goto erret;
910
911 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
912 goto erret;
913
914 if ((atp = AsnReadId(aip, amp, atp)) != TERM_LOOKUP_type)
915 goto erret;
916 if (AsnReadVal(aip, atp, &av) <= 0)
917 goto erret;
918 p->type = av.intvalue;
919
920 if ((atp = AsnReadId(aip, amp, atp)) != TERM_LOOKUP_fld)
921 goto erret;
922 if (AsnReadVal(aip, atp, &av) <= 0)
923 goto erret;
924 p->fld = av.intvalue;
925
926 if ((atp = AsnReadId(aip, amp, atp)) != TERM_LOOKUP_term)
927 goto erret;
928 if (AsnReadVal(aip, atp, &av) <= 0)
929 goto erret;
930 p->term = av.ptrvalue;
931
932 atp = AsnReadId(aip, amp, atp);
933 if (orig == NULL)
934 {
935 if (atp != TERM_LOOKUP)
936 goto erret;
937 }
938 else { /* check for "close struct" associated with "orig" */
939 if (atp != orig)
940 goto erret;
941 }
942
943 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
944 goto erret;
945
946 ret:
947 AsnUnlinkType(orig);
948 return p;
949
950 erret:
951 p = TermLookupFree(p);
952 goto ret;
953 }
954
955 NLM_EXTERN Boolean LIBCALL
TermLookupAsnWrite(TermLookupPtr p,AsnIoPtr aip,AsnTypePtr orig)956 TermLookupAsnWrite (TermLookupPtr p, AsnIoPtr aip, AsnTypePtr orig)
957 {
958 DataVal av;
959 Boolean retval = FALSE;
960 AsnTypePtr atp;
961
962 if (! NetEntAsnLoad() )
963 return FALSE;
964
965 if (aip == NULL)
966 return FALSE;
967
968 atp = AsnLinkType(orig, TERM_LOOKUP); /* link local tree */
969
970 if (atp == NULL)
971 return FALSE;
972
973 if (p == NULL)
974 {
975 AsnNullValueMsg(aip, atp);
976 goto erret;
977 }
978
979 if (! AsnStartStruct(aip, atp))
980 goto erret;
981
982 av.intvalue = p->type;
983 AsnWrite (aip, TERM_LOOKUP_type, &av);
984 av.intvalue = p->fld;
985 AsnWrite (aip, TERM_LOOKUP_fld, &av);
986 av.ptrvalue = p->term;
987 AsnWrite (aip, TERM_LOOKUP_term, &av);
988
989 if (! AsnEndStruct(aip, atp))
990 goto erret;
991
992 retval = TRUE;
993
994 erret:
995 AsnUnlinkType(orig); /* unlink local tree */
996 return retval;
997 }
998
999 /************************** Term-Page-Info **********************************/
1000
1001 NLM_EXTERN TermPageInfoPtr LIBCALL
TermPageInfoNew(void)1002 TermPageInfoNew(void)
1003 {
1004 TermPageInfoPtr p;
1005
1006 p = MemNew(sizeof(TermPageInfo));
1007 p->term = NULL;
1008 return p;
1009 }
1010
1011 NLM_EXTERN TermPageInfoPtr LIBCALL
TermPageInfoFree(TermPageInfoPtr p)1012 TermPageInfoFree(TermPageInfoPtr p)
1013 {
1014 if (p == NULL)
1015 return NULL;
1016 MemFree (p->term);
1017
1018 return MemFree(p);
1019 }
1020
1021 NLM_EXTERN TermPageInfoPtr LIBCALL
TermPageInfoAsnRead(AsnIoPtr aip,AsnTypePtr orig)1022 TermPageInfoAsnRead (AsnIoPtr aip, AsnTypePtr orig)
1023 {
1024 DataVal av;
1025 TermPageInfoPtr p;
1026 AsnTypePtr atp;
1027
1028 if (!NetEntAsnLoad())
1029 return NULL;
1030
1031 if (aip == NULL)
1032 return NULL;
1033
1034 if (orig == NULL)
1035 atp = AsnReadId(aip, amp, TERM_PAGE_INFO);
1036 else
1037 atp = AsnLinkType(orig, TERM_PAGE_INFO); /* link in local tree */
1038
1039 if (atp == NULL)
1040 return NULL;
1041
1042 p = TermPageInfoNew();
1043 if (p == NULL)
1044 goto erret;
1045
1046 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
1047 goto erret;
1048
1049 if ((atp = AsnReadId(aip, amp, atp)) != TERM_PAGE_INFO_term)
1050 goto erret;
1051 if (AsnReadVal(aip, atp, &av) <= 0)
1052 goto erret;
1053 p->term = av.ptrvalue;
1054
1055 if ((atp = AsnReadId(aip, amp, atp)) != TERM_PAGE_INFO_spec_count)
1056 goto erret;
1057 if (AsnReadVal(aip, atp, &av) <= 0)
1058 goto erret;
1059 p->spec_count = av.intvalue;
1060
1061 if ((atp = AsnReadId(aip, amp, atp)) != TERM_PAGE_INFO_tot_count)
1062 goto erret;
1063 if (AsnReadVal(aip, atp, &av) <= 0)
1064 goto erret;
1065 p->tot_count = av.intvalue;
1066
1067 atp = AsnReadId(aip, amp, atp);
1068 if (orig == NULL)
1069 {
1070 if (atp != TERM_PAGE_INFO)
1071 goto erret;
1072 }
1073 else { /* check for "close struct" associated with "orig" */
1074 if (atp != orig)
1075 goto erret;
1076 }
1077
1078 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
1079 goto erret;
1080
1081 ret:
1082 AsnUnlinkType(orig);
1083 return p;
1084
1085 erret:
1086 p = TermPageInfoFree(p);
1087 goto ret;
1088 }
1089
1090 NLM_EXTERN Boolean LIBCALL
TermPageInfoAsnWrite(TermPageInfoPtr p,AsnIoPtr aip,AsnTypePtr orig)1091 TermPageInfoAsnWrite (TermPageInfoPtr p, AsnIoPtr aip, AsnTypePtr orig)
1092 {
1093 DataVal av;
1094 Boolean retval = FALSE;
1095 AsnTypePtr atp;
1096
1097 if (! NetEntAsnLoad() )
1098 return FALSE;
1099
1100 if (aip == NULL)
1101 return FALSE;
1102
1103 atp = AsnLinkType(orig, TERM_PAGE_INFO); /* link local tree */
1104
1105 if (atp == NULL)
1106 return FALSE;
1107
1108 if (p == NULL)
1109 {
1110 AsnNullValueMsg(aip, atp);
1111 goto erret;
1112 }
1113
1114 if (! AsnStartStruct(aip, atp))
1115 goto erret;
1116
1117 av.ptrvalue = p->term;
1118 AsnWrite (aip, TERM_PAGE_INFO_term, &av);
1119 av.intvalue = p->spec_count;
1120 AsnWrite (aip, TERM_PAGE_INFO_spec_count, &av);
1121 av.intvalue = p->tot_count;
1122 AsnWrite (aip, TERM_PAGE_INFO_tot_count, &av);
1123
1124 if (! AsnEndStruct(aip, atp))
1125 goto erret;
1126
1127 retval = TRUE;
1128
1129 erret:
1130 AsnUnlinkType(orig); /* unlink local tree */
1131 return retval;
1132 }
1133
1134 /************************** Term-Counts **********************************/
1135
1136 NLM_EXTERN TermCountsPtr LIBCALL
TermCountsNew(void)1137 TermCountsNew(void)
1138 {
1139 TermCountsPtr p;
1140
1141 p = MemNew(sizeof(TermCounts));
1142 return p;
1143 }
1144
1145 NLM_EXTERN TermCountsPtr LIBCALL
TermCountsFree(TermCountsPtr p)1146 TermCountsFree(TermCountsPtr p)
1147 {
1148 if (p == NULL)
1149 return NULL;
1150
1151 return MemFree(p);
1152 }
1153
1154 NLM_EXTERN TermCountsPtr LIBCALL
TermCountsAsnRead(AsnIoPtr aip,AsnTypePtr orig)1155 TermCountsAsnRead (AsnIoPtr aip, AsnTypePtr orig)
1156 {
1157 DataVal av;
1158 TermCountsPtr p;
1159 AsnTypePtr atp;
1160
1161 if (!NetEntAsnLoad())
1162 return NULL;
1163
1164 if (aip == NULL)
1165 return NULL;
1166
1167 if (orig == NULL)
1168 atp = AsnReadId(aip, amp, TERM_COUNTS);
1169 else
1170 atp = AsnLinkType(orig, TERM_COUNTS); /* link in local tree */
1171
1172 if (atp == NULL)
1173 return NULL;
1174
1175 p = TermCountsNew();
1176 if (p == NULL)
1177 goto erret;
1178
1179 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
1180 goto erret;
1181
1182 if ((atp = AsnReadId(aip, amp, atp)) != TERM_COUNTS_found)
1183 goto erret;
1184 if (AsnReadVal(aip, atp, &av) <= 0)
1185 goto erret;
1186 p->found = av.boolvalue;
1187
1188 if ((atp = AsnReadId(aip, amp, atp)) != TERM_COUNTS_spec_count)
1189 goto erret;
1190 if (AsnReadVal(aip, atp, &av) <= 0)
1191 goto erret;
1192 p->spec_count = av.intvalue;
1193
1194 if ((atp = AsnReadId(aip, amp, atp)) != TERM_COUNTS_tot_count)
1195 goto erret;
1196 if (AsnReadVal(aip, atp, &av) <= 0)
1197 goto erret;
1198 p->tot_count = av.intvalue;
1199
1200 atp = AsnReadId(aip, amp, atp);
1201 if (orig == NULL)
1202 {
1203 if (atp != TERM_COUNTS)
1204 goto erret;
1205 }
1206 else { /* check for "close struct" associated with "orig" */
1207 if (atp != orig)
1208 goto erret;
1209 }
1210
1211 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
1212 goto erret;
1213
1214 ret:
1215 AsnUnlinkType(orig);
1216 return p;
1217
1218 erret:
1219 p = TermCountsFree(p);
1220 goto ret;
1221 }
1222
1223 NLM_EXTERN Boolean LIBCALL
TermCountsAsnWrite(TermCountsPtr p,AsnIoPtr aip,AsnTypePtr orig)1224 TermCountsAsnWrite (TermCountsPtr p, AsnIoPtr aip, AsnTypePtr orig)
1225 {
1226 DataVal av;
1227 Boolean retval = FALSE;
1228 AsnTypePtr atp;
1229
1230 if (! NetEntAsnLoad() )
1231 return FALSE;
1232
1233 if (aip == NULL)
1234 return FALSE;
1235
1236 atp = AsnLinkType(orig, TERM_COUNTS); /* link local tree */
1237
1238 if (atp == NULL)
1239 return FALSE;
1240
1241 if (p == NULL)
1242 {
1243 AsnNullValueMsg(aip, atp);
1244 goto erret;
1245 }
1246
1247 if (! AsnStartStruct(aip, atp))
1248 goto erret;
1249
1250 av.boolvalue = p->found;
1251 AsnWrite (aip, TERM_COUNTS_found, &av);
1252 av.intvalue = p->spec_count;
1253 AsnWrite (aip, TERM_COUNTS_spec_count, &av);
1254 av.intvalue = p->tot_count;
1255 AsnWrite (aip, TERM_COUNTS_tot_count, &av);
1256
1257 if (! AsnEndStruct(aip, atp))
1258 goto erret;
1259
1260 retval = TRUE;
1261
1262 erret:
1263 AsnUnlinkType(orig); /* unlink local tree */
1264 return retval;
1265 }
1266
1267 /************************** LinkSetGet ****************************************/
1268
1269 NLM_EXTERN LinkSetGetPtr LIBCALL
LinkSetGetNew(void)1270 LinkSetGetNew(void)
1271 {
1272 LinkSetGetPtr p;
1273
1274 p = MemNew(sizeof(LinkSetGet));
1275 if (p != NULL)
1276 {
1277 p->query_size = 0;
1278 p->query = NULL;
1279 }
1280 return p;
1281 }
1282
1283 NLM_EXTERN LinkSetGetPtr LIBCALL
LinkSetGetFree(LinkSetGetPtr p)1284 LinkSetGetFree(LinkSetGetPtr p)
1285 {
1286 if (p == NULL)
1287 return NULL;
1288 MemFree (p->query);
1289 return MemFree(p);
1290 }
1291
1292 NLM_EXTERN LinkSetGetPtr LIBCALL
LinkSetGetAsnRead(AsnIoPtr aip,AsnTypePtr orig)1293 LinkSetGetAsnRead (AsnIoPtr aip, AsnTypePtr orig)
1294 {
1295 DataVal av;
1296 LinkSetGetPtr p;
1297 AsnTypePtr atp;
1298 Int4 num;
1299
1300 if (!NetEntAsnLoad())
1301 return NULL;
1302
1303 if (aip == NULL)
1304 return NULL;
1305
1306 if (orig == NULL)
1307 atp = AsnReadId(aip, amp, LINK_SETGET);
1308 else
1309 atp = AsnLinkType(orig, LINK_SETGET); /* link in local tree */
1310
1311 if (atp == NULL)
1312 return NULL;
1313
1314 p = LinkSetGetNew();
1315 if (p == NULL)
1316 goto erret;
1317
1318 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
1319 goto erret;
1320
1321 atp = AsnReadId(aip, amp, atp); /* find the num */
1322 if (atp == NULL)
1323 goto erret;
1324 if (AsnReadVal(aip, atp, &av) <= 0) /* get the num */
1325 goto erret;
1326 p->max = av.intvalue;
1327
1328 atp = AsnReadId(aip, amp, atp);
1329 if (atp == NULL)
1330 goto erret;
1331 if (AsnReadVal(aip, atp, &av) <= 0)
1332 goto erret;
1333 p->link_to_cls = av.intvalue;
1334
1335 atp = AsnReadId(aip, amp, atp);
1336 if (atp == NULL)
1337 goto erret;
1338 if (AsnReadVal(aip, atp, &av) <= 0)
1339 goto erret;
1340 p->query_cls = av.intvalue;
1341
1342 atp = AsnReadId(aip, amp, atp);
1343 if (atp == LINK_SETGET_mark_missing)
1344 {
1345 if (AsnReadVal(aip, atp, &av) <= 0)
1346 goto erret;
1347 p->mark_missing = av.boolvalue;
1348 atp = AsnReadId(aip, amp, atp);
1349 }
1350
1351 if (atp != LINK_SETGET_query_size)
1352 goto erret;
1353 if (AsnReadVal(aip, atp, &av) <= 0)
1354 goto erret;
1355 p->query_size = av.intvalue;
1356
1357 if ((atp = AsnReadId(aip, amp, atp)) != LINK_SETGET_query)
1358 goto erret;
1359 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
1360 goto erret;
1361
1362 p->query = (DocUidPtr) MemNew(sizeof(DocUid) * (size_t) p->query_size);
1363 atp = AsnReadId(aip, amp, atp);
1364
1365 for (num = 0; num < p->query_size && atp == LINK_SETGET_query_E; num++)
1366 {
1367 if (AsnReadVal(aip, atp, &av) <= 0)
1368 goto erret;
1369 p->query[num] = av.intvalue;
1370 atp = AsnReadId(aip, amp, atp);
1371 }
1372
1373 /* check for count mis-match */
1374 if (num != p->query_size || atp != LINK_SETGET_query)
1375 goto erret;
1376
1377 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
1378 goto erret;
1379
1380 atp = AsnReadId(aip, amp, atp);
1381 if (orig == NULL)
1382 {
1383 if (atp != LINK_SETGET)
1384 goto erret;
1385 }
1386 else { /* check for "close struct" associated with "orig" */
1387 if (atp != orig)
1388 goto erret;
1389 }
1390 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
1391 goto erret;
1392
1393 ret:
1394 AsnUnlinkType(orig);
1395 return p;
1396
1397 erret:
1398 p = LinkSetGetFree(p);
1399 goto ret;
1400 }
1401
1402
1403 NLM_EXTERN Boolean LIBCALL
LinkSetGetAsnWrite(LinkSetGetPtr p,AsnIoPtr aip,AsnTypePtr orig)1404 LinkSetGetAsnWrite (LinkSetGetPtr p, AsnIoPtr aip, AsnTypePtr orig)
1405 {
1406 DataVal av;
1407 Int4 i;
1408 AsnTypePtr atp;
1409 Boolean retval = FALSE;
1410
1411 if (! NetEntAsnLoad() )
1412 return FALSE;
1413
1414 if (aip == NULL)
1415 return FALSE;
1416
1417 atp = AsnLinkType(orig, LINK_SETGET); /* link local tree */
1418
1419 if (atp == NULL)
1420 return FALSE;
1421
1422 if (p == NULL)
1423 {
1424 AsnNullValueMsg(aip, atp);
1425 goto erret;
1426 }
1427
1428
1429 if (! AsnStartStruct(aip, atp))
1430 goto erret;
1431 av.intvalue = p->max;
1432 AsnWrite (aip, LINK_SETGET_max, &av);
1433 av.intvalue = p->link_to_cls;
1434 AsnWrite (aip, LINK_SETGET_link_to_cls, &av);
1435 av.intvalue = p->query_cls;
1436 AsnWrite (aip, LINK_SETGET_query_cls, &av);
1437 av.boolvalue = p->mark_missing;
1438 AsnWrite (aip, LINK_SETGET_mark_missing, &av);
1439 av.intvalue = p->query_size;
1440 AsnWrite (aip, LINK_SETGET_query_size, &av);
1441
1442 AsnStartStruct (aip, LINK_SETGET_query);
1443 for (i = 0; i < p->query_size; i++)
1444 {
1445 av.intvalue = p->query[i];
1446 AsnWrite (aip, LINK_SETGET_query_E, &av);
1447 }
1448 AsnEndStruct (aip, LINK_SETGET_query);
1449
1450 if (! AsnEndStruct(aip, atp))
1451 goto erret;
1452
1453 retval = TRUE;
1454
1455 erret:
1456 AsnUnlinkType(orig); /* unlink local tree */
1457 return retval;
1458 }
1459
1460 /************************** Medline-Summary **********************************/
1461
1462 NLM_EXTERN DocSumPtr LIBCALL
MlSumNew(void)1463 MlSumNew(void)
1464 {
1465 DocSumPtr p;
1466
1467 p = MemNew(sizeof(DocSum));
1468 p->caption = NULL;
1469 p->title = NULL;
1470 return p;
1471 }
1472
1473 NLM_EXTERN DocSumPtr LIBCALL
MlSumFree(DocSumPtr p)1474 MlSumFree(DocSumPtr p)
1475 {
1476 if (p == NULL)
1477 return NULL;
1478 MemFree(p->caption);
1479 MemFree(p->title);
1480
1481 return MemFree(p);
1482 }
1483
1484 NLM_EXTERN DocSumPtr LIBCALL
MlSumAsnRead(AsnIoPtr aip,AsnTypePtr orig)1485 MlSumAsnRead (AsnIoPtr aip, AsnTypePtr orig)
1486 {
1487 DataVal av;
1488 DocSumPtr p;
1489 AsnTypePtr atp;
1490
1491 if (!NetEntAsnLoad())
1492 return NULL;
1493
1494 if (aip == NULL)
1495 return NULL;
1496
1497 if (orig == NULL)
1498 atp = AsnReadId(aip, amp, ML_SUMMARY);
1499 else
1500 atp = AsnLinkType(orig, ML_SUMMARY); /* link in local tree */
1501
1502 if (atp == NULL)
1503 return NULL;
1504
1505 p = MlSumNew();
1506 if (p == NULL)
1507 goto erret;
1508
1509 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
1510 goto erret;
1511
1512 if ((atp = AsnReadId(aip, amp, atp)) != ML_SUMMARY_muid)
1513 goto erret;
1514 if (AsnReadVal(aip, atp, &av) <= 0)
1515 goto erret;
1516 p->uid = av.intvalue;
1517
1518 if ((atp = AsnReadId(aip, amp, atp)) != ML_SUMMARY_no_abstract)
1519 goto erret;
1520 if (AsnReadVal(aip, atp, &av) <= 0)
1521 goto erret;
1522 p->no_abstract = av.boolvalue;
1523
1524 if ((atp = AsnReadId(aip, amp, atp)) != ML_SUMMARY_translated_title)
1525 goto erret;
1526 if (AsnReadVal(aip, atp, &av) <= 0)
1527 goto erret;
1528 p->translated_title = av.boolvalue;
1529
1530 if ((atp = AsnReadId(aip, amp, atp)) != ML_SUMMARY_no_authors)
1531 goto erret;
1532 if (AsnReadVal(aip, atp, &av) <= 0)
1533 goto erret;
1534 p->no_authors = av.boolvalue;
1535
1536 atp = AsnReadId(aip, amp, atp);
1537 if (atp == ML_SUMMARY_caption)
1538 {
1539 if (AsnReadVal(aip, atp, &av) <= 0)
1540 goto erret;
1541 p->caption = av.ptrvalue;
1542 atp = AsnReadId(aip, amp, atp);
1543 }
1544
1545 if (atp == ML_SUMMARY_title)
1546 {
1547 if (AsnReadVal(aip, atp, &av) <= 0)
1548 goto erret;
1549 p->title = av.ptrvalue;
1550 atp = AsnReadId(aip, amp, atp);
1551 }
1552
1553 if (orig == NULL)
1554 {
1555 if (atp != ML_SUMMARY)
1556 goto erret;
1557 }
1558 else { /* check for "close struct" associated with "orig" */
1559 if (atp != orig)
1560 goto erret;
1561 }
1562
1563 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
1564 goto erret;
1565
1566 ret:
1567 AsnUnlinkType(orig);
1568 return p;
1569
1570 erret:
1571 p = DocSumFree(p);
1572 goto ret;
1573 }
1574
1575 NLM_EXTERN Boolean LIBCALL
MlSumAsnWrite(DocSumPtr p,AsnIoPtr aip,AsnTypePtr orig)1576 MlSumAsnWrite (DocSumPtr p, AsnIoPtr aip, AsnTypePtr orig)
1577 {
1578 DataVal av;
1579 Boolean retval = FALSE;
1580 AsnTypePtr atp;
1581
1582 if (! NetEntAsnLoad() )
1583 return FALSE;
1584
1585 if (aip == NULL)
1586 return FALSE;
1587
1588 atp = AsnLinkType(orig, ML_SUMMARY); /* link local tree */
1589
1590 if (atp == NULL)
1591 return FALSE;
1592
1593 if (p == NULL)
1594 {
1595 AsnNullValueMsg(aip, atp);
1596 goto erret;
1597 }
1598
1599 if (! AsnStartStruct(aip, atp))
1600 goto erret;
1601
1602 av.intvalue = p->uid;
1603 AsnWrite (aip, ML_SUMMARY_muid, &av);
1604 av.boolvalue = p->no_abstract;
1605 AsnWrite (aip, ML_SUMMARY_no_abstract, &av);
1606 av.boolvalue = p->translated_title;
1607 AsnWrite (aip, ML_SUMMARY_translated_title, &av);
1608 av.boolvalue = p->no_authors;
1609 AsnWrite (aip, ML_SUMMARY_no_authors, &av);
1610 if (p->caption != NULL)
1611 {
1612 av.ptrvalue = p->caption;
1613 AsnWrite (aip, ML_SUMMARY_caption, &av);
1614 }
1615 if (p->title != NULL)
1616 {
1617 av.ptrvalue = p->title;
1618 AsnWrite (aip, ML_SUMMARY_title, &av);
1619 }
1620
1621 if (! AsnEndStruct(aip, atp))
1622 goto erret;
1623
1624 retval = TRUE;
1625
1626 erret:
1627 AsnUnlinkType(orig); /* unlink local tree */
1628 return retval;
1629 }
1630
1631 /************************** Sequence-Summary **********************************/
1632
1633 NLM_EXTERN DocSumPtr LIBCALL
SeqSumNew(void)1634 SeqSumNew(void)
1635 {
1636 DocSumPtr p;
1637
1638 p = MemNew(sizeof(DocSum));
1639 p->caption = NULL;
1640 p->title = NULL;
1641 return p;
1642 }
1643
1644 NLM_EXTERN DocSumPtr LIBCALL
SeqSumFree(DocSumPtr p)1645 SeqSumFree(DocSumPtr p)
1646 {
1647 if (p == NULL)
1648 return NULL;
1649 MemFree(p->caption);
1650 MemFree(p->title);
1651
1652 return MemFree(p);
1653 }
1654
1655 NLM_EXTERN DocSumPtr LIBCALL
SeqSumAsnRead(AsnIoPtr aip,AsnTypePtr orig)1656 SeqSumAsnRead (AsnIoPtr aip, AsnTypePtr orig)
1657 {
1658 DataVal av;
1659 DocSumPtr p;
1660 AsnTypePtr atp;
1661
1662 if (!NetEntAsnLoad())
1663 return NULL;
1664
1665 if (aip == NULL)
1666 return NULL;
1667
1668 if (orig == NULL)
1669 atp = AsnReadId(aip, amp, SEQ_SUMMARY);
1670 else
1671 atp = AsnLinkType(orig, SEQ_SUMMARY); /* link in local tree */
1672
1673 if (atp == NULL)
1674 return NULL;
1675
1676 p = SeqSumNew();
1677 if (p == NULL)
1678 goto erret;
1679
1680 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
1681 goto erret;
1682
1683 if ((atp = AsnReadId(aip, amp, atp)) != SEQ_SUMMARY_id)
1684 goto erret;
1685 if (AsnReadVal(aip, atp, &av) <= 0)
1686 goto erret;
1687 p->uid = av.intvalue;
1688
1689 atp = AsnReadId(aip, amp, atp);
1690 if (atp == SEQ_SUMMARY_caption)
1691 {
1692 if (AsnReadVal(aip, atp, &av) <= 0)
1693 goto erret;
1694 p->caption = av.ptrvalue;
1695 atp = AsnReadId(aip, amp, atp);
1696 }
1697
1698 if (atp == SEQ_SUMMARY_title)
1699 {
1700 if (AsnReadVal(aip, atp, &av) <= 0)
1701 goto erret;
1702 p->title = av.ptrvalue;
1703 atp = AsnReadId(aip, amp, atp);
1704 }
1705
1706 if (orig == NULL)
1707 {
1708 if (atp != SEQ_SUMMARY)
1709 goto erret;
1710 }
1711 else { /* check for "close struct" associated with "orig" */
1712 if (atp != orig)
1713 goto erret;
1714 }
1715
1716 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
1717 goto erret;
1718
1719 ret:
1720 AsnUnlinkType(orig);
1721 return p;
1722
1723 erret:
1724 p = DocSumFree(p);
1725 goto ret;
1726 }
1727
1728 NLM_EXTERN Boolean LIBCALL
SeqSumAsnWrite(DocSumPtr p,AsnIoPtr aip,AsnTypePtr orig)1729 SeqSumAsnWrite (DocSumPtr p, AsnIoPtr aip, AsnTypePtr orig)
1730 {
1731 DataVal av;
1732 Boolean retval = FALSE;
1733 AsnTypePtr atp;
1734
1735 if (! NetEntAsnLoad() )
1736 return FALSE;
1737
1738 if (aip == NULL)
1739 return FALSE;
1740
1741 atp = AsnLinkType(orig, SEQ_SUMMARY); /* link local tree */
1742
1743 if (atp == NULL)
1744 return FALSE;
1745
1746 if (p == NULL)
1747 {
1748 AsnNullValueMsg(aip, atp);
1749 goto erret;
1750 }
1751
1752 if (! AsnStartStruct(aip, atp))
1753 goto erret;
1754
1755 av.intvalue = p->uid;
1756 AsnWrite (aip, SEQ_SUMMARY_id, &av);
1757 if (p->caption != NULL)
1758 {
1759 av.ptrvalue = p->caption;
1760 AsnWrite (aip, SEQ_SUMMARY_caption, &av);
1761 }
1762 if (p->title != NULL)
1763 {
1764 av.ptrvalue = p->title;
1765 AsnWrite (aip, SEQ_SUMMARY_title, &av);
1766 }
1767
1768 if (! AsnEndStruct(aip, atp))
1769 goto erret;
1770
1771 retval = TRUE;
1772
1773 erret:
1774 AsnUnlinkType(orig); /* unlink local tree */
1775 return retval;
1776 }
1777
1778 /************************** Entrez-DocGet **********************************/
1779
1780 NLM_EXTERN EntrezDocGetPtr LIBCALL
EntrezDocGetNew(void)1781 EntrezDocGetNew(void)
1782 {
1783 EntrezDocGetPtr p;
1784
1785 p = MemNew(sizeof(EntrezDocGet));
1786 p->ids = NULL;
1787 p->defer_count = 0;
1788 return p;
1789 }
1790
1791 NLM_EXTERN EntrezDocGetPtr LIBCALL
EntrezDocGetFree(EntrezDocGetPtr p)1792 EntrezDocGetFree(EntrezDocGetPtr p)
1793 {
1794 if (p == NULL)
1795 return NULL;
1796 EntrezIdsFree(p->ids);
1797
1798 return MemFree(p);
1799 }
1800
1801 NLM_EXTERN EntrezDocGetPtr LIBCALL
EntrezDocGetAsnRead(AsnIoPtr aip,AsnTypePtr orig)1802 EntrezDocGetAsnRead (AsnIoPtr aip, AsnTypePtr orig)
1803 {
1804 DataVal av;
1805 EntrezDocGetPtr p;
1806 AsnTypePtr atp;
1807
1808 if (!NetEntAsnLoad())
1809 return NULL;
1810
1811 if (aip == NULL)
1812 return NULL;
1813
1814 if (orig == NULL)
1815 atp = AsnReadId(aip, amp, ENTREZ_DOCGET);
1816 else
1817 atp = AsnLinkType(orig, ENTREZ_DOCGET); /* link in local tree */
1818
1819 if (atp == NULL)
1820 return NULL;
1821
1822 p = EntrezDocGetNew();
1823 if (p == NULL)
1824 goto erret;
1825
1826 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
1827 goto erret;
1828
1829 if ((atp = AsnReadId(aip, amp, atp)) != ENTREZ_DOCGET_class)
1830 goto erret;
1831 if (AsnReadVal(aip, atp, &av) <= 0)
1832 goto erret;
1833 p->cls = av.intvalue;
1834
1835 p->mark_missing = FALSE;
1836 if ((atp = AsnReadId(aip, amp, atp)) == ENTREZ_DOCGET_mark_missing)
1837 {
1838 if (AsnReadVal(aip, atp, &av) <= 0)
1839 goto erret;
1840 p->mark_missing = av.boolvalue;
1841 atp = AsnReadId(aip, amp, atp);
1842 }
1843
1844 if (atp != ENTREZ_DOCGET_ids)
1845 goto erret;
1846 p->ids = EntrezIdsAsnRead(aip, atp);
1847 if (p->ids == NULL)
1848 goto erret;
1849
1850 p->defer_count = 0;
1851 if ((atp = AsnReadId(aip, amp, atp)) == ENTREZ_DOCGET_defer_count)
1852 {
1853 if (AsnReadVal(aip, atp, &av) < 0)
1854 goto erret;
1855 p->defer_count = av.intvalue;
1856 atp = AsnReadId(aip, amp, atp);
1857 }
1858
1859 if (orig == NULL)
1860 {
1861 if (atp != ENTREZ_DOCGET)
1862 goto erret;
1863 }
1864 else { /* check for "close struct" associated with "orig" */
1865 if (atp != orig)
1866 goto erret;
1867 }
1868
1869 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
1870 goto erret;
1871
1872 ret:
1873 AsnUnlinkType(orig);
1874 return p;
1875
1876 erret:
1877 p = EntrezDocGetFree(p);
1878 goto ret;
1879 }
1880
1881 NLM_EXTERN Boolean LIBCALL
EntrezDocGetAsnWrite(EntrezDocGetPtr p,AsnIoPtr aip,AsnTypePtr orig)1882 EntrezDocGetAsnWrite (EntrezDocGetPtr p, AsnIoPtr aip, AsnTypePtr orig)
1883 {
1884 DataVal av;
1885 Boolean retval = FALSE;
1886 AsnTypePtr atp;
1887
1888 if (! NetEntAsnLoad() )
1889 return FALSE;
1890
1891 if (aip == NULL)
1892 return FALSE;
1893
1894 atp = AsnLinkType(orig, ENTREZ_DOCGET); /* link local tree */
1895
1896 if (atp == NULL)
1897 return FALSE;
1898
1899 if (p == NULL)
1900 {
1901 AsnNullValueMsg(aip, atp);
1902 goto erret;
1903 }
1904
1905 if (! AsnStartStruct(aip, atp))
1906 goto erret;
1907
1908 av.intvalue = p->cls;
1909 AsnWrite (aip, ENTREZ_DOCGET_class, &av);
1910 av.boolvalue = p->mark_missing;
1911 AsnWrite (aip, ENTREZ_DOCGET_mark_missing, &av);
1912 if (! EntrezIdsAsnWrite(p->ids, aip, ENTREZ_DOCGET_ids) )
1913 goto erret;
1914 av.intvalue = p->defer_count;
1915 AsnWrite (aip, ENTREZ_DOCGET_defer_count, &av);
1916
1917 if (! AsnEndStruct(aip, atp))
1918 goto erret;
1919
1920 retval = TRUE;
1921
1922 erret:
1923 AsnUnlinkType(orig); /* unlink local tree */
1924 return retval;
1925 }
1926
1927
1928 /************************** MedlineEntryList *********************************/
1929
1930 NLM_EXTERN MedlineEntryListPtr LIBCALL
MedlineEntryListNew(void)1931 MedlineEntryListNew(void)
1932 {
1933 MedlineEntryListPtr p;
1934
1935 p = MemNew(sizeof(MedlineEntryList));
1936 if (p != NULL)
1937 {
1938 p->num = 0;
1939 p->data = NULL;
1940 p->marked_missing = NULL;
1941 }
1942 return p;
1943 }
1944
1945 NLM_EXTERN MedlineEntryListPtr LIBCALL
MedlineEntryListFree(MedlineEntryListPtr p)1946 MedlineEntryListFree(MedlineEntryListPtr p)
1947 {
1948 Int4 i;
1949
1950 if (p == NULL)
1951 return NULL;
1952 if (p->data != NULL)
1953 {
1954 for (i = 0; i < p->num; i++)
1955 MedlineEntryFree(p->data[i]);
1956 }
1957 MemFree (p->data);
1958 EntrezIdsFree (p->marked_missing);
1959 return MemFree(p);
1960 }
1961
1962 NLM_EXTERN MedlineEntryListPtr LIBCALL
MedlineEntryListAsnRead(AsnIoPtr aip,AsnTypePtr orig)1963 MedlineEntryListAsnRead (AsnIoPtr aip, AsnTypePtr orig)
1964 {
1965 DataVal av;
1966 MedlineEntryListPtr p;
1967 AsnTypePtr atp;
1968 Int4 num;
1969
1970 if (!NetEntAsnLoad())
1971 return NULL;
1972
1973 if (aip == NULL)
1974 return NULL;
1975
1976 if (orig == NULL)
1977 atp = AsnReadId(aip, amp, ENTREZ_MEDLINE_ENTRY_LIST);
1978 else
1979 atp = AsnLinkType(orig, ENTREZ_MEDLINE_ENTRY_LIST); /* link in local tree */
1980
1981 if (atp == NULL)
1982 return NULL;
1983
1984 p = MedlineEntryListNew();
1985 if (p == NULL)
1986 goto erret;
1987
1988 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
1989 goto erret;
1990
1991 atp = AsnReadId(aip, amp, atp); /* find the num */
1992 if (atp == NULL)
1993 goto erret;
1994 if (AsnReadVal(aip, atp, &av) <= 0) /* get the num */
1995 goto erret;
1996 p->num = av.intvalue;
1997
1998 atp = AsnReadId(aip, amp, atp); /* find the data start-struct */
1999 if (atp == NULL)
2000 goto erret;
2001 if (AsnReadVal(aip, atp, &av) <= 0) /* get the data start-struct */
2002 goto erret;
2003
2004 p->data = (MedlineEntryPtr PNTR) MemNew(sizeof(MedlineEntryPtr) * p->num);
2005 for (num = 0; num < p->num; num++)
2006 p->data[num] = NULL;
2007 atp = AsnReadId(aip, amp, atp);
2008
2009 for (num = 0; num < p->num && atp == MEDLINE_ENTRY_LIST_data_E; num++)
2010 {
2011 if ((p->data[num] = MedlineEntryAsnRead(aip, atp)) == NULL)
2012 goto erret;
2013 atp = AsnReadId(aip, amp, atp);
2014 }
2015
2016 /* check for count mis-match */
2017 if (num != p->num)
2018 goto erret;
2019
2020 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
2021 goto erret;
2022
2023 atp = AsnReadId(aip, amp, atp);
2024
2025 if (atp == ENTRY_LIST_marked_missing)
2026 {
2027 p->marked_missing = EntrezIdsAsnRead(aip, atp);
2028 atp = AsnReadId(aip, amp, atp);
2029 }
2030
2031 if (orig == NULL)
2032 {
2033 if (atp != ENTREZ_MEDLINE_ENTRY_LIST)
2034 goto erret;
2035 }
2036 else { /* check for "close struct" associated with "orig" */
2037 if (atp != orig)
2038 goto erret;
2039 }
2040 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
2041 goto erret;
2042
2043 ret:
2044 AsnUnlinkType(orig);
2045 return p;
2046
2047 erret:
2048 p = MedlineEntryListFree(p);
2049 goto ret;
2050 }
2051
2052
2053 NLM_EXTERN Boolean LIBCALL
MedlineEntryListAsnWrite(MedlineEntryListPtr p,AsnIoPtr aip,AsnTypePtr orig)2054 MedlineEntryListAsnWrite (MedlineEntryListPtr p, AsnIoPtr aip, AsnTypePtr orig)
2055 {
2056 DataVal av;
2057 Int4 i;
2058 AsnTypePtr atp;
2059 Boolean retval = FALSE;
2060
2061 if (! NetEntAsnLoad() )
2062 return FALSE;
2063
2064 if (aip == NULL)
2065 return FALSE;
2066
2067 atp = AsnLinkType(orig, ENTREZ_MEDLINE_ENTRY_LIST); /* link local tree */
2068
2069 if (atp == NULL)
2070 return FALSE;
2071
2072 if (p == NULL)
2073 {
2074 AsnNullValueMsg(aip, atp);
2075 goto erret;
2076 }
2077
2078 if (! AsnStartStruct(aip, atp))
2079 goto erret;
2080 av.intvalue = p->num;
2081 AsnWrite (aip, ENTREZ_MEDLINE_ENTRY_LIST_num, &av);
2082
2083 AsnStartStruct (aip, ENTREZ_MEDLINE_ENTRY_LIST_data);
2084 for (i = 0; i < p->num; i++)
2085 {
2086 MedlineEntryAsnWrite(p->data[i], aip, MEDLINE_ENTRY_LIST_data_E);
2087 }
2088 AsnEndStruct (aip, ENTREZ_MEDLINE_ENTRY_LIST_data);
2089
2090 if (p->marked_missing != NULL) /* optional */
2091 {
2092 EntrezIdsAsnWrite(p->marked_missing, aip, ENTRY_LIST_marked_missing);
2093 }
2094
2095 if (! AsnEndStruct(aip, atp))
2096 goto erret;
2097
2098 retval = TRUE;
2099
2100 erret:
2101 AsnUnlinkType(orig); /* unlink local tree */
2102 return retval;
2103 }
2104
2105
2106 /************************** MlSummaryList ****************************************/
2107
2108 NLM_EXTERN MlSummaryListPtr LIBCALL
MlSummaryListNew(void)2109 MlSummaryListNew(void)
2110 {
2111 MlSummaryListPtr p;
2112
2113 p = MemNew(sizeof(MlSummaryList));
2114 if (p != NULL)
2115 {
2116 p->num = 0;
2117 p->data = NULL;
2118 }
2119 return p;
2120 }
2121
2122 NLM_EXTERN MlSummaryListPtr LIBCALL
MlSummaryListFree(MlSummaryListPtr p)2123 MlSummaryListFree(MlSummaryListPtr p)
2124 {
2125 Int4 i;
2126
2127 if (p == NULL)
2128 return NULL;
2129 if (p->data != NULL)
2130 {
2131 for (i = 0; i < p->num; i++)
2132 MlSumFree(p->data[i]);
2133 }
2134 MemFree (p->data);
2135 return MemFree(p);
2136 }
2137
2138 NLM_EXTERN MlSummaryListPtr LIBCALL
MlSummaryListAsnRead(AsnIoPtr aip,AsnTypePtr orig)2139 MlSummaryListAsnRead (AsnIoPtr aip, AsnTypePtr orig)
2140 {
2141 DataVal av;
2142 MlSummaryListPtr p;
2143 AsnTypePtr atp;
2144 Int4 num;
2145
2146 if (!NetEntAsnLoad())
2147 return NULL;
2148
2149 if (aip == NULL)
2150 return NULL;
2151
2152 if (orig == NULL)
2153 atp = AsnReadId(aip, amp, ML_SUMMARY_LIST);
2154 else
2155 atp = AsnLinkType(orig, ML_SUMMARY_LIST); /* link in local tree */
2156
2157 if (atp == NULL)
2158 return NULL;
2159
2160 p = MlSummaryListNew();
2161 if (p == NULL)
2162 goto erret;
2163
2164 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
2165 goto erret;
2166
2167 atp = AsnReadId(aip, amp, atp); /* find the num */
2168 if (atp == NULL)
2169 goto erret;
2170 if (AsnReadVal(aip, atp, &av) <= 0) /* get the num */
2171 goto erret;
2172 p->num = av.intvalue;
2173
2174 atp = AsnReadId(aip, amp, atp); /* find the data start-struct */
2175 if (atp == NULL)
2176 goto erret;
2177 if (AsnReadVal(aip, atp, &av) <= 0) /* get the data start-struct */
2178 goto erret;
2179
2180 p->data = (DocSumPtr PNTR) MemNew(sizeof(DocSumPtr) * p->num);
2181 for (num = 0; num < p->num; num++)
2182 p->data[num] = NULL;
2183 atp = AsnReadId(aip, amp, atp);
2184
2185 for (num = 0; num < p->num && atp == ML_SUMMARY_LIST_data_E; num++)
2186 {
2187 if ((p->data[num] = MlSumAsnRead(aip, atp)) == NULL)
2188 goto erret;
2189 atp = AsnReadId(aip, amp, atp);
2190 }
2191
2192 /* check for count mis-match */
2193 if (num != p->num || atp != ML_SUMMARY_LIST_data)
2194 goto erret;
2195
2196 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
2197 goto erret;
2198
2199 atp = AsnReadId(aip, amp, atp);
2200 if (orig == NULL)
2201 {
2202 if (atp != ML_SUMMARY_LIST)
2203 goto erret;
2204 }
2205 else { /* check for "close struct" associated with "orig" */
2206 if (atp != orig)
2207 goto erret;
2208 }
2209 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
2210 goto erret;
2211
2212 ret:
2213 AsnUnlinkType(orig);
2214 return p;
2215
2216 erret:
2217 p = MlSummaryListFree(p);
2218 goto ret;
2219 }
2220
2221
2222 NLM_EXTERN Boolean LIBCALL
MlSummaryListAsnWrite(MlSummaryListPtr p,AsnIoPtr aip,AsnTypePtr orig)2223 MlSummaryListAsnWrite (MlSummaryListPtr p, AsnIoPtr aip, AsnTypePtr orig)
2224 {
2225 DataVal av;
2226 Int4 i;
2227 AsnTypePtr atp;
2228 Boolean retval = FALSE;
2229
2230 if (! NetEntAsnLoad() )
2231 return FALSE;
2232
2233 if (aip == NULL)
2234 return FALSE;
2235
2236 atp = AsnLinkType(orig, ML_SUMMARY_LIST); /* link local tree */
2237
2238 if (atp == NULL)
2239 return FALSE;
2240
2241 if (p == NULL)
2242 {
2243 AsnNullValueMsg(aip, atp);
2244 goto erret;
2245 }
2246
2247 if (! AsnStartStruct(aip, atp))
2248 goto erret;
2249 av.intvalue = p->num;
2250 AsnWrite (aip, ML_SUMMARY_LIST_num, &av);
2251
2252 AsnStartStruct (aip, ML_SUMMARY_LIST_data);
2253 for (i = 0; i < p->num; i++)
2254 {
2255 MlSumAsnWrite(p->data[i], aip, ML_SUMMARY_LIST_data_E);
2256 }
2257 AsnEndStruct (aip, ML_SUMMARY_LIST_data);
2258
2259 if (! AsnEndStruct(aip, atp))
2260 goto erret;
2261
2262 retval = TRUE;
2263
2264 erret:
2265 AsnUnlinkType(orig); /* unlink local tree */
2266 return retval;
2267 }
2268
2269 /************************** EntrezSeqGet **************************************/
2270
2271 NLM_EXTERN EntrezSeqGetPtr LIBCALL
EntrezSeqGetNew(void)2272 EntrezSeqGetNew(void)
2273 {
2274 EntrezSeqGetPtr p;
2275
2276 p = MemNew(sizeof(EntrezSeqGet));
2277 if (p != NULL)
2278 {
2279 p->ids = NULL;
2280 }
2281 return p;
2282 }
2283
2284 NLM_EXTERN EntrezSeqGetPtr LIBCALL
EntrezSeqGetFree(EntrezSeqGetPtr p)2285 EntrezSeqGetFree(EntrezSeqGetPtr p)
2286 {
2287 if (p == NULL)
2288 return NULL;
2289 EntrezIdsFree (p->ids);
2290 return MemFree(p);
2291 }
2292
2293 NLM_EXTERN EntrezSeqGetPtr LIBCALL
EntrezSeqGetAsnRead(AsnIoPtr aip,AsnTypePtr orig)2294 EntrezSeqGetAsnRead (AsnIoPtr aip, AsnTypePtr orig)
2295 {
2296 DataVal av;
2297 EntrezSeqGetPtr p;
2298 AsnTypePtr atp;
2299
2300 if (!NetEntAsnLoad())
2301 return NULL;
2302
2303 if (aip == NULL)
2304 return NULL;
2305
2306 if (orig == NULL)
2307 atp = AsnReadId(aip, amp, ENTREZ_SEQGET);
2308 else
2309 atp = AsnLinkType(orig, ENTREZ_SEQGET); /* link in local tree */
2310
2311 if (atp == NULL)
2312 return NULL;
2313
2314 p = EntrezSeqGetNew();
2315 if (p == NULL)
2316 goto erret;
2317
2318 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
2319 goto erret;
2320
2321 atp = AsnReadId(aip, amp, atp);
2322 if (atp == NULL)
2323 goto erret;
2324 if (AsnReadVal(aip, atp, &av) <= 0)
2325 goto erret;
2326 p->retype = av.intvalue;
2327
2328 p->mark_missing = FALSE;
2329 atp = AsnReadId(aip, amp, atp);
2330 if (atp == ENTREZ_SEQGET_mark_missing) {
2331 if (AsnReadVal(aip, atp, &av) <= 0)
2332 goto erret;
2333 p->mark_missing = av.boolvalue;
2334 atp = AsnReadId(aip, amp, atp);
2335 }
2336
2337 if (atp == NULL)
2338 goto erret;
2339 p->ids = EntrezIdsAsnRead(aip, atp);
2340
2341 atp = AsnReadId(aip, amp, atp);
2342 if (orig == NULL)
2343 {
2344 if (atp != ENTREZ_SEQGET)
2345 goto erret;
2346 }
2347 else { /* check for "close struct" associated with "orig" */
2348 if (atp != orig)
2349 goto erret;
2350 }
2351 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
2352 goto erret;
2353
2354 ret:
2355 AsnUnlinkType(orig);
2356 return p;
2357
2358 erret:
2359 p = EntrezSeqGetFree(p);
2360 goto ret;
2361 }
2362
2363
2364 NLM_EXTERN Boolean LIBCALL
EntrezSeqGetAsnWrite(EntrezSeqGetPtr p,AsnIoPtr aip,AsnTypePtr orig)2365 EntrezSeqGetAsnWrite (EntrezSeqGetPtr p, AsnIoPtr aip, AsnTypePtr orig)
2366 {
2367 DataVal av;
2368 AsnTypePtr atp;
2369 Boolean retval = FALSE;
2370
2371 if (! NetEntAsnLoad() )
2372 return FALSE;
2373
2374 if (aip == NULL)
2375 return FALSE;
2376
2377 atp = AsnLinkType(orig, ENTREZ_SEQGET); /* link local tree */
2378
2379 if (atp == NULL)
2380 return FALSE;
2381
2382 if (p == NULL)
2383 {
2384 AsnNullValueMsg(aip, atp);
2385 goto erret;
2386 }
2387
2388 if (! AsnStartStruct(aip, atp))
2389 goto erret;
2390 av.intvalue = p->retype;
2391 AsnWrite (aip, ENTREZ_SEQGET_retype, &av);
2392 av.boolvalue = p->mark_missing;
2393 AsnWrite (aip, ENTREZ_SEQGET_mark_missing, &av);
2394 EntrezIdsAsnWrite(p->ids, aip, ENTREZ_SEQGET_ids);
2395
2396 if (! AsnEndStruct(aip, atp))
2397 goto erret;
2398
2399 retval = TRUE;
2400
2401 erret:
2402 AsnUnlinkType(orig); /* unlink local tree */
2403 return retval;
2404 }
2405
2406
2407 /************************** SeqSummaryList ****************************************/
2408
2409 NLM_EXTERN SeqSummaryListPtr LIBCALL
SeqSummaryListNew(void)2410 SeqSummaryListNew(void)
2411 {
2412 SeqSummaryListPtr p;
2413
2414 p = MemNew(sizeof(SeqSummaryList));
2415 if (p != NULL)
2416 {
2417 p->num = 0;
2418 p->data = NULL;
2419 }
2420 return p;
2421 }
2422
2423 NLM_EXTERN SeqSummaryListPtr LIBCALL
SeqSummaryListFree(SeqSummaryListPtr p)2424 SeqSummaryListFree(SeqSummaryListPtr p)
2425 {
2426 Int4 i;
2427
2428 if (p == NULL)
2429 return NULL;
2430 if (p->data != NULL)
2431 {
2432 for (i = 0; i < p->num; i++)
2433 SeqSumFree(p->data[i]);
2434 }
2435 MemFree (p->data);
2436 return MemFree(p);
2437 }
2438
2439 NLM_EXTERN SeqSummaryListPtr LIBCALL
SeqSummaryListAsnRead(AsnIoPtr aip,AsnTypePtr orig)2440 SeqSummaryListAsnRead (AsnIoPtr aip, AsnTypePtr orig)
2441 {
2442 DataVal av;
2443 SeqSummaryListPtr p;
2444 AsnTypePtr atp;
2445 Int4 num;
2446
2447 if (!NetEntAsnLoad())
2448 return NULL;
2449
2450 if (aip == NULL)
2451 return NULL;
2452
2453 if (orig == NULL)
2454 atp = AsnReadId(aip, amp, SEQ_SUMMARY_LIST);
2455 else
2456 atp = AsnLinkType(orig, SEQ_SUMMARY_LIST); /* link in local tree */
2457
2458 if (atp == NULL)
2459 return NULL;
2460
2461 p = SeqSummaryListNew();
2462 if (p == NULL)
2463 goto erret;
2464
2465 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
2466 goto erret;
2467
2468 atp = AsnReadId(aip, amp, atp); /* find the num */
2469 if (atp == NULL)
2470 goto erret;
2471 if (AsnReadVal(aip, atp, &av) <= 0) /* get the num */
2472 goto erret;
2473 p->num = av.intvalue;
2474
2475 atp = AsnReadId(aip, amp, atp); /* find the data start-struct */
2476 if (atp == NULL)
2477 goto erret;
2478 if (AsnReadVal(aip, atp, &av) <= 0) /* get the data start-struct */
2479 goto erret;
2480
2481 p->data = (DocSumPtr PNTR) MemNew(sizeof(DocSumPtr) * (size_t) p->num);
2482 for (num = 0; num < p->num; num++)
2483 p->data[num] = NULL;
2484 atp = AsnReadId(aip, amp, atp);
2485
2486 for (num = 0; num < p->num && atp == SEQ_SUMMARY_LIST_data_E; num++)
2487 {
2488 if ((p->data[num] = SeqSumAsnRead(aip, atp)) == NULL)
2489 goto erret;
2490 atp = AsnReadId(aip, amp, atp);
2491 }
2492
2493 /* check for count mis-match */
2494 if (num != p->num || atp != SEQ_SUMMARY_LIST_data)
2495 goto erret;
2496
2497 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
2498 goto erret;
2499
2500 atp = AsnReadId(aip, amp, atp);
2501 if (orig == NULL)
2502 {
2503 if (atp != SEQ_SUMMARY_LIST)
2504 goto erret;
2505 }
2506 else { /* check for "close struct" associated with "orig" */
2507 if (atp != orig)
2508 goto erret;
2509 }
2510 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
2511 goto erret;
2512
2513 ret:
2514 AsnUnlinkType(orig);
2515 return p;
2516
2517 erret:
2518 p = SeqSummaryListFree(p);
2519 goto ret;
2520 }
2521
2522
2523 NLM_EXTERN Boolean LIBCALL
SeqSummaryListAsnWrite(SeqSummaryListPtr p,AsnIoPtr aip,AsnTypePtr orig)2524 SeqSummaryListAsnWrite (SeqSummaryListPtr p, AsnIoPtr aip, AsnTypePtr orig)
2525 {
2526 DataVal av;
2527 Int4 i;
2528 AsnTypePtr atp;
2529 Boolean retval = FALSE;
2530
2531 if (! NetEntAsnLoad() )
2532 return FALSE;
2533
2534 if (aip == NULL)
2535 return FALSE;
2536
2537 atp = AsnLinkType(orig, SEQ_SUMMARY_LIST); /* link local tree */
2538
2539 if (atp == NULL)
2540 return FALSE;
2541
2542 if (p == NULL)
2543 {
2544 AsnNullValueMsg(aip, atp);
2545 goto erret;
2546 }
2547
2548 if (! AsnStartStruct(aip, atp))
2549 goto erret;
2550 av.intvalue = p->num;
2551 AsnWrite (aip, SEQ_SUMMARY_LIST_num, &av);
2552
2553 AsnStartStruct (aip, SEQ_SUMMARY_LIST_data);
2554 for (i = 0; i < p->num; i++)
2555 {
2556 SeqSumAsnWrite(p->data[i], aip, SEQ_SUMMARY_LIST_data_E);
2557 }
2558 AsnEndStruct (aip, SEQ_SUMMARY_LIST_data);
2559
2560 if (! AsnEndStruct(aip, atp))
2561 goto erret;
2562
2563 retval = TRUE;
2564
2565 erret:
2566 AsnUnlinkType(orig); /* unlink local tree */
2567 return retval;
2568 }
2569
2570 /************************** SeqEntryList **************************************/
2571
2572 NLM_EXTERN SeqEntryListPtr LIBCALL
SeqEntryListNew(void)2573 SeqEntryListNew(void)
2574 {
2575 SeqEntryListPtr p;
2576
2577 p = MemNew(sizeof(*p));
2578 if (p != NULL)
2579 {
2580 p->num = 0;
2581 p->data = NULL;
2582 p->marked_missing = NULL;
2583 }
2584 return p;
2585 }
2586
2587 NLM_EXTERN SeqEntryListPtr LIBCALL
SeqEntryListFree(SeqEntryListPtr p)2588 SeqEntryListFree(SeqEntryListPtr p)
2589 {
2590 Int4 i;
2591
2592 if (p == NULL)
2593 return NULL;
2594 if (p->data != NULL)
2595 {
2596 for (i = 0; i < p->num; i++)
2597 SeqEntryFree(p->data[i]);
2598 }
2599 MemFree (p->data);
2600 EntrezIdsFree (p->marked_missing);
2601 return MemFree(p);
2602 }
2603
2604 NLM_EXTERN SeqEntryListPtr LIBCALL
SeqEntryListAsnRead(AsnIoPtr aip,AsnTypePtr orig)2605 SeqEntryListAsnRead (AsnIoPtr aip, AsnTypePtr orig)
2606 {
2607 DataVal av;
2608 SeqEntryListPtr p;
2609 AsnTypePtr atp;
2610 Int4 num;
2611
2612 if (!NetEntAsnLoad())
2613 return NULL;
2614
2615 if (aip == NULL)
2616 return NULL;
2617
2618 if (orig == NULL)
2619 atp = AsnReadId(aip, amp, ENTREZ_SEQ_ENTRY_LIST);
2620 else
2621 atp = AsnLinkType(orig, ENTREZ_SEQ_ENTRY_LIST); /* link in local tree */
2622
2623 if (atp == NULL)
2624 return NULL;
2625
2626 p = SeqEntryListNew();
2627 if (p == NULL)
2628 goto erret;
2629
2630 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
2631 goto erret;
2632
2633 atp = AsnReadId(aip, amp, atp); /* find the num */
2634 if (atp == NULL)
2635 goto erret;
2636 if (AsnReadVal(aip, atp, &av) <= 0) /* get the num */
2637 goto erret;
2638 p->num = av.intvalue;
2639
2640 atp = AsnReadId(aip, amp, atp); /* find the data start-struct */
2641 if (atp == NULL)
2642 goto erret;
2643 if (AsnReadVal(aip, atp, &av) <= 0) /* get the data start-struct */
2644 goto erret;
2645
2646 p->data = (SeqEntryPtr PNTR) MemNew(sizeof(SeqEntryPtr) * p->num);
2647 for (num = 0; num < p->num; num++)
2648 p->data[num] = NULL;
2649 atp = AsnReadId(aip, amp, atp);
2650
2651 for (num = 0; num < p->num && atp == ENTREZ_SEQ_ENTRY_LIST_data_E; num++)
2652 {
2653 if ((p->data[num] = SeqEntryAsnRead(aip, atp)) == NULL)
2654 goto erret;
2655 atp = AsnReadId(aip, amp, atp);
2656 }
2657
2658 /* check for count mis-match */
2659 if (num != p->num)
2660 goto erret;
2661
2662 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
2663 goto erret;
2664
2665 atp = AsnReadId(aip, amp, atp);
2666 if (atp == SEQ_ENTRY_LIST_marked_missing)
2667 {
2668 p->marked_missing = EntrezIdsAsnRead(aip, atp);
2669 atp = AsnReadId(aip, amp, atp);
2670 }
2671
2672 if (orig == NULL)
2673 {
2674 if (atp != ENTREZ_SEQ_ENTRY_LIST)
2675 goto erret;
2676 }
2677 else { /* check for "close struct" associated with "orig" */
2678 if (atp != orig)
2679 goto erret;
2680 }
2681 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
2682 goto erret;
2683
2684 ret:
2685 AsnUnlinkType(orig);
2686 return p;
2687
2688 erret:
2689 p = SeqEntryListFree(p);
2690 goto ret;
2691 }
2692
2693
2694 NLM_EXTERN Boolean LIBCALL
SeqEntryListAsnWrite(SeqEntryListPtr p,AsnIoPtr aip,AsnTypePtr orig)2695 SeqEntryListAsnWrite (SeqEntryListPtr p, AsnIoPtr aip, AsnTypePtr orig)
2696 {
2697 DataVal av;
2698 Int4 i;
2699 AsnTypePtr atp;
2700 Boolean retval = FALSE;
2701
2702 if (! NetEntAsnLoad() )
2703 return FALSE;
2704
2705 if (aip == NULL)
2706 return FALSE;
2707
2708 atp = AsnLinkType(orig, ENTREZ_SEQ_ENTRY_LIST); /* link local tree */
2709
2710 if (atp == NULL)
2711 return FALSE;
2712
2713 if (p == NULL)
2714 {
2715 AsnNullValueMsg(aip, atp);
2716 goto erret;
2717 }
2718
2719 if (! AsnStartStruct(aip, atp))
2720 goto erret;
2721 av.intvalue = p->num;
2722 AsnWrite (aip, ENTREZ_SEQ_ENTRY_LIST_num, &av);
2723
2724 AsnStartStruct (aip, ENTREZ_SEQ_ENTRY_LIST_data);
2725 for (i = 0; i < p->num; i++)
2726 {
2727 SeqEntryAsnWrite(p->data[i], aip, ENTREZ_SEQ_ENTRY_LIST_data_E);
2728 }
2729 AsnEndStruct (aip, ENTREZ_SEQ_ENTRY_LIST_data);
2730
2731 if (p->marked_missing != NULL) /* optional */
2732 {
2733 EntrezIdsAsnWrite(p->marked_missing, aip, SEQ_ENTRY_LIST_marked_missing);
2734 }
2735
2736 if (! AsnEndStruct(aip, atp))
2737 goto erret;
2738
2739 retval = TRUE;
2740
2741 erret:
2742 AsnUnlinkType(orig); /* unlink local tree */
2743 return retval;
2744 }
2745
2746 #ifdef Biostruc_supported
2747 /************************** BiostrucList *********************************/
2748
2749 NLM_EXTERN BiostrucListPtr LIBCALL
BiostrucListNew(void)2750 BiostrucListNew(void)
2751 {
2752 BiostrucListPtr p;
2753
2754 p = MemNew(sizeof(BiostrucList));
2755 if (p != NULL)
2756 {
2757 p->num = 0;
2758 p->data = NULL;
2759 p->marked_missing = NULL;
2760 }
2761 return p;
2762 }
2763
2764 NLM_EXTERN BiostrucListPtr LIBCALL
BiostrucListFree(BiostrucListPtr p)2765 BiostrucListFree(BiostrucListPtr p)
2766 {
2767 Int4 i;
2768
2769 if (p == NULL)
2770 return NULL;
2771 if (p->data != NULL)
2772 {
2773 for (i = 0; i < p->num; i++)
2774 BiostrucFree(p->data[i]);
2775 }
2776 MemFree (p->data);
2777 EntrezIdsFree (p->marked_missing);
2778 return MemFree(p);
2779 }
2780
2781 NLM_EXTERN BiostrucListPtr LIBCALL
BiostrucListAsnRead(AsnIoPtr aip,AsnTypePtr orig)2782 BiostrucListAsnRead (AsnIoPtr aip, AsnTypePtr orig)
2783 {
2784 DataVal av;
2785 BiostrucListPtr p;
2786 AsnTypePtr atp;
2787 Int4 num;
2788
2789 if (!NetEntAsnLoad())
2790 return NULL;
2791
2792 if (aip == NULL)
2793 return NULL;
2794
2795 if (orig == NULL)
2796 atp = AsnReadId(aip, amp, ENTREZ_BIOSTRUC_LIST);
2797 else
2798 atp = AsnLinkType(orig, ENTREZ_BIOSTRUC_LIST); /* link in local tree */
2799
2800 if (atp == NULL)
2801 return NULL;
2802
2803 p = BiostrucListNew();
2804 if (p == NULL)
2805 goto erret;
2806
2807 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
2808 goto erret;
2809
2810 atp = AsnReadId(aip, amp, atp); /* find the num */
2811 if (atp == NULL)
2812 goto erret;
2813 if (AsnReadVal(aip, atp, &av) <= 0) /* get the num */
2814 goto erret;
2815 p->num = av.intvalue;
2816
2817 atp = AsnReadId(aip, amp, atp); /* find the data start-struct */
2818 if (atp == NULL)
2819 goto erret;
2820 if (AsnReadVal(aip, atp, &av) <= 0) /* get the data start-struct */
2821 goto erret;
2822
2823 p->data = (BiostrucPtr PNTR) MemNew(sizeof(BiostrucPtr) * p->num);
2824 for (num = 0; num < p->num; num++)
2825 p->data[num] = NULL;
2826 atp = AsnReadId(aip, amp, atp);
2827
2828 for (num = 0; num < p->num && atp == ENTREZ_BIOSTRUC_LIST_data_E; num++)
2829 {
2830 if ((p->data[num] = BiostrucAsnRead(aip, atp)) == NULL)
2831 goto erret;
2832 atp = AsnReadId(aip, amp, atp);
2833 }
2834
2835 /* check for count mis-match */
2836 if (num != p->num)
2837 goto erret;
2838
2839 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
2840 goto erret;
2841
2842 atp = AsnReadId(aip, amp, atp);
2843
2844 if (atp == BIOSTRUC_LIST_marked_missing)
2845 {
2846 p->marked_missing = EntrezIdsAsnRead(aip, atp);
2847 atp = AsnReadId(aip, amp, atp);
2848 }
2849
2850 if (orig == NULL)
2851 {
2852 if (atp != ENTREZ_BIOSTRUC_LIST)
2853 goto erret;
2854 }
2855 else { /* check for "close struct" associated with "orig" */
2856 if (atp != orig)
2857 goto erret;
2858 }
2859 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
2860 goto erret;
2861
2862 ret:
2863 AsnUnlinkType(orig);
2864 return p;
2865
2866 erret:
2867 p = BiostrucListFree(p);
2868 goto ret;
2869 }
2870
2871
2872 NLM_EXTERN Boolean LIBCALL
BiostrucListAsnWrite(BiostrucListPtr p,AsnIoPtr aip,AsnTypePtr orig)2873 BiostrucListAsnWrite (BiostrucListPtr p, AsnIoPtr aip, AsnTypePtr orig)
2874 {
2875 DataVal av;
2876 Int4 i;
2877 AsnTypePtr atp;
2878 Boolean retval = FALSE;
2879
2880 if (! NetEntAsnLoad() )
2881 return FALSE;
2882
2883 if (aip == NULL)
2884 return FALSE;
2885
2886 atp = AsnLinkType(orig, ENTREZ_BIOSTRUC_LIST); /* link local tree */
2887
2888 if (atp == NULL)
2889 return FALSE;
2890
2891 if (p == NULL)
2892 {
2893 AsnNullValueMsg(aip, atp);
2894 goto erret;
2895 }
2896
2897 if (! AsnStartStruct(aip, atp))
2898 goto erret;
2899 av.intvalue = p->num;
2900 AsnWrite (aip, ENTREZ_BIOSTRUC_LIST_num, &av);
2901
2902 AsnStartStruct (aip, ENTREZ_BIOSTRUC_LIST_data);
2903 for (i = 0; i < p->num; i++)
2904 {
2905 BiostrucAsnWrite(p->data[i], aip, ENTREZ_BIOSTRUC_LIST_data_E);
2906 }
2907 AsnEndStruct (aip, ENTREZ_BIOSTRUC_LIST_data);
2908
2909 if (p->marked_missing != NULL) /* optional */
2910 {
2911 EntrezIdsAsnWrite(p->marked_missing, aip, BIOSTRUC_LIST_marked_missing);
2912 }
2913
2914 if (! AsnEndStruct(aip, atp))
2915 goto erret;
2916
2917 retval = TRUE;
2918
2919 erret:
2920 AsnUnlinkType(orig); /* unlink local tree */
2921 return retval;
2922 }
2923
2924
2925 #endif /* Biostruc_supported */
2926
2927 /**************************************************
2928 *
2929 * EntrezNeighborTextAsnRead()
2930 *
2931 **************************************************/
2932
2933 NLM_EXTERN EntrezNeighborTextPtr LIBCALL
EntrezNeighborTextAsnRead(AsnIoPtr aip,AsnTypePtr orig)2934 EntrezNeighborTextAsnRead(AsnIoPtr aip, AsnTypePtr orig)
2935 {
2936 DataVal av;
2937 AsnTypePtr atp;
2938 AsnReadFunc func;
2939 EntrezNeighborTextPtr ptr;
2940
2941 if (! NetEntAsnLoad())
2942 return NULL;
2943
2944 if (aip == NULL) {
2945 return NULL;
2946 }
2947
2948 if (orig == NULL) { /* EntrezNeighborText ::= (self contained) */
2949 atp = AsnReadId(aip, amp, ENTREZ_NEIGHBOR_TEXT);
2950 } else {
2951 atp = AsnLinkType(orig, ENTREZ_NEIGHBOR_TEXT);
2952 }
2953 /* link in local tree */
2954 if (atp == NULL) {
2955 return NULL;
2956 }
2957
2958 ptr = EntrezNeighborTextNew();
2959 if (ptr == NULL) {
2960 goto erret;
2961 }
2962 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
2963 goto erret;
2964 }
2965
2966 func = NULL;
2967
2968 atp = AsnReadId(aip,amp, atp);
2969 if (atp == ENTREZ_NEIGHBOR_TEXT_fld) {
2970 if ( AsnReadVal(aip, atp, &av) <= 0) {
2971 goto erret;
2972 }
2973 ptr -> fld =av.intvalue;
2974 atp = AsnReadId(aip,amp, atp);
2975 }
2976 if (atp == TEXT_percent_terms_to_use) {
2977 if ( AsnReadVal(aip, atp, &av) <= 0) {
2978 goto erret;
2979 }
2980 ptr -> percent_terms_to_use =av.intvalue;
2981 atp = AsnReadId(aip,amp, atp);
2982 }
2983 if (atp == NEIGHBOR_TEXT_max_neighbors) {
2984 if ( AsnReadVal(aip, atp, &av) <= 0) {
2985 goto erret;
2986 }
2987 ptr -> max_neighbors =av.intvalue;
2988 atp = AsnReadId(aip,amp, atp);
2989 }
2990 if (atp == ENTREZ_NEIGHBOR_TEXT_min_score) {
2991 if ( AsnReadVal(aip, atp, &av) <= 0) {
2992 goto erret;
2993 }
2994 ptr -> min_score =av.intvalue;
2995 atp = AsnReadId(aip,amp, atp);
2996 }
2997 if (atp == NEIGHBOR_TEXT_normal_text) {
2998 if ( AsnReadVal(aip, atp, &av) <= 0) {
2999 goto erret;
3000 }
3001 ptr -> normalText =av.ptrvalue;
3002 atp = AsnReadId(aip,amp, atp);
3003 }
3004 if (atp == NEIGHBOR_TEXT_special_text) {
3005 if ( AsnReadVal(aip, atp, &av) <= 0) {
3006 goto erret;
3007 }
3008 ptr -> specialText =av.ptrvalue;
3009 atp = AsnReadId(aip,amp, atp);
3010 }
3011
3012 if (AsnReadVal(aip, atp, &av) <= 0) {
3013 goto erret;
3014 }
3015 /* end struct */
3016
3017 ret:
3018 AsnUnlinkType(orig); /* unlink local tree */
3019 return ptr;
3020
3021 erret:
3022 ptr = EntrezNeighborTextFree(ptr);
3023 goto ret;
3024 }
3025
3026
3027
3028 /**************************************************
3029 *
3030 * EntrezNeighborTextAsnWrite()
3031 *
3032 **************************************************/
3033 NLM_EXTERN Boolean LIBCALL
EntrezNeighborTextAsnWrite(EntrezNeighborTextPtr ptr,AsnIoPtr aip,AsnTypePtr orig)3034 EntrezNeighborTextAsnWrite(EntrezNeighborTextPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
3035 {
3036 DataVal av;
3037 AsnTypePtr atp;
3038 Boolean retval = FALSE;
3039
3040 if (! NetEntAsnLoad() )
3041 return FALSE;
3042
3043 if (aip == NULL) {
3044 return FALSE;
3045 }
3046
3047 atp = AsnLinkType(orig, ENTREZ_NEIGHBOR_TEXT); /* link local tree */
3048 if (atp == NULL) {
3049 return FALSE;
3050 }
3051
3052 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3053
3054 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
3055 goto erret;
3056 }
3057
3058 av.intvalue = ptr -> fld;
3059 retval = AsnWrite(aip, ENTREZ_NEIGHBOR_TEXT_fld, &av);
3060 av.intvalue = ptr -> percent_terms_to_use;
3061 retval = AsnWrite(aip, TEXT_percent_terms_to_use, &av);
3062 av.intvalue = ptr -> max_neighbors;
3063 retval = AsnWrite(aip, NEIGHBOR_TEXT_max_neighbors, &av);
3064 av.intvalue = ptr -> min_score;
3065 retval = AsnWrite(aip, ENTREZ_NEIGHBOR_TEXT_min_score, &av);
3066
3067 if (ptr -> normalText != NULL) {
3068 av.ptrvalue = ptr -> normalText;
3069 retval = AsnWrite(aip, NEIGHBOR_TEXT_normal_text, &av);
3070 }
3071
3072 if (ptr -> specialText != NULL) {
3073 av.ptrvalue = ptr -> specialText;
3074 retval = AsnWrite(aip, NEIGHBOR_TEXT_special_text, &av);
3075 }
3076
3077 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
3078 goto erret;
3079 }
3080 retval = TRUE;
3081
3082 erret:
3083 AsnUnlinkType(orig); /* unlink local tree */
3084 return retval;
3085 }
3086
3087
3088 /**************************************************
3089 *
3090 * ChildLinkNew()
3091 *
3092 ***************************************************/
3093
ChildLinkNew(void)3094 static ChildLinkPtr LIBCALL ChildLinkNew(void)
3095 {
3096 ChildLinkPtr ptr = MemNew((size_t) sizeof(ChildLink));
3097 return ptr;
3098
3099 }
3100
3101
3102 /**************************************************
3103 *
3104 * ChildLinkFree()
3105 *
3106 **************************************************/
3107
ChildLinkFree(ChildLinkPtr ptr)3108 static ChildLinkPtr LIBCALL ChildLinkFree(ChildLinkPtr ptr)
3109 {
3110
3111 if(ptr == NULL)
3112 {
3113 return NULL;
3114 }
3115 MemFree(ptr -> name);
3116 return MemFree(ptr);
3117 }
3118
3119 /******************************************
3120 *
3121 * ChildLinkedListFree()
3122 *
3123 *******************************************/
3124
ChildLinkedListFree(ChildLinkPtr ptr)3125 static void LIBCALL ChildLinkedListFree(ChildLinkPtr ptr)
3126 {
3127 ChildLinkPtr next;
3128 while(ptr != NULL)
3129 {
3130 next = ptr -> next;
3131 ChildLinkFree(ptr);
3132 ptr = next;
3133 }
3134 }
3135
3136
3137
3138 /**************************************************
3139 *
3140 * ChildLinkAsnRead()
3141 *
3142 **************************************************/
3143
ChildLinkAsnRead(AsnIoPtr aip,AsnTypePtr orig)3144 static ChildLinkPtr LIBCALL ChildLinkAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3145 {
3146 DataVal av;
3147 AsnTypePtr atp;
3148 AsnReadFunc func;
3149 ChildLinkPtr ChildPtr;
3150
3151 if (! loaded)
3152 {
3153 if (! NetEntAsnLoad()) {
3154 return NULL;
3155 }
3156 }
3157
3158 if (aip == NULL) {
3159 return NULL;
3160 }
3161
3162 if (orig == NULL) {
3163 atp = AsnReadId(aip, amp, ENTREZ_TREE_CHILD);
3164 } else {
3165 atp = AsnLinkType(orig, ENTREZ_TREE_CHILD);
3166 }
3167 /* link in local tree */
3168 if (atp == NULL) {
3169 return NULL;
3170 }
3171
3172 ChildPtr = ChildLinkNew();
3173 if (ChildPtr == NULL) {
3174 goto erret;
3175 }
3176 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
3177 goto erret;
3178 }
3179
3180 func = NULL;
3181
3182 atp = AsnReadId(aip,amp, atp);
3183 if (atp == ENTREZ_TREE_CHILD_name) {
3184 if ( AsnReadVal(aip, atp, &av) <= 0) {
3185 goto erret;
3186 }
3187 ChildPtr -> name = av.ptrvalue;
3188 atp = AsnReadId(aip,amp, atp);
3189 }
3190 if (atp == ENTREZ_TREE_CHILD_is_leaf_node) {
3191 if ( AsnReadVal(aip, atp, &av) <= 0) {
3192 goto erret;
3193 }
3194 ChildPtr -> isLeafNode = av.boolvalue;
3195 atp = AsnReadId(aip,amp, atp);
3196 }
3197 if (atp == ENTREZ_TREE_CHILD_special) {
3198 if ( AsnReadVal(aip, atp, &av) <= 0) {
3199 goto erret;
3200 }
3201 ChildPtr -> special = av.intvalue;
3202 atp = AsnReadId(aip,amp, atp);
3203 }
3204 if (atp == ENTREZ_TREE_CHILD_total) {
3205 if ( AsnReadVal(aip, atp, &av) <= 0) {
3206 goto erret;
3207 }
3208 ChildPtr -> total = av.intvalue;
3209 atp = AsnReadId(aip,amp, atp);
3210 }
3211
3212 if (AsnReadVal(aip, atp, &av) <= 0) {
3213 goto erret;
3214 }
3215 /* end struct */
3216
3217 ret:
3218 AsnUnlinkType(orig); /* unlink local tree */
3219 return ChildPtr;
3220
3221 erret:
3222 ChildLinkFree(ChildPtr);
3223 goto ret;
3224 }
3225
3226
3227
3228 /**************************************************
3229 *
3230 * ChildLinkAsnWrite()
3231 *
3232 **************************************************/
3233 static Boolean LIBCALL
ChildLinkAsnWrite(ChildLinkPtr ptr,AsnIoPtr aip,AsnTypePtr orig)3234 ChildLinkAsnWrite(ChildLinkPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
3235 {
3236 DataVal av;
3237 AsnTypePtr atp;
3238 Boolean retval = FALSE;
3239
3240 if (! loaded)
3241 {
3242 if (! NetEntAsnLoad()) {
3243 return FALSE;
3244 }
3245 }
3246
3247 if (aip == NULL) {
3248 return FALSE;
3249 }
3250
3251 atp = AsnLinkType(orig, ENTREZ_TREE_CHILD); /* link local tree */
3252 if (atp == NULL) {
3253 return FALSE;
3254 }
3255
3256 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3257
3258 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
3259 goto erret;
3260 }
3261
3262 if (ptr -> name != NULL) {
3263 av.ptrvalue = ptr -> name;
3264 retval = AsnWrite(aip, ENTREZ_TREE_CHILD_name, &av);
3265 }
3266 av.boolvalue = ptr -> isLeafNode;
3267 retval = AsnWrite(aip, ENTREZ_TREE_CHILD_is_leaf_node, &av);
3268 av.intvalue = ptr -> special;
3269 retval = AsnWrite(aip, ENTREZ_TREE_CHILD_special, &av);
3270 av.intvalue = ptr -> total;
3271 retval = AsnWrite(aip, ENTREZ_TREE_CHILD_total, &av);
3272 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
3273 goto erret;
3274 }
3275 retval = TRUE;
3276
3277 erret:
3278 AsnUnlinkType(orig); /* unlink local tree */
3279 return retval;
3280 }
3281
ChildLinkedListToArray(ChildLinkPtr Link,Int4 numChildren)3282 static EntrezHierarchyChildPtr ChildLinkedListToArray(ChildLinkPtr Link,
3283 Int4 numChildren)
3284 {
3285 Int4 Index = 0;
3286 EntrezHierarchyChildPtr Array;
3287
3288 if (numChildren <= 0)
3289 return NULL;
3290
3291 Array = MemNew(sizeof(EntrezHierarchyChild) * numChildren);
3292 while (Link != NULL)
3293 {
3294 Array[Index].name = StringSave(Link -> name);
3295 Array[Index].isLeafNode = Link -> isLeafNode;
3296 Array[Index].special = Link -> special;
3297 Array[Index].total = Link -> total;
3298 Index++;
3299 Link = Link -> next;
3300 }
3301
3302 if (Index != numChildren)
3303 {
3304 fprintf(stderr,"ChildLinkedListToArray : counts do not match!\n");
3305 exit (0);
3306 }
3307
3308 return Array;
3309 }
3310
ArrayToChildLinkedList(EntrezHierarchyChildPtr Array,Int4 numChildren)3311 static ChildLinkPtr ArrayToChildLinkedList(
3312 EntrezHierarchyChildPtr Array,
3313 Int4 numChildren)
3314 {
3315 Int4 Index;
3316 ChildLinkPtr Link, Start;
3317
3318 if (numChildren <= 0)
3319 return NULL;
3320
3321 for (Index = 0; Index < numChildren; Index++)
3322 {
3323 if (Index == 0)
3324 Start = Link = ChildLinkNew();
3325 else
3326 {
3327 Link -> next = ChildLinkNew();
3328 Link = Link -> next;
3329 }
3330
3331 Link -> name = StringSave(Array[Index].name);
3332 Link -> isLeafNode = Array[Index].isLeafNode;
3333 Link -> special = Array[Index].special;
3334 Link -> total = Array[Index].total;
3335 }
3336
3337 Link -> next = NULL;
3338 return (Start);
3339
3340 }
3341
LineageListToArray(ValNodePtr Lineage,Int4 numInLineage)3342 static CharPtr PNTR LineageListToArray(ValNodePtr Lineage,
3343 Int4 numInLineage)
3344 {
3345 CharPtr PNTR start;
3346 CharPtr PNTR ptr;
3347
3348 if (numInLineage <= 0)
3349 return NULL;
3350
3351 start = ptr = MemNew(sizeof(CharPtr) * numInLineage);
3352 while (Lineage != NULL)
3353 {
3354 *ptr++ = StringSave(Lineage -> data.ptrvalue);
3355 Lineage = Lineage -> next;
3356 }
3357
3358 if ((long) (ptr - start) != numInLineage)
3359 {
3360 fprintf(stderr,"mismatch in LineageListToArray!\n");
3361 exit (0);
3362 }
3363
3364 return start;
3365 }
3366
LineageArrayToList(CharPtr PNTR Lineage,Int4 numInLineage)3367 static ValNodePtr LineageArrayToList(CharPtr PNTR Lineage, Int4 numInLineage)
3368 {
3369 ValNodePtr ptr, start;
3370 Int4 index;
3371
3372 if (numInLineage <= 0)
3373 return NULL;
3374
3375 for (index = 0; index < numInLineage; index++)
3376 {
3377 if (index == 0)
3378 {
3379 start = ptr = MemNew(sizeof(ValNode));
3380 }
3381 else
3382 {
3383 ptr -> next = MemNew(sizeof(ValNode));
3384 ptr = ptr ->next;
3385 }
3386
3387 ptr -> choice = 0;
3388 ptr -> data.ptrvalue = StringSave(Lineage[index]);
3389 }
3390
3391 ptr -> next = NULL;
3392
3393 return start;
3394 }
3395
FreeLineageList(ValNodePtr ptr)3396 static void FreeLineageList(ValNodePtr ptr)
3397 {
3398 ValNodePtr next;
3399
3400 while(ptr != NULL)
3401 {
3402 next = ptr ->next;
3403 MemFree(ptr -> data.ptrvalue);
3404 MemFree(ptr);
3405 ptr = next;
3406 }
3407 }
3408
3409
3410 /**************************************************
3411 *
3412 * EntrezHierarchyNew()
3413 *
3414 **************************************************/
3415
EntrezHierarchyNew(void)3416 NLM_EXTERN EntrezHierarchyPtr LIBCALL EntrezHierarchyNew(void)
3417 {
3418 EntrezHierarchyPtr ptr = MemNew((size_t) sizeof(EntrezHierarchy));
3419 return ptr;
3420 }
3421
3422
3423 /**************************************************
3424 *
3425 * EntrezHierarchyFree() is defined in accentr.c
3426 *
3427 **************************************************/
3428
3429
3430
3431 /**************************************************
3432 *
3433 * EntrezHierarchyAsnRead()
3434 *
3435 **************************************************/
3436
EntrezHierarchyAsnRead(AsnIoPtr aip,AsnTypePtr orig)3437 NLM_EXTERN EntrezHierarchyPtr LIBCALL EntrezHierarchyAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3438 {
3439 DataVal av;
3440 AsnTypePtr atp;
3441 Boolean isError;
3442 AsnReadFunc func;
3443 EntrezHierarchyPtr ptr;
3444 ChildLinkPtr ChildLinkedList;
3445 ValNodePtr LineageList;
3446
3447 if (! loaded)
3448 {
3449 if (! NetEntAsnLoad())
3450 {
3451 return NULL;
3452 }
3453 }
3454
3455 if (aip == NULL)
3456 {
3457 return NULL;
3458 }
3459
3460 if (orig == NULL)
3461 { /* EntrezHierarchy ::= (self contained) */
3462 atp = AsnReadId(aip, amp, ENTREZ_TREE);
3463 }
3464 else
3465 {
3466 atp = AsnLinkType(orig, ENTREZ_TREE);
3467 }
3468 /* link in local tree */
3469 if (atp == NULL)
3470 {
3471 return NULL;
3472 }
3473
3474 ptr = EntrezHierarchyNew();
3475 if (ptr == NULL)
3476 {
3477 goto erret;
3478 }
3479 if (AsnReadVal(aip, atp, &av) <= 0)
3480 { /* read the start struct */
3481 goto erret;
3482 }
3483
3484 func = NULL;
3485
3486 atp = AsnReadId(aip,amp, atp);
3487 if (atp == ENTREZ_TREE_num_in_lineage)
3488 {
3489 if ( AsnReadVal(aip, atp, &av) <= 0)
3490 {
3491 goto erret;
3492 }
3493 ptr -> numInLineage = av.intvalue;
3494 atp = AsnReadId(aip,amp, atp);
3495 }
3496 if (atp == ENTREZ_TREE_num_children)
3497 {
3498 if ( AsnReadVal(aip, atp, &av) <= 0)
3499 {
3500 goto erret;
3501 }
3502 ptr -> numChildren = av.intvalue;
3503 atp = AsnReadId(aip,amp, atp);
3504 }
3505 if (atp == ENTREZ_TREE_term)
3506 {
3507 if ( AsnReadVal(aip, atp, &av) <= 0)
3508 {
3509 goto erret;
3510 }
3511 ptr -> term = av.ptrvalue;
3512 atp = AsnReadId(aip,amp, atp);
3513 }
3514 if (atp == ENTREZ_TREE_lineage)
3515 {
3516 LineageList = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
3517 if (isError && LineageList == NULL)
3518
3519 {
3520 goto erret;
3521 }
3522 ptr -> lineage = LineageListToArray(LineageList,
3523 ptr->numInLineage);
3524 FreeLineageList(LineageList);
3525 atp = AsnReadId(aip,amp, atp);
3526 }
3527
3528 if (atp == ENTREZ_TREE_children)
3529 {
3530 ChildLinkedList = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError,
3531 (AsnReadFunc) ChildLinkAsnRead,
3532 (AsnOptFreeFunc) ChildLinkFree);
3533 if (isError && ChildLinkedList == NULL)
3534
3535 {
3536 goto erret;
3537 }
3538 ptr -> children = ChildLinkedListToArray(ChildLinkedList,
3539 ptr ->numChildren);
3540 ChildLinkedListFree(ChildLinkedList);
3541 atp = AsnReadId(aip,amp, atp);
3542 }
3543 if (atp == ENTREZ_TREE_canonical_form)
3544 {
3545 if ( AsnReadVal(aip, atp, &av) <= 0)
3546 {
3547 goto erret;
3548 }
3549 ptr -> canonicalForm = av.ptrvalue;
3550 atp = AsnReadId(aip,amp, atp);
3551 }
3552
3553 if (AsnReadVal(aip, atp, &av) <= 0)
3554 {
3555 goto erret;
3556 }
3557 /* end struct */
3558
3559 ret:
3560 AsnUnlinkType(orig); /* unlink local tree */
3561 return ptr;
3562
3563 erret:
3564 ptr = EntrezHierarchyFree(ptr);
3565 goto ret;
3566 }
3567
3568
3569
3570 /**************************************************
3571 *
3572 * EntrezHierarchyAsnWrite()
3573 *
3574 **************************************************/
3575 NLM_EXTERN Boolean LIBCALL
EntrezHierarchyAsnWrite(EntrezHierarchyPtr ptr,AsnIoPtr aip,AsnTypePtr orig)3576 EntrezHierarchyAsnWrite(EntrezHierarchyPtr ptr, AsnIoPtr aip,
3577 AsnTypePtr orig)
3578
3579 {
3580 DataVal av;
3581 AsnTypePtr atp;
3582 Boolean retval = FALSE;
3583 ValNodePtr LineageList;
3584 ChildLinkPtr ChildLinkedList;
3585
3586 if (! loaded)
3587 {
3588 if (! NetEntAsnLoad())
3589 {
3590 return FALSE;
3591 }
3592 }
3593
3594 if (aip == NULL)
3595 {
3596 return FALSE;
3597 }
3598
3599 atp = AsnLinkType(orig, ENTREZ_TREE); /* link local tree */
3600 if (atp == NULL)
3601 {
3602 return FALSE;
3603 }
3604
3605 if (ptr == NULL)
3606 {
3607 AsnNullValueMsg(aip, atp); goto erret;
3608 }
3609
3610 if (! AsnOpenStruct(aip, atp, (Pointer) ptr))
3611 {
3612 goto erret;
3613 }
3614
3615 av.intvalue = ptr -> numInLineage;
3616 retval = AsnWrite(aip, ENTREZ_TREE_num_in_lineage, &av);
3617 av.intvalue = ptr -> numChildren;
3618 retval = AsnWrite(aip, ENTREZ_TREE_num_children, &av);
3619 if (ptr -> term != NULL)
3620 {
3621 av.ptrvalue = ptr -> term;
3622 retval = AsnWrite(aip, ENTREZ_TREE_term, &av);
3623 }
3624
3625 LineageList = LineageArrayToList(ptr -> lineage,ptr -> numInLineage);
3626 retval = AsnGenericBaseSeqOfAsnWrite(LineageList ,ASNCODE_PTRVAL_SLOT,
3627 aip,ENTREZ_TREE_lineage,
3628 ENTREZ_TREE_lineage_E);
3629 FreeLineageList(LineageList);
3630
3631 ChildLinkedList = ArrayToChildLinkedList(ptr -> children,ptr->numChildren);
3632 AsnGenericUserSeqOfAsnWrite(ChildLinkedList,
3633 (AsnWriteFunc) ChildLinkAsnWrite, aip,
3634 ENTREZ_TREE_children, ENTREZ_TREE_children_E);
3635 ChildLinkedListFree(ChildLinkedList);
3636
3637 if (ptr -> canonicalForm != NULL)
3638 {
3639 av.ptrvalue = ptr -> canonicalForm;
3640 retval = AsnWrite(aip, ENTREZ_TREE_canonical_form, &av);
3641 }
3642 if (! AsnCloseStruct(aip, atp, (Pointer)ptr))
3643 {
3644 goto erret;
3645 }
3646 retval = TRUE;
3647
3648 erret:
3649 AsnUnlinkType(orig); /* unlink local tree */
3650 return retval;
3651 }
3652
3653
3654 /**************************************************
3655 *
3656 * EntrezBlastreqNew()
3657 *
3658 **************************************************/
3659
3660 NLM_EXTERN EntrezBlastreqPtr LIBCALL
EntrezBlastreqNew(void)3661 EntrezBlastreqNew(void)
3662 {
3663 EntrezBlastreqPtr ptr = MemNew((size_t) sizeof(EntrezBlastreq));
3664
3665 ptr->showprogress = FALSE;
3666
3667 return ptr;
3668
3669 }
3670
3671
3672 /**************************************************
3673 *
3674 * EntrezBlastreqFree()
3675 *
3676 **************************************************/
3677
3678 NLM_EXTERN EntrezBlastreqPtr LIBCALL
EntrezBlastreqFree(EntrezBlastreqPtr ptr)3679 EntrezBlastreqFree(EntrezBlastreqPtr ptr)
3680 {
3681
3682 if(ptr == NULL) {
3683 return NULL;
3684 }
3685 BioseqFree(ptr -> bsp);
3686 MemFree(ptr -> program);
3687 MemFree(ptr -> database);
3688 MemFree(ptr -> options);
3689 return MemFree(ptr);
3690 }
3691
3692
3693 /**************************************************
3694 *
3695 * EntrezBlastreqAsnRead()
3696 *
3697 **************************************************/
3698
3699 NLM_EXTERN EntrezBlastreqPtr LIBCALL
EntrezBlastreqAsnRead(AsnIoPtr aip,AsnTypePtr orig)3700 EntrezBlastreqAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3701 {
3702 DataVal av;
3703 AsnTypePtr atp;
3704 Boolean isError = FALSE;
3705 AsnReadFunc func;
3706 EntrezBlastreqPtr ptr;
3707
3708 if (! loaded)
3709 {
3710 if (! NetEntAsnLoad()) {
3711 return NULL;
3712 }
3713 }
3714
3715 if (aip == NULL) {
3716 return NULL;
3717 }
3718
3719 if (orig == NULL) { /* EntrezBlastreq ::= (self contained) */
3720 atp = AsnReadId(aip, amp, ENTREZ_BLASTREQ);
3721 } else {
3722 atp = AsnLinkType(orig, ENTREZ_BLASTREQ);
3723 }
3724 /* link in local tree */
3725 if (atp == NULL) {
3726 return NULL;
3727 }
3728
3729 ptr = EntrezBlastreqNew();
3730 if (ptr == NULL) {
3731 goto erret;
3732 }
3733 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
3734 goto erret;
3735 }
3736
3737 atp = AsnReadId(aip,amp, atp);
3738 func = NULL;
3739
3740 if (atp == ENTREZ_BLASTREQ_bsp) {
3741 ptr -> bsp = BioseqAsnRead(aip, atp);
3742 if (aip -> io_failure) {
3743 goto erret;
3744 }
3745 atp = AsnReadId(aip,amp, atp);
3746 }
3747 if (atp == ENTREZ_BLASTREQ_bsp_database) {
3748 if ( AsnReadVal(aip, atp, &av) <= 0) {
3749 goto erret;
3750 }
3751 ptr -> bsp_database = av.intvalue;
3752 atp = AsnReadId(aip,amp, atp);
3753 }
3754 if (atp == ENTREZ_BLASTREQ_program) {
3755 if ( AsnReadVal(aip, atp, &av) <= 0) {
3756 goto erret;
3757 }
3758 ptr -> program = av.ptrvalue;
3759 atp = AsnReadId(aip,amp, atp);
3760 }
3761 if (atp == ENTREZ_BLASTREQ_database) {
3762 if ( AsnReadVal(aip, atp, &av) <= 0) {
3763 goto erret;
3764 }
3765 ptr -> database = av.ptrvalue;
3766 atp = AsnReadId(aip,amp, atp);
3767 }
3768 if (atp == ENTREZ_BLASTREQ_options) {
3769 if ( AsnReadVal(aip, atp, &av) <= 0) {
3770 goto erret;
3771 }
3772 ptr -> options = av.ptrvalue;
3773 atp = AsnReadId(aip,amp, atp);
3774 }
3775 if (atp == ENTREZ_BLASTREQ_showprogress) {
3776 if ( AsnReadVal(aip, atp, &av) <= 0) {
3777 goto erret;
3778 }
3779 ptr -> showprogress = av.boolvalue;
3780 atp = AsnReadId(aip,amp, atp);
3781 }
3782
3783 if (AsnReadVal(aip, atp, &av) <= 0) {
3784 goto erret;
3785 }
3786 /* end struct */
3787
3788 ret:
3789 AsnUnlinkType(orig); /* unlink local tree */
3790 return ptr;
3791
3792 erret:
3793 aip -> io_failure = TRUE;
3794 ptr = EntrezBlastreqFree(ptr);
3795 goto ret;
3796 }
3797
3798
3799
3800 /**************************************************
3801 *
3802 * EntrezBlastreqAsnWrite()
3803 *
3804 **************************************************/
3805 NLM_EXTERN Boolean LIBCALL
EntrezBlastreqAsnWrite(EntrezBlastreqPtr ptr,AsnIoPtr aip,AsnTypePtr orig)3806 EntrezBlastreqAsnWrite(EntrezBlastreqPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
3807 {
3808 DataVal av;
3809 AsnTypePtr atp;
3810 Boolean retval = FALSE;
3811
3812 if (! loaded)
3813 {
3814 if (! NetEntAsnLoad()) {
3815 return FALSE;
3816 }
3817 }
3818
3819 if (aip == NULL) {
3820 return FALSE;
3821 }
3822
3823 atp = AsnLinkType(orig, ENTREZ_BLASTREQ); /* link local tree */
3824 if (atp == NULL) {
3825 return FALSE;
3826 }
3827
3828 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
3829 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
3830 goto erret;
3831 }
3832
3833 if (ptr -> bsp != NULL) {
3834 if ( ! BioseqAsnWrite(ptr -> bsp, aip, ENTREZ_BLASTREQ_bsp)) {
3835 goto erret;
3836 }
3837 }
3838 av.intvalue = ptr -> bsp_database;
3839 retval = AsnWrite(aip, ENTREZ_BLASTREQ_bsp_database, &av);
3840 if (ptr -> program != NULL) {
3841 av.ptrvalue = ptr -> program;
3842 retval = AsnWrite(aip, ENTREZ_BLASTREQ_program, &av);
3843 }
3844 if (ptr -> database != NULL) {
3845 av.ptrvalue = ptr -> database;
3846 retval = AsnWrite(aip, ENTREZ_BLASTREQ_database, &av);
3847 }
3848 if (ptr -> options != NULL) {
3849 av.ptrvalue = ptr -> options;
3850 retval = AsnWrite(aip, ENTREZ_BLASTREQ_options, &av);
3851 }
3852 av.boolvalue = ptr -> bsp_database;
3853 retval = AsnWrite(aip, ENTREZ_BLASTREQ_showprogress, &av);
3854 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
3855 goto erret;
3856 }
3857 retval = TRUE;
3858
3859 erret:
3860 AsnUnlinkType(orig); /* unlink local tree */
3861 return retval;
3862 }
3863
3864
3865
3866 /**************************************************
3867 *
3868 * EntrezExtraInfoNew()
3869 *
3870 **************************************************/
3871
3872 NLM_EXTERN EntrezExtraInfoPtr LIBCALL
EntrezExtraInfoNew(void)3873 EntrezExtraInfoNew(void)
3874 {
3875 EntrezExtraInfoPtr ptr = MemNew((size_t) sizeof(EntrezExtraInfo));
3876
3877 return ptr;
3878
3879 }
3880
3881
3882 /**************************************************
3883 *
3884 * EntrezExtraInfoFree()
3885 *
3886 **************************************************/
3887
3888 NLM_EXTERN EntrezExtraInfoPtr LIBCALL
EntrezExtraInfoFree(EntrezExtraInfoPtr ptr)3889 EntrezExtraInfoFree(EntrezExtraInfoPtr ptr)
3890 {
3891
3892 if(ptr == NULL) {
3893 return NULL;
3894 }
3895 return MemFree(ptr);
3896 }
3897
3898
3899 /**************************************************
3900 *
3901 * EntrezExtraInfoAsnRead()
3902 *
3903 **************************************************/
3904
3905 NLM_EXTERN EntrezExtraInfoPtr LIBCALL
EntrezExtraInfoAsnRead(AsnIoPtr aip,AsnTypePtr orig)3906 EntrezExtraInfoAsnRead(AsnIoPtr aip, AsnTypePtr orig)
3907 {
3908 DataVal av;
3909 AsnTypePtr atp;
3910 Boolean isError = FALSE;
3911 AsnReadFunc func;
3912 EntrezExtraInfoPtr ptr;
3913
3914 if (! loaded)
3915 {
3916 if (! NetEntAsnLoad()) {
3917 return NULL;
3918 }
3919 }
3920
3921 if (aip == NULL) {
3922 return NULL;
3923 }
3924
3925 if (orig == NULL) { /* EntrezExtraInfo ::= (self contained) */
3926 atp = AsnReadId(aip, amp, ENTREZ_EXTRA_INFO);
3927 } else {
3928 atp = AsnLinkType(orig, ENTREZ_EXTRA_INFO);
3929 }
3930 /* link in local tree */
3931 if (atp == NULL) {
3932 return NULL;
3933 }
3934
3935 ptr = EntrezExtraInfoNew();
3936 if (ptr == NULL) {
3937 goto erret;
3938 }
3939 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
3940 goto erret;
3941 }
3942
3943 atp = AsnReadId(aip,amp, atp);
3944 func = NULL;
3945
3946 if (atp == ENTREZ_EXTRA_INFO_maxlinks) {
3947 if ( AsnReadVal(aip, atp, &av) <= 0) {
3948 goto erret;
3949 }
3950 ptr -> maxlinks = av.intvalue;
3951 atp = AsnReadId(aip,amp, atp);
3952 }
3953 if (atp == EXTRA_INFO_canneighbortext) {
3954 if ( AsnReadVal(aip, atp, &av) <= 0) {
3955 goto erret;
3956 }
3957 ptr -> canneighbortext = av.boolvalue;
3958 atp = AsnReadId(aip,amp, atp);
3959 }
3960 if (atp == EXTRA_INFO_expanded_medline) {
3961 if ( AsnReadVal(aip, atp, &av) <= 0) {
3962 goto erret;
3963 }
3964 ptr -> expanded_medline = av.boolvalue;
3965 atp = AsnReadId(aip,amp, atp);
3966 }
3967 if (atp == ENTREZ_EXTRA_INFO_canblast) {
3968 if ( AsnReadVal(aip, atp, &av) <= 0) {
3969 goto erret;
3970 }
3971 ptr -> canblast = av.boolvalue;
3972 atp = AsnReadId(aip,amp, atp);
3973 }
3974
3975 if (AsnReadVal(aip, atp, &av) <= 0) {
3976 goto erret;
3977 }
3978 /* end struct */
3979
3980 ret:
3981 AsnUnlinkType(orig); /* unlink local tree */
3982 return ptr;
3983
3984 erret:
3985 aip -> io_failure = TRUE;
3986 ptr = EntrezExtraInfoFree(ptr);
3987 goto ret;
3988 }
3989
3990
3991
3992 /**************************************************
3993 *
3994 * EntrezExtraInfoAsnWrite()
3995 *
3996 **************************************************/
3997 NLM_EXTERN Boolean LIBCALL
EntrezExtraInfoAsnWrite(EntrezExtraInfoPtr ptr,AsnIoPtr aip,AsnTypePtr orig)3998 EntrezExtraInfoAsnWrite(EntrezExtraInfoPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
3999 {
4000 DataVal av;
4001 AsnTypePtr atp;
4002 Boolean retval = FALSE;
4003
4004 if (! loaded)
4005 {
4006 if (! NetEntAsnLoad()) {
4007 return FALSE;
4008 }
4009 }
4010
4011 if (aip == NULL) {
4012 return FALSE;
4013 }
4014
4015 atp = AsnLinkType(orig, ENTREZ_EXTRA_INFO); /* link local tree */
4016 if (atp == NULL) {
4017 return FALSE;
4018 }
4019
4020 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4021 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
4022 goto erret;
4023 }
4024
4025 av.intvalue = ptr -> maxlinks;
4026 retval = AsnWrite(aip, ENTREZ_EXTRA_INFO_maxlinks, &av);
4027 av.boolvalue = ptr -> canneighbortext;
4028 retval = AsnWrite(aip, EXTRA_INFO_canneighbortext, &av);
4029 av.boolvalue = ptr -> expanded_medline;
4030 retval = AsnWrite(aip, EXTRA_INFO_expanded_medline, &av);
4031 av.boolvalue = ptr -> canblast;
4032 retval = AsnWrite(aip, ENTREZ_EXTRA_INFO_canblast, &av);
4033 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4034 goto erret;
4035 }
4036 retval = TRUE;
4037
4038 erret:
4039 AsnUnlinkType(orig); /* unlink local tree */
4040 return retval;
4041 }
4042
4043
4044 /************************** NewSummaryList ****************************************/
4045
4046 NLM_EXTERN NewSummaryListPtr LIBCALL
NewSummaryListNew(void)4047 NewSummaryListNew(void)
4048 {
4049 NewSummaryListPtr p;
4050
4051 p = MemNew(sizeof(NewSummaryList));
4052 if (p != NULL)
4053 {
4054 p->num = 0;
4055 p->data = NULL;
4056 }
4057 return p;
4058 }
4059
4060 NLM_EXTERN NewSummaryListPtr LIBCALL
NewSummaryListFree(NewSummaryListPtr p)4061 NewSummaryListFree(NewSummaryListPtr p)
4062 {
4063 Int4 i;
4064
4065 if (p == NULL)
4066 return NULL;
4067 if (p->data != NULL)
4068 {
4069 for (i = 0; i < p->num; i++)
4070 DocSumFree(p->data[i]);
4071 }
4072 MemFree (p->data);
4073 return MemFree(p);
4074 }
4075
4076 NLM_EXTERN NewSummaryListPtr LIBCALL
NewSummaryListAsnRead(AsnIoPtr aip,AsnTypePtr orig)4077 NewSummaryListAsnRead (AsnIoPtr aip, AsnTypePtr orig)
4078 {
4079 DataVal av;
4080 NewSummaryListPtr p;
4081 AsnTypePtr atp;
4082 Int4 num;
4083
4084 if (!NetEntAsnLoad())
4085 return NULL;
4086
4087 if (aip == NULL)
4088 return NULL;
4089
4090 if (orig == NULL)
4091 atp = AsnReadId(aip, amp, NEW_SUMMARY_LIST);
4092 else
4093 atp = AsnLinkType(orig, NEW_SUMMARY_LIST); /* link in local tree */
4094
4095 if (atp == NULL)
4096 return NULL;
4097
4098 p = NewSummaryListNew();
4099 if (p == NULL)
4100 goto erret;
4101
4102 if (AsnReadVal(aip, atp, &av) <= 0) /* read the start struct */
4103 goto erret;
4104
4105 atp = AsnReadId(aip, amp, atp); /* find the num */
4106 if (atp == NULL)
4107 goto erret;
4108 if (AsnReadVal(aip, atp, &av) <= 0) /* get the num */
4109 goto erret;
4110 p->num = av.intvalue;
4111
4112 atp = AsnReadId(aip, amp, atp); /* find the type */
4113 if (atp == NULL)
4114 goto erret;
4115 if (AsnReadVal(aip, atp, &av) <= 0) /* get the type */
4116 goto erret;
4117 p->type = av.intvalue;
4118
4119 atp = AsnReadId(aip, amp, atp); /* find the data start-struct */
4120 if (atp == NULL)
4121 goto erret;
4122 if (AsnReadVal(aip, atp, &av) <= 0) /* get the data start-struct */
4123 goto erret;
4124
4125 p->data = (DocSumPtr PNTR) MemNew(sizeof(DocSumPtr) * (size_t) p->num);
4126 for (num = 0; num < p->num; num++)
4127 p->data[num] = NULL;
4128 atp = AsnReadId(aip, amp, atp);
4129
4130 for (num = 0; num < p->num && atp == NEW_SUMMARY_LIST_data_E; num++)
4131 {
4132 if ((p->data[num] = DocSumAsnRead(aip, atp)) == NULL)
4133 goto erret;
4134 atp = AsnReadId(aip, amp, atp);
4135 }
4136
4137 /* check for count mis-match */
4138 if (num != p->num || atp != NEW_SUMMARY_LIST_data)
4139 goto erret;
4140
4141 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
4142 goto erret;
4143
4144 atp = AsnReadId(aip, amp, atp);
4145 if (orig == NULL)
4146 {
4147 if (atp != NEW_SUMMARY_LIST)
4148 goto erret;
4149 }
4150 else { /* check for "close struct" associated with "orig" */
4151 if (atp != orig)
4152 goto erret;
4153 }
4154 if (AsnReadVal(aip, atp, NULL) <= 0) /* discard NULL */
4155 goto erret;
4156
4157 ret:
4158 AsnUnlinkType(orig);
4159 return p;
4160
4161 erret:
4162 p = NewSummaryListFree(p);
4163 goto ret;
4164 }
4165
4166
4167 NLM_EXTERN Boolean LIBCALL
NewSummaryListAsnWrite(NewSummaryListPtr p,AsnIoPtr aip,AsnTypePtr orig)4168 NewSummaryListAsnWrite (NewSummaryListPtr p, AsnIoPtr aip, AsnTypePtr orig)
4169 {
4170 DataVal av;
4171 Int4 i;
4172 AsnTypePtr atp;
4173 Boolean retval = FALSE;
4174
4175 if (! NetEntAsnLoad() )
4176 return FALSE;
4177
4178 if (aip == NULL)
4179 return FALSE;
4180
4181 atp = AsnLinkType(orig, NEW_SUMMARY_LIST); /* link local tree */
4182
4183 if (atp == NULL)
4184 return FALSE;
4185
4186 if (p == NULL)
4187 {
4188 AsnNullValueMsg(aip, atp);
4189 goto erret;
4190 }
4191
4192 if (! AsnStartStruct(aip, atp))
4193 goto erret;
4194 av.intvalue = p->num;
4195 AsnWrite (aip, NEW_SUMMARY_LIST_num, &av);
4196 av.intvalue = p->type;
4197 AsnWrite (aip, NEW_SUMMARY_LIST_type, &av);
4198
4199 AsnStartStruct (aip, NEW_SUMMARY_LIST_data);
4200 for (i = 0; i < p->num; i++)
4201 {
4202 DocSumAsnWrite(p->data[i], aip, NEW_SUMMARY_LIST_data_E);
4203 }
4204 AsnEndStruct (aip, NEW_SUMMARY_LIST_data);
4205
4206 if (! AsnEndStruct(aip, atp))
4207 goto erret;
4208
4209 retval = TRUE;
4210
4211 erret:
4212 AsnUnlinkType(orig); /* unlink local tree */
4213 return retval;
4214 }
4215
4216 /**************************************************
4217 *
4218 * ClusterArticlesNew()
4219 *
4220 **************************************************/
4221
4222 NLM_EXTERN ClusterArticlesPtr LIBCALL
ClusterArticlesNew(void)4223 ClusterArticlesNew(void)
4224 {
4225 ClusterArticlesPtr ptr = MemNew((size_t) sizeof(ClusterArticles));
4226
4227 return ptr;
4228
4229 }
4230
4231
4232 /**************************************************
4233 *
4234 * ClusterArticlesFree()
4235 *
4236 **************************************************/
4237
4238 NLM_EXTERN ClusterArticlesPtr LIBCALL
ClusterArticlesFree(ClusterArticlesPtr ptr)4239 ClusterArticlesFree(ClusterArticlesPtr ptr)
4240 {
4241
4242 if(ptr == NULL) {
4243 return NULL;
4244 }
4245 EntrezIdsFree(ptr -> ids);
4246 return MemFree(ptr);
4247 }
4248
4249
4250 /**************************************************
4251 *
4252 * ClusterArticlesAsnRead()
4253 *
4254 **************************************************/
4255
4256 NLM_EXTERN ClusterArticlesPtr LIBCALL
ClusterArticlesAsnRead(AsnIoPtr aip,AsnTypePtr orig)4257 ClusterArticlesAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4258 {
4259 DataVal av;
4260 AsnTypePtr atp;
4261 Boolean isError = FALSE;
4262 AsnReadFunc func;
4263 ClusterArticlesPtr ptr;
4264
4265 if (! loaded)
4266 {
4267 if (! NetEntAsnLoad()) {
4268 return NULL;
4269 }
4270 }
4271
4272 if (aip == NULL) {
4273 return NULL;
4274 }
4275
4276 if (orig == NULL) { /* ClusterArticles ::= (self contained) */
4277 atp = AsnReadId(aip, amp, CLUSTER_ARTICLES);
4278 } else {
4279 atp = AsnLinkType(orig, CLUSTER_ARTICLES);
4280 }
4281 /* link in local tree */
4282 if (atp == NULL) {
4283 return NULL;
4284 }
4285
4286 ptr = ClusterArticlesNew();
4287 if (ptr == NULL) {
4288 goto erret;
4289 }
4290 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4291 goto erret;
4292 }
4293
4294 atp = AsnReadId(aip,amp, atp);
4295 func = NULL;
4296
4297 if (atp == CLUSTER_ARTICLES_ids) {
4298 ptr -> ids = EntrezIdsAsnRead(aip, atp);
4299 if (aip -> io_failure) {
4300 goto erret;
4301 }
4302 atp = AsnReadId(aip,amp, atp);
4303 }
4304 if (atp == CLUSTER_ARTICLES_fld) {
4305 if ( AsnReadVal(aip, atp, &av) <= 0) {
4306 goto erret;
4307 }
4308 ptr -> fld = av.intvalue;
4309 atp = AsnReadId(aip,amp, atp);
4310 }
4311 if (atp == CLUSTER_ARTICLES_min_cluster) {
4312 if ( AsnReadVal(aip, atp, &av) <= 0) {
4313 goto erret;
4314 }
4315 ptr -> min_cluster = av.intvalue;
4316 atp = AsnReadId(aip,amp, atp);
4317 }
4318 if (atp == CLUSTER_ARTICLES_max_cluster) {
4319 if ( AsnReadVal(aip, atp, &av) <= 0) {
4320 goto erret;
4321 }
4322 ptr -> max_cluster = av.intvalue;
4323 atp = AsnReadId(aip,amp, atp);
4324 }
4325 if (atp == CLUSTER_ARTICLES_max_terms) {
4326 if ( AsnReadVal(aip, atp, &av) <= 0) {
4327 goto erret;
4328 }
4329 ptr -> max_terms = av.intvalue;
4330 atp = AsnReadId(aip,amp, atp);
4331 }
4332
4333 if (AsnReadVal(aip, atp, &av) <= 0) {
4334 goto erret;
4335 }
4336 /* end struct */
4337
4338 ret:
4339 AsnUnlinkType(orig); /* unlink local tree */
4340 return ptr;
4341
4342 erret:
4343 aip -> io_failure = TRUE;
4344 ptr = ClusterArticlesFree(ptr);
4345 goto ret;
4346 }
4347
4348
4349
4350 /**************************************************
4351 *
4352 * ClusterArticlesAsnWrite()
4353 *
4354 **************************************************/
4355 NLM_EXTERN Boolean LIBCALL
ClusterArticlesAsnWrite(ClusterArticlesPtr ptr,AsnIoPtr aip,AsnTypePtr orig)4356 ClusterArticlesAsnWrite(ClusterArticlesPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
4357 {
4358 DataVal av;
4359 AsnTypePtr atp;
4360 Boolean retval = FALSE;
4361
4362 if (! loaded)
4363 {
4364 if (! NetEntAsnLoad()) {
4365 return FALSE;
4366 }
4367 }
4368
4369 if (aip == NULL) {
4370 return FALSE;
4371 }
4372
4373 atp = AsnLinkType(orig, CLUSTER_ARTICLES); /* link local tree */
4374 if (atp == NULL) {
4375 return FALSE;
4376 }
4377
4378 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4379 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
4380 goto erret;
4381 }
4382
4383 if (ptr -> ids != NULL) {
4384 if ( ! EntrezIdsAsnWrite(ptr -> ids, aip, CLUSTER_ARTICLES_ids)) {
4385 goto erret;
4386 }
4387 }
4388 av.intvalue = ptr -> fld;
4389 retval = AsnWrite(aip, CLUSTER_ARTICLES_fld, &av);
4390 av.intvalue = ptr -> min_cluster;
4391 retval = AsnWrite(aip, CLUSTER_ARTICLES_min_cluster, &av);
4392 av.intvalue = ptr -> max_cluster;
4393 retval = AsnWrite(aip, CLUSTER_ARTICLES_max_cluster, &av);
4394 av.intvalue = ptr -> max_terms;
4395 retval = AsnWrite(aip, CLUSTER_ARTICLES_max_terms, &av);
4396 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4397 goto erret;
4398 }
4399 retval = TRUE;
4400
4401 erret:
4402 AsnUnlinkType(orig); /* unlink local tree */
4403 return retval;
4404 }
4405
4406
4407
4408 /**************************************************
4409 *
4410 * ClusterRespNew()
4411 *
4412 **************************************************/
4413
4414 NLM_EXTERN ClusterRespPtr LIBCALL
ClusterRespNew(void)4415 ClusterRespNew(void)
4416 {
4417 ClusterRespPtr ptr = MemNew((size_t) sizeof(ClusterResp));
4418
4419 return ptr;
4420
4421 }
4422
4423
4424 /**************************************************
4425 *
4426 * ClusterRespFree()
4427 *
4428 **************************************************/
4429
4430 NLM_EXTERN ClusterRespPtr LIBCALL
ClusterRespFree(ClusterRespPtr ptr)4431 ClusterRespFree(ClusterRespPtr ptr)
4432 {
4433
4434 if(ptr == NULL) {
4435 return NULL;
4436 }
4437 AsnGenericBaseSeqOfFree(ptr -> terms ,ASNCODE_PTRVAL_SLOT);
4438 AsnGenericBaseSeqOfFree(ptr -> term_counts ,ASNCODE_INTVAL_SLOT);
4439 return MemFree(ptr);
4440 }
4441
4442
4443 /**************************************************
4444 *
4445 * ClusterRespAsnRead()
4446 *
4447 **************************************************/
4448
4449 NLM_EXTERN ClusterRespPtr LIBCALL
ClusterRespAsnRead(AsnIoPtr aip,AsnTypePtr orig)4450 ClusterRespAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4451 {
4452 DataVal av;
4453 AsnTypePtr atp;
4454 Boolean isError = FALSE;
4455 AsnReadFunc func;
4456 ClusterRespPtr ptr;
4457
4458 if (! loaded)
4459 {
4460 if (! NetEntAsnLoad()) {
4461 return NULL;
4462 }
4463 }
4464
4465 if (aip == NULL) {
4466 return NULL;
4467 }
4468
4469 if (orig == NULL) { /* ClusterResp ::= (self contained) */
4470 atp = AsnReadId(aip, amp, CLUSTER_RESP);
4471 } else {
4472 atp = AsnLinkType(orig, CLUSTER_RESP);
4473 }
4474 /* link in local tree */
4475 if (atp == NULL) {
4476 return NULL;
4477 }
4478
4479 ptr = ClusterRespNew();
4480 if (ptr == NULL) {
4481 goto erret;
4482 }
4483 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4484 goto erret;
4485 }
4486
4487 atp = AsnReadId(aip,amp, atp);
4488 func = NULL;
4489
4490 if (atp == CLUSTER_RESP_count) {
4491 if ( AsnReadVal(aip, atp, &av) <= 0) {
4492 goto erret;
4493 }
4494 ptr -> count = av.intvalue;
4495 atp = AsnReadId(aip,amp, atp);
4496 }
4497 if (atp == CLUSTER_RESP_terms) {
4498 ptr -> terms = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
4499 if (isError && ptr -> terms == NULL) {
4500 goto erret;
4501 }
4502 atp = AsnReadId(aip,amp, atp);
4503 }
4504 if (atp == CLUSTER_RESP_term_counts) {
4505 ptr -> term_counts = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_INTVAL_SLOT, &isError);
4506 if (isError && ptr -> term_counts == NULL) {
4507 goto erret;
4508 }
4509 atp = AsnReadId(aip,amp, atp);
4510 }
4511
4512 if (AsnReadVal(aip, atp, &av) <= 0) {
4513 goto erret;
4514 }
4515 /* end struct */
4516
4517 ret:
4518 AsnUnlinkType(orig); /* unlink local tree */
4519 return ptr;
4520
4521 erret:
4522 aip -> io_failure = TRUE;
4523 ptr = ClusterRespFree(ptr);
4524 goto ret;
4525 }
4526
4527
4528
4529 /**************************************************
4530 *
4531 * ClusterRespAsnWrite()
4532 *
4533 **************************************************/
4534 NLM_EXTERN Boolean LIBCALL
ClusterRespAsnWrite(ClusterRespPtr ptr,AsnIoPtr aip,AsnTypePtr orig)4535 ClusterRespAsnWrite(ClusterRespPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
4536 {
4537 DataVal av;
4538 AsnTypePtr atp;
4539 Boolean retval = FALSE;
4540
4541 if (! loaded)
4542 {
4543 if (! NetEntAsnLoad()) {
4544 return FALSE;
4545 }
4546 }
4547
4548 if (aip == NULL) {
4549 return FALSE;
4550 }
4551
4552 atp = AsnLinkType(orig, CLUSTER_RESP); /* link local tree */
4553 if (atp == NULL) {
4554 return FALSE;
4555 }
4556
4557 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4558 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
4559 goto erret;
4560 }
4561
4562 av.intvalue = ptr -> count;
4563 retval = AsnWrite(aip, CLUSTER_RESP_count, &av);
4564 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> terms ,ASNCODE_PTRVAL_SLOT, aip, CLUSTER_RESP_terms, CLUSTER_RESP_terms_E);
4565 retval = AsnGenericBaseSeqOfAsnWrite(ptr -> term_counts ,ASNCODE_INTVAL_SLOT, aip, CLUSTER_RESP_term_counts, CLUSTER_RESP_term_counts_E);
4566 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4567 goto erret;
4568 }
4569 retval = TRUE;
4570
4571 erret:
4572 AsnUnlinkType(orig); /* unlink local tree */
4573 return retval;
4574 }
4575
4576 /**************************************************
4577 *
4578 * DateConstraintsNew()
4579 *
4580 **************************************************/
4581
4582 NLM_EXTERN DateConstraintsPtr LIBCALL
DateConstraintsNew(void)4583 DateConstraintsNew(void)
4584 {
4585 DateConstraintsPtr ptr = MemNew((size_t) sizeof(DateConstraints));
4586
4587 return ptr;
4588
4589 }
4590
4591
4592 /**************************************************
4593 *
4594 * DateConstraintsFree()
4595 *
4596 **************************************************/
4597
4598 NLM_EXTERN DateConstraintsPtr LIBCALL
DateConstraintsFree(DateConstraintsPtr ptr)4599 DateConstraintsFree(DateConstraintsPtr ptr)
4600 {
4601
4602 if(ptr == NULL) {
4603 return NULL;
4604 }
4605 AsnGenericUserSeqOfFree(ptr -> date_vec, (AsnOptFreeFunc) DateVectorFree);
4606 return MemFree(ptr);
4607 }
4608
4609
4610 /**************************************************
4611 *
4612 * DateConstraintsAsnRead()
4613 *
4614 **************************************************/
4615
4616 NLM_EXTERN DateConstraintsPtr LIBCALL
DateConstraintsAsnRead(AsnIoPtr aip,AsnTypePtr orig)4617 DateConstraintsAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4618 {
4619 DataVal av;
4620 AsnTypePtr atp;
4621 Boolean isError = FALSE;
4622 AsnReadFunc func;
4623 DateConstraintsPtr ptr;
4624
4625 if (! loaded)
4626 {
4627 if (! NetEntAsnLoad()) {
4628 return NULL;
4629 }
4630 }
4631
4632 if (aip == NULL) {
4633 return NULL;
4634 }
4635
4636 if (orig == NULL) { /* DateConstraints ::= (self contained) */
4637 atp = AsnReadId(aip, amp, DATE_CONSTRAINTS);
4638 } else {
4639 atp = AsnLinkType(orig, DATE_CONSTRAINTS);
4640 }
4641 /* link in local tree */
4642 if (atp == NULL) {
4643 return NULL;
4644 }
4645
4646 ptr = DateConstraintsNew();
4647 if (ptr == NULL) {
4648 goto erret;
4649 }
4650 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4651 goto erret;
4652 }
4653
4654 atp = AsnReadId(aip,amp, atp);
4655 func = NULL;
4656
4657 if (atp == DATE_CONSTRAINTS_count) {
4658 if ( AsnReadVal(aip, atp, &av) <= 0) {
4659 goto erret;
4660 }
4661 ptr -> count = av.intvalue;
4662 atp = AsnReadId(aip,amp, atp);
4663 }
4664 if (atp == DATE_CONSTRAINTS_date_vec) {
4665 ptr -> date_vec = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) DateVectorAsnRead, (AsnOptFreeFunc) DateVectorFree);
4666 if (isError && ptr -> date_vec == NULL) {
4667 goto erret;
4668 }
4669 atp = AsnReadId(aip,amp, atp);
4670 }
4671
4672 if (AsnReadVal(aip, atp, &av) <= 0) {
4673 goto erret;
4674 }
4675 /* end struct */
4676
4677 ret:
4678 AsnUnlinkType(orig); /* unlink local tree */
4679 return ptr;
4680
4681 erret:
4682 aip -> io_failure = TRUE;
4683 ptr = DateConstraintsFree(ptr);
4684 goto ret;
4685 }
4686
4687
4688
4689 /**************************************************
4690 *
4691 * DateConstraintsAsnWrite()
4692 *
4693 **************************************************/
4694 NLM_EXTERN Boolean LIBCALL
DateConstraintsAsnWrite(DateConstraintsPtr ptr,AsnIoPtr aip,AsnTypePtr orig)4695 DateConstraintsAsnWrite(DateConstraintsPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
4696 {
4697 DataVal av;
4698 AsnTypePtr atp;
4699 Boolean retval = FALSE;
4700
4701 if (! loaded)
4702 {
4703 if (! NetEntAsnLoad()) {
4704 return FALSE;
4705 }
4706 }
4707
4708 if (aip == NULL) {
4709 return FALSE;
4710 }
4711
4712 atp = AsnLinkType(orig, DATE_CONSTRAINTS); /* link local tree */
4713 if (atp == NULL) {
4714 return FALSE;
4715 }
4716
4717 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4718 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
4719 goto erret;
4720 }
4721
4722 av.intvalue = ptr -> count;
4723 retval = AsnWrite(aip, DATE_CONSTRAINTS_count, &av);
4724 AsnGenericUserSeqOfAsnWrite(ptr -> date_vec, (AsnWriteFunc) DateVectorAsnWrite, aip, DATE_CONSTRAINTS_date_vec, DATE_CONSTRAINTS_date_vec_E);
4725 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4726 goto erret;
4727 }
4728 retval = TRUE;
4729
4730 erret:
4731 AsnUnlinkType(orig); /* unlink local tree */
4732 return retval;
4733 }
4734
4735
4736
4737 /**************************************************
4738 *
4739 * DateVectorNew()
4740 *
4741 **************************************************/
4742
4743 NLM_EXTERN DateVectorPtr LIBCALL
DateVectorNew(void)4744 DateVectorNew(void)
4745 {
4746 DateVectorPtr ptr = MemNew((size_t) sizeof(DateVector));
4747
4748 return ptr;
4749
4750 }
4751
4752
4753 /**************************************************
4754 *
4755 * DateVectorFree()
4756 *
4757 **************************************************/
4758
4759 NLM_EXTERN DateVectorPtr LIBCALL
DateVectorFree(DateVectorPtr ptr)4760 DateVectorFree(DateVectorPtr ptr)
4761 {
4762
4763 if(ptr == NULL) {
4764 return NULL;
4765 }
4766 DateFree(ptr -> begin_date);
4767 DateFree(ptr -> end_date);
4768 MemFree(ptr -> field_abbr);
4769 return MemFree(ptr);
4770 }
4771
4772
4773 /**************************************************
4774 *
4775 * DateVectorAsnRead()
4776 *
4777 **************************************************/
4778
4779 NLM_EXTERN DateVectorPtr LIBCALL
DateVectorAsnRead(AsnIoPtr aip,AsnTypePtr orig)4780 DateVectorAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4781 {
4782 DataVal av;
4783 AsnTypePtr atp;
4784 Boolean isError = FALSE;
4785 AsnReadFunc func;
4786 DateVectorPtr ptr;
4787
4788 if (! loaded)
4789 {
4790 if (! NetEntAsnLoad()) {
4791 return NULL;
4792 }
4793 }
4794
4795 if (aip == NULL) {
4796 return NULL;
4797 }
4798
4799 if (orig == NULL) { /* DateVector ::= (self contained) */
4800 atp = AsnReadId(aip, amp, DATE_VECTOR);
4801 } else {
4802 atp = AsnLinkType(orig, DATE_VECTOR);
4803 }
4804 /* link in local tree */
4805 if (atp == NULL) {
4806 return NULL;
4807 }
4808
4809 ptr = DateVectorNew();
4810 if (ptr == NULL) {
4811 goto erret;
4812 }
4813 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4814 goto erret;
4815 }
4816
4817 atp = AsnReadId(aip,amp, atp);
4818 func = NULL;
4819
4820 if (atp == DATE_VECTOR_begin_date) {
4821 ptr -> begin_date = DateAsnRead(aip, atp);
4822 if (aip -> io_failure) {
4823 goto erret;
4824 }
4825 atp = AsnReadId(aip,amp, atp);
4826 }
4827 if (atp == DATE_VECTOR_end_date) {
4828 ptr -> end_date = DateAsnRead(aip, atp);
4829 if (aip -> io_failure) {
4830 goto erret;
4831 }
4832 atp = AsnReadId(aip,amp, atp);
4833 }
4834 if (atp == DATE_VECTOR_field_abbr) {
4835 if ( AsnReadVal(aip, atp, &av) <= 0) {
4836 goto erret;
4837 }
4838 ptr -> field_abbr = av.ptrvalue;
4839 atp = AsnReadId(aip,amp, atp);
4840 }
4841
4842 if (AsnReadVal(aip, atp, &av) <= 0) {
4843 goto erret;
4844 }
4845 /* end struct */
4846
4847 ret:
4848 AsnUnlinkType(orig); /* unlink local tree */
4849 return ptr;
4850
4851 erret:
4852 aip -> io_failure = TRUE;
4853 ptr = DateVectorFree(ptr);
4854 goto ret;
4855 }
4856
4857
4858
4859 /**************************************************
4860 *
4861 * DateVectorAsnWrite()
4862 *
4863 **************************************************/
4864 NLM_EXTERN Boolean LIBCALL
DateVectorAsnWrite(DateVectorPtr ptr,AsnIoPtr aip,AsnTypePtr orig)4865 DateVectorAsnWrite(DateVectorPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
4866 {
4867 DataVal av;
4868 AsnTypePtr atp;
4869 Boolean retval = FALSE;
4870
4871 if (! loaded)
4872 {
4873 if (! NetEntAsnLoad()) {
4874 return FALSE;
4875 }
4876 }
4877
4878 if (aip == NULL) {
4879 return FALSE;
4880 }
4881
4882 atp = AsnLinkType(orig, DATE_VECTOR); /* link local tree */
4883 if (atp == NULL) {
4884 return FALSE;
4885 }
4886
4887 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
4888 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
4889 goto erret;
4890 }
4891
4892 if (ptr -> begin_date != NULL) {
4893 if ( ! DateAsnWrite(ptr -> begin_date, aip, DATE_VECTOR_begin_date)) {
4894 goto erret;
4895 }
4896 }
4897 if (ptr -> end_date != NULL) {
4898 if ( ! DateAsnWrite(ptr -> end_date, aip, DATE_VECTOR_end_date)) {
4899 goto erret;
4900 }
4901 }
4902 if (ptr -> field_abbr != NULL) {
4903 av.ptrvalue = ptr -> field_abbr;
4904 retval = AsnWrite(aip, DATE_VECTOR_field_abbr, &av);
4905 }
4906 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
4907 goto erret;
4908 }
4909 retval = TRUE;
4910
4911 erret:
4912 AsnUnlinkType(orig); /* unlink local tree */
4913 return retval;
4914 }
4915
4916
4917
4918 /**************************************************
4919 *
4920 * GetByFidNew()
4921 *
4922 **************************************************/
4923
4924 NLM_EXTERN GetByFidPtr LIBCALL
GetByFidNew(void)4925 GetByFidNew(void)
4926 {
4927 GetByFidPtr ptr = MemNew((size_t) sizeof(GetByFid));
4928
4929 return ptr;
4930
4931 }
4932
4933
4934 /**************************************************
4935 *
4936 * GetByFidFree()
4937 *
4938 **************************************************/
4939
4940 NLM_EXTERN GetByFidPtr LIBCALL
GetByFidFree(GetByFidPtr ptr)4941 GetByFidFree(GetByFidPtr ptr)
4942 {
4943
4944 if(ptr == NULL) {
4945 return NULL;
4946 }
4947 return MemFree(ptr);
4948 }
4949
4950
4951 /**************************************************
4952 *
4953 * GetByFidAsnRead()
4954 *
4955 **************************************************/
4956
4957 NLM_EXTERN GetByFidPtr LIBCALL
GetByFidAsnRead(AsnIoPtr aip,AsnTypePtr orig)4958 GetByFidAsnRead(AsnIoPtr aip, AsnTypePtr orig)
4959 {
4960 DataVal av;
4961 AsnTypePtr atp;
4962 Boolean isError = FALSE;
4963 AsnReadFunc func;
4964 GetByFidPtr ptr;
4965
4966 if (! loaded)
4967 {
4968 if (! NetEntAsnLoad()) {
4969 return NULL;
4970 }
4971 }
4972
4973 if (aip == NULL) {
4974 return NULL;
4975 }
4976
4977 if (orig == NULL) { /* GetByFid ::= (self contained) */
4978 atp = AsnReadId(aip, amp, GET_BY_FID);
4979 } else {
4980 atp = AsnLinkType(orig, GET_BY_FID);
4981 }
4982 /* link in local tree */
4983 if (atp == NULL) {
4984 return NULL;
4985 }
4986
4987 ptr = GetByFidNew();
4988 if (ptr == NULL) {
4989 goto erret;
4990 }
4991 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
4992 goto erret;
4993 }
4994
4995 atp = AsnReadId(aip,amp, atp);
4996 func = NULL;
4997
4998 if (atp == GET_BY_FID_mmdbid) {
4999 if ( AsnReadVal(aip, atp, &av) <= 0) {
5000 goto erret;
5001 }
5002 ptr -> mmdbid = av.intvalue;
5003 atp = AsnReadId(aip,amp, atp);
5004 }
5005 if (atp == GET_BY_FID_feature_id) {
5006 if ( AsnReadVal(aip, atp, &av) <= 0) {
5007 goto erret;
5008 }
5009 ptr -> feature_id = av.intvalue;
5010 atp = AsnReadId(aip,amp, atp);
5011 }
5012 if (atp == GET_BY_FID_feature_set_id) {
5013 if ( AsnReadVal(aip, atp, &av) <= 0) {
5014 goto erret;
5015 }
5016 ptr -> feature_set_id = av.intvalue;
5017 atp = AsnReadId(aip,amp, atp);
5018 }
5019
5020 if (AsnReadVal(aip, atp, &av) <= 0) {
5021 goto erret;
5022 }
5023 /* end struct */
5024
5025 ret:
5026 AsnUnlinkType(orig); /* unlink local tree */
5027 return ptr;
5028
5029 erret:
5030 aip -> io_failure = TRUE;
5031 ptr = GetByFidFree(ptr);
5032 goto ret;
5033 }
5034
5035
5036
5037 /**************************************************
5038 *
5039 * GetByFidAsnWrite()
5040 *
5041 **************************************************/
5042 NLM_EXTERN Boolean LIBCALL
GetByFidAsnWrite(GetByFidPtr ptr,AsnIoPtr aip,AsnTypePtr orig)5043 GetByFidAsnWrite(GetByFidPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
5044 {
5045 DataVal av;
5046 AsnTypePtr atp;
5047 Boolean retval = FALSE;
5048
5049 if (! loaded)
5050 {
5051 if (! NetEntAsnLoad()) {
5052 return FALSE;
5053 }
5054 }
5055
5056 if (aip == NULL) {
5057 return FALSE;
5058 }
5059
5060 atp = AsnLinkType(orig, GET_BY_FID); /* link local tree */
5061 if (atp == NULL) {
5062 return FALSE;
5063 }
5064
5065 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5066 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
5067 goto erret;
5068 }
5069
5070 av.intvalue = ptr -> mmdbid;
5071 retval = AsnWrite(aip, GET_BY_FID_mmdbid, &av);
5072 av.intvalue = ptr -> feature_id;
5073 retval = AsnWrite(aip, GET_BY_FID_feature_id, &av);
5074 av.intvalue = ptr -> feature_set_id;
5075 retval = AsnWrite(aip, GET_BY_FID_feature_set_id, &av);
5076 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
5077 goto erret;
5078 }
5079 retval = TRUE;
5080
5081 erret:
5082 AsnUnlinkType(orig); /* unlink local tree */
5083 return retval;
5084 }
5085
5086
5087
5088 /**************************************************
5089 *
5090 * GetFeatIdsNew()
5091 *
5092 **************************************************/
5093
5094 NLM_EXTERN GetFeatIdsPtr LIBCALL
GetFeatIdsNew(void)5095 GetFeatIdsNew(void)
5096 {
5097 GetFeatIdsPtr ptr = MemNew((size_t) sizeof(GetFeatIds));
5098
5099 return ptr;
5100
5101 }
5102
5103
5104 /**************************************************
5105 *
5106 * GetFeatIdsFree()
5107 *
5108 **************************************************/
5109
5110 NLM_EXTERN GetFeatIdsPtr LIBCALL
GetFeatIdsFree(GetFeatIdsPtr ptr)5111 GetFeatIdsFree(GetFeatIdsPtr ptr)
5112 {
5113
5114 if(ptr == NULL) {
5115 return NULL;
5116 }
5117 return MemFree(ptr);
5118 }
5119
5120
5121 /**************************************************
5122 *
5123 * GetFeatIdsAsnRead()
5124 *
5125 **************************************************/
5126
5127 NLM_EXTERN GetFeatIdsPtr LIBCALL
GetFeatIdsAsnRead(AsnIoPtr aip,AsnTypePtr orig)5128 GetFeatIdsAsnRead(AsnIoPtr aip, AsnTypePtr orig)
5129 {
5130 DataVal av;
5131 AsnTypePtr atp;
5132 Boolean isError = FALSE;
5133 AsnReadFunc func;
5134 GetFeatIdsPtr ptr;
5135
5136 if (! loaded)
5137 {
5138 if (! NetEntAsnLoad()) {
5139 return NULL;
5140 }
5141 }
5142
5143 if (aip == NULL) {
5144 return NULL;
5145 }
5146
5147 if (orig == NULL) { /* GetFeatIds ::= (self contained) */
5148 atp = AsnReadId(aip, amp, GET_FEAT_IDS);
5149 } else {
5150 atp = AsnLinkType(orig, GET_FEAT_IDS);
5151 }
5152 /* link in local tree */
5153 if (atp == NULL) {
5154 return NULL;
5155 }
5156
5157 ptr = GetFeatIdsNew();
5158 if (ptr == NULL) {
5159 goto erret;
5160 }
5161 if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
5162 goto erret;
5163 }
5164
5165 atp = AsnReadId(aip,amp, atp);
5166 func = NULL;
5167
5168 if (atp == GET_FEAT_IDS_mmdbid) {
5169 if ( AsnReadVal(aip, atp, &av) <= 0) {
5170 goto erret;
5171 }
5172 ptr -> mmdbid = av.intvalue;
5173 atp = AsnReadId(aip,amp, atp);
5174 }
5175 if (atp == GET_FEAT_IDS_feature_type) {
5176 if ( AsnReadVal(aip, atp, &av) <= 0) {
5177 goto erret;
5178 }
5179 ptr -> feature_type = av.intvalue;
5180 atp = AsnReadId(aip,amp, atp);
5181 }
5182 if (atp == GET_FEAT_IDS_feature_set_id) {
5183 if ( AsnReadVal(aip, atp, &av) <= 0) {
5184 goto erret;
5185 }
5186 ptr -> feature_set_id = av.intvalue;
5187 atp = AsnReadId(aip,amp, atp);
5188 }
5189
5190 if (AsnReadVal(aip, atp, &av) <= 0) {
5191 goto erret;
5192 }
5193 /* end struct */
5194
5195 ret:
5196 AsnUnlinkType(orig); /* unlink local tree */
5197 return ptr;
5198
5199 erret:
5200 aip -> io_failure = TRUE;
5201 ptr = GetFeatIdsFree(ptr);
5202 goto ret;
5203 }
5204
5205
5206
5207 /**************************************************
5208 *
5209 * GetFeatIdsAsnWrite()
5210 *
5211 **************************************************/
5212 NLM_EXTERN Boolean LIBCALL
GetFeatIdsAsnWrite(GetFeatIdsPtr ptr,AsnIoPtr aip,AsnTypePtr orig)5213 GetFeatIdsAsnWrite(GetFeatIdsPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
5214 {
5215 DataVal av;
5216 AsnTypePtr atp;
5217 Boolean retval = FALSE;
5218
5219 if (! loaded)
5220 {
5221 if (! NetEntAsnLoad()) {
5222 return FALSE;
5223 }
5224 }
5225
5226 if (aip == NULL) {
5227 return FALSE;
5228 }
5229
5230 atp = AsnLinkType(orig, GET_FEAT_IDS); /* link local tree */
5231 if (atp == NULL) {
5232 return FALSE;
5233 }
5234
5235 if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
5236 if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
5237 goto erret;
5238 }
5239
5240 av.intvalue = ptr -> mmdbid;
5241 retval = AsnWrite(aip, GET_FEAT_IDS_mmdbid, &av);
5242 av.intvalue = ptr -> feature_type;
5243 retval = AsnWrite(aip, GET_FEAT_IDS_feature_type, &av);
5244 av.intvalue = ptr -> feature_set_id;
5245 retval = AsnWrite(aip, GET_FEAT_IDS_feature_set_id, &av);
5246 if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
5247 goto erret;
5248 }
5249 retval = TRUE;
5250
5251 erret:
5252 AsnUnlinkType(orig); /* unlink local tree */
5253 return retval;
5254 }
5255
5256