1 /* objgen.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: objgen.c
27 *
28 * Author: James Ostell
29 *
30 * Version Creation Date: 1/1/91
31 *
32 * $Revision: 6.21 $
33 *
34 * File Description: Object manager for module NCBI-General
35 *
36 * Modifications:
37 * --------------------------------------------------------------------------
38 * Date Name Description of modification
39 * ------- ---------- -----------------------------------------------------
40 * 05-13-93 Schuler All public functions are now declared LIBCALL.
41 * 06-21-93 Schuler Made a static copy of NCBI_months[] in this file
42 * (because it cannot be exported from ncbitime.c when
43 * it is linked as a DLL).
44 *
45 * ==========================================================================
46 */
47 #include <asngen.h> /* the AsnTool header */
48 #include <objgen.h> /* the general objects interface */
49
50
51 static Boolean loaded = FALSE;
52
53 /* ValNode equivalent functions that allocate ObjValNode size */
54
SeqDescrNew(ValNodePtr vnp)55 NLM_EXTERN ValNodePtr LIBCALL SeqDescrNew (ValNodePtr vnp)
56
57 {
58 ValNodePtr newnode;
59
60 newnode = (ValNodePtr) Nlm_MemNew(sizeof(ObjValNode));
61 if (newnode == NULL) return NULL;
62 newnode->extended = 1; /* extended flag indicates extra fields are present */
63 if (vnp != NULL)
64 {
65 while (vnp->next != NULL)
66 vnp = vnp->next;
67 vnp->next = newnode;
68 }
69 return newnode;
70 }
71
SeqDescrAdd(ValNodePtr PNTR head)72 NLM_EXTERN ValNodePtr LIBCALL SeqDescrAdd (ValNodePtr PNTR head)
73
74 {
75 ValNodePtr newnode;
76
77 if (head != NULL)
78 {
79 newnode = SeqDescrNew (*head);
80 if (*head == NULL)
81 *head = newnode;
82 }
83 else
84 newnode = SeqDescrNew (NULL);
85
86 return newnode;
87 }
88
SeqDescrAddPointer(ValNodePtr PNTR head,Int2 choice,VoidPtr value)89 NLM_EXTERN ValNodePtr LIBCALL SeqDescrAddPointer (ValNodePtr PNTR head, Int2 choice, VoidPtr value)
90
91 {
92 ValNodePtr newnode;
93
94 newnode = SeqDescrAdd (head);
95 if (newnode != NULL)
96 {
97 newnode->choice = (Uint1) choice;
98 newnode->data.ptrvalue = value;
99 }
100
101 return newnode;
102 }
103
104 /*****************************************************************************
105 *
106 * GeneralAsnLoad()
107 *
108 *****************************************************************************/
GeneralAsnLoad(void)109 NLM_EXTERN Boolean LIBCALL GeneralAsnLoad (void)
110 {
111 if (loaded)
112 return TRUE;
113
114 if (AsnLoad())
115 loaded = TRUE;
116 return loaded;
117 }
118
119 /*****************************************************************************
120 *
121 * Date Routines
122 *
123 *****************************************************************************/
124 /*****************************************************************************
125 *
126 * DateNew()
127 *
128 *****************************************************************************/
DateNew(void)129 NLM_EXTERN NCBI_DatePtr LIBCALL DateNew (void)
130 {
131 NCBI_DatePtr dp = NULL;
132
133 dp = (NCBI_DatePtr)MemNew(sizeof(NCBI_Date));
134 dp->data[4] = 255; /* hour not set */
135 dp->data[5] = 255; /* minute not set */
136 dp->data[6] = 255; /* second not set */
137 return dp;
138 }
139
140 /*****************************************************************************
141 *
142 * DateFree(dp)
143 *
144 *****************************************************************************/
DateFree(NCBI_DatePtr dp)145 NLM_EXTERN NCBI_DatePtr LIBCALL DateFree (NCBI_DatePtr dp)
146 {
147 if (dp == NULL)
148 return dp;
149
150 MemFree(dp->str);
151 return (NCBI_DatePtr)MemFree(dp);
152 }
153
154 /*****************************************************************************
155 *
156 * DateClean(dp)
157 *
158 *****************************************************************************/
DateClean(NCBI_DatePtr dp)159 NLM_EXTERN NCBI_DatePtr LIBCALL DateClean (NCBI_DatePtr dp)
160 {
161 if (dp == NULL)
162 return dp;
163
164 memset(dp, 0, sizeof(NCBI_Date));
165 dp->data[4] = 255; /* hour not set */
166 dp->data[5] = 255; /* minute not set */
167 dp->data[6] = 255; /* second not set */
168 return dp;
169 }
170
171 /*****************************************************************************
172 *
173 * DateWrite(dp, year, month, day, season)
174 * if dp->data[0] not set
175 * if year != 0, it's a std date
176 * else it's a str date
177 * if a std date, season = season
178 * if a str date, season = str
179 *
180 *****************************************************************************/
DateWrite(NCBI_DatePtr dp,Int2 year,Int2 month,Int2 day,CharPtr season)181 NLM_EXTERN Boolean LIBCALL DateWrite (NCBI_DatePtr dp, Int2 year, Int2 month, Int2 day, CharPtr season)
182 {
183 if (dp == NULL)
184 return FALSE;
185
186 if (dp->str != NULL) /* remove previous string if any */
187 MemFree(dp->str);
188
189 dp->data[4] = 255; /* set time fields to not-set */
190 dp->data[5] = 255;
191 dp->data[6] = 255;
192
193 if (year == 0) /* date-str */
194 {
195 if (season == NULL) /* not optional */
196 return FALSE;
197 dp->data[0] = 0; /* set type */
198 dp->data[1] = 0; /* clear the rest */
199 dp->data[2] = 0;
200 dp->data[3] = 0;
201 dp->str = StringSave(season);
202 }
203 else
204 { /* date-std */
205 dp->data[0] = 1; /* set type */
206 year -= 1900;
207 if ((year < 1) || (year > 255)) /* year not optional */
208 return FALSE;
209 if ((month < 0) || (month > 12))
210 return FALSE;
211 if ((day < 0) || (day > 31))
212 return FALSE;
213 dp->data[1] = (Uint1)year;
214 dp->data[2] = (Uint1)month;
215 dp->data[3] = (Uint1)day;
216 dp->str = StringSave(season);
217 }
218 return TRUE;
219 }
220
221 /*****************************************************************************
222 *
223 * DateRead(dp, &year, &month, &day, season)
224 * season is buffer to copy season/str into
225 *
226 *****************************************************************************/
DateRead(NCBI_DatePtr dp,Int2Ptr yearptr,Int2Ptr monthptr,Int2Ptr dayptr,CharPtr season)227 NLM_EXTERN Boolean LIBCALL DateRead (NCBI_DatePtr dp, Int2Ptr yearptr, Int2Ptr monthptr, Int2Ptr dayptr, CharPtr season)
228 {
229 if (dp == NULL)
230 return FALSE;
231
232 if (dp->data[0] == 0) /* str type */
233 {
234 if (season == NULL)
235 return FALSE;
236 StringCpy(season, dp->str);
237 }
238 else /* std type */
239 {
240 if (yearptr != NULL)
241 *yearptr = (Int2)dp->data[1] + 1900;
242 if (monthptr != NULL)
243 *monthptr = (Int2)dp->data[2];
244 if (dayptr != NULL)
245 *dayptr = (Int2)dp->data[3];
246 if (season != NULL)
247 {
248 if (dp->str == NULL)
249 *season = '\0';
250 else
251 StringCpy(season, dp->str);
252 }
253 }
254 return TRUE;
255 }
256
257
258 /*****************************************************************************
259 *
260 * DatePrint(dp, buf)
261 *
262 *****************************************************************************/
DatePrint(NCBI_DatePtr dp,CharPtr to)263 NLM_EXTERN Boolean LIBCALL DatePrint (NCBI_DatePtr dp, CharPtr to)
264
265 {
266 Char tbuf[10];
267
268 *to = '\0';
269
270 if (dp->data[0] == 0) /* str type */
271 {
272 StringCpy(to, dp->str); /* just copy string */
273 }
274 else
275 {
276 if (dp->data[2] > 0)
277 {
278 if (dp->data[2] > 12) {
279 to = StringMove (to, "inv");
280 } else {
281 to = StringMove(to, NCBI_months[dp->data[2] - 1]);
282 }
283 *to = ' ';
284 to++;
285 *to = '\0';
286 }
287 if (dp->data[3] > 0)
288 {
289 sprintf(tbuf, "%d, ", dp->data[3]); /* for MS windows sprintf */
290 to = StringMove(to, tbuf);
291 }
292 if (dp->data[1] == 0)
293 to = StringMove(to, "????");
294 else
295 {
296 sprintf(tbuf, "%d", (int)(dp->data[1] + 1900));
297 to = StringMove(to, tbuf);
298 }
299 if (dp->str != NULL)
300 {
301 *to = ';';
302 to++;
303 *to = ' ';
304 to++;
305 to = StringMove(to, dp->str);
306 }
307 }
308 return TRUE;
309 }
310
311 /*****************************************************************************
312 *
313 * DateCurr()
314 *
315 *****************************************************************************/
DateCurr(void)316 NLM_EXTERN NCBI_DatePtr LIBCALL DateCurr (void)
317 {
318 NCBI_DatePtr dp;
319 Nlm_DayTime dt;
320
321 dp = DateNew();
322 if (dp == NULL) return dp;
323 GetDayTime(&dt);
324 dp->data[0] = (Uint1)1; /* date.std */
325 dp->data[1] = (Uint1)dt.tm_year;
326 dp->data[2] = (Uint1)(dt.tm_mon + 1);
327 dp->data[3] = (Uint1)dt.tm_mday;
328
329 return dp;
330 }
331
332 /*****************************************************************************
333 *
334 * DateTimeCurr()
335 *
336 *****************************************************************************/
DateTimeCurr(void)337 NLM_EXTERN NCBI_DatePtr LIBCALL DateTimeCurr (void)
338 {
339 NCBI_DatePtr dp;
340 Nlm_DayTime dt;
341
342 dp = DateNew();
343 if (dp == NULL) return dp;
344 GetDayTime(&dt);
345 dp->data[0] = (Uint1)1; /* date.std */
346 dp->data[1] = (Uint1)dt.tm_year;
347 dp->data[2] = (Uint1)(dt.tm_mon + 1);
348 dp->data[3] = (Uint1)dt.tm_mday;
349 dp->data[4] = (Uint1)(dt.tm_hour);
350 dp->data[5] = (Uint1)(dt.tm_min);
351 dp->data[6] = (Uint1)(dt.tm_sec);
352
353 return dp;
354 }
355
356 /*****************************************************************************
357 *
358 * DateDup(dp)
359 *
360 *****************************************************************************/
DateDup(NCBI_DatePtr dp)361 NLM_EXTERN NCBI_DatePtr LIBCALL DateDup (NCBI_DatePtr dp)
362 {
363 NCBI_DatePtr np;
364
365 if (dp == NULL)
366 return dp;
367
368 np = DateNew();
369 if (np == NULL) return np;
370 MemCopy(np, dp, sizeof(NCBI_Date));
371 if (dp->str != NULL)
372 np->str = StringSave(dp->str);
373 return np;
374 }
375
376 /*****************************************************************************
377 *
378 * DateAsnWrite(dp, aip, atp)
379 * atp is the current type (if identifier of a parent struct)
380 * if atp == NULL, then assumes it stands alone (Date ::=)
381 *
382 *****************************************************************************/
DateAsnWrite(NCBI_DatePtr dp,AsnIoPtr aip,AsnTypePtr orig)383 NLM_EXTERN Boolean LIBCALL DateAsnWrite (NCBI_DatePtr dp, AsnIoPtr aip, AsnTypePtr orig)
384 {
385 DataVal av;
386 AsnTypePtr atp;
387 Boolean retval = FALSE;
388
389 if (! loaded)
390 {
391 if (! GeneralAsnLoad())
392 return FALSE;
393 }
394
395 if (aip == NULL)
396 return FALSE;
397
398 atp = AsnLinkType(orig, DATE); /* link local tree */
399 if (atp == NULL)
400 return FALSE;
401
402 if (dp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
403
404 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
405
406 av.ptrvalue = (Pointer)dp;
407
408 if (dp->data[0] == 0) /* str type */
409 {
410 if (! AsnWriteChoice(aip, atp, (Int2)0, &av)) goto erret;
411 av.ptrvalue = dp->str;
412 if (! AsnWrite(aip, DATE_str, &av)) goto erret; /* write the choice */
413 }
414 else /* std type */
415 {
416 if (! AsnWriteChoice(aip, atp, (Int2)1, &av)) goto erret;
417
418 if (! AsnOpenStruct(aip, DATE_std, (Pointer)dp))
419 goto erret;
420
421 if (dp->data[1] == 0) /* not set properly */
422 av.intvalue = 0; /* carry it through */
423 else
424 av.intvalue = (Int4)dp->data[1] + 1900;
425 if (! AsnWrite(aip, DATE_STD_year, &av)) goto erret;
426 if (dp->data[2] != 0)
427 {
428 av.intvalue = dp->data[2];
429 if (! AsnWrite(aip, DATE_STD_month, &av)) goto erret;
430 }
431 if (dp->data[3] != 0)
432 {
433 av.intvalue = dp->data[3];
434 if (! AsnWrite(aip, DATE_STD_day, &av)) goto erret;
435 }
436 if (dp->str != NULL)
437 {
438 av.ptrvalue = dp->str;
439 if (! AsnWrite(aip, DATE_STD_season, &av)) goto erret;
440 }
441 if (dp->data[4] < 24)
442 {
443 av.intvalue = dp->data[4];
444 if (! AsnWrite(aip, DATE_STD_hour, &av)) goto erret;
445 }
446 if (dp->data[5] < 60)
447 {
448 av.intvalue = dp->data[5];
449 if (! AsnWrite(aip, DATE_STD_minute, &av)) goto erret;
450 }
451 if (dp->data[6] < 60)
452 {
453 av.intvalue = dp->data[6];
454 if (! AsnWrite(aip, DATE_STD_second, &av)) goto erret;
455 }
456
457 if (! AsnCloseStruct(aip, DATE_std, (Pointer)dp))
458 goto erret;
459 }
460 retval = TRUE;
461 erret:
462 AsnUnlinkType(orig); /* unlink local tree */
463 return retval;
464 }
465
466 /*****************************************************************************
467 *
468 * DateAsnRead(aip, atp)
469 * atp is the current type (if identifier of a parent struct)
470 * assumption is readIdent has occurred
471 * if atp == NULL, then assumes it stands alone and read ident
472 * has not occurred.
473 *
474 *****************************************************************************/
DateAsnRead(AsnIoPtr aip,AsnTypePtr orig)475 NLM_EXTERN NCBI_DatePtr LIBCALL DateAsnRead (AsnIoPtr aip, AsnTypePtr orig)
476 {
477 DataVal av;
478 AsnTypePtr atp;
479 NCBI_DatePtr dp=NULL;
480
481 if (! loaded)
482 {
483 if (! GeneralAsnLoad())
484 return dp;
485 }
486
487 if (aip == NULL)
488 return dp;
489
490 if (orig == NULL) /* Date ::= (self contained) */
491 atp = AsnReadId(aip, amp, DATE);
492 else
493 atp = AsnLinkType(orig, DATE); /* link in local tree */
494 if (atp == NULL)
495 return dp;
496
497 dp = DateNew();
498 if (dp == NULL)
499 goto erret;
500
501 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* read the CHOICE value (nothing) */
502 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* find the choice */
503 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* get the first value */
504
505 if (atp == DATE_str) /* str type */
506 {
507 dp->str = (CharPtr)av.ptrvalue; /* save the string */
508 }
509 else if (atp == DATE_std) /* std type */
510 {
511 dp->data[0] = 1; /* set type */
512 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* get the year */
513 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
514 if (av.intvalue == 0) /* year not set */
515 dp->data[1] = 0; /* don't blow it */
516 else
517 dp->data[1] = (Uint1)(av.intvalue - 1900);
518 /* check optionals */
519 while ((atp = AsnReadId(aip, amp, atp)) != DATE_std)
520 {
521 if (atp == NULL)
522 goto erret;
523 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
524 if (atp == DATE_STD_month)
525 dp->data[2] = (Uint1)av.intvalue;
526 else if (atp == DATE_STD_day)
527 dp->data[3] = (Uint1)av.intvalue;
528 else if (atp == DATE_STD_season)
529 dp->str = (CharPtr)av.ptrvalue;
530 else if (atp == DATE_STD_hour)
531 dp->data[4] = (Uint1)av.intvalue;
532 else if (atp == DATE_STD_minute)
533 dp->data[5] = (Uint1)av.intvalue;
534 else if (atp == DATE_STD_second)
535 dp->data[6] = (Uint1)av.intvalue;
536 }
537 if (atp == NULL) goto erret;
538 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* read last END_STRUCT */
539 }
540 ret:
541 AsnUnlinkType(orig); /* unlink local tree */
542 return dp;
543 erret:
544 dp = DateFree(dp);
545 goto ret;
546 }
547
548 /*****************************************************************************
549 *
550 * Int2 DateMatch(a, b, all)
551 * returns 0 = same
552 * 1, -1 = different (b is after a = -1)
553 * 2, -2 = couldn't match, arbitrary ordering
554 * if (all) then all fields in one must be in the other
555 * else, matches only fields found in both
556 * string dates just come in alphabetical order
557 *
558 * thus, for 0,1,-1 return values are like strcmp()
559 *
560 *****************************************************************************/
DateMatch(DatePtr a,DatePtr b,Boolean all)561 NLM_EXTERN Int2 LIBCALL DateMatch (DatePtr a, DatePtr b, Boolean all)
562 {
563 Int2 retval = 2;
564
565 if ((a != NULL) && (b != NULL))
566 {
567 if (a->data[0] == b->data[0]) /* same type */
568 {
569 if (a->data[0] == 0) /* string date */
570 {
571 retval = (Int2)StringICmp(a->str, b->str);
572 if (retval > 0)
573 return retval;
574 else if (retval < 0)
575 return (Int2) -1;
576 }
577 else /* std date */
578 {
579 if (a->data[1] > b->data[1]) /* year */
580 return (Int2)1;
581 else if (a->data[1] < b->data[1])
582 return (Int2)-1;
583 if (((a->data[2] != 0) && (b->data[2] != 0)) || all)
584 {
585 if (a->data[2] > b->data[2]) /* month */
586 return (Int2)1;
587 else if (a->data[2] < b->data[2])
588 return (Int2)-1;
589 }
590 if (((a->data[3] != 0) && (b->data[3] != 0)) || all)
591 {
592 if (a->data[3] > b->data[3]) /* day */
593 return (Int2)1;
594 else if (a->data[3] < b->data[3])
595 return (Int2)-1;
596 }
597 if (((a->str != NULL) && (b->str != NULL)) || all)
598 {
599 if ((a->str == NULL) && (b->str != NULL))
600 return (Int2) -1;
601 else if ((a->str != NULL) && (b->str == NULL))
602 return (Int2) 1;
603 retval = StringICmp(a->str, b->str);
604 if (retval > 0)
605 return (Int2)1;
606 else if (retval < 0)
607 return (Int2)-1;
608 }
609 }
610 retval = 0;
611 }
612 else
613 {
614 if (a->data[0] == 1)
615 return (Int2) -2;
616 else
617 return retval;
618 }
619 }
620 else if (all)
621 {
622 if (a == NULL)
623 return (Int2) -2;
624 else
625 return retval;
626 }
627 return retval;
628 }
629
630 /*****************************************************************************
631 *
632 * DateCheck (dp)
633 * Checks the date and month values in a date structure
634 * returns:
635 * -4 = NULL pointer passed in
636 * -3 = string date, can't be checked
637 * -2 = month not set (but otherwise ok)
638 * -1 = day not set (but otherwise ok)
639 * 0 = date ok, month,day,year all set
640 * 1 = day invalid
641 * 2 = month invalid
642 * 3 = year not set (required for date)
643 *
644 *****************************************************************************/
DateCheck(DatePtr dp)645 NLM_EXTERN Int2 LIBCALL DateCheck (DatePtr dp)
646 {
647 Int2 day, month, year, last;
648 static Uint1 days[12] = { 31, 28, 31, 30, 31,
649 30, 31, 31, 30, 31, 30, 31 };
650
651 if (dp == NULL) {
652 return -4;
653 }
654 if (dp->data[0] == 1) {
655 if (! dp->data[1])
656 return 3;
657 year = (Int2)dp->data[1] + 1900;
658 month = dp->data[2];
659 day = dp->data[3];
660 if (! month) /* month not set */
661 return -2;
662 if (month > 12)
663 return 2;
664 if (! day)
665 return -1;
666 last = days[month-1];
667 if ((month == 2) && (year%4 == 0) && (year != 2000)) {
668 last = 29;
669 }
670 if (day > last) {
671 return 1;
672 }
673 }
674 else
675 return -3;
676
677 return 0;
678 }
679
DateParse(CharPtr str)680 NLM_EXTERN DatePtr LIBCALL DateParse (CharPtr str)
681
682 {
683 Int4 day = -1, month = -1, year = -1;
684 DatePtr dp;
685 CharPtr ptr;
686 Char tmp [64];
687 long int val;
688
689 if (StringHasNoText (str)) return NULL;
690
691 StringNCpy_0 (tmp, str, sizeof (tmp));
692 ptr = StringChr (tmp, '/');
693 if (ptr == NULL) {
694 ptr = StringChr (tmp, '-');
695 }
696 if (ptr != NULL) {
697 *ptr = '\0';
698 ptr++;
699 if (sscanf (tmp, "%ld", &val) == 1) {
700 month = (Int4) val;
701 }
702 str = StringChr (ptr, '/');
703 if (str == NULL) {
704 str = StringChr (ptr, '-');
705 }
706 if (str != NULL) {
707 *str = '\0';
708 str++;
709 if (sscanf (ptr, "%ld", &val) == 1) {
710 day = (Int4) val;
711 }
712 if (sscanf (str, "%ld", &val) == 1) {
713 year = (Int4) val;
714 }
715 }
716 }
717
718 if (month < 0 || day < 0 || year < 2000) return NULL;
719 if (month > 12 || day > 31 || year > 2099) return NULL;
720
721 dp = DateNew ();
722 if (dp == NULL) return NULL;
723
724 dp->data [0] = 1;
725 dp->data [1] = (Uint1) (year - 1900);
726 dp->data [2] = (Uint1) month;
727 dp->data [3] = (Uint1) day;
728
729 return dp;
730 }
731
732 /*****************************************************************************
733 *
734 * DbtagNew()
735 *
736 *****************************************************************************/
DbtagNew(void)737 NLM_EXTERN DbtagPtr LIBCALL DbtagNew (void)
738 {
739 DbtagPtr dbt;
740
741 dbt = (DbtagPtr)MemNew(sizeof(Dbtag));
742 return dbt;
743 }
744
745 /*****************************************************************************
746 *
747 * DbtagFree()
748 *
749 *****************************************************************************/
DbtagFree(DbtagPtr dbt)750 NLM_EXTERN DbtagPtr LIBCALL DbtagFree (DbtagPtr dbt)
751 {
752 if (dbt == NULL)
753 return dbt;
754
755 dbt->tag = ObjectIdFree(dbt->tag);
756 MemFree(dbt->db);
757 return (DbtagPtr)MemFree(dbt);
758 }
759
760 /*****************************************************************************
761 *
762 * DbtagAsnRead(aip, atp)
763 *
764 *****************************************************************************/
DbtagAsnRead(AsnIoPtr aip,AsnTypePtr orig)765 NLM_EXTERN DbtagPtr LIBCALL DbtagAsnRead (AsnIoPtr aip, AsnTypePtr orig)
766 {
767 DbtagPtr dbt=NULL;
768 DataVal av;
769 AsnTypePtr atp;
770
771 if (! loaded)
772 {
773 if (! GeneralAsnLoad())
774 return dbt;
775 }
776
777 if (aip == NULL)
778 return dbt;
779
780 if (orig == NULL) /* Dbtag ::= */
781 atp = AsnReadId(aip, amp, DBTAG);
782 else
783 atp = AsnLinkType(orig, DBTAG);
784 if (atp == NULL)
785 return dbt;
786
787 dbt = DbtagNew();
788 if (dbt == NULL)
789 goto erret;
790
791 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* read the START_STRUCT */
792
793 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* read the db */
794 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
795 dbt->db = (CharPtr)av.ptrvalue;
796
797 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* read tag */
798 dbt->tag = ObjectIdAsnRead(aip, atp);
799 if (dbt->tag == NULL)
800 goto erret;
801
802 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* END_STRUCT */
803 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
804 ret:
805 AsnUnlinkType(orig);
806 return dbt;
807 erret:
808 dbt = DbtagFree(dbt);
809 goto ret;
810 }
811
812 /*****************************************************************************
813 *
814 * DbtagAsnWrite(dbt, aip, atp)
815 *
816 *****************************************************************************/
DbtagAsnWrite(DbtagPtr dbt,AsnIoPtr aip,AsnTypePtr orig)817 NLM_EXTERN Boolean LIBCALL DbtagAsnWrite (DbtagPtr dbt, AsnIoPtr aip, AsnTypePtr orig)
818 {
819 DataVal av;
820 AsnTypePtr atp;
821 Boolean retval = FALSE;
822
823 if (! loaded)
824 {
825 if (! GeneralAsnLoad())
826 return FALSE;
827 }
828
829 if (aip == NULL)
830 return FALSE;
831
832 atp = AsnLinkType(orig, DBTAG);
833 if (atp == NULL)
834 return FALSE;
835
836 if (dbt == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
837
838 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
839
840 if (! AsnOpenStruct(aip, atp, (Pointer)dbt)) goto erret;
841
842 av.ptrvalue = dbt->db;
843 if (! AsnWrite(aip, DBTAG_db, &av)) goto erret;
844 if (! ObjectIdAsnWrite(dbt->tag, aip, DBTAG_tag)) goto erret;
845
846 if (! AsnCloseStruct(aip, atp, (Pointer)dbt)) goto erret;
847 retval = TRUE;
848 erret:
849 AsnUnlinkType(orig);
850 return retval;
851 }
852
853 /*****************************************************************************
854 *
855 * DbtagMatch(a, b)
856 *
857 *****************************************************************************/
DbtagMatchEx(DbtagPtr a,DbtagPtr b,Boolean case_sensitive)858 NLM_EXTERN Boolean LIBCALL DbtagMatchEx (DbtagPtr a, DbtagPtr b, Boolean case_sensitive)
859 {
860 if (a == b)
861 return TRUE;
862
863 if ((a == NULL) || (b == NULL))
864 return FALSE;
865
866 if (case_sensitive) {
867 if (StringCmp (a->db, b->db) != 0) {
868 return FALSE;
869 }
870 } else if (StringICmp(a->db, b->db) != 0) {
871 return FALSE;
872 }
873
874 return ObjectIdMatchEx(a->tag, b->tag, case_sensitive);
875 }
876
877
DbtagMatch(DbtagPtr a,DbtagPtr b)878 NLM_EXTERN Boolean LIBCALL DbtagMatch (DbtagPtr a, DbtagPtr b)
879 {
880 return DbtagMatchEx (a, b, FALSE);
881 }
882
883
884 /*****************************************************************************
885 *
886 * DbtagDup(oldtag)
887 *
888 *****************************************************************************/
DbtagDup(DbtagPtr oldtag)889 NLM_EXTERN DbtagPtr LIBCALL DbtagDup (DbtagPtr oldtag)
890 {
891 DbtagPtr newtag;
892
893 if (oldtag == NULL)
894 return oldtag;
895
896 newtag = DbtagNew();
897 if (newtag == NULL) return newtag;
898 newtag->db = StringSave(oldtag->db);
899 newtag->tag = ObjectIdDup(oldtag->tag);
900 return newtag;
901 }
902
903 /*****************************************************************************
904 *
905 * DbtagLabel(dbt, buf, buflen)
906 *
907 *****************************************************************************/
DbtagLabel(DbtagPtr dbt,CharPtr buf,Int2 buflen)908 NLM_EXTERN Int2 LIBCALL DbtagLabel(DbtagPtr dbt, CharPtr buf, Int2 buflen)
909 {
910 Char numbuf[15];
911 CharPtr tp = NULL;
912
913 if (dbt == NULL) return 0;
914
915 if (dbt->tag != NULL)
916 {
917 if (dbt->tag->str != NULL)
918 tp = dbt->tag->str;
919 else
920 {
921 sprintf(numbuf, "%ld", (long)(dbt->tag->id));
922 tp = numbuf;
923 }
924 }
925
926 return LabelCopyExtra(buf, ": ", buflen, dbt->db, tp);
927 }
928
929 /*****************************************************************************
930 *
931 * ObjectIdNew()
932 *
933 *****************************************************************************/
ObjectIdNew(void)934 NLM_EXTERN ObjectIdPtr LIBCALL ObjectIdNew (void)
935 {
936 ObjectIdPtr oid;
937
938 oid = (ObjectIdPtr)MemNew(sizeof(ObjectId));
939 return oid;
940 }
941
942 /*****************************************************************************
943 *
944 * ObjectIdFree()
945 *
946 *****************************************************************************/
ObjectIdFree(ObjectIdPtr oid)947 NLM_EXTERN ObjectIdPtr LIBCALL ObjectIdFree (ObjectIdPtr oid)
948 {
949 if (oid == NULL)
950 return oid;
951
952 MemFree(oid->str);
953 return (ObjectIdPtr)MemFree(oid);
954 }
955
956 /*****************************************************************************
957 *
958 * ObjectIdAsnRead(aip, atp)
959 *
960 *****************************************************************************/
ObjectIdAsnRead(AsnIoPtr aip,AsnTypePtr orig)961 NLM_EXTERN ObjectIdPtr LIBCALL ObjectIdAsnRead (AsnIoPtr aip, AsnTypePtr orig)
962 {
963 ObjectIdPtr oid = NULL;
964 DataVal av;
965 AsnTypePtr atp;
966
967 if (! loaded)
968 {
969 if (! GeneralAsnLoad())
970 return oid;
971 }
972
973 if (aip == NULL)
974 return oid;
975
976 if (orig == NULL) /* ObjectId ::= */
977 atp = AsnReadId(aip, amp, OBJECT_ID);
978 else
979 atp = AsnLinkType(orig, OBJECT_ID);
980 if (atp == NULL)
981 return oid;
982
983 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* read the CHOICE value (nothing) */
984
985 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* read the CHOICE type */
986 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* and the value */
987
988 oid = ObjectIdNew();
989 if (oid == NULL)
990 goto erret;
991 if (atp == OBJECT_ID_id)
992 oid->id = av.intvalue;
993 else
994 oid->str = (CharPtr)av.ptrvalue;
995 ret:
996 AsnUnlinkType(orig);
997 return oid;
998 erret:
999 oid = ObjectIdFree(oid);
1000 goto ret;
1001 }
1002
1003 /*****************************************************************************
1004 *
1005 * ObjectIdAsnWrite(oid, aip, atp)
1006 *
1007 *****************************************************************************/
ObjectIdAsnWrite(ObjectIdPtr oid,AsnIoPtr aip,AsnTypePtr orig)1008 NLM_EXTERN Boolean LIBCALL ObjectIdAsnWrite (ObjectIdPtr oid, AsnIoPtr aip, AsnTypePtr orig)
1009 {
1010 DataVal av;
1011 AsnTypePtr atp;
1012 Boolean retval = FALSE;
1013
1014 if (! loaded)
1015 {
1016 if (! GeneralAsnLoad())
1017 return FALSE;
1018 }
1019
1020 if (aip == NULL)
1021 return FALSE;
1022
1023 atp = AsnLinkType(orig, OBJECT_ID);
1024 if (atp == NULL)
1025 return FALSE;
1026
1027 if (oid == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1028
1029 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1030
1031 if (! AsnWrite(aip, atp, &av)) goto erret; /* write the CHOICE (no value) */
1032
1033 if (oid->str == NULL) /* id used */
1034 {
1035 av.intvalue = oid->id;
1036 atp = OBJECT_ID_id;
1037 }
1038 else /* str used */
1039 {
1040 av.ptrvalue = oid->str;
1041 atp = OBJECT_ID_str;
1042 }
1043
1044 if (! AsnWrite(aip, atp, &av)) goto erret;
1045 retval = TRUE;
1046 erret:
1047 AsnUnlinkType(orig);
1048 return retval;
1049 }
1050
1051 /*****************************************************************************
1052 *
1053 * Boolean ObjectIdMatch(a, b)
1054 *
1055 *****************************************************************************/
ObjectIdMatchEx(ObjectIdPtr a,ObjectIdPtr b,Boolean case_sensitive)1056 NLM_EXTERN Boolean LIBCALL ObjectIdMatchEx (ObjectIdPtr a, ObjectIdPtr b, Boolean case_sensitive)
1057 {
1058 Boolean rval = FALSE;
1059 Char buf [16];
1060
1061 if (a == b)
1062 {
1063 rval = TRUE;
1064 }
1065
1066 if ((a == NULL) || (b == NULL)) /* only one is null */
1067 {
1068 return FALSE;
1069 }
1070
1071 if ((a->str != NULL) && (b->str != NULL)) /* same type */
1072 {
1073 if (case_sensitive)
1074 {
1075 if (StringCmp (a->str, b->str) == 0)
1076 {
1077 rval = TRUE;
1078 }
1079 else
1080 {
1081 rval = FALSE;
1082 }
1083 }
1084 else
1085 {
1086 if (StringICmp(a->str, b->str) == 0)
1087 {
1088 rval = TRUE;
1089 }
1090 else
1091 {
1092 rval = FALSE;
1093 }
1094 }
1095 }
1096 else if ((a->str == NULL) && (b->str == NULL)) /* must be same kind */
1097 {
1098 if (a->id == b->id)
1099 {
1100 rval = TRUE;
1101 }
1102 else
1103 {
1104 rval = FALSE;
1105 }
1106 } else if (a->str != NULL && b->str == NULL) { /* allow numeric string to match id value */
1107 sprintf (buf, "%ld", (long) b->id);
1108 if (StringICmp (a->str, buf) == 0) {
1109 rval = TRUE;
1110 } else {
1111 rval = FALSE;
1112 }
1113 } else if (a->str == NULL && b->str != NULL) {
1114 sprintf (buf, "%ld", (long) a->id);
1115 if (StringICmp (b->str, buf) == 0) {
1116 rval = TRUE;
1117 } else {
1118 rval = FALSE;
1119 }
1120 }
1121 else /* different kinds */
1122 {
1123 rval = FALSE;
1124 }
1125 return rval;
1126 }
1127
ObjectIdMatch(ObjectIdPtr a,ObjectIdPtr b)1128 NLM_EXTERN Boolean LIBCALL ObjectIdMatch (ObjectIdPtr a, ObjectIdPtr b)
1129 {
1130 return ObjectIdMatchEx (a, b, FALSE);
1131 }
1132
1133
1134 /*****************************************************************************
1135 *
1136 * ObjectIdDup(oldid)
1137 *
1138 *****************************************************************************/
ObjectIdDup(ObjectIdPtr oldid)1139 NLM_EXTERN ObjectIdPtr LIBCALL ObjectIdDup (ObjectIdPtr oldid)
1140 {
1141 ObjectIdPtr newid;
1142
1143 if (oldid == NULL)
1144 return oldid;
1145
1146 newid = ObjectIdNew();
1147 newid->id = oldid->id;
1148 newid->str = StringSave(oldid->str);
1149 return newid;
1150 }
1151
1152 /*****************************************************************************
1153 *
1154 * NameStdNew()
1155 *
1156 *****************************************************************************/
NameStdNew(void)1157 NLM_EXTERN NameStdPtr LIBCALL NameStdNew (void)
1158 {
1159 NameStdPtr nsp;
1160
1161 nsp = (NameStdPtr)MemNew(sizeof(NameStd));
1162 return nsp;
1163 }
1164
1165 /*****************************************************************************
1166 *
1167 * NameStdFree()
1168 *
1169 *****************************************************************************/
NameStdFree(NameStdPtr nsp)1170 NLM_EXTERN NameStdPtr LIBCALL NameStdFree (NameStdPtr nsp)
1171 {
1172 Int2 i;
1173
1174 if (nsp == NULL)
1175 return nsp;
1176
1177 for (i = 0; i < 7; i++)
1178 MemFree(nsp->names[i]);
1179 return (NameStdPtr)MemFree(nsp);
1180 }
1181
1182 /*****************************************************************************
1183 *
1184 * NameStdAsnRead(aip, atp)
1185 *
1186 *****************************************************************************/
NameStdAsnRead(AsnIoPtr aip,AsnTypePtr orig)1187 NLM_EXTERN NameStdPtr LIBCALL NameStdAsnRead (AsnIoPtr aip, AsnTypePtr orig)
1188 {
1189 NameStdPtr nsp=NULL;
1190 DataVal av;
1191 AsnTypePtr atp, start;
1192 Int2 i;
1193
1194 if (! loaded)
1195 {
1196 if (! GeneralAsnLoad())
1197 return nsp;
1198 }
1199
1200 if (aip == NULL)
1201 return nsp;
1202
1203 if (orig == NULL) /* NameStd ::= */
1204 atp = AsnReadId(aip, amp, NAME_STD);
1205 else
1206 atp = AsnLinkType(orig, NAME_STD);
1207 start = atp;
1208 if (atp == NULL)
1209 return nsp;
1210
1211 nsp = NameStdNew();
1212 if (nsp == NULL)
1213 goto erret;
1214
1215 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* read the START_STRUCT */
1216
1217 do
1218 {
1219 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret;
1220 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
1221 if (atp == NAME_STD_last)
1222 i = 0;
1223 else if (atp == NAME_STD_first)
1224 i = 1;
1225 else if (atp == NAME_STD_middle)
1226 i = 2;
1227 else if (atp == NAME_STD_full)
1228 i = 3;
1229 else if (atp == NAME_STD_initials)
1230 i = 4;
1231 else if (atp == NAME_STD_suffix)
1232 i = 5;
1233 else if (atp == NAME_STD_title)
1234 i = 6;
1235 else
1236 i = 10;
1237
1238 if (i < 10)
1239 nsp->names[i] = (CharPtr)av.ptrvalue;
1240 } while (atp != start);
1241 ret:
1242 AsnUnlinkType(orig);
1243 return nsp;
1244 erret:
1245 nsp = NameStdFree(nsp);
1246 goto ret;
1247 }
1248
1249 /*****************************************************************************
1250 *
1251 * NameStdAsnWrite(nsp, aip, atp)
1252 *
1253 *****************************************************************************/
NameStdAsnWrite(NameStdPtr nsp,AsnIoPtr aip,AsnTypePtr orig)1254 NLM_EXTERN Boolean LIBCALL NameStdAsnWrite (NameStdPtr nsp, AsnIoPtr aip, AsnTypePtr orig)
1255 {
1256 DataVal av;
1257 AsnTypePtr atp, ptr;
1258 Int2 i;
1259 Boolean retval = FALSE;
1260
1261 if (! loaded)
1262 {
1263 if (! GeneralAsnLoad())
1264 return FALSE;
1265 }
1266
1267 if (aip == NULL)
1268 return FALSE;
1269
1270 atp = AsnLinkType(orig, NAME_STD);
1271 if (atp == NULL)
1272 return FALSE;
1273
1274 if (nsp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1275
1276 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1277
1278 if (! AsnOpenStruct(aip, atp, (Pointer)nsp)) goto erret;
1279
1280 for (i = 0; i < 7; i++)
1281 {
1282 if (nsp->names[i] != NULL)
1283 {
1284 av.ptrvalue = nsp->names[i];
1285 switch (i)
1286 {
1287 case 0:
1288 ptr = NAME_STD_last;
1289 break;
1290 case 1:
1291 ptr = NAME_STD_first;
1292 break;
1293 case 2:
1294 ptr = NAME_STD_middle;
1295 break;
1296 case 3:
1297 ptr = NAME_STD_full;
1298 break;
1299 case 4:
1300 ptr = NAME_STD_initials;
1301 break;
1302 case 5:
1303 ptr = NAME_STD_suffix;
1304 break;
1305 case 6:
1306 ptr = NAME_STD_title;
1307 break;
1308 }
1309 if (! AsnWrite(aip, ptr, &av)) goto erret;
1310 }
1311 }
1312
1313 if (! AsnCloseStruct(aip, atp, (Pointer)nsp)) goto erret;
1314 retval = TRUE;
1315 erret:
1316 AsnUnlinkType(orig);
1317 return retval;
1318 }
1319
1320 /*****************************************************************************
1321 *
1322 * NameStdMatch(nsp1, nsp2)
1323 *
1324 *****************************************************************************/
NameStdMatch(NameStdPtr nsp1,NameStdPtr nsp2)1325 NLM_EXTERN Boolean LIBCALL NameStdMatch (NameStdPtr nsp1, NameStdPtr nsp2)
1326 {
1327 Int4 j;
1328
1329 if (nsp1 == NULL && nsp2 == NULL)
1330 {
1331 return TRUE;
1332 }
1333 else if (nsp1 == NULL || nsp2 == NULL)
1334 {
1335 return FALSE;
1336 }
1337
1338 for (j = 0; j < 7; j++)
1339 {
1340 if (StringCmp (nsp1->names [j], nsp2->names[j]) != 0)
1341 {
1342 return FALSE;
1343 }
1344 }
1345 return TRUE;
1346 }
1347
1348 /*****************************************************************************
1349 *
1350 * PersonIdNew()
1351 *
1352 *****************************************************************************/
PersonIdNew(void)1353 NLM_EXTERN PersonIdPtr LIBCALL PersonIdNew (void)
1354 {
1355 PersonIdPtr pid;
1356
1357 pid = (PersonIdPtr)MemNew(sizeof(PersonId));
1358 return pid;
1359 }
1360
1361 /*****************************************************************************
1362 *
1363 * PersonIdFree()
1364 *
1365 *****************************************************************************/
PersonIdFree(PersonIdPtr pid)1366 NLM_EXTERN PersonIdPtr LIBCALL PersonIdFree (PersonIdPtr pid)
1367 {
1368 if (pid == NULL)
1369 return pid;
1370
1371 if (pid->choice == 1) /* Dbtag */
1372 DbtagFree((DbtagPtr)pid->data);
1373 else if (pid->choice == 2) /* Name-std */
1374 NameStdFree((NameStdPtr)pid->data);
1375 else
1376 MemFree(pid->data);
1377 return (PersonIdPtr)MemFree(pid);
1378 }
1379
1380 /*****************************************************************************
1381 *
1382 * PersonIdAsnRead(aip, atp)
1383 *
1384 *****************************************************************************/
PersonIdAsnRead(AsnIoPtr aip,AsnTypePtr orig)1385 NLM_EXTERN PersonIdPtr LIBCALL PersonIdAsnRead (AsnIoPtr aip, AsnTypePtr orig)
1386 {
1387 PersonIdPtr pid=NULL;
1388 DataVal av;
1389 AsnTypePtr atp;
1390
1391 if (! loaded)
1392 {
1393 if (! GeneralAsnLoad())
1394 return pid;
1395 }
1396
1397 if (aip == NULL)
1398 return pid;
1399
1400 if (orig == NULL) /* PersonId ::= */
1401 atp = AsnReadId(aip, amp, PERSON_ID);
1402 else
1403 atp = AsnLinkType(orig, PERSON_ID);
1404 if (atp == NULL) return pid;
1405
1406 pid = PersonIdNew();
1407 if (pid == NULL) goto erret;
1408
1409 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* read the CHOICE (nothing) */
1410
1411 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* identify the CHOICE type */
1412 if (atp == PERSON_ID_dbtag)
1413 {
1414 pid->choice = 1;
1415 pid->data = DbtagAsnRead(aip, atp);
1416 }
1417 else if (atp == PERSON_ID_name)
1418 {
1419 pid->choice = 2;
1420 pid->data = NameStdAsnRead(aip, atp);
1421 }
1422 else
1423 {
1424 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* a string type */
1425 pid->data = av.ptrvalue;
1426 if (atp == PERSON_ID_ml)
1427 pid->choice = 3;
1428 else if (atp == PERSON_ID_str)
1429 pid->choice = 4; /* str */
1430 else if (atp == PERSON_ID_consortium)
1431 pid->choice = 5; /* consortium */
1432 }
1433 if (pid->data == NULL)
1434 goto erret;
1435 ret:
1436 AsnUnlinkType(orig);
1437 return pid;
1438 erret:
1439 pid = PersonIdFree(pid);
1440 goto ret;
1441 }
1442
1443 /*****************************************************************************
1444 *
1445 * PersonIdAsnWrite(pid, aip, atp)
1446 *
1447 *****************************************************************************/
PersonIdAsnWrite(PersonIdPtr pid,AsnIoPtr aip,AsnTypePtr orig)1448 NLM_EXTERN Boolean LIBCALL PersonIdAsnWrite (PersonIdPtr pid, AsnIoPtr aip, AsnTypePtr orig)
1449 {
1450 DataVal av;
1451 AsnTypePtr atp;
1452 Boolean retval = FALSE;
1453
1454 if (! loaded)
1455 {
1456 if (! GeneralAsnLoad())
1457 return FALSE;
1458 }
1459
1460 if (aip == NULL)
1461 return FALSE;
1462
1463 atp = AsnLinkType(orig, PERSON_ID);
1464 if (atp == NULL)
1465 goto erret;
1466
1467 if (pid == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1468
1469 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1470
1471 if (! AsnWrite(aip, atp, &av)) goto erret; /* write the CHOICE, no value */
1472
1473 av.ptrvalue = pid->data;
1474 switch (pid->choice)
1475 {
1476 case 1:
1477 if (! DbtagAsnWrite((DbtagPtr)(pid->data), aip, PERSON_ID_dbtag))
1478 goto erret;
1479 break;
1480 case 2:
1481 if (! NameStdAsnWrite((NameStdPtr)(pid->data), aip, PERSON_ID_name))
1482 goto erret;
1483 break;
1484 case 3:
1485 if (! AsnWrite(aip, PERSON_ID_ml, &av)) goto erret;
1486 break;
1487 case 4:
1488 if (! AsnWrite(aip, PERSON_ID_str, &av)) goto erret;
1489 break;
1490 case 5:
1491 if (! AsnWrite(aip, PERSON_ID_consortium, &av)) goto erret;
1492 break;
1493 }
1494 retval = TRUE;
1495 erret:
1496 AsnUnlinkType(orig);
1497 return retval;
1498 }
1499
1500 /*****************************************************************************
1501 *
1502 * PersonIdLabel(pid, buf, buflen, format)
1503 * Makes a short label, lastname then initials if it can
1504 * format = PIDLABEL_GENBANK last,initials
1505 * PIDLABEL_EMBL last initials
1506 *
1507 * Modeled from GBGetAuthNames in asn2ff
1508 * returns number of bytes in buf
1509 * buf MUST be at least (buflen + 1) long
1510 *
1511 *****************************************************************************/
PersonIdLabel(PersonIdPtr pid,CharPtr buf,Int2 buflen,Int2 format)1512 NLM_EXTERN Int2 LIBCALL PersonIdLabel (PersonIdPtr pid, CharPtr buf, Int2 buflen, Int2 format)
1513 {
1514 NameStdPtr nsp;
1515 Int2 len, diff;
1516 Char tbuf[2];
1517 CharPtr tmp;
1518
1519 if ((pid == NULL) || (buflen < 0) || (buf == NULL))
1520 return 0;
1521
1522 if (buflen == 0) /* on a boundary */
1523 {
1524 *(buf-1) = '>';
1525 return 0;
1526 }
1527
1528 *buf = '?';
1529 *(buf+1) = '\0';
1530 len = buflen;
1531 if (format == PIDLABEL_GENBANK)
1532 tbuf[0] = ',';
1533 else
1534 tbuf[0] = ' ';
1535 tbuf[1] = '\0';
1536
1537 if (pid->choice == 2) /* structured name */
1538 {
1539 nsp = (NameStdPtr)(pid->data);
1540 if (nsp->names[0] != NULL) /* last name */
1541 {
1542 diff = LabelCopy(buf, nsp->names[0], buflen);
1543 buflen -= diff; buf += diff;
1544 if (nsp->names[4])
1545 {
1546 diff = LabelCopyExtra(buf, nsp->names[4], buflen, tbuf, NULL);
1547 buflen -= diff; buf += diff;
1548 }
1549 if (nsp->names[5]) /* suffix */
1550 {
1551 tbuf[0] = ' ';
1552 diff = LabelCopyExtra(buf, nsp->names[5], buflen, tbuf, NULL);
1553 buflen -= diff; buf += diff;
1554 }
1555 }
1556 else if (nsp->names[3] != NULL) /* full name */
1557 {
1558 diff = LabelCopy(buf, nsp->names[3], buflen);
1559 buflen -= diff; buf += diff;
1560 }
1561 }
1562 else if ((pid->choice == 3) || (pid->choice == 4) || (pid->choice == 5))
1563 {
1564 diff = LabelCopy(buf, (CharPtr)(pid->data), buflen);
1565 if (format == PIDLABEL_EMBL)
1566 {
1567 for (tmp = buf; *tmp != '\0'; tmp ++)
1568 {
1569 if (*tmp == ',')
1570 {
1571 *tmp = ' ';
1572 break;
1573 }
1574 }
1575 }
1576 buflen -= diff; buf += diff;
1577 }
1578 else
1579 return LabelCopy(buf, "Unsupported PersonID", buflen);
1580
1581 return (len - buflen);
1582 }
1583
1584 /*****************************************************************************
1585 *
1586 * PersonIdMatch(pip1, pip2)
1587 *
1588 *****************************************************************************/
PersonIdMatch(PersonIdPtr pip1,PersonIdPtr pip2)1589 NLM_EXTERN Boolean LIBCALL PersonIdMatch (PersonIdPtr pip1, PersonIdPtr pip2)
1590 {
1591 Boolean does_match = TRUE;
1592
1593 if (pip1 == NULL && pip2 == NULL)
1594 {
1595 return TRUE;
1596 }
1597 else if (pip1 == NULL || pip2 == NULL)
1598 {
1599 return FALSE;
1600 }
1601 else if (pip1->choice != pip2->choice)
1602 {
1603 return FALSE;
1604 }
1605
1606 switch (pip1->choice)
1607 {
1608 case 0:
1609 /* not set */
1610 break;
1611 case 1:
1612 /* dbtag */
1613 does_match = DbtagMatch (pip1->data, pip2->data);
1614 break;
1615 case 2:
1616 /* name */
1617 does_match = NameStdMatch (pip1->data, pip2->data);
1618 break;
1619 case 3: /* ml */
1620 case 4: /* str */
1621 case 5: /* consortium */
1622 if (StringCmp (pip1->data, pip2->data) != 0)
1623 {
1624 does_match = FALSE;
1625 }
1626 break;
1627 }
1628 return does_match;
1629 }
1630
1631 /*****************************************************************************
1632 *
1633 * IntFuzzNew()
1634 *
1635 *****************************************************************************/
IntFuzzNew(void)1636 NLM_EXTERN IntFuzzPtr LIBCALL IntFuzzNew (void)
1637 {
1638 IntFuzzPtr ifp;
1639
1640 ifp = (IntFuzzPtr)MemNew(sizeof(IntFuzz));
1641 return ifp;
1642 }
1643
1644 /*****************************************************************************
1645 *
1646 * IntFuzzFree()
1647 *
1648 *****************************************************************************/
IntFuzzFree(IntFuzzPtr ifp)1649 NLM_EXTERN IntFuzzPtr LIBCALL IntFuzzFree (IntFuzzPtr ifp)
1650 {
1651 if (ifp == NULL)
1652 return ifp;
1653 MemFree(ifp->alt);
1654 return (IntFuzzPtr)MemFree(ifp);
1655 }
1656
1657 /*****************************************************************************
1658 *
1659 * IntFuzzAsnRead(aip, atp)
1660 *
1661 *****************************************************************************/
IntFuzzAsnRead(AsnIoPtr aip,AsnTypePtr orig)1662 NLM_EXTERN IntFuzzPtr LIBCALL IntFuzzAsnRead (AsnIoPtr aip, AsnTypePtr orig)
1663 {
1664 IntFuzzPtr ifp=NULL;
1665 DataVal av;
1666 AsnTypePtr atp;
1667 Int4Ptr tmp;
1668
1669 if (! loaded)
1670 {
1671 if (! GeneralAsnLoad())
1672 return ifp;
1673 }
1674
1675 if (aip == NULL)
1676 return ifp;
1677
1678 if (orig == NULL) /* IntFuzz ::= */
1679 atp = AsnReadId(aip, amp, INT_FUZZ);
1680 else
1681 atp = AsnLinkType(orig, INT_FUZZ);
1682 if (atp == NULL)
1683 return ifp;
1684
1685 ifp = IntFuzzNew();
1686 if (ifp == NULL)
1687 goto erret;
1688
1689 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* read the CHOICE (nothing) */
1690
1691 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* identify the CHOICE type */
1692 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* read first value */
1693 ifp->a = av.intvalue; /* ok in 3/4 of cases */
1694
1695 if (atp == INT_FUZZ_p_m) /* plus-minus */
1696 {
1697 ifp->choice = 1;
1698 }
1699 else if (atp == INT_FUZZ_pct)
1700 {
1701 ifp->choice = 3;
1702 }
1703 else if (atp == INT_FUZZ_lim)
1704 {
1705 ifp->choice = 4;
1706 }
1707 else if (atp == INT_FUZZ_range) /* range, read a SEQUENCE */
1708 {
1709 ifp->choice = 2;
1710 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* max */
1711 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
1712 ifp->a = av.intvalue;
1713 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* min */
1714 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
1715 ifp->b = av.intvalue;
1716 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* end of structure */
1717 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
1718 }
1719 else if (atp == INT_FUZZ_alt)
1720 {
1721 ifp->choice = 5;
1722 ifp->a = 0;
1723 ifp->b = 0;
1724 while ((atp = AsnReadId(aip, amp, atp)) == INT_FUZZ_alt_E)
1725 {
1726 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
1727 if (ifp->a == ifp->b) /* need more room */
1728 {
1729 tmp = ifp->alt;
1730 ifp->alt = MemNew((size_t)(ifp->b + 10) * sizeof(Int4));
1731 if (ifp->alt == NULL) goto erret;
1732 MemMove(ifp->alt, tmp, (size_t)(ifp->b * sizeof(Int4)));
1733 MemFree(tmp);
1734 ifp->b += 10;
1735 }
1736 ifp->alt[ifp->a] = av.intvalue;
1737 ifp->a++;
1738
1739 }
1740 if (atp == NULL) goto erret;
1741 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
1742 }
1743 ret:
1744 AsnUnlinkType(orig);
1745 return ifp;
1746 erret:
1747 ifp = IntFuzzFree(ifp);
1748 goto ret;
1749 }
1750
1751 /*****************************************************************************
1752 *
1753 * IntFuzzAsnWrite(ifp, aip, atp)
1754 *
1755 *****************************************************************************/
IntFuzzAsnWrite(IntFuzzPtr ifp,AsnIoPtr aip,AsnTypePtr orig)1756 NLM_EXTERN Boolean LIBCALL IntFuzzAsnWrite (IntFuzzPtr ifp, AsnIoPtr aip, AsnTypePtr orig)
1757 {
1758 DataVal av;
1759 AsnTypePtr atp, ptr;
1760 Boolean retval = FALSE;
1761 Int4 i;
1762
1763 if (! loaded)
1764 {
1765 if (! GeneralAsnLoad())
1766 return FALSE;
1767 }
1768
1769 if (aip == NULL)
1770 return FALSE;
1771
1772 atp = AsnLinkType(orig, INT_FUZZ);
1773 if (atp == NULL) return FALSE;
1774
1775 if (ifp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
1776
1777 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
1778
1779 av.ptrvalue = (Pointer)ifp;
1780 if (! AsnWriteChoice(aip, atp, (Int2)ifp->choice, &av)) goto erret;
1781
1782 av.intvalue = ifp->a; /* ok in 3/4 choices */
1783 ptr = NULL;
1784
1785 switch (ifp->choice)
1786 {
1787 case 1:
1788 ptr = INT_FUZZ_p_m;
1789 break;
1790 case 2:
1791 if (! AsnOpenStruct(aip, INT_FUZZ_range, (Pointer)ifp))
1792 goto erret;
1793 if (! AsnWrite(aip, INT_FUZZ_range_max, &av)) goto erret;
1794 av.intvalue = ifp->b;
1795 if (! AsnWrite(aip, INT_FUZZ_range_min, &av)) goto erret;
1796 if (! AsnCloseStruct(aip, INT_FUZZ_range, (Pointer)ifp))
1797 goto erret;
1798 break;
1799 case 3:
1800 ptr = INT_FUZZ_pct;
1801 break;
1802 case 4:
1803 ptr = INT_FUZZ_lim;
1804 break;
1805 case 5:
1806 if (! AsnOpenStruct(aip, INT_FUZZ_alt, (Pointer)ifp))
1807 goto erret;
1808 for (i = 0; i < ifp->a; i++)
1809 {
1810 av.intvalue = ifp->alt[i];
1811 if (! AsnWrite(aip, INT_FUZZ_alt_E, &av)) goto erret;
1812 }
1813 if (! AsnCloseStruct(aip, INT_FUZZ_alt, (Pointer)ifp))
1814 goto erret;
1815 break;
1816 }
1817
1818 if (ptr != NULL) /* 3/5 types */
1819 if (! AsnWrite(aip, ptr, &av)) goto erret;
1820 retval = TRUE;
1821 erret:
1822 AsnUnlinkType(orig);
1823 return retval;
1824 }
1825
1826 /*****************************************************************************
1827 *
1828 * UserFieldNew()
1829 *
1830 *****************************************************************************/
UserFieldNew(void)1831 NLM_EXTERN UserFieldPtr LIBCALL UserFieldNew (void)
1832 {
1833 UserFieldPtr ufp;
1834
1835 ufp = (UserFieldPtr)MemNew(sizeof(UserField));
1836 return ufp;
1837 }
1838
1839 /*****************************************************************************
1840 *
1841 * UserFieldFree()
1842 *
1843 *****************************************************************************/
UserFieldFree(UserFieldPtr ufp)1844 NLM_EXTERN UserFieldPtr LIBCALL UserFieldFree (UserFieldPtr ufp)
1845 {
1846 Int4 i, num;
1847 CharPtr PNTR cpp;
1848 ByteStorePtr PNTR bpp;
1849 UserFieldPtr ufpa, ufpb;
1850 UserObjectPtr uopa, uopb;
1851
1852 if (ufp == NULL)
1853 return ufp;
1854
1855 num = ufp->num;
1856
1857 if (ufp->label != NULL)
1858 ufp->label = ObjectIdFree(ufp->label);
1859
1860 switch (ufp->choice)
1861 {
1862 case 1: /* str */
1863 case 8: /* ints */
1864 case 9: /* reals */
1865 MemFree(ufp->data.ptrvalue);
1866 break;
1867 case 5: /* os */
1868 BSFree((ByteStorePtr) ufp->data.ptrvalue);
1869 break;
1870 case 6: /* object */
1871 UserObjectFree((UserObjectPtr) ufp->data.ptrvalue);
1872 break;
1873 case 7: /* strs */
1874 cpp = (CharPtr PNTR) ufp->data.ptrvalue;
1875 if( cpp ) {
1876 for (i = 0; i < num; i++)
1877 MemFree(cpp[i]);
1878 MemFree(cpp);
1879 }
1880 break;
1881 case 10: /* oss */
1882 bpp = (ByteStorePtr PNTR) ufp->data.ptrvalue;
1883 for (i = 0; i < num; i++)
1884 BSFree(bpp[i]);
1885 MemFree(bpp);
1886 break;
1887 case 11: /* fields */
1888 ufpa = (UserFieldPtr) ufp->data.ptrvalue;
1889 while (ufpa != NULL)
1890 {
1891 ufpb = ufpa->next;
1892 UserFieldFree(ufpa);
1893 ufpa = ufpb;
1894 }
1895 break;
1896 case 12: /* objects */
1897 uopa = (UserObjectPtr) ufp->data.ptrvalue;
1898 while (uopa != NULL)
1899 {
1900 uopb = uopa->next;
1901 UserObjectFree(uopa);
1902 uopa = uopb;
1903 }
1904 break;
1905
1906 }
1907 return (UserFieldPtr)MemFree(ufp);
1908 }
1909
1910 /*****************************************************************************
1911 *
1912 * UserFieldAsnRead(aip, atp)
1913 *
1914 *****************************************************************************/
UserFieldAsnRead(AsnIoPtr aip,AsnTypePtr orig)1915 NLM_EXTERN UserFieldPtr LIBCALL UserFieldAsnRead (AsnIoPtr aip, AsnTypePtr orig)
1916 {
1917 UserFieldPtr ufp=NULL;
1918 DataVal av;
1919 AsnTypePtr atp;
1920 Int4 num = 0, i = 0;
1921 CharPtr PNTR cpp;
1922 ByteStorePtr PNTR bpp;
1923 Int4Ptr ip;
1924 FloatHiPtr fp;
1925 UserFieldPtr ufpa, ufpb = NULL;
1926 UserObjectPtr uopa, uopb = NULL;
1927 ValNodePtr vnp, first = NULL, last = NULL;
1928 static char * emsg1 = "Too many %s in UserField. line %ld",
1929 * emsg2 = "Too few %s in UserField. line %ld";
1930
1931 if (! loaded)
1932 {
1933 if (! GeneralAsnLoad())
1934 return ufp;
1935 }
1936
1937 if (aip == NULL)
1938 return ufp;
1939
1940 if (orig == NULL) /* UserField ::= */
1941 atp = AsnReadId(aip, amp, USER_FIELD);
1942 else
1943 atp = AsnLinkType(orig, USER_FIELD);
1944 if (atp == NULL)
1945 return ufp;
1946
1947 ufp = UserFieldNew();
1948 if (ufp == NULL)
1949 goto erret;
1950
1951 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* read start struct */
1952
1953 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* object id */
1954 ufp->label = ObjectIdAsnRead(aip, atp);
1955 if (ufp->label == NULL) goto erret;
1956
1957 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* could be num */
1958 if (atp == USER_FIELD_num)
1959 {
1960 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
1961 num = av.intvalue;
1962 ufp->num = num;
1963 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret;
1964 }
1965
1966 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* read the CHOICE (nothing) */
1967
1968 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* identify the CHOICE type */
1969
1970 if (atp == USER_FIELD_data_object)
1971 {
1972 ufp->choice = 6;
1973 ufp->data.ptrvalue = (Pointer) UserObjectAsnRead(aip, atp);
1974 if (ufp->data.ptrvalue == NULL) goto erret;
1975 }
1976 else if (atp == USER_FIELD_data_strs)
1977 {
1978 ufp->choice = 7;
1979 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* start SEQUENCE OF */
1980
1981 while ((atp = AsnReadId(aip, amp, atp)) == USER_FIELD_data_strs_E)
1982 {
1983 if (num > 0 && i >= num)
1984 {
1985 ErrPost(CTX_NCBIOBJ,1, emsg1, "strs", aip->linenumber);
1986 goto erret;
1987 }
1988 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
1989 /*
1990 cpp[i] = (CharPtr)av.ptrvalue;
1991 */
1992 vnp = ValNodeAddStr (&last, 0, (CharPtr)av.ptrvalue);
1993 if (first == NULL) {
1994 first = vnp;
1995 }
1996 last = vnp;
1997 i++;
1998 }
1999 if (atp == NULL) goto erret;
2000 if (num > 0 && i != num)
2001 {
2002 ErrPost(CTX_NCBIOBJ,1, emsg2, "strs", aip->linenumber);
2003 goto erret;
2004 }
2005 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* end SEQUENCE OF */
2006
2007 num = i;
2008 ufp->num = num;
2009
2010 if (num > 0) {
2011 ufp->data.ptrvalue = MemNew((size_t)(sizeof(CharPtr) * num));
2012 cpp = (CharPtr PNTR) ufp->data.ptrvalue;
2013 if (cpp == NULL) goto erret;
2014 for (vnp = first, i = 0; vnp != NULL && i < num; vnp = vnp->next, i++) {
2015 cpp [i] = (CharPtr) vnp->data.ptrvalue;
2016 }
2017 }
2018
2019 ValNodeFree (first);
2020 }
2021 else if (atp == USER_FIELD_data_ints)
2022 {
2023 ufp->choice = 8;
2024 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* start SEQUENCE OF */
2025
2026 while ((atp = AsnReadId(aip, amp, atp)) == USER_FIELD_data_ints_E)
2027 {
2028 if (num > 0 && i >= num)
2029 {
2030 ErrPost(CTX_NCBIOBJ,1, emsg1, "ints", aip->linenumber);
2031 goto erret;
2032 }
2033 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
2034 /*
2035 ip[i] = av.intvalue;
2036 */
2037 vnp = ValNodeAddInt (&last, 0, (Int4)av.intvalue);
2038 if (first == NULL) {
2039 first = vnp;
2040 }
2041 last = vnp;
2042 i++;
2043 }
2044 if (atp == NULL) goto erret;
2045 if (num > 0 && i != num)
2046 {
2047 ErrPost(CTX_NCBIOBJ,1, emsg2, "ints", aip->linenumber);
2048 goto erret;
2049 }
2050 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* end SEQUENCE OF */
2051
2052 num = i;
2053 ufp->num = num;
2054
2055 if (num > 0) {
2056 ufp->data.ptrvalue = MemNew((size_t)(sizeof(Int4) * num));
2057 ip = (Int4Ptr) ufp->data.ptrvalue;
2058 if (ip == NULL) goto erret;
2059 for (vnp = first, i = 0; vnp != NULL && i < num; vnp = vnp->next, i++) {
2060 ip [i] = (Int4) vnp->data.intvalue;
2061 }
2062 }
2063
2064 ValNodeFree (first);
2065 }
2066 else if (atp == USER_FIELD_data_reals)
2067 {
2068 ufp->choice = 9;
2069 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* start SEQUENCE OF */
2070
2071 while ((atp = AsnReadId(aip, amp, atp)) == USER_FIELD_data_reals_E)
2072 {
2073 if (num > 0 && i >= num)
2074 {
2075 ErrPost(CTX_NCBIOBJ,1, emsg1, "reals", aip->linenumber);
2076 goto erret;
2077 }
2078 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
2079 /*
2080 fp[i] = av.realvalue;
2081 */
2082 vnp = ValNodeAddFloat (&last, 0, (FloatHi)av.realvalue);
2083 if (first == NULL) {
2084 first = vnp;
2085 }
2086 last = vnp;
2087 i++;
2088 }
2089 if (atp == NULL) goto erret;
2090 if (num > 0 && i != num)
2091 {
2092 ErrPost(CTX_NCBIOBJ,1, emsg2, "reals", aip->linenumber);
2093 goto erret;
2094 }
2095 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* end SEQUENCE OF */
2096
2097 num = i;
2098 ufp->num = num;
2099
2100 if (num > 0) {
2101 ufp->data.ptrvalue = MemNew((size_t)(sizeof(FloatHi) * num));
2102 fp = (FloatHiPtr) ufp->data.ptrvalue;
2103 if (fp == NULL) goto erret;
2104 for (vnp = first, i = 0; vnp != NULL && i < num; vnp = vnp->next, i++) {
2105 fp [i] = (FloatHi) vnp->data.realvalue;
2106 }
2107 }
2108
2109 ValNodeFree (first);
2110 }
2111 else if (atp == USER_FIELD_data_oss)
2112 {
2113 ufp->choice = 10;
2114 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* start SEQUENCE OF */
2115
2116 while ((atp = AsnReadId(aip, amp, atp)) == USER_FIELD_data_oss_E)
2117 {
2118 if (num > 0 && i >= num)
2119 {
2120 ErrPost(CTX_NCBIOBJ,1, emsg1, "oss", aip->linenumber);
2121 goto erret;
2122 }
2123 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
2124 /*
2125 bpp[i] = (ByteStorePtr)av.ptrvalue;
2126 */
2127 vnp = ValNodeAddPointer (&last, 0, (Pointer)av.ptrvalue);
2128 if (first == NULL) {
2129 first = vnp;
2130 }
2131 last = vnp;
2132 i++;
2133 }
2134 if (atp == NULL) goto erret;
2135 if (num > 0 && i != num)
2136 {
2137 ErrPost(CTX_NCBIOBJ,1, emsg2, "oss", aip->linenumber);
2138 goto erret;
2139 }
2140 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* end SEQUENCE OF */
2141
2142 num = i;
2143 ufp->num = num;
2144
2145 if (num > 0) {
2146 ufp->data.ptrvalue = MemNew((size_t)(sizeof(ByteStorePtr) * num));
2147 bpp = (ByteStorePtr PNTR) ufp->data.ptrvalue;
2148 if (bpp == NULL) goto erret;
2149
2150 for (vnp = first, i = 0; vnp != NULL && i < num; vnp = vnp->next, i++) {
2151 bpp [i] = (ByteStorePtr) vnp->data.ptrvalue;
2152 }
2153 }
2154
2155 ValNodeFree (first);
2156 }
2157 else if (atp == USER_FIELD_data_fields)
2158 {
2159 ufp->choice = 11;
2160 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* start SEQUENCE OF */
2161 while ((atp = AsnReadId(aip, amp, atp)) == USER_FIELD_data_fields_E)
2162 {
2163 ufpa = UserFieldAsnRead(aip, atp);
2164 if (ufpa == NULL) goto erret;
2165 if (ufpb == NULL)
2166 ufp->data.ptrvalue = (Pointer) ufpa;
2167 else
2168 ufpb->next = ufpa;
2169 ufpb = ufpa;
2170 }
2171 if (atp == NULL) goto erret;
2172 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* end SEQUENCE OF */
2173 }
2174 else if (atp == USER_FIELD_data_objects)
2175 {
2176 ufp->choice = 12;
2177 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* start SEQUENCE OF */
2178 while ((atp = AsnReadId(aip, amp, atp)) == USER_FIELD_data_objects_E)
2179 {
2180 uopa = UserObjectAsnRead(aip, atp);
2181 if (uopa == NULL) goto erret;
2182 if (uopb == NULL)
2183 ufp->data.ptrvalue = (Pointer) uopa;
2184 else
2185 uopb->next = uopa;
2186 uopb = uopa;
2187 }
2188 if (atp == NULL) goto erret;
2189 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* end SEQUENCE OF */
2190 }
2191 else
2192 {
2193 if (AsnReadVal(aip, atp, &ufp->data) <= 0) goto erret;
2194 if (atp == USER_FIELD_data_str)
2195 ufp->choice = 1;
2196 else if (atp == USER_FIELD_data_int)
2197 ufp->choice = 2;
2198 else if (atp == USER_FIELD_data_real)
2199 ufp->choice = 3;
2200 else if (atp == USER_FIELD_data_bool)
2201 ufp->choice = 4;
2202 else if (atp == USER_FIELD_data_os)
2203 ufp->choice = 5;
2204 }
2205
2206 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* end struct */
2207 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
2208 ret:
2209 AsnUnlinkType(orig);
2210 return ufp;
2211 erret:
2212 ufp = UserFieldFree(ufp);
2213 goto ret;
2214 }
2215
2216 /*****************************************************************************
2217 *
2218 * UserFieldAsnWrite(ufp, aip, atp)
2219 *
2220 *****************************************************************************/
UserFieldAsnWrite(UserFieldPtr ufp,AsnIoPtr aip,AsnTypePtr orig)2221 NLM_EXTERN Boolean LIBCALL UserFieldAsnWrite (UserFieldPtr ufp, AsnIoPtr aip, AsnTypePtr orig)
2222 {
2223 DataVal av;
2224 AsnTypePtr atp;
2225 Int4 num, i;
2226 CharPtr PNTR cpp;
2227 ByteStorePtr PNTR bpp;
2228 Int4Ptr ip;
2229 FloatHiPtr fp;
2230 UserFieldPtr ufpa;
2231 UserObjectPtr uopa;
2232 Boolean retval = FALSE;
2233
2234 if (! loaded)
2235 {
2236 if (! GeneralAsnLoad())
2237 return FALSE;
2238 }
2239
2240 if (aip == NULL)
2241 return FALSE;
2242
2243 atp = AsnLinkType(orig, USER_FIELD);
2244 if (atp == NULL) return FALSE;
2245
2246 if (ufp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2247
2248 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
2249
2250 if (! AsnOpenStruct(aip, atp, (Pointer)ufp)) goto erret; /* start the struct */
2251 if (! ObjectIdAsnWrite(ufp->label, aip, USER_FIELD_label))
2252 goto erret;
2253 num = ufp->num;
2254
2255 if (num > 0)
2256 {
2257 av.intvalue = num;
2258 if (! AsnWrite(aip, USER_FIELD_num, &av)) goto erret;
2259 }
2260
2261 if (! AsnWriteChoice(aip, USER_FIELD_data, (Int2)ufp->choice, &ufp->data))
2262 goto erret;
2263
2264 switch (ufp->choice)
2265 {
2266 case 1:
2267 if (! AsnWrite(aip, USER_FIELD_data_str, &ufp->data))
2268 goto erret;
2269 break;
2270 case 2:
2271 if (! AsnWrite(aip, USER_FIELD_data_int, &ufp->data))
2272 goto erret;
2273 break;
2274 case 3:
2275 if (! AsnWrite(aip, USER_FIELD_data_real, &ufp->data))
2276 goto erret;
2277 break;
2278 case 4:
2279 if (! AsnWrite(aip, USER_FIELD_data_bool, &ufp->data))
2280 goto erret;
2281 break;
2282 case 5:
2283 if (! AsnWrite(aip, USER_FIELD_data_os, &ufp->data))
2284 goto erret;
2285 break;
2286 case 6:
2287 if (! UserObjectAsnWrite((UserObjectPtr)ufp->data.ptrvalue, aip, USER_FIELD_data_object))
2288 goto erret;
2289 break;
2290 case 7:
2291 cpp = (CharPtr PNTR) ufp->data.ptrvalue;
2292 if (! AsnOpenStruct(aip, USER_FIELD_data_strs, (Pointer)cpp))
2293 goto erret;
2294 for (i = 0; i < num; i++)
2295 {
2296 av.ptrvalue = (Pointer) cpp[i];
2297 if (! AsnWrite(aip, USER_FIELD_data_strs_E, &av)) goto erret;
2298 }
2299 if (! AsnCloseStruct(aip, USER_FIELD_data_strs, (Pointer)cpp))
2300 goto erret;
2301 break;
2302 case 8:
2303 ip = (Int4Ptr) ufp->data.ptrvalue;
2304 if (! AsnOpenStruct(aip, USER_FIELD_data_ints, (Pointer)ip))
2305 goto erret;
2306 for (i = 0; i < num; i++)
2307 {
2308 av.intvalue = ip[i];
2309 if (! AsnWrite(aip, USER_FIELD_data_ints_E, &av)) goto erret;
2310 }
2311 if (! AsnCloseStruct(aip, USER_FIELD_data_ints, (Pointer)ip))
2312 goto erret;
2313 break;
2314 case 9:
2315 fp = (FloatHiPtr) ufp->data.ptrvalue;
2316 if (! AsnOpenStruct(aip, USER_FIELD_data_reals, (Pointer)fp))
2317 goto erret;
2318 for (i = 0; i < num; i++)
2319 {
2320 av.realvalue = fp[i];
2321 if (! AsnWrite(aip, USER_FIELD_data_reals_E, &av)) goto erret;
2322 }
2323 if (! AsnCloseStruct(aip, USER_FIELD_data_reals, (Pointer)fp))
2324 goto erret;
2325 break;
2326 case 10:
2327 bpp = (ByteStorePtr PNTR) ufp->data.ptrvalue;
2328 if (! AsnOpenStruct(aip, USER_FIELD_data_oss, (Pointer)bpp))
2329 goto erret;
2330 for (i = 0; i < num; i++)
2331 {
2332 av.ptrvalue = (Pointer) bpp[i];
2333 if (! AsnWrite(aip, USER_FIELD_data_oss_E, &av)) goto erret;
2334 }
2335 if (! AsnCloseStruct(aip, USER_FIELD_data_oss, (Pointer)bpp))
2336 goto erret;
2337 break;
2338 case 11:
2339 ufpa = (UserFieldPtr) ufp->data.ptrvalue;
2340 if (! AsnOpenStruct(aip, USER_FIELD_data_fields, ufp->data.ptrvalue))
2341 goto erret;
2342 while (ufpa != NULL)
2343 {
2344 if (! UserFieldAsnWrite(ufpa, aip, USER_FIELD_data_fields_E))
2345 goto erret;
2346 ufpa = ufpa->next;
2347 }
2348 if (! AsnCloseStruct(aip, USER_FIELD_data_fields, ufp->data.ptrvalue))
2349 goto erret;
2350 break;
2351 case 12:
2352 uopa = (UserObjectPtr) ufp->data.ptrvalue;
2353 if (! AsnOpenStruct(aip, USER_FIELD_data_objects, ufp->data.ptrvalue))
2354 goto erret;
2355 while (uopa != NULL)
2356 {
2357 if (! UserObjectAsnWrite(uopa, aip, USER_FIELD_data_objects_E))
2358 goto erret;
2359 uopa = uopa->next;
2360 }
2361 if (! AsnCloseStruct(aip, USER_FIELD_data_objects, ufp->data.ptrvalue))
2362 goto erret;
2363 break;
2364 }
2365 if (! AsnCloseStruct(aip, atp, (Pointer)ufp)) goto erret;
2366 retval = TRUE;
2367 erret:
2368 AsnUnlinkType(orig);
2369 return retval;
2370 }
2371
2372 /*****************************************************************************
2373 *
2374 * UserObjectNew()
2375 *
2376 *****************************************************************************/
UserObjectNew(void)2377 NLM_EXTERN UserObjectPtr LIBCALL UserObjectNew (void)
2378 {
2379 UserObjectPtr uop;
2380
2381 uop = (UserObjectPtr)MemNew(sizeof(UserObject));
2382 return uop;
2383 }
2384
2385 /*****************************************************************************
2386 *
2387 * UserObjectFree()
2388 *
2389 *****************************************************************************/
UserObjectFree(UserObjectPtr uop)2390 NLM_EXTERN UserObjectPtr LIBCALL UserObjectFree (UserObjectPtr uop)
2391 {
2392 UserFieldPtr ufpa, ufpb;
2393
2394 if (uop == NULL)
2395 return uop;
2396
2397 MemFree(uop->_class);
2398 ObjectIdFree(uop->type);
2399 ufpa = uop->data;
2400 while (ufpa != NULL)
2401 {
2402 ufpb = ufpa->next;
2403 UserFieldFree(ufpa);
2404 ufpa = ufpb;
2405 }
2406 return (UserObjectPtr)MemFree(uop);
2407 }
2408
2409 /*****************************************************************************
2410 *
2411 * UserObjectAsnRead(aip, atp)
2412 *
2413 *****************************************************************************/
UserObjectAsnRead(AsnIoPtr aip,AsnTypePtr orig)2414 NLM_EXTERN UserObjectPtr LIBCALL UserObjectAsnRead (AsnIoPtr aip, AsnTypePtr orig)
2415 {
2416 UserObjectPtr uop=NULL;
2417 DataVal av;
2418 AsnTypePtr atp;
2419 UserFieldPtr ufpa, ufpb = NULL;
2420
2421 if (! loaded)
2422 {
2423 if (! GeneralAsnLoad())
2424 return uop;
2425 }
2426
2427 if (aip == NULL)
2428 return uop;
2429
2430 if (orig == NULL) /* UserObject ::= */
2431 atp = AsnReadId(aip, amp, USER_OBJECT);
2432 else
2433 atp = AsnLinkType(orig, USER_OBJECT);
2434 if (atp == NULL)
2435 return uop;
2436
2437 uop = UserObjectNew();
2438 if (uop == NULL)
2439 goto erret;
2440
2441 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* read the start struct */
2442
2443 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* class? */
2444 if (atp == USER_OBJECT_class)
2445 {
2446 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
2447 uop->_class = (CharPtr) av.ptrvalue;
2448 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret;
2449 }
2450
2451 uop->type = ObjectIdAsnRead(aip, atp);
2452 if (uop->type == NULL) goto erret;
2453
2454 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* start SEQUENCE OF */
2455 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
2456 while ((atp = AsnReadId(aip, amp, atp)) == USER_OBJECT_data_E)
2457 {
2458 ufpa = UserFieldAsnRead(aip, atp);
2459 if (ufpa == NULL)
2460 goto erret;
2461 if (ufpb == NULL)
2462 uop->data = ufpa;
2463 else
2464 ufpb->next = ufpa;
2465 ufpb = ufpa;
2466 }
2467 if (atp == NULL) goto erret;
2468 if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* end SEQUENCE OF */
2469 atp = AsnReadId(aip, amp, atp); if (atp == NULL) goto erret; /* end SEQUENCE */
2470 if (AsnReadVal(aip, atp, &av) <= 0) goto erret;
2471 ret:
2472 AsnUnlinkType(orig);
2473 return uop;
2474 erret:
2475 uop = UserObjectFree(uop);
2476 goto ret;
2477 }
2478
2479 /*****************************************************************************
2480 *
2481 * UserObjectAsnWrite(uop, aip, atp)
2482 *
2483 *****************************************************************************/
UserObjectAsnWrite(UserObjectPtr uop,AsnIoPtr aip,AsnTypePtr orig)2484 NLM_EXTERN Boolean LIBCALL UserObjectAsnWrite (UserObjectPtr uop, AsnIoPtr aip, AsnTypePtr orig)
2485 {
2486 DataVal av;
2487 AsnTypePtr atp;
2488 UserFieldPtr ufp;
2489 Boolean retval = FALSE;
2490
2491 if (! loaded)
2492 {
2493 if (! GeneralAsnLoad())
2494 return FALSE;
2495 }
2496
2497 if (aip == NULL)
2498 return FALSE;
2499
2500 atp = AsnLinkType(orig, USER_OBJECT);
2501 if (atp == NULL) return FALSE;
2502
2503 if (uop == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
2504
2505 MemSet ((Pointer) (&av), 0, sizeof (DataVal));
2506
2507 if (! AsnOpenStruct(aip, atp, (Pointer)uop)) goto erret;
2508
2509 if (uop->_class != NULL)
2510 {
2511 av.ptrvalue = (Pointer) uop->_class;
2512 if (! AsnWrite(aip, USER_OBJECT_class, &av)) goto erret;
2513 }
2514
2515 if (! ObjectIdAsnWrite(uop->type, aip, USER_OBJECT_type))
2516 goto erret;
2517
2518 if (! AsnOpenStruct(aip, USER_OBJECT_data, (Pointer)uop->data))
2519 goto erret;
2520 ufp = uop->data;
2521 while (ufp != NULL)
2522 {
2523 if (! UserFieldAsnWrite(ufp, aip, USER_OBJECT_data_E))
2524 goto erret;
2525 ufp = ufp->next;
2526 }
2527 if (! AsnCloseStruct(aip, USER_OBJECT_data, (Pointer)uop->data))
2528 goto erret;
2529
2530 if (! AsnCloseStruct(aip, atp, (Pointer)uop)) goto erret;
2531 retval = TRUE;
2532 erret:
2533 AsnUnlinkType(orig);
2534 return retval;
2535 }
2536
2537
2538
2539
2540
2541