summaryrefslogtreecommitdiff
path: root/object
diff options
context:
space:
mode:
Diffstat (limited to 'object')
-rw-r--r--object/objalign.c28
-rw-r--r--object/objbibli.c7
-rw-r--r--object/objfdef.c16
-rw-r--r--object/objfdef.h5
-rw-r--r--object/objfeat.c3068
-rw-r--r--object/objfeat.h337
-rw-r--r--object/objgbseq.c1211
-rw-r--r--object/objgbseq.h225
-rw-r--r--object/objgen.c125
-rw-r--r--object/objgen.h63
-rw-r--r--object/objinsdseq.c1211
-rw-r--r--object/objinsdseq.h225
-rwxr-xr-xobject/objmacro.c1316
-rwxr-xr-xobject/objmacro.h127
-rw-r--r--object/objmedli.c9
-rw-r--r--object/objpub.c24
-rw-r--r--object/objvalid.c352
-rw-r--r--object/objvalid.h55
18 files changed, 7329 insertions, 1075 deletions
diff --git a/object/objalign.c b/object/objalign.c
index f2a61d45..9615354b 100644
--- a/object/objalign.c
+++ b/object/objalign.c
@@ -29,7 +29,7 @@
*
* Version Creation Date: 4/1/91
*
-* $Revision: 6.16 $
+* $Revision: 6.17 $
*
* File Description: Object manager for module NCBI-Seqalign
*
@@ -333,6 +333,7 @@ NLM_EXTERN SeqAlignPtr LIBCALL SeqAlignFree (SeqAlignPtr sap)
DenseDiagPtr ddp, ddpnext;
StdSegPtr ssp, sspnext;
ValNodePtr anp, next;
+ UserObjectPtr uopa, uopb;
if (sap == NULL)
return (SeqAlignPtr)NULL;
@@ -384,7 +385,16 @@ NLM_EXTERN SeqAlignPtr LIBCALL SeqAlignFree (SeqAlignPtr sap)
/*
AsnGenericChoiceSeqOfFree(sap -> id, (AsnOptFreeFunc) ObjectIdFree);
*/
+ uopa = (UserObjectPtr) sap->ext;
+ while (uopa != NULL) {
+ uopb = uopa->next;
+ uopa->next = NULL;
+ UserObjectFree (uopa);
+ uopa = uopb;
+ }
+ /*
AsnGenericUserSeqOfFree(sap -> ext, (AsnOptFreeFunc) UserObjectFree);
+ */
SeqLocSetFree(sap->bounds);
SeqIdFree(sap->master);
@@ -408,6 +418,7 @@ NLM_EXTERN Boolean LIBCALL SeqAlignAsnWrite (SeqAlignPtr sap, AsnIoPtr aip, AsnT
StdSegPtr ssp;
Boolean retval = FALSE;
ValNodePtr anp;
+ UserObjectPtr uop;
if (! loaded)
{
@@ -540,8 +551,19 @@ NLM_EXTERN Boolean LIBCALL SeqAlignAsnWrite (SeqAlignPtr sap, AsnIoPtr aip, AsnT
{
ErrPostEx(SEV_ERROR,0,0,"ASN3: SeqAlign.ext stripped");
}
- else
- AsnGenericUserSeqOfAsnWrite(sap -> ext, (AsnWriteFunc) UserObjectAsnWrite, aip, SEQ_ALIGN_ext, SEQ_ALIGN_ext_E);
+ else {
+ uop = (UserObjectPtr) sap->ext;
+ if (! AsnOpenStruct(aip, SEQ_ALIGN_ext, sap->ext)) goto erret;
+ while (uop != NULL)
+ {
+ if (! UserObjectAsnWrite(uop, aip, SEQ_ALIGN_ext_E)) goto erret;
+ uop = uop->next;
+ }
+ if (! AsnCloseStruct(aip, SEQ_ALIGN_ext, sap->ext)) goto erret;
+ }
+ /*
+ AsnGenericUserSeqOfAsnWrite(sap -> ext, (AsnWriteFunc) UserObjectAsnWrite, aip, SEQ_ALIGN_ext, SEQ_ALIGN_ext_E);
+ */
}
if (! AsnCloseStruct(aip, atp, (Pointer)sap))
diff --git a/object/objbibli.c b/object/objbibli.c
index 89449d9c..e78075fc 100644
--- a/object/objbibli.c
+++ b/object/objbibli.c
@@ -29,7 +29,7 @@
*
* Version Creation Date: 1/1/91
*
-* $Revision: 6.7 $
+* $Revision: 6.8 $
*
* File Description: Object manager for module NCBI-Biblio
*
@@ -41,6 +41,9 @@
* 07-19-93 Ostell Support for ASN30 added
*
* $Log: objbibli.c,v $
+* Revision 6.8 2009/10/02 19:44:48 kans
+* address clang static analyzer warnings
+*
* Revision 6.7 2006/02/22 17:31:45 kans
* fix to AuthListMatch (CB)
*
@@ -3635,7 +3638,7 @@ NLM_EXTERN PatPriorityPtr LIBCALL PatPrioritySetFree (PatPriorityPtr ppp)
*****************************************************************************/
NLM_EXTERN PatPriorityPtr LIBCALL PatPrioritySetAsnRead (AsnIoPtr aip, AsnTypePtr set, AsnTypePtr element)
{
- PatPriorityPtr ppp=NULL, head, last;
+ PatPriorityPtr ppp=NULL, head = NULL, last;
DataVal av;
AsnTypePtr atp;
diff --git a/object/objfdef.c b/object/objfdef.c
index de0067c4..800fdd25 100644
--- a/object/objfdef.c
+++ b/object/objfdef.c
@@ -29,7 +29,7 @@
*
* Version Creation Date: 9/94
*
-* $Revision: 6.39 $
+* $Revision: 6.41 $
*
* File Description: Object manager for feature definitions
*
@@ -700,7 +700,8 @@ static CharPtr featDefSetMemStr = "FeatDefGroupSet ::= {\n" \
"{ typelabel \"oriT\" , menulabel \"Origin of Transcription\" , featdef-key 93 , seqfeat-key 8 , entrygroup 5 , displaygroup 5 , molgroup na } ,\n" \
"{ typelabel \"ncRNA\" , menulabel \"Non-coding RNA\" , featdef-key 94 , seqfeat-key 5 , entrygroup 3 , displaygroup 3 , molgroup na } ,\n" \
"{ typelabel \"tmRNA\" , menulabel \"Transfer-messenger RNA\" , featdef-key 95 , seqfeat-key 5 , entrygroup 3 , displaygroup 3 , molgroup na } ,\n" \
-"{ typelabel \"CloneRef\" , menulabel \"Clone Reference\" , featdef-key 96 , seqfeat-key 21 , entrygroup 0 , displaygroup 0 , molgroup na } } };\n";
+"{ typelabel \"CloneRef\" , menulabel \"Clone Reference\" , featdef-key 96 , seqfeat-key 21 , entrygroup 0 , displaygroup 0 , molgroup na } ,\n" \
+"{ typelabel \"VariationRef\" , menulabel \"Variation Reference\" , featdef-key 97 , seqfeat-key 22 , entrygroup 0 , displaygroup 0 , molgroup na } } };\n";
#endif
/*****************************************************************************
@@ -985,6 +986,8 @@ NLM_EXTERN Uint1 LIBCALL FindFeatDefType(SeqFeatPtr sfp)
return FEATDEF_BIOSRC;
case SEQFEAT_CLONEREF:
return FEATDEF_CLONEREF;
+ case SEQFEAT_VARIATIONREF:
+ return FEATDEF_VARIATIONREF;
}
return FEATDEF_BAD;
@@ -1338,6 +1341,8 @@ protref: if (prp->name != NULL)
label = (sfp->data.value.ptrvalue);
if (StringICmp (label, "Domain") == 0 && sfp->comment != NULL) {
label = sfp->comment;
+ } else if (StringICmp (label, "Variant") == 0 && sfp->comment != NULL) {
+ label = sfp->comment;
}
break;
case SEQFEAT_COMMENT:
@@ -1397,6 +1402,8 @@ protref: if (prp->name != NULL)
goto orgref;
case SEQFEAT_CLONEREF:
break;
+ case SEQFEAT_VARIATIONREF:
+ break;
default:
break;
}
@@ -1489,6 +1496,11 @@ NLM_EXTERN Int2 LIBCALL FeatDefLabel (SeqFeatPtr sfp, CharPtr buf, Int2 buflen,
sfp->comment != NULL) {
StringCpy (tbuf, "Domain");
typelabel = tbuf;
+ } else if (sfp->data.choice == SEQFEAT_REGION &&
+ StringICmp ((CharPtr) sfp->data.value.ptrvalue, "Variant") == 0 &&
+ sfp->comment != NULL) {
+ StringCpy (tbuf, "Variant");
+ typelabel = tbuf;
}
}
else
diff --git a/object/objfdef.h b/object/objfdef.h
index 38aca1fd..7e114bc7 100644
--- a/object/objfdef.h
+++ b/object/objfdef.h
@@ -29,7 +29,7 @@
*
* Version Creation Date: 9/94
*
-* $Revision: 6.7 $
+* $Revision: 6.8 $
*
* File Description: Object manager for feature definitions
*
@@ -314,8 +314,9 @@ NLM_EXTERN FeatDefPtr LIBCALL FeatDefFindNext PROTO((FeatDefPtr curr, Uint1Ptr k
#define FEATDEF_ncRNA 94
#define FEATDEF_tmRNA 95
#define FEATDEF_CLONEREF 96
+#define FEATDEF_VARIATIONREF 97
-#define FEATDEF_MAX 97 /* size of array needed for featdef filter parameters */
+#define FEATDEF_MAX 98 /* size of array needed for featdef filter parameters */
#ifdef __cplusplus
diff --git a/object/objfeat.c b/object/objfeat.c
index 2f91c27f..0185f4e6 100644
--- a/object/objfeat.c
+++ b/object/objfeat.c
@@ -29,7 +29,7 @@
*
* Version Creation Date: 4/1/91
*
-* $Revision: 6.44 $
+* $Revision: 6.55 $
*
* File Description: Object manager for module NCBI-SeqFeat
*
@@ -54,6 +54,7 @@ static char *this_file = __FILE__;
#include <asnfeat.h> /* the AsnTool header */
#include <objmgr.h>
#include <objfdef.h>
+#include <objseq.h>
static Boolean loaded = FALSE;
@@ -795,6 +796,9 @@ NLM_EXTERN void LIBCALL SeqFeatDataFree(ChoicePtr cp)
case SEQFEAT_CLONEREF:
CloneRefFree((CloneRefPtr)pnt);
break;
+ case SEQFEAT_VARIATIONREF:
+ VariationRefFree((VariationRefPtr)pnt);
+ break;
}
return;
}
@@ -917,6 +921,10 @@ NLM_EXTERN Boolean LIBCALL SeqFeatDataAsnWrite (ChoicePtr cp, AsnIoPtr aip, AsnT
if (! CloneRefAsnWrite((CloneRefPtr)pnt, aip, SEQFEATDATA_clone))
goto erret;
break;
+ case SEQFEAT_VARIATIONREF:
+ if (! VariationRefAsnWrite((VariationRefPtr)pnt, aip, SEQFEATDATA_variation))
+ goto erret;
+ break;
}
retval = TRUE;
@@ -1097,6 +1105,13 @@ NLM_EXTERN Boolean LIBCALL SeqFeatDataAsnRead (AsnIoPtr aip, AsnTypePtr orig, Ch
if (cp->value.ptrvalue == NULL)
goto erret;
}
+ else if (atp == SEQFEATDATA_variation)
+ {
+ cp->choice = SEQFEAT_VARIATIONREF ;
+ cp->value.ptrvalue = (Pointer)VariationRefAsnRead(aip, atp);
+ if (cp->value.ptrvalue == NULL)
+ goto erret;
+ }
retval = TRUE;
erret:
@@ -2525,7 +2540,7 @@ NLM_EXTERN RnaRefPtr LIBCALL RnaRefFree (RnaRefPtr rrp)
NLM_EXTERN Boolean LIBCALL RnaRefAsnWrite (RnaRefPtr rrp, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
- AsnTypePtr atp, tmp;
+ AsnTypePtr atp, tmp = NULL;
tRNAPtr trna;
RNAGenPtr rgp;
Int2 i;
@@ -4227,6 +4242,19 @@ NLM_EXTERN Boolean LIBCALL OrgNameAsnWrite (OrgNamePtr onp, AsnIoPtr aip, AsnTyp
}
}
+ if (onp->pgcode)
+ {
+ if (aip->spec_version == 3) /* ASN3 strip new value */
+ {
+ ErrPostEx(SEV_ERROR,0,0,"ASN3: OrgName.pgcode stripped");
+ }
+ else
+ {
+ av.intvalue = (Int4)(onp->pgcode);
+ if (! AsnWrite(aip, ORGNAME_pgcode, &av)) goto erret;
+ }
+ }
+
if (! AsnCloseStruct(aip, atp, (Pointer)onp))
goto erret;
@@ -4354,6 +4382,15 @@ NLM_EXTERN OrgNamePtr LIBCALL OrgNameAsnRead (AsnIoPtr aip, AsnTypePtr orig)
else
onp->div = (CharPtr)(av.ptrvalue);
}
+ else if (atp == ORGNAME_pgcode)
+ {
+ if (aip->spec_version == 3) /* ASN3 strip new value */
+ {
+ ErrPostEx(SEV_ERROR,0,0,"ASN3: OrgName.pgcode stripped");
+ }
+ else
+ onp->pgcode = (Uint1)av.intvalue;
+ }
}
}
if (AsnReadVal(aip, atp, &av) <= 0) goto erret; /* end struct */
@@ -7791,3 +7828,3030 @@ erret:
return retval;
}
+
+/**************************************************
+*
+* VariationRefNew()
+*
+**************************************************/
+NLM_EXTERN
+VariationRefPtr LIBCALL
+VariationRefNew(void)
+{
+ VariationRefPtr ptr = MemNew((size_t) sizeof(VariationRef));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* Consequence_loss_of_heterozygosityNew()
+*
+**************************************************/
+NLM_EXTERN
+Consequence_loss_of_heterozygosityPtr LIBCALL
+Consequence_loss_of_heterozygosityNew(void)
+{
+ Consequence_loss_of_heterozygosityPtr ptr = MemNew((size_t) sizeof(Consequence_loss_of_heterozygosity));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* VariationRefFree()
+*
+**************************************************/
+NLM_EXTERN
+VariationRefPtr LIBCALL
+VariationRefFree(VariationRefPtr ptr)
+{
+ if(ptr == NULL) {
+ return NULL;
+ }
+ DbtagFree(ptr -> id);
+ DbtagFree(ptr -> parent_id);
+ ObjectIdFree(ptr -> sample_id);
+ AsnGenericValNodeSetFree(ptr -> other_ids, (AsnOptFreeFunc) DbtagFree);
+ /*
+ AsnGenericUserSeqOfFree(ptr -> other_ids, (AsnOptFreeFunc) DbtagFree);
+ */
+ MemFree(ptr -> name);
+ /*
+ AsnGenericValNodeSetFree(ptr -> synonyms, (AsnOptFreeFunc) MemFree);
+ */
+ AsnGenericBaseSeqOfFree(ptr -> synonyms ,ASNCODE_PTRVAL_SLOT);
+ MemFree(ptr -> description);
+ AsnGenericValNodeSetFree(ptr -> phenotype, (AsnOptFreeFunc) PhenotypeFree);
+ /*
+ AsnGenericUserSeqOfFree(ptr -> phenotype, (AsnOptFreeFunc) PhenotypeFree);
+ */
+ AsnGenericBaseSeqOfFree(ptr -> method ,ASNCODE_INTVAL_SLOT);
+ AsnGenericValNodeSetFree(ptr -> population_data, (AsnOptFreeFunc) PopulationDataFree);
+ /*
+ AsnGenericUserSeqOfFree(ptr -> population_data, (AsnOptFreeFunc) PopulationDataFree);
+ */
+ VariantPropertiesFree(ptr -> variant_prop);
+ AsnGenericValNodeSetFree(ptr -> clinical_test, (AsnOptFreeFunc) DbtagFree);
+ /*
+ AsnGenericUserSeqOfFree(ptr -> clinical_test, (AsnOptFreeFunc) DbtagFree);
+ */
+ PubFree(ptr -> pub);
+ VarRefDataFree(ptr -> data);
+ ConsequenceFree(ptr -> consequence);
+ SeqLocFree(ptr -> location);
+ AsnGenericValNodeSetFree(ptr -> ext_locs, (AsnOptFreeFunc) ExtLocFree);
+ /*
+ AsnGenericUserSeqOfFree(ptr -> ext_locs, (AsnOptFreeFunc) ExtLocFree);
+ */
+ UserObjectFree(ptr -> ext);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* ConsequenceFree()
+*
+**************************************************/
+NLM_EXTERN
+ConsequencePtr LIBCALL
+ConsequenceFree(ValNodePtr anp)
+{
+
+ if (anp == NULL) {
+ return NULL;
+ }
+
+ AsnGenericChoiceSeqOfFree(anp, (AsnOptFreeFunc) Consequence_elementFree);
+ return NULL;
+}
+
+
+/**************************************************
+*
+* VariationRefAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+VariationRefPtr LIBCALL
+VariationRefAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean isError = FALSE;
+ AsnReadFunc func;
+ VariationRefPtr ptr;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* VariationRef ::= (self contained) */
+ atp = AsnReadId(aip, amp, VARIATION_REF);
+ } else {
+ atp = AsnLinkType(orig, VARIATION_REF);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = VariationRefNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == VARIATION_REF_id) {
+ ptr -> id = DbtagAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_parent_id) {
+ ptr -> parent_id = DbtagAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_sample_id) {
+ ptr -> sample_id = ObjectIdAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_other_ids) {
+ ptr -> other_ids = AsnGenericValNodeSetAsnRead (aip, amp, atp, &isError, (AsnReadFunc) DbtagAsnRead, (AsnOptFreeFunc) DbtagFree);
+ /*
+ ptr -> other_ids = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) DbtagAsnRead, (AsnOptFreeFunc) DbtagFree);
+ */
+ if (isError && ptr -> other_ids == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_name) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> name = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_synonyms) {
+ /*
+ ptr -> synonyms = AsnGenericValNodeSetAsnRead(aip, amp, atp, &isError, (AsnReadFunc) NULL, (AsnOptFreeFunc) MemFree);
+ */
+ ptr -> synonyms = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
+ if (isError && ptr -> synonyms == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_description) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> description = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_phenotype) {
+ ptr -> phenotype = AsnGenericValNodeSetAsnRead (aip, amp, atp, &isError, (AsnReadFunc) PhenotypeAsnRead, (AsnOptFreeFunc) PhenotypeFree);
+ /*
+ ptr -> phenotype = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) PhenotypeAsnRead, (AsnOptFreeFunc) PhenotypeFree);
+ */
+ if (isError && ptr -> phenotype == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_method) {
+ ptr -> method = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_INTVAL_SLOT, &isError);
+ if (isError && ptr -> method == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_population_data) {
+ ptr -> population_data = AsnGenericValNodeSetAsnRead (aip, amp, atp, &isError, (AsnReadFunc) PopulationDataAsnRead, (AsnOptFreeFunc) PopulationDataFree);
+ /*
+ ptr -> population_data = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) PopulationDataAsnRead, (AsnOptFreeFunc) PopulationDataFree);
+ */
+ if (isError && ptr -> population_data == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_variant_prop) {
+ ptr -> variant_prop = VariantPropertiesAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_validated) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> validated = av.boolvalue;
+ ptr -> OBbits__ |= 1<<0;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_clinical_test) {
+ ptr -> clinical_test = AsnGenericValNodeSetAsnRead(aip, amp, atp, &isError, (AsnReadFunc) DbtagAsnRead, (AsnOptFreeFunc) DbtagFree);
+ /*
+ ptr -> clinical_test = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) DbtagAsnRead, (AsnOptFreeFunc) DbtagFree);
+ */
+ if (isError && ptr -> clinical_test == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_allele_origin) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> allele_origin = av.intvalue;
+ ptr -> OBbits__ |= 1<<1;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_allele_state) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> allele_state = av.intvalue;
+ ptr -> OBbits__ |= 1<<2;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_allele_frequency) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> allele_frequency = av.realvalue;
+ ptr -> OBbits__ |= 1<<3;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == REF_is_ancestral_allele) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> is_ancestral_allele = av.boolvalue;
+ ptr -> OBbits__ |= 1<<4;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_pub) {
+ ptr -> pub = PubAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_data) {
+ ptr -> data = VarRefDataAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_consequence) {
+ ptr -> consequence = ConsequenceAsnRead(aip, atp);
+ if (isError && ptr -> consequence == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_location) {
+ ptr -> location = SeqLocAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_ext_locs) {
+ ptr -> ext_locs = AsnGenericValNodeSetAsnRead (aip, amp, atp, &isError, (AsnReadFunc) ExtLocAsnRead, (AsnOptFreeFunc) ExtLocFree);
+ /*
+ ptr -> ext_locs = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) ExtLocAsnRead, (AsnOptFreeFunc) ExtLocFree);
+ */
+ if (isError && ptr -> ext_locs == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_ext) {
+ ptr -> ext = UserObjectAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = VariationRefFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* ConsequenceAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+ConsequencePtr LIBCALL
+ConsequenceAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+
+
+ AsnTypePtr atp;
+ ValNodePtr anp;
+ Boolean isError = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* Consequence_element ::= (self contained) */
+ atp = AsnReadId(aip, amp, VARIATION_REF_consequence);
+ } else {
+ atp = AsnLinkType(orig, VARIATION_REF_consequence); /* link in local tree */
+ }
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ anp =
+ AsnGenericChoiceSeqOfAsnRead(aip, amp, atp, &isError,
+ (AsnReadFunc) Consequence_elementAsnRead, (AsnOptFreeFunc) Consequence_elementFree);
+ if (isError)
+ goto erret;
+
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return anp;
+
+erret:
+ aip -> io_failure = TRUE;
+ goto ret;
+}
+
+
+/**************************************************
+*
+* VariationRefAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+VariationRefAsnWrite(VariationRefPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, VARIATION_REF); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> id != NULL) {
+ if ( ! DbtagAsnWrite(ptr -> id, aip, VARIATION_REF_id)) {
+ goto erret;
+ }
+ }
+ if (ptr -> parent_id != NULL) {
+ if ( ! DbtagAsnWrite(ptr -> parent_id, aip, VARIATION_REF_parent_id)) {
+ goto erret;
+ }
+ }
+ if (ptr -> sample_id != NULL) {
+ if ( ! ObjectIdAsnWrite(ptr -> sample_id, aip, VARIATION_REF_sample_id)) {
+ goto erret;
+ }
+ }
+ if (ptr -> other_ids != NULL) {
+ AsnGenericValNodeSetAsnWrite (ptr -> other_ids, (AsnWriteFunc) DbtagAsnWrite, aip, VARIATION_REF_other_ids, VARIATION_REF_other_ids_E);
+ /*
+ AsnGenericUserSeqOfAsnWrite(ptr -> other_ids, (AsnWriteFunc) DbtagAsnWrite, aip, VARIATION_REF_other_ids, VARIATION_REF_other_ids_E);
+ */
+ }
+ if (ptr -> name != NULL) {
+ av.ptrvalue = ptr -> name;
+ retval = AsnWrite(aip, VARIATION_REF_name, &av);
+ }
+ if (ptr -> synonyms != NULL) {
+ retval = AsnGenericBaseSeqOfAsnWrite(ptr -> synonyms ,ASNCODE_PTRVAL_SLOT, aip, VARIATION_REF_synonyms, VARIATION_REF_synonyms_E);
+ }
+ if (ptr -> description != NULL) {
+ av.ptrvalue = ptr -> description;
+ retval = AsnWrite(aip, VARIATION_REF_description, &av);
+ }
+ if (ptr -> phenotype != NULL) {
+ AsnGenericValNodeSetAsnWrite (ptr -> phenotype, (AsnWriteFunc) PhenotypeAsnWrite, aip, VARIATION_REF_phenotype, VARIATION_REF_phenotype_E);
+ /*
+ AsnGenericUserSeqOfAsnWrite(ptr -> phenotype, (AsnWriteFunc) PhenotypeAsnWrite, aip, VARIATION_REF_phenotype, VARIATION_REF_phenotype_E);
+ */
+ }
+ if (ptr -> method != NULL) {
+ retval = AsnGenericBaseSeqOfAsnWrite(ptr -> method ,ASNCODE_INTVAL_SLOT, aip, VARIATION_REF_method, VARIATION_REF_method_E);
+ }
+ if (ptr -> population_data != NULL) {
+ AsnGenericValNodeSetAsnWrite (ptr -> population_data, (AsnWriteFunc) PopulationDataAsnWrite, aip, VARIATION_REF_population_data, VARIATION_REF_population_data_E);
+ /*
+ AsnGenericUserSeqOfAsnWrite(ptr -> population_data, (AsnWriteFunc) PopulationDataAsnWrite, aip, VARIATION_REF_population_data, VARIATION_REF_population_data_E);
+ */
+ }
+ if (ptr -> variant_prop != NULL) {
+ if ( ! VariantPropertiesAsnWrite(ptr -> variant_prop, aip, VARIATION_REF_variant_prop)) {
+ goto erret;
+ }
+ }
+ if (ptr -> validated || (ptr -> OBbits__ & (1<<0) )){ av.boolvalue = ptr -> validated;
+ retval = AsnWrite(aip, VARIATION_REF_validated, &av);
+ }
+ if (ptr -> clinical_test != NULL) {
+ AsnGenericValNodeSetAsnWrite (ptr -> clinical_test, (AsnWriteFunc) DbtagAsnWrite, aip, VARIATION_REF_clinical_test, VARIATION_REF_clinical_test_E);
+ /*
+ AsnGenericUserSeqOfAsnWrite(ptr -> clinical_test, (AsnWriteFunc) DbtagAsnWrite, aip, VARIATION_REF_clinical_test, VARIATION_REF_clinical_test_E);
+ */
+ }
+ if (ptr -> allele_origin || (ptr -> OBbits__ & (1<<1) )){ av.intvalue = ptr -> allele_origin;
+ retval = AsnWrite(aip, VARIATION_REF_allele_origin, &av);
+ }
+ if (ptr -> allele_state || (ptr -> OBbits__ & (1<<2) )){ av.intvalue = ptr -> allele_state;
+ retval = AsnWrite(aip, VARIATION_REF_allele_state, &av);
+ }
+ if (ptr -> allele_frequency || (ptr -> OBbits__ & (1<<3) )){ av.realvalue = ptr -> allele_frequency;
+ retval = AsnWrite(aip, VARIATION_REF_allele_frequency, &av);
+ }
+ if (ptr -> is_ancestral_allele || (ptr -> OBbits__ & (1<<4) )){ av.boolvalue = ptr -> is_ancestral_allele;
+ retval = AsnWrite(aip, REF_is_ancestral_allele, &av);
+ }
+ if (ptr -> pub != NULL) {
+ if ( ! PubAsnWrite(ptr -> pub, aip, VARIATION_REF_pub)) {
+ goto erret;
+ }
+ }
+ if (ptr -> data != NULL) {
+ if ( ! VarRefDataAsnWrite(ptr -> data, aip, VARIATION_REF_data)) {
+ goto erret;
+ }
+ }
+ if (ptr -> consequence != NULL) {
+ retval = ConsequenceAsnWrite(ptr -> consequence, aip,VARIATION_REF_consequence);
+ }
+ if (ptr -> location != NULL) {
+ if ( ! SeqLocAsnWrite(ptr -> location, aip, VARIATION_REF_location)) {
+ goto erret;
+ }
+ }
+ if (ptr -> ext_locs != NULL) {
+ AsnGenericValNodeSetAsnWrite (ptr -> ext_locs, (AsnWriteFunc) ExtLocAsnWrite, aip, VARIATION_REF_ext_locs, VARIATION_REF_ext_locs_E);
+ /*
+ AsnGenericUserSeqOfAsnWrite(ptr -> ext_locs, (AsnWriteFunc) ExtLocAsnWrite, aip, VARIATION_REF_ext_locs, VARIATION_REF_ext_locs_E);
+ */
+ }
+ if (ptr -> ext != NULL) {
+ if ( ! UserObjectAsnWrite(ptr -> ext, aip, VARIATION_REF_ext)) {
+ goto erret;
+ }
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* ConsequenceAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+ConsequenceAsnWrite(ValNodePtr anp, AsnIoPtr aip, AsnTypePtr orig)
+
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad())
+ return FALSE;
+ }
+
+ if (aip == NULL)
+ return FALSE;
+
+ atp = AsnLinkType(orig, VARIATION_REF_consequence); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+
+ av.ptrvalue = (Pointer)anp;
+ retval = AsnGenericChoiceSeqOfAsnWrite(anp,
+ (AsnWriteFunc) Consequence_elementAsnWrite, aip, atp, VARIATION_REF_consequence_E);
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+/**************************************************
+*
+* Consequence_elementAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+Consequence_elementAsnWrite(Consequence_elementPtr anp, AsnIoPtr aip, AsnTypePtr orig)
+
+{
+ DataVal av;
+ AsnTypePtr atp, writetype = NULL;
+ Pointer pnt;
+ AsnWriteFunc func = NULL;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad())
+ return FALSE;
+ }
+
+ if (aip == NULL)
+ return FALSE;
+
+ atp = AsnLinkType(orig, VARIATION_REF_consequence_E); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+
+ av.ptrvalue = (Pointer)anp;
+ if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
+ goto erret;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ case Consequence_unknown:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, REF_consequence_E_unknown, &av);
+ break;
+ case Consequence_splicing:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, REF_consequence_E_splicing, &av);
+ break;
+ case Consequence_note:
+ av.ptrvalue = anp->data.ptrvalue;
+ retval = AsnWrite(aip, REF_consequence_E_note, &av);
+ break;
+ case Consequence_variation:
+ writetype = REF_consequence_E_variation;
+ func = (AsnWriteFunc) VariationRefAsnWrite;
+ break;
+ case Consequence_Consequence_Frameshift:
+ writetype = REF_consequence_E_frameshift;
+ func = (AsnWriteFunc) Consequence_frameshiftAsnWrite;
+ break;
+ case Consequence_Consequence_LossOfHeterozygosity:
+ writetype = E_loss_of_heterozygosity;
+ func = (AsnWriteFunc) Consequence_loss_of_heterozygosityAsnWrite;
+ break;
+ }
+ if (writetype != NULL) {
+ retval = (* func)(pnt, aip, writetype); /* write it out */
+ }
+ if (!retval) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+/**************************************************
+*
+* Consequence_loss_of_heterozygosityAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+Consequence_loss_of_heterozygosityAsnWrite(Consequence_loss_of_heterozygosityPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, E_loss_of_heterozygosity); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> reference != NULL) {
+ av.ptrvalue = ptr -> reference;
+ retval = AsnWrite(aip, of_heterozygosity_reference, &av);
+ }
+ if (ptr -> test != NULL) {
+ av.ptrvalue = ptr -> test;
+ retval = AsnWrite(aip, E_loss_of_heterozygosity_test, &av);
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* Consequence_frameshiftAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+Consequence_frameshiftAsnWrite(Consequence_frameshiftPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, REF_consequence_E_frameshift); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> phase || (ptr -> OBbits__ & (1<<0) )){ av.intvalue = ptr -> phase;
+ retval = AsnWrite(aip, consequence_E_frameshift_phase, &av);
+ }
+ if (ptr -> x_length || (ptr -> OBbits__ & (1<<1) )){ av.intvalue = ptr -> x_length;
+ retval = AsnWrite(aip, E_frameshift_x_length, &av);
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* Data_setAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+VarRefDataSetAsnWrite(VarRefDataSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, VARIATION_REF_data_set); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ av.intvalue = ptr -> type;
+ retval = AsnWrite(aip, VARIATION_REF_data_set_type, &av);
+ AsnGenericValNodeSetAsnWrite(ptr -> variations, (AsnWriteFunc) VariationRefAsnWrite, aip, REF_data_set_variations, REF_data_set_variations_E);
+ /*
+ AsnGenericUserSeqOfAsnWrite(ptr -> variations, (AsnWriteFunc) VariationRefAsnWrite, aip, REF_data_set_variations, REF_data_set_variations_E);
+ */
+ if (ptr -> name != NULL) {
+ av.ptrvalue = ptr -> name;
+ retval = AsnWrite(aip, VARIATION_REF_data_set_name, &av);
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+/**************************************************
+*
+* VarRefDataAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+VarRefDataAsnWrite( VarRefDataPtr anp, AsnIoPtr aip, AsnTypePtr orig)
+
+{
+ DataVal av;
+ AsnTypePtr atp, writetype = NULL;
+ Pointer pnt;
+ AsnWriteFunc func = NULL;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad())
+ return FALSE;
+ }
+
+ if (aip == NULL)
+ return FALSE;
+
+ atp = AsnLinkType(orig, VARIATION_REF_data); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+
+ av.ptrvalue = (Pointer)anp;
+ if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
+ goto erret;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ case VarRefData_unknown:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, VARIATION_REF_data_unknown, &av);
+ break;
+ case VarRefData_note:
+ av.ptrvalue = anp->data.ptrvalue;
+ retval = AsnWrite(aip, VARIATION_REF_data_note, &av);
+ break;
+ case VarRefData_uniparental_disomy:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, REF_data_uniparental_disomy, &av);
+ break;
+ case VarRefData_instance:
+ writetype = VARIATION_REF_data_instance;
+ func = (AsnWriteFunc) VariationInstAsnWrite;
+ break;
+ case VarRefData_set:
+ writetype = VARIATION_REF_data_set;
+ func = (AsnWriteFunc) VarRefDataSetAsnWrite;
+ break;
+ }
+ if (writetype != NULL) {
+ retval = (* func)(pnt, aip, writetype); /* write it out */
+ }
+ if (!retval) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* Consequence_elementAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+Consequence_elementPtr LIBCALL
+Consequence_elementAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ ValNodePtr anp;
+ Uint1 choice;
+ Boolean nullIsError = FALSE;
+ AsnReadFunc func;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* Consequence_element ::= (self contained) */
+ atp = AsnReadId(aip, amp, VARIATION_REF_consequence_E);
+ } else {
+ atp = AsnLinkType(orig, VARIATION_REF_consequence_E); /* link in local tree */
+ }
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ anp = ValNodeNew(NULL);
+ if (anp == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
+ goto erret;
+ }
+
+ func = NULL;
+
+ atp = AsnReadId(aip, amp, atp); /* find the choice */
+ if (atp == NULL) {
+ goto erret;
+ }
+ if (atp == REF_consequence_E_unknown) {
+ choice = Consequence_unknown;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == REF_consequence_E_splicing) {
+ choice = Consequence_splicing;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == REF_consequence_E_note) {
+ choice = Consequence_note;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.ptrvalue = av.ptrvalue;
+ }
+ else if (atp == REF_consequence_E_variation) {
+ choice = Consequence_variation;
+ func = (AsnReadFunc) VariationRefAsnRead;
+ }
+ else if (atp == REF_consequence_E_frameshift) {
+ choice = Consequence_Consequence_Frameshift;
+ func = (AsnReadFunc) Consequence_frameshiftAsnRead;
+ }
+ else if (atp == E_loss_of_heterozygosity) {
+ choice = Consequence_Consequence_LossOfHeterozygosity;
+ func = (AsnReadFunc) Consequence_loss_of_heterozygosityAsnRead;
+ }
+ anp->choice = choice;
+ if (func != NULL)
+ {
+ anp->data.ptrvalue = (* func)(aip, atp);
+ if (aip -> io_failure) goto erret;
+
+ if (nullIsError && anp->data.ptrvalue == NULL) {
+ goto erret;
+ }
+ }
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return anp;
+
+erret:
+ anp = MemFree(anp);
+ aip -> io_failure = TRUE;
+ goto ret;
+}
+
+
+/**************************************************
+*
+* Consequence_loss_of_heterozygosityAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+Consequence_loss_of_heterozygosityPtr LIBCALL
+Consequence_loss_of_heterozygosityAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ AsnReadFunc func;
+ Consequence_loss_of_heterozygosityPtr ptr;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* Consequence_loss_of_heterozygosity ::= (self contained) */
+ atp = AsnReadId(aip, amp, E_loss_of_heterozygosity);
+ } else {
+ atp = AsnLinkType(orig, E_loss_of_heterozygosity);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = Consequence_loss_of_heterozygosityNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == of_heterozygosity_reference) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> reference = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == E_loss_of_heterozygosity_test) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> test = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = Consequence_loss_of_heterozygosityFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* Consequence_frameshiftAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+Consequence_frameshiftPtr LIBCALL
+Consequence_frameshiftAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ AsnReadFunc func;
+ Consequence_frameshiftPtr ptr;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* Consequence_frameshift ::= (self contained) */
+ atp = AsnReadId(aip, amp, REF_consequence_E_frameshift);
+ } else {
+ atp = AsnLinkType(orig, REF_consequence_E_frameshift);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = Consequence_frameshiftNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == consequence_E_frameshift_phase) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> phase = av.intvalue;
+ ptr -> OBbits__ |= 1<<0;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == E_frameshift_x_length) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> x_length = av.intvalue;
+ ptr -> OBbits__ |= 1<<1;
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = Consequence_frameshiftFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* Data_setFree()
+*
+**************************************************/
+NLM_EXTERN
+VarRefDataSetPtr LIBCALL
+VarRefDataSetFree(VarRefDataSetPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ AsnGenericValNodeSetFree (ptr -> variations, (AsnOptFreeFunc) VariationRefFree);
+ /*
+ AsnGenericUserSeqOfFree(ptr -> variations, (AsnOptFreeFunc) VariationRefFree);
+ */
+ MemFree(ptr -> name);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* VarRefDataFree()
+*
+**************************************************/
+NLM_EXTERN
+VarRefDataPtr LIBCALL
+VarRefDataFree(ValNodePtr anp)
+{
+ Pointer pnt;
+
+ if (anp == NULL) {
+ return NULL;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ default:
+ break;
+ case VarRefData_note:
+ MemFree(anp -> data.ptrvalue);
+ break;
+ case VarRefData_instance:
+ VariationInstFree(anp -> data.ptrvalue);
+ break;
+ case VarRefData_set:
+ VarRefDataSetFree(anp -> data.ptrvalue);
+ break;
+ }
+ return MemFree(anp);
+}
+
+
+/**************************************************
+*
+* Data_setNew()
+*
+**************************************************/
+NLM_EXTERN
+VarRefDataSetPtr LIBCALL
+VarRefDataSetNew(void)
+{
+ VarRefDataSetPtr ptr = MemNew((size_t) sizeof(VarRefData));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* Data_setAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+VarRefDataSetPtr LIBCALL
+VarRefDataSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean isError = FALSE;
+ AsnReadFunc func;
+ VarRefDataSetPtr ptr;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* Data_set ::= (self contained) */
+ atp = AsnReadId(aip, amp, VARIATION_REF_data_set);
+ } else {
+ atp = AsnLinkType(orig, VARIATION_REF_data_set);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = VarRefDataSetNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == VARIATION_REF_data_set_type) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> type = av.intvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == REF_data_set_variations) {
+ ptr -> variations = AsnGenericValNodeSetAsnRead (aip, amp, atp, &isError, (AsnReadFunc) VariationRefAsnRead, (AsnOptFreeFunc) VariationRefFree);
+ /*
+ ptr -> variations = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) VariationRefAsnRead, (AsnOptFreeFunc) VariationRefFree);
+ */
+ if (isError && ptr -> variations == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_REF_data_set_name) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> name = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = VarRefDataSetFree(ptr);
+ goto ret;
+}
+
+
+/**************************************************
+*
+* VarRefDataAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+VarRefDataPtr LIBCALL
+VarRefDataAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ ValNodePtr anp;
+ Uint1 choice;
+ Boolean nullIsError = FALSE;
+ AsnReadFunc func;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* data ::= (self contained) */
+ atp = AsnReadId(aip, amp, VARIATION_REF_data);
+ } else {
+ atp = AsnLinkType(orig, VARIATION_REF_data); /* link in local tree */
+ }
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ anp = ValNodeNew(NULL);
+ if (anp == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
+ goto erret;
+ }
+
+ func = NULL;
+
+ atp = AsnReadId(aip, amp, atp); /* find the choice */
+ if (atp == NULL) {
+ goto erret;
+ }
+ if (atp == VARIATION_REF_data_unknown) {
+ choice = VarRefData_unknown;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == VARIATION_REF_data_note) {
+ choice = VarRefData_note;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.ptrvalue = av.ptrvalue;
+ }
+ else if (atp == REF_data_uniparental_disomy) {
+ choice = VarRefData_uniparental_disomy;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == VARIATION_REF_data_instance) {
+ choice = VarRefData_instance;
+ func = (AsnReadFunc) VariationInstAsnRead;
+ }
+ else if (atp == VARIATION_REF_data_set) {
+ choice = VarRefData_set;
+ func = (AsnReadFunc) VarRefDataSetAsnRead;
+ }
+ anp->choice = choice;
+ if (func != NULL)
+ {
+ anp->data.ptrvalue = (* func)(aip, atp);
+ if (aip -> io_failure) goto erret;
+
+ if (nullIsError && anp->data.ptrvalue == NULL) {
+ goto erret;
+ }
+ }
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return anp;
+
+erret:
+ anp = MemFree(anp);
+ aip -> io_failure = TRUE;
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* Consequence_elementFree()
+*
+**************************************************/
+NLM_EXTERN
+Consequence_elementPtr LIBCALL
+Consequence_elementFree(ValNodePtr anp)
+{
+ Pointer pnt;
+
+ if (anp == NULL) {
+ return NULL;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ default:
+ break;
+ case Consequence_note:
+ MemFree(anp -> data.ptrvalue);
+ break;
+ case Consequence_variation:
+ VariationRefFree(anp -> data.ptrvalue);
+ break;
+ case Consequence_Consequence_Frameshift:
+ Consequence_frameshiftFree(anp -> data.ptrvalue);
+ break;
+ case Consequence_Consequence_LossOfHeterozygosity:
+ Consequence_loss_of_heterozygosityFree(anp -> data.ptrvalue);
+ break;
+ }
+ return MemFree(anp);
+}
+
+
+/**************************************************
+*
+* Consequence_loss_of_heterozygosityFree()
+*
+**************************************************/
+NLM_EXTERN
+Consequence_loss_of_heterozygosityPtr LIBCALL
+Consequence_loss_of_heterozygosityFree(Consequence_loss_of_heterozygosityPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ MemFree(ptr -> reference);
+ MemFree(ptr -> test);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* Consequence_frameshiftFree()
+*
+**************************************************/
+NLM_EXTERN
+Consequence_frameshiftPtr LIBCALL
+Consequence_frameshiftFree(Consequence_frameshiftPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* Consequence_frameshiftNew()
+*
+**************************************************/
+NLM_EXTERN
+Consequence_frameshiftPtr LIBCALL
+Consequence_frameshiftNew(void)
+{
+ Consequence_frameshiftPtr ptr = MemNew((size_t) sizeof(Consequence_frameshift));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* VariationInstNew()
+*
+**************************************************/
+NLM_EXTERN
+VariationInstPtr LIBCALL
+VariationInstNew(void)
+{
+ VariationInstPtr ptr = MemNew((size_t) sizeof(VariationInst));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* VariationInstFree()
+*
+**************************************************/
+NLM_EXTERN
+VariationInstPtr LIBCALL
+VariationInstFree(VariationInstPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ AsnGenericValNodeSetFree (ptr -> delta, (AsnOptFreeFunc) DeltaItemFree);
+ /*
+ AsnGenericUserSeqOfFree(ptr -> delta, (AsnOptFreeFunc) DeltaItemFree);
+ */
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* VariationInstAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+VariationInstPtr LIBCALL
+VariationInstAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean isError = FALSE;
+ AsnReadFunc func;
+ VariationInstPtr ptr;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* VariationInst ::= (self contained) */
+ atp = AsnReadId(aip, amp, VARIATION_INST);
+ } else {
+ atp = AsnLinkType(orig, VARIATION_INST);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = VariationInstNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == VARIATION_INST_type) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> type = av.intvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIATION_INST_delta) {
+ ptr -> delta = AsnGenericValNodeSetAsnRead (aip, amp, atp, &isError, (AsnReadFunc) DeltaItemAsnRead, (AsnOptFreeFunc) DeltaItemFree);
+ /*
+ ptr -> delta = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) DeltaItemAsnRead, (AsnOptFreeFunc) DeltaItemFree);
+ */
+ if (isError && ptr -> delta == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = VariationInstFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* VariationInstAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+VariationInstAsnWrite(VariationInstPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, VARIATION_INST); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ av.intvalue = ptr -> type;
+ retval = AsnWrite(aip, VARIATION_INST_type, &av);
+ AsnGenericValNodeSetAsnWrite (ptr -> delta, (AsnWriteFunc) DeltaItemAsnWrite, aip, VARIATION_INST_delta, VARIATION_INST_delta_E);
+ /*
+ AsnGenericUserSeqOfAsnWrite(ptr -> delta, (AsnWriteFunc) DeltaItemAsnWrite, aip, VARIATION_INST_delta, VARIATION_INST_delta_E);
+ */
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* ProjectDataNew()
+*
+**************************************************/
+NLM_EXTERN
+ProjectDataPtr LIBCALL
+ProjectDataNew(void)
+{
+ ProjectDataPtr ptr = MemNew((size_t) sizeof(ProjectData));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* VariantPropertiesNew()
+*
+**************************************************/
+NLM_EXTERN
+VariantPropertiesPtr LIBCALL
+VariantPropertiesNew(void)
+{
+ VariantPropertiesPtr ptr = MemNew((size_t) sizeof(VariantProperties));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* ProjectDataFree()
+*
+**************************************************/
+NLM_EXTERN
+ProjectDataPtr LIBCALL
+ProjectDataFree(ProjectDataPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ AsnGenericBaseSeqOfFree(ptr -> project_ids ,ASNCODE_INTVAL_SLOT);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+/**************************************************
+*
+* VariantPropertiesFree()
+*
+**************************************************/
+NLM_EXTERN
+VariantPropertiesPtr LIBCALL
+VariantPropertiesFree(VariantPropertiesPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ ProjectDataFree(ptr -> project_data);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* ProjectDataAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+ProjectDataPtr LIBCALL
+ProjectDataAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean isError = FALSE;
+ AsnReadFunc func;
+ ProjectDataPtr ptr;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* ProjectData ::= (self contained) */
+ atp = AsnReadId(aip, amp, VARIANTPROPERTIES_project_data);
+ } else {
+ atp = AsnLinkType(orig, VARIANTPROPERTIES_project_data);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = ProjectDataNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == project_data_E_project_ids) {
+ ptr -> project_ids = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_INTVAL_SLOT, &isError);
+ if (isError && ptr -> project_ids == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = ProjectDataFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* VariantPropertiesAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+VariantPropertiesPtr LIBCALL
+VariantPropertiesAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ AsnReadFunc func;
+ VariantPropertiesPtr ptr;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* VariantProperties ::= (self contained) */
+ atp = AsnReadId(aip, amp, VARIANTPROPERTIES);
+ } else {
+ atp = AsnLinkType(orig, VARIANTPROPERTIES);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = VariantPropertiesNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == VARIANTPROPERTIES_version) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> version = av.intvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIANTPROPERTIES_resource_link) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> resource_link = av.intvalue;
+ ptr -> OBbits__ |= 1<<0;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIANTPROPERTIES_gene_location) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> gene_location = av.intvalue;
+ ptr -> OBbits__ |= 1<<1;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIANTPROPERTIES_effect) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> effect = av.intvalue;
+ ptr -> OBbits__ |= 1<<2;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIANTPROPERTIES_mapping) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> mapping = av.intvalue;
+ ptr -> OBbits__ |= 1<<3;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIANTPROPERTIES_map_weight) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> map_weight = av.intvalue;
+ ptr -> OBbits__ |= 1<<4;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == frequency_based_validation) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> freq_based_validation = av.intvalue;
+ ptr -> OBbits__ |= 1<<5;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIANTPROPERTIES_genotype) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> genotype = av.intvalue;
+ ptr -> OBbits__ |= 1<<6;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIANTPROPERTIES_project_data) {
+ ptr -> project_data = ProjectDataAsnRead(aip, atp);
+ if (ptr -> project_data == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIANTPROPERTIES_quality_check) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> quality_check = av.intvalue;
+ ptr -> OBbits__ |= 1<<7;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == VARIANTPROPERTIES_confidence) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> confidence = av.intvalue;
+ ptr -> OBbits__ |= 1<<8;
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = VariantPropertiesFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* ProjectDataAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+ProjectDataAsnWrite(ProjectDataPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, VARIANTPROPERTIES_project_data); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ retval = AsnGenericBaseSeqOfAsnWrite(ptr -> project_ids ,ASNCODE_INTVAL_SLOT, aip, project_data_E_project_ids, project_data_E_project_ids_E);
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* VariantPropertiesAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+VariantPropertiesAsnWrite(VariantPropertiesPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, VARIANTPROPERTIES); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ av.intvalue = ptr -> version;
+ retval = AsnWrite(aip, VARIANTPROPERTIES_version, &av);
+ if (ptr -> resource_link || (ptr -> OBbits__ & (1<<0) )){ av.intvalue = ptr -> resource_link;
+ retval = AsnWrite(aip, VARIANTPROPERTIES_resource_link, &av);
+ }
+ if (ptr -> gene_location || (ptr -> OBbits__ & (1<<1) )){ av.intvalue = ptr -> gene_location;
+ retval = AsnWrite(aip, VARIANTPROPERTIES_gene_location, &av);
+ }
+ if (ptr -> effect || (ptr -> OBbits__ & (1<<2) )){ av.intvalue = ptr -> effect;
+ retval = AsnWrite(aip, VARIANTPROPERTIES_effect, &av);
+ }
+ if (ptr -> mapping || (ptr -> OBbits__ & (1<<3) )){ av.intvalue = ptr -> mapping;
+ retval = AsnWrite(aip, VARIANTPROPERTIES_mapping, &av);
+ }
+ if (ptr -> map_weight || (ptr -> OBbits__ & (1<<4) )){ av.intvalue = ptr -> map_weight;
+ retval = AsnWrite(aip, VARIANTPROPERTIES_map_weight, &av);
+ }
+ if (ptr -> freq_based_validation || (ptr -> OBbits__ & (1<<5) )){ av.intvalue = ptr -> freq_based_validation;
+ retval = AsnWrite(aip, frequency_based_validation, &av);
+ }
+ if (ptr -> genotype || (ptr -> OBbits__ & (1<<6) )){ av.intvalue = ptr -> genotype;
+ retval = AsnWrite(aip, VARIANTPROPERTIES_genotype, &av);
+ }
+ retval = ProjectDataAsnWrite(ptr -> project_data, aip,VARIANTPROPERTIES_project_data);
+ if (ptr -> quality_check || (ptr -> OBbits__ & (1<<7) )){ av.intvalue = ptr -> quality_check;
+ retval = AsnWrite(aip, VARIANTPROPERTIES_quality_check, &av);
+ }
+ if (ptr -> confidence || (ptr -> OBbits__ & (1<<8) )){ av.intvalue = ptr -> confidence;
+ retval = AsnWrite(aip, VARIANTPROPERTIES_confidence, &av);
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* PhenotypeNew()
+*
+**************************************************/
+NLM_EXTERN
+PhenotypePtr LIBCALL
+PhenotypeNew(void)
+{
+ PhenotypePtr ptr = MemNew((size_t) sizeof(Phenotype));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* PhenotypeFree()
+*
+**************************************************/
+NLM_EXTERN
+PhenotypePtr LIBCALL
+PhenotypeFree(PhenotypePtr ptr)
+{
+ if(ptr == NULL) {
+ return NULL;
+ }
+ MemFree(ptr -> source);
+ MemFree(ptr -> term);
+ /*
+ AsnGenericUserSeqOfFree(ptr -> xref, (AsnOptFreeFunc) DbtagFree);
+ */
+ AsnGenericValNodeSetFree (ptr->xref, (AsnOptFreeFunc) DbtagFree);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* PhenotypeAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+PhenotypePtr LIBCALL
+PhenotypeAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ AsnReadFunc func;
+ PhenotypePtr ptr;
+ Boolean isError = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* Phenotype ::= (self contained) */
+ atp = AsnReadId(aip, amp, PHENOTYPE);
+ } else {
+ atp = AsnLinkType(orig, PHENOTYPE);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = PhenotypeNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == PHENOTYPE_source) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> source = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == PHENOTYPE_term) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> term = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == PHENOTYPE_xref) {
+ ptr->xref = AsnGenericValNodeSetAsnRead (aip, amp, atp, &isError, (AsnReadFunc) DbtagAsnRead, (AsnOptFreeFunc) DbtagFree);
+ /*
+ ptr -> xref = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) DbtagAsnRead, (AsnOptFreeFunc) DbtagFree);
+ */
+ if (isError && ptr -> xref == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == PHENOTYPE_clinical_significance) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> clinical_significance = av.intvalue;
+ ptr -> OBbits__ |= 1<<0;
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = PhenotypeFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* PhenotypeAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+PhenotypeAsnWrite(PhenotypePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, PHENOTYPE); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> source != NULL) {
+ av.ptrvalue = ptr -> source;
+ retval = AsnWrite(aip, PHENOTYPE_source, &av);
+ }
+ if (ptr -> term != NULL) {
+ av.ptrvalue = ptr -> term;
+ retval = AsnWrite(aip, PHENOTYPE_term, &av);
+ }
+ AsnGenericValNodeSetAsnWrite (ptr->xref, (AsnWriteFunc) DbtagAsnWrite, aip, PHENOTYPE_xref, PHENOTYPE_xref_E);
+ /*
+ AsnGenericUserSeqOfAsnWrite(ptr -> xref, (AsnWriteFunc) DbtagAsnWrite, aip, PHENOTYPE_xref, PHENOTYPE_xref_E);
+ */
+ if (ptr -> clinical_significance || (ptr -> OBbits__ & (1<<0) )){ av.intvalue = ptr -> clinical_significance;
+ retval = AsnWrite(aip, PHENOTYPE_clinical_significance, &av);
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* PopulationDataNew()
+*
+**************************************************/
+NLM_EXTERN
+PopulationDataPtr LIBCALL
+PopulationDataNew(void)
+{
+ PopulationDataPtr ptr = MemNew((size_t) sizeof(PopulationData));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* PopulationDataFree()
+*
+**************************************************/
+NLM_EXTERN
+PopulationDataPtr LIBCALL
+PopulationDataFree(PopulationDataPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ MemFree(ptr -> population);
+ AsnGenericValNodeSetFree (ptr -> sample_ids, (AsnOptFreeFunc) ObjectIdFree);
+ /*
+ AsnGenericChoiceSeqOfFree(ptr -> sample_ids, (AsnOptFreeFunc) ObjectIdFree);
+ */
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* PopulationDataAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+PopulationDataPtr LIBCALL
+PopulationDataAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean isError = FALSE;
+ AsnReadFunc func;
+ PopulationDataPtr ptr;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* PopulationData ::= (self contained) */
+ atp = AsnReadId(aip, amp, POPULATION_DATA);
+ } else {
+ atp = AsnLinkType(orig, POPULATION_DATA);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = PopulationDataNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == POPULATION_DATA_population) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> population = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == DATA_genotype_frequency) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> genotype_frequency = av.realvalue;
+ ptr -> OBbits__ |= 1<<0;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == DATA_chromosomes_tested) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> chromosomes_tested = av.intvalue;
+ ptr -> OBbits__ |= 1<<1;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == POPULATION_DATA_sample_ids) {
+ ptr -> sample_ids = AsnGenericValNodeSetAsnRead(aip, amp, atp, &isError, (AsnReadFunc) ObjectIdAsnRead, (AsnOptFreeFunc) ObjectIdFree);
+ /*
+ ptr -> sample_ids = AsnGenericChoiceSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) ObjectIdAsnRead, (AsnOptFreeFunc) ObjectIdFree);
+ */
+ if (isError && ptr -> sample_ids == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = PopulationDataFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* PopulationDataAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+PopulationDataAsnWrite(PopulationDataPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, POPULATION_DATA); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> population != NULL) {
+ av.ptrvalue = ptr -> population;
+ retval = AsnWrite(aip, POPULATION_DATA_population, &av);
+ }
+ if (ptr -> genotype_frequency || (ptr -> OBbits__ & (1<<0) )){ av.realvalue = ptr -> genotype_frequency;
+ retval = AsnWrite(aip, DATA_genotype_frequency, &av);
+ }
+ if (ptr -> chromosomes_tested || (ptr -> OBbits__ & (1<<1) )){ av.intvalue = ptr -> chromosomes_tested;
+ retval = AsnWrite(aip, DATA_chromosomes_tested, &av);
+ }
+ AsnGenericValNodeSetAsnWrite(ptr -> sample_ids, (AsnWriteFunc) ObjectIdAsnWrite, aip, POPULATION_DATA_sample_ids, POPULATION_DATA_sample_ids_E);
+ /*
+ AsnGenericChoiceSeqOfAsnWrite(ptr -> sample_ids, (AsnWriteFunc) ObjectIdAsnWrite, aip, POPULATION_DATA_sample_ids, POPULATION_DATA_sample_ids_E);
+ */
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* ExtLocNew()
+*
+**************************************************/
+NLM_EXTERN
+ExtLocPtr LIBCALL
+ExtLocNew(void)
+{
+ ExtLocPtr ptr = MemNew((size_t) sizeof(ExtLoc));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* ExtLocFree()
+*
+**************************************************/
+NLM_EXTERN
+ExtLocPtr LIBCALL
+ExtLocFree(ExtLocPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ ObjectIdFree(ptr -> id);
+ SeqLocFree(ptr -> location);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* ExtLocAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+ExtLocPtr LIBCALL
+ExtLocAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ AsnReadFunc func;
+ ExtLocPtr ptr;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* ExtLoc ::= (self contained) */
+ atp = AsnReadId(aip, amp, EXT_LOC);
+ } else {
+ atp = AsnLinkType(orig, EXT_LOC);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = ExtLocNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == EXT_LOC_id) {
+ ptr -> id = ObjectIdAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == EXT_LOC_location) {
+ ptr -> location = SeqLocAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = ExtLocFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* ExtLocAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+ExtLocAsnWrite(ExtLocPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, EXT_LOC); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> id != NULL) {
+ if ( ! ObjectIdAsnWrite(ptr -> id, aip, EXT_LOC_id)) {
+ goto erret;
+ }
+ }
+ if (ptr -> location != NULL) {
+ if ( ! SeqLocAsnWrite(ptr -> location, aip, EXT_LOC_location)) {
+ goto erret;
+ }
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* DeltaItemNew()
+*
+**************************************************/
+NLM_EXTERN
+DeltaItemPtr LIBCALL
+DeltaItemNew(void)
+{
+ DeltaItemPtr ptr = MemNew((size_t) sizeof(DeltaItem));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* DeltaItemFree()
+*
+**************************************************/
+NLM_EXTERN
+DeltaItemPtr LIBCALL
+DeltaItemFree(DeltaItemPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ Seq_seqFree(ptr -> Seq_seq);
+ IntFuzzFree(ptr -> multiplier_fuzz);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* Seq_seqFree()
+*
+**************************************************/
+NLM_EXTERN
+Seq_seqPtr LIBCALL
+Seq_seqFree(ValNodePtr anp)
+{
+ Pointer pnt;
+
+ if (anp == NULL) {
+ return NULL;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ default:
+ break;
+ case Seq_seq_literal:
+ SeqLitFree(anp -> data.ptrvalue);
+ break;
+ case Seq_seq_loc:
+ SeqLocFree(anp -> data.ptrvalue);
+ break;
+ }
+ return MemFree(anp);
+}
+
+
+/**************************************************
+*
+* DeltaItemAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+DeltaItemPtr LIBCALL
+DeltaItemAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ AsnReadFunc func;
+ DeltaItemPtr ptr;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* DeltaItem ::= (self contained) */
+ atp = AsnReadId(aip, amp, DELTA_ITEM);
+ } else {
+ atp = AsnLinkType(orig, DELTA_ITEM);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = DeltaItemNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == DELTA_ITEM_seq) {
+ ptr -> Seq_seq = Seq_seqAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == DELTA_ITEM_multiplier) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> multiplier = av.intvalue;
+ ptr -> OBbits__ |= 1<<0;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == DELTA_ITEM_multiplier_fuzz) {
+ ptr -> multiplier_fuzz = IntFuzzAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == DELTA_ITEM_action) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> action = av.intvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = DeltaItemFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* Seq_seqAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+Seq_seqPtr LIBCALL
+Seq_seqAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ ValNodePtr anp;
+ Uint1 choice;
+ Boolean nullIsError = FALSE;
+ AsnReadFunc func;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* Seq_seq ::= (self contained) */
+ atp = AsnReadId(aip, amp, DELTA_ITEM_seq);
+ } else {
+ atp = AsnLinkType(orig, DELTA_ITEM_seq); /* link in local tree */
+ }
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ anp = ValNodeNew(NULL);
+ if (anp == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
+ goto erret;
+ }
+
+ func = NULL;
+
+ atp = AsnReadId(aip, amp, atp); /* find the choice */
+ if (atp == NULL) {
+ goto erret;
+ }
+ if (atp == DELTA_ITEM_seq_literal) {
+ choice = Seq_seq_literal;
+ func = (AsnReadFunc) SeqLitAsnRead;
+ }
+ else if (atp == DELTA_ITEM_seq_loc) {
+ choice = Seq_seq_loc;
+ func = (AsnReadFunc) SeqLocAsnRead;
+ }
+ else if (atp == DELTA_ITEM_seq_this) {
+ choice = Seq_seq_this__;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ anp->choice = choice;
+ if (func != NULL)
+ {
+ anp->data.ptrvalue = (* func)(aip, atp);
+ if (aip -> io_failure) goto erret;
+
+ if (nullIsError && anp->data.ptrvalue == NULL) {
+ goto erret;
+ }
+ }
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return anp;
+
+erret:
+ anp = MemFree(anp);
+ aip -> io_failure = TRUE;
+ goto ret;
+}
+
+
+/**************************************************
+*
+* DeltaItemAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+DeltaItemAsnWrite(DeltaItemPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, DELTA_ITEM); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> Seq_seq != NULL) {
+ if ( ! Seq_seqAsnWrite(ptr -> Seq_seq, aip, DELTA_ITEM_seq)) {
+ goto erret;
+ }
+ }
+ if (ptr -> multiplier || (ptr -> OBbits__ & (1<<0) )){ av.intvalue = ptr -> multiplier;
+ retval = AsnWrite(aip, DELTA_ITEM_multiplier, &av);
+ }
+ if (ptr -> multiplier_fuzz != NULL) {
+ if ( ! IntFuzzAsnWrite(ptr -> multiplier_fuzz, aip, DELTA_ITEM_multiplier_fuzz)) {
+ goto erret;
+ }
+ }
+ av.intvalue = ptr -> action;
+ retval = AsnWrite(aip, DELTA_ITEM_action, &av);
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* Seq_seqAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+Seq_seqAsnWrite(Seq_seqPtr anp, AsnIoPtr aip, AsnTypePtr orig)
+
+{
+ DataVal av;
+ AsnTypePtr atp, writetype = NULL;
+ Pointer pnt;
+ AsnWriteFunc func = NULL;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! SeqFeatAsnLoad())
+ return FALSE;
+ }
+
+ if (aip == NULL)
+ return FALSE;
+
+ atp = AsnLinkType(orig, DELTA_ITEM_seq); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+
+ av.ptrvalue = (Pointer)anp;
+ if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
+ goto erret;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ case Seq_seq_literal:
+ writetype = DELTA_ITEM_seq_literal;
+ func = (AsnWriteFunc) SeqLitAsnWrite;
+ break;
+ case Seq_seq_loc:
+ writetype = DELTA_ITEM_seq_loc;
+ func = (AsnWriteFunc) SeqLocAsnWrite;
+ break;
+ case Seq_seq_this__:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, DELTA_ITEM_seq_this, &av);
+ break;
+ }
+ if (writetype != NULL) {
+ retval = (* func)(pnt, aip, writetype); /* write it out */
+ }
+ if (!retval) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
diff --git a/object/objfeat.h b/object/objfeat.h
index 8f954bfd..b0826848 100644
--- a/object/objfeat.h
+++ b/object/objfeat.h
@@ -29,7 +29,7 @@
*
* Version Creation Date: 4/1/91
*
-* $Revision: 6.20 $
+* $Revision: 6.29 $
*
* File Description: Object manager interface for module NCBI-SeqFeat
*
@@ -157,6 +157,7 @@ NLM_EXTERN SeqFeatXrefPtr LIBCALL SeqFeatXrefFree PROTO((SeqFeatXrefPtr sfxp));
19 = het data.value.ptrvalue=CharPtr Heterogen -- cofactor, prosthetic grp, etc, bound to seq
20 = biosrc, data.value.ptrvalue = BioSource
21 = cloneref, data.value.ptrvalue = CloneRef
+ 22 = variation, data.value.ptrvalue = VariationRef
*
*
*****************************************************************************/
@@ -221,8 +222,9 @@ NLM_EXTERN SeqFeatXrefPtr LIBCALL SeqFeatToXref PROTO((SeqFeatPtr sfp));
#define SEQFEAT_HET 19
#define SEQFEAT_BIOSRC 20
#define SEQFEAT_CLONEREF 21
+#define SEQFEAT_VARIATIONREF 22
-#define SEQFEAT_MAX 22 /* size of array needed for seqfeat filter parameters */
+#define SEQFEAT_MAX 23 /* size of array needed for seqfeat filter parameters */
/*****************************************************************************
*
@@ -545,7 +547,8 @@ typedef struct orgname {
OrgModPtr mod; /* OrgMods */
CharPtr lineage; /* lineage to this org */
Uint1 gcode, /* genetic code using GenBank keys */
- mgcode; /* mitochondrial genetic code using GenBank keys..0=none */
+ mgcode, /* mitochondrial genetic code using GenBank keys..0=none */
+ pgcode; /* plastid genetic code using GenBank keys..0=none */
CharPtr div; /* GenBank division code */
struct orgname PNTR next; /* for MultiOrgName */
} OrgName, PNTR OrgNamePtr;
@@ -809,7 +812,335 @@ NLM_EXTERN CloneRefPtr LIBCALL CloneRefAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
NLM_EXTERN Boolean LIBCALL CloneRefAsnWrite PROTO (( CloneRefPtr , AsnIoPtr, AsnTypePtr));
+/**************************************************
+*
+* Phenotype
+*
+**************************************************/
+typedef struct phenotype {
+ struct phenotype PNTR next;
+ Uint4 OBbits__;
+ CharPtr source;
+ CharPtr term;
+ ValNodePtr xref;
+#define OB__Phenotype_clinical_significance 0
+
+ Int4 clinical_significance;
+} Phenotype, PNTR PhenotypePtr;
+
+
+NLM_EXTERN PhenotypePtr LIBCALL PhenotypeFree PROTO ((PhenotypePtr ));
+NLM_EXTERN PhenotypePtr LIBCALL PhenotypeNew PROTO (( void ));
+NLM_EXTERN PhenotypePtr LIBCALL PhenotypeAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL PhenotypeAsnWrite PROTO (( PhenotypePtr , AsnIoPtr, AsnTypePtr));
+
+
+
+/**************************************************
+*
+* PopulationData
+*
+**************************************************/
+typedef struct population_data {
+ struct population_data PNTR next;
+ Uint4 OBbits__;
+ CharPtr population;
+#define OB__Population_data_genotype_frequency 0
+
+ FloatHi genotype_frequency;
+#define OB__Population_data_chromosomes_tested 1
+
+ Int4 chromosomes_tested;
+ ValNodePtr sample_ids;
+} PopulationData, PNTR PopulationDataPtr;
+
+
+NLM_EXTERN PopulationDataPtr LIBCALL PopulationDataFree PROTO ((PopulationDataPtr ));
+NLM_EXTERN PopulationDataPtr LIBCALL PopulationDataNew PROTO (( void ));
+NLM_EXTERN PopulationDataPtr LIBCALL PopulationDataAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL PopulationDataAsnWrite PROTO (( PopulationDataPtr , AsnIoPtr, AsnTypePtr));
+
+
+
+/**************************************************
+*
+* ProjectData
+*
+**************************************************/
+
+typedef struct struct_ProjectData {
+ Uint4 OBbits__;
+ ValNodePtr project_ids;
+} ProjectData, PNTR ProjectDataPtr;
+
+
+NLM_EXTERN ProjectDataPtr LIBCALL ProjectDataFree PROTO ((ProjectDataPtr ));
+NLM_EXTERN ProjectDataPtr LIBCALL ProjectDataNew PROTO (( void ));
+NLM_EXTERN ProjectDataPtr LIBCALL ProjectDataAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL ProjectDataAsnWrite PROTO (( ProjectDataPtr , AsnIoPtr, AsnTypePtr));
+
+
+
+/**************************************************
+*
+* VariantProperties
+*
+**************************************************/
+typedef struct struct_VariantProperties {
+ Uint4 OBbits__;
+ Int4 version;
+#define OB__VariantProperties_resource_link 0
+
+ Int4 resource_link;
+#define OB__VariantProperties_gene_location 1
+
+ Int4 gene_location;
+#define OB__VariantProperties_effect 2
+
+ Int4 effect;
+#define OB__VariantProperties_mapping 3
+
+ Int4 mapping;
+#define OB__VariantProperties_map_weight 4
+
+ Int4 map_weight;
+#define OB__frequency_based_validation 5
+
+ Int4 freq_based_validation;
+#define OB__VariantProperties_genotype 6
+
+ Int4 genotype;
+ ProjectDataPtr project_data;
+#define OB__VariantProperties_quality_check 7
+
+ Int4 quality_check;
+#define OB__VariantProperties_confidence 8
+
+ Int4 confidence;
+} VariantProperties, PNTR VariantPropertiesPtr;
+
+
+NLM_EXTERN VariantPropertiesPtr LIBCALL VariantPropertiesFree PROTO ((VariantPropertiesPtr ));
+NLM_EXTERN VariantPropertiesPtr LIBCALL VariantPropertiesNew PROTO (( void ));
+NLM_EXTERN VariantPropertiesPtr LIBCALL VariantPropertiesAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL VariantPropertiesAsnWrite PROTO (( VariantPropertiesPtr , AsnIoPtr, AsnTypePtr));
+
+
+
+/**************************************************
+*
+* ExtLoc
+*
+**************************************************/
+typedef struct ext_loc {
+ struct ext_loc PNTR next;
+ Uint4 OBbits__;
+ ObjectIdPtr id;
+ SeqLocPtr location;
+} ExtLoc, PNTR ExtLocPtr;
+
+
+NLM_EXTERN ExtLocPtr LIBCALL ExtLocFree PROTO ((ExtLocPtr ));
+NLM_EXTERN ExtLocPtr LIBCALL ExtLocNew PROTO (( void ));
+NLM_EXTERN ExtLocPtr LIBCALL ExtLocAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL ExtLocAsnWrite PROTO (( ExtLocPtr , AsnIoPtr, AsnTypePtr));
+
+
+
+/**************************************************
+*
+* VariationRef
+*
+**************************************************/
+typedef struct variation_ref {
+ struct variation_ref PNTR next;
+ Uint4 OBbits__;
+ DbtagPtr id;
+ DbtagPtr parent_id;
+ ObjectIdPtr sample_id;
+ ValNodePtr other_ids;
+ CharPtr name;
+ ValNodePtr synonyms;
+ CharPtr description;
+ ValNodePtr phenotype;
+ ValNodePtr method;
+ ValNodePtr population_data;
+ VariantPropertiesPtr variant_prop;
+#define OB__Variation_ref_validated 0
+
+ Uint1 validated;
+ ValNodePtr clinical_test;
+#define OB__Variation_ref_allele_origin 1
+
+ Int4 allele_origin;
+#define OB__Variation_ref_allele_state 2
+
+ Int4 allele_state;
+#define OB__Variation_ref_allele_frequency 3
+
+ FloatHi allele_frequency;
+#define OB__Variation_ref_is_ancestral_allele 4
+
+ Uint1 is_ancestral_allele;
+ ValNodePtr pub;
+ ValNodePtr data;
+ ValNodePtr consequence;
+ ValNodePtr location;
+ ValNodePtr ext_locs;
+ UserObjectPtr ext;
+} VariationRef, PNTR VariationRefPtr;
+
+
+NLM_EXTERN VariationRefPtr LIBCALL VariationRefFree PROTO ((VariationRefPtr ));
+NLM_EXTERN VariationRefPtr LIBCALL VariationRefNew PROTO (( void ));
+NLM_EXTERN VariationRefPtr LIBCALL VariationRefAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL VariationRefAsnWrite PROTO (( VariationRefPtr , AsnIoPtr, AsnTypePtr));
+
+typedef ValNodePtr ConsequencePtr;
+typedef ValNode Consequence;
+
+NLM_EXTERN ConsequencePtr LIBCALL ConsequenceFree PROTO ((ConsequencePtr ));
+NLM_EXTERN ConsequencePtr LIBCALL ConsequenceAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL ConsequenceAsnWrite PROTO (( ConsequencePtr , AsnIoPtr, AsnTypePtr));
+
+typedef ValNodePtr Consequence_elementPtr;
+typedef ValNode Consequence_element;
+
+#define Consequence_unknown 1
+#define Consequence_splicing 2
+#define Consequence_note 3
+#define Consequence_variation 4
+#define Consequence_Consequence_Frameshift 5
+#define Consequence_Consequence_LossOfHeterozygosity 6
+
+NLM_EXTERN Consequence_elementPtr LIBCALL Consequence_elementFree PROTO ((Consequence_elementPtr ));
+NLM_EXTERN Consequence_elementPtr LIBCALL Consequence_elementAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL Consequence_elementAsnWrite PROTO (( Consequence_elementPtr , AsnIoPtr, AsnTypePtr));
+
+/**************************************************
+*
+* Consequence_loss_of_heterozygosity
+*
+**************************************************/
+
+typedef struct consequence_LossOfHeterozygosity {
+ Uint4 OBbits__;
+ CharPtr reference;
+ CharPtr test;
+} Consequence_loss_of_heterozygosity, PNTR Consequence_loss_of_heterozygosityPtr;
+
+NLM_EXTERN Consequence_loss_of_heterozygosityPtr LIBCALL Consequence_loss_of_heterozygosityFree PROTO ((Consequence_loss_of_heterozygosityPtr ));
+NLM_EXTERN Consequence_loss_of_heterozygosityPtr LIBCALL Consequence_loss_of_heterozygosityNew PROTO (( void ));
+NLM_EXTERN Consequence_loss_of_heterozygosityPtr LIBCALL Consequence_loss_of_heterozygosityAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL Consequence_loss_of_heterozygosityAsnWrite PROTO (( Consequence_loss_of_heterozygosityPtr , AsnIoPtr, AsnTypePtr));
+
+
+/**************************************************
+*
+* Consequence_frameshift
+*
+**************************************************/
+
+typedef struct consequence_Frameshift {
+ Uint4 OBbits__;
+#define OB__frameshift_phase 0
+
+ Int4 phase;
+#define OB__frameshift_x_length 1
+
+ Int4 x_length;
+} Consequence_frameshift, PNTR Consequence_frameshiftPtr;
+
+NLM_EXTERN Consequence_frameshiftPtr LIBCALL Consequence_frameshiftFree PROTO ((Consequence_frameshiftPtr ));
+NLM_EXTERN Consequence_frameshiftPtr LIBCALL Consequence_frameshiftNew PROTO (( void ));
+NLM_EXTERN Consequence_frameshiftPtr LIBCALL Consequence_frameshiftAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL Consequence_frameshiftAsnWrite PROTO (( Consequence_frameshiftPtr , AsnIoPtr, AsnTypePtr));
+
+typedef ValNodePtr VarRefDataPtr;
+typedef ValNode VarRefData;
+
+#define VarRefData_unknown 1
+#define VarRefData_note 2
+#define VarRefData_uniparental_disomy 3
+#define VarRefData_instance 4
+#define VarRefData_set 5
+
+NLM_EXTERN VarRefDataPtr LIBCALL VarRefDataFree PROTO ((VarRefDataPtr ));
+NLM_EXTERN VarRefDataPtr LIBCALL VarRefDataAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL VarRefDataAsnWrite PROTO (( VarRefDataPtr , AsnIoPtr, AsnTypePtr));
+
+
+/**************************************************
+*
+* Data_set
+*
+**************************************************/
+
+typedef struct varRefData_Set {
+ Uint4 OBbits__;
+ Int4 type;
+ ValNodePtr variations;
+ CharPtr name;
+} VarRefDataSet, PNTR VarRefDataSetPtr;
+
+NLM_EXTERN VarRefDataSetPtr LIBCALL VarRefDataSetFree PROTO ((VarRefDataSetPtr ));
+NLM_EXTERN VarRefDataSetPtr LIBCALL VarRefDataSetNew PROTO (( void ));
+NLM_EXTERN VarRefDataSetPtr LIBCALL VarRefDataSetAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL VarRefDataSetAsnWrite PROTO (( VarRefDataSetPtr , AsnIoPtr, AsnTypePtr));
+
+
+/**************************************************
+*
+* DeltaItem
+*
+**************************************************/
+typedef struct delta_item {
+ struct delta_item PNTR next;
+ Uint4 OBbits__;
+ ValNodePtr Seq_seq;
+#define OB__Delta_item_multiplier 0
+
+ Int4 multiplier;
+ IntFuzzPtr multiplier_fuzz;
+ Int4 action;
+} DeltaItem, PNTR DeltaItemPtr;
+
+
+NLM_EXTERN DeltaItemPtr LIBCALL DeltaItemFree PROTO ((DeltaItemPtr ));
+NLM_EXTERN DeltaItemPtr LIBCALL DeltaItemNew PROTO (( void ));
+NLM_EXTERN DeltaItemPtr LIBCALL DeltaItemAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL DeltaItemAsnWrite PROTO (( DeltaItemPtr , AsnIoPtr, AsnTypePtr));
+
+
+/**************************************************
+*
+* VariationInst
+*
+**************************************************/
+typedef struct variation_inst {
+ Uint4 OBbits__;
+ Int4 type;
+ ValNodePtr delta;
+} VariationInst, PNTR VariationInstPtr;
+
+
+NLM_EXTERN VariationInstPtr LIBCALL VariationInstFree PROTO ((VariationInstPtr ));
+NLM_EXTERN VariationInstPtr LIBCALL VariationInstNew PROTO (( void ));
+NLM_EXTERN VariationInstPtr LIBCALL VariationInstAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL VariationInstAsnWrite PROTO (( VariationInstPtr , AsnIoPtr, AsnTypePtr));
+
+
+
+typedef ValNodePtr Seq_seqPtr;
+typedef ValNode Seq_seq;
+
+#define Seq_seq_literal 1
+#define Seq_seq_loc 2
+#define Seq_seq_this__ 3
+NLM_EXTERN Seq_seqPtr LIBCALL Seq_seqFree PROTO ((Seq_seqPtr ));
+NLM_EXTERN Seq_seqPtr LIBCALL Seq_seqAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL Seq_seqAsnWrite PROTO (( Seq_seqPtr , AsnIoPtr, AsnTypePtr));
diff --git a/object/objgbseq.c b/object/objgbseq.c
index dc59967f..c7171cc7 100644
--- a/object/objgbseq.c
+++ b/object/objgbseq.c
@@ -31,7 +31,7 @@ objgbseqAsnLoad(void)
/**************************************************
* Generated object loaders for Module NCBI-GBSeq
-* Generated using ASNCODE Revision: 6.16 at Jan 15, 2009 2:16 PM
+* Generated using ASNCODE Revision: 6.17 at May 26, 2010 12:37 PM
*
**************************************************/
@@ -63,7 +63,6 @@ NLM_EXTERN
GBSetPtr LIBCALL
GBSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
- DataVal av;
AsnTypePtr atp;
Boolean isError = FALSE;
AsnReadFunc func;
@@ -119,7 +118,6 @@ erret:
NLM_EXTERN Boolean LIBCALL
GBSetAsnWrite(GBSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
- DataVal av;
AsnTypePtr atp;
Boolean retval = FALSE;
@@ -202,13 +200,16 @@ GBSeqFree(GBSeqPtr ptr)
MemFree(ptr -> taxonomy);
AsnGenericUserSeqOfFree(ptr -> references, (AsnOptFreeFunc) GBReferenceFree);
MemFree(ptr -> comment);
- GBTagsetFree(ptr -> tagset);
+ AsnGenericUserSeqOfFree(ptr -> comment_set, (AsnOptFreeFunc) GBCommentFree);
+ AsnGenericUserSeqOfFree(ptr -> struc_comments, (AsnOptFreeFunc) GBStrucCommentFree);
MemFree(ptr -> primary);
MemFree(ptr -> source_db);
MemFree(ptr -> database_reference);
AsnGenericUserSeqOfFree(ptr -> feature_table, (AsnOptFreeFunc) GBFeatureFree);
+ AsnGenericUserSeqOfFree(ptr -> feature_set, (AsnOptFreeFunc) GBFeatureSetFree);
MemFree(ptr -> sequence);
MemFree(ptr -> contig);
+ AsnGenericUserSeqOfFree(ptr -> alt_seq, (AsnOptFreeFunc) GBAltSeqDataFree);
return MemFree(ptr);
}
@@ -428,9 +429,16 @@ GBSeqAsnRead(AsnIoPtr aip, AsnTypePtr orig)
ptr -> comment = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBSEQ_tagset) {
- ptr -> tagset = GBTagsetAsnRead(aip, atp);
- if (aip -> io_failure) {
+ if (atp == GBSEQ_comment_set) {
+ ptr -> comment_set = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) GBCommentAsnRead, (AsnOptFreeFunc) GBCommentFree);
+ if (isError && ptr -> comment_set == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == GBSEQ_struc_comments) {
+ ptr -> struc_comments = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) GBStrucCommentAsnRead, (AsnOptFreeFunc) GBStrucCommentFree);
+ if (isError && ptr -> struc_comments == NULL) {
goto erret;
}
atp = AsnReadId(aip,amp, atp);
@@ -463,6 +471,13 @@ GBSeqAsnRead(AsnIoPtr aip, AsnTypePtr orig)
}
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == GBSEQ_feature_set) {
+ ptr -> feature_set = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) GBFeatureSetAsnRead, (AsnOptFreeFunc) GBFeatureSetFree);
+ if (isError && ptr -> feature_set == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
if (atp == GBSEQ_sequence) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -477,6 +492,13 @@ GBSeqAsnRead(AsnIoPtr aip, AsnTypePtr orig)
ptr -> contig = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == GBSEQ_alt_seq) {
+ ptr -> alt_seq = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) GBAltSeqDataAsnRead, (AsnOptFreeFunc) GBAltSeqDataFree);
+ if (isError && ptr -> alt_seq == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
if (AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -610,11 +632,8 @@ GBSeqAsnWrite(GBSeqPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
av.ptrvalue = ptr -> comment;
retval = AsnWrite(aip, GBSEQ_comment, &av);
}
- if (ptr -> tagset != NULL) {
- if ( ! GBTagsetAsnWrite(ptr -> tagset, aip, GBSEQ_tagset)) {
- goto erret;
- }
- }
+ AsnGenericUserSeqOfAsnWrite(ptr -> comment_set, (AsnWriteFunc) GBCommentAsnWrite, aip, GBSEQ_comment_set, GBSEQ_comment_set_E);
+ AsnGenericUserSeqOfAsnWrite(ptr -> struc_comments, (AsnWriteFunc) GBStrucCommentAsnWrite, aip, GBSEQ_struc_comments, GBSEQ_struc_comments_E);
if (ptr -> primary != NULL) {
av.ptrvalue = ptr -> primary;
retval = AsnWrite(aip, GBSEQ_primary, &av);
@@ -628,6 +647,7 @@ GBSeqAsnWrite(GBSeqPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
retval = AsnWrite(aip, GBSEQ_database_reference, &av);
}
AsnGenericUserSeqOfAsnWrite(ptr -> feature_table, (AsnWriteFunc) GBFeatureAsnWrite, aip, GBSEQ_feature_table, GBSEQ_feature_table_E);
+ AsnGenericUserSeqOfAsnWrite(ptr -> feature_set, (AsnWriteFunc) GBFeatureSetAsnWrite, aip, GBSEQ_feature_set, GBSEQ_feature_set_E);
if (ptr -> sequence != NULL) {
av.ptrvalue = ptr -> sequence;
retval = AsnWrite(aip, GBSEQ_sequence, &av);
@@ -636,6 +656,7 @@ GBSeqAsnWrite(GBSeqPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
av.ptrvalue = ptr -> contig;
retval = AsnWrite(aip, GBSEQ_contig, &av);
}
+ AsnGenericUserSeqOfAsnWrite(ptr -> alt_seq, (AsnWriteFunc) GBAltSeqDataAsnWrite, aip, GBSEQ_alt_seq, GBSEQ_alt_seq_E);
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
}
@@ -894,14 +915,14 @@ erret:
/**************************************************
*
-* GBTagsetNew()
+* GBCommentNew()
*
**************************************************/
NLM_EXTERN
-GBTagsetPtr LIBCALL
-GBTagsetNew(void)
+GBCommentPtr LIBCALL
+GBCommentNew(void)
{
- GBTagsetPtr ptr = MemNew((size_t) sizeof(GBTagset));
+ GBCommentPtr ptr = MemNew((size_t) sizeof(GBComment));
return ptr;
@@ -910,39 +931,37 @@ GBTagsetNew(void)
/**************************************************
*
-* GBTagsetFree()
+* GBCommentFree()
*
**************************************************/
NLM_EXTERN
-GBTagsetPtr LIBCALL
-GBTagsetFree(GBTagsetPtr ptr)
+GBCommentPtr LIBCALL
+GBCommentFree(GBCommentPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- MemFree(ptr -> authority);
- MemFree(ptr -> version);
- MemFree(ptr -> url);
- GBTagsFree(ptr -> tags);
+ MemFree(ptr -> type);
+ AsnGenericUserSeqOfFree(ptr -> paragraphs, (AsnOptFreeFunc) GBCommentParagraphFree);
return MemFree(ptr);
}
/**************************************************
*
-* GBTagsetAsnRead()
+* GBCommentAsnRead()
*
**************************************************/
NLM_EXTERN
-GBTagsetPtr LIBCALL
-GBTagsetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+GBCommentPtr LIBCALL
+GBCommentAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
Boolean isError = FALSE;
AsnReadFunc func;
- GBTagsetPtr ptr;
+ GBCommentPtr ptr;
if (! loaded)
{
@@ -955,17 +974,17 @@ GBTagsetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* GBTagset ::= (self contained) */
- atp = AsnReadId(aip, amp, GBTAGSET);
+ if (orig == NULL) { /* GBComment ::= (self contained) */
+ atp = AsnReadId(aip, amp, GBCOMMENT);
} else {
- atp = AsnLinkType(orig, GBTAGSET);
+ atp = AsnLinkType(orig, GBCOMMENT);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- ptr = GBTagsetNew();
+ ptr = GBCommentNew();
if (ptr == NULL) {
goto erret;
}
@@ -976,30 +995,180 @@ GBTagsetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
atp = AsnReadId(aip,amp, atp);
func = NULL;
- if (atp == GBTAGSET_authority) {
+ if (atp == GBCOMMENT_type) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> authority = av.ptrvalue;
+ ptr -> type = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBTAGSET_version) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
+ if (atp == GBCOMMENT_paragraphs) {
+ ptr -> paragraphs = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) GBCommentParagraphAsnRead, (AsnOptFreeFunc) GBCommentParagraphFree);
+ if (isError && ptr -> paragraphs == NULL) {
goto erret;
}
- ptr -> version = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBTAGSET_url) {
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = GBCommentFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* GBCommentAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+GBCommentAsnWrite(GBCommentPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! objgbseqAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, GBCOMMENT); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> type != NULL) {
+ av.ptrvalue = ptr -> type;
+ retval = AsnWrite(aip, GBCOMMENT_type, &av);
+ }
+ AsnGenericUserSeqOfAsnWrite(ptr -> paragraphs, (AsnWriteFunc) GBCommentParagraphAsnWrite, aip, GBCOMMENT_paragraphs, GBCOMMENT_paragraphs_E);
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* GBStrucCommentNew()
+*
+**************************************************/
+NLM_EXTERN
+GBStrucCommentPtr LIBCALL
+GBStrucCommentNew(void)
+{
+ GBStrucCommentPtr ptr = MemNew((size_t) sizeof(GBStrucComment));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* GBStrucCommentFree()
+*
+**************************************************/
+NLM_EXTERN
+GBStrucCommentPtr LIBCALL
+GBStrucCommentFree(GBStrucCommentPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ MemFree(ptr -> name);
+ AsnGenericUserSeqOfFree(ptr -> items, (AsnOptFreeFunc) GBStrucCommentItemFree);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* GBStrucCommentAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+GBStrucCommentPtr LIBCALL
+GBStrucCommentAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean isError = FALSE;
+ AsnReadFunc func;
+ GBStrucCommentPtr ptr;
+
+ if (! loaded)
+ {
+ if (! objgbseqAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* GBStrucComment ::= (self contained) */
+ atp = AsnReadId(aip, amp, GBSTRUCCOMMENT);
+ } else {
+ atp = AsnLinkType(orig, GBSTRUCCOMMENT);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = GBStrucCommentNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == GBSTRUCCOMMENT_name) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> url = av.ptrvalue;
+ ptr -> name = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBTAGSET_tags) {
- ptr -> tags = GBTagsAsnRead(aip, atp);
- if (aip -> io_failure) {
+ if (atp == GBSTRUCCOMMENT_items) {
+ ptr -> items = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) GBStrucCommentItemAsnRead, (AsnOptFreeFunc) GBStrucCommentItemFree);
+ if (isError && ptr -> items == NULL) {
goto erret;
}
atp = AsnReadId(aip,amp, atp);
@@ -1016,7 +1185,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = GBTagsetFree(ptr);
+ ptr = GBStrucCommentFree(ptr);
goto ret;
}
@@ -1024,11 +1193,11 @@ erret:
/**************************************************
*
-* GBTagsetAsnWrite()
+* GBStrucCommentAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-GBTagsetAsnWrite(GBTagsetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+GBStrucCommentAsnWrite(GBStrucCommentPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -1045,7 +1214,7 @@ GBTagsetAsnWrite(GBTagsetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, GBTAGSET); /* link local tree */
+ atp = AsnLinkType(orig, GBSTRUCCOMMENT); /* link local tree */
if (atp == NULL) {
return FALSE;
}
@@ -1055,23 +1224,11 @@ GBTagsetAsnWrite(GBTagsetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
- if (ptr -> authority != NULL) {
- av.ptrvalue = ptr -> authority;
- retval = AsnWrite(aip, GBTAGSET_authority, &av);
- }
- if (ptr -> version != NULL) {
- av.ptrvalue = ptr -> version;
- retval = AsnWrite(aip, GBTAGSET_version, &av);
- }
- if (ptr -> url != NULL) {
- av.ptrvalue = ptr -> url;
- retval = AsnWrite(aip, GBTAGSET_url, &av);
- }
- if (ptr -> tags != NULL) {
- if ( ! GBTagsAsnWrite(ptr -> tags, aip, GBTAGSET_tags)) {
- goto erret;
- }
+ if (ptr -> name != NULL) {
+ av.ptrvalue = ptr -> name;
+ retval = AsnWrite(aip, GBSTRUCCOMMENT_name, &av);
}
+ AsnGenericUserSeqOfAsnWrite(ptr -> items, (AsnWriteFunc) GBStrucCommentItemAsnWrite, aip, GBSTRUCCOMMENT_items, GBSTRUCCOMMENT_items_E);
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
}
@@ -1118,6 +1275,7 @@ GBFeatureFree(GBFeaturePtr ptr)
AsnGenericUserSeqOfFree(ptr -> intervals, (AsnOptFreeFunc) GBIntervalFree);
MemFree(ptr -> operator__);
AsnGenericUserSeqOfFree(ptr -> quals, (AsnOptFreeFunc) GBQualifierFree);
+ AsnGenericUserSeqOfFree(ptr -> xrefs, (AsnOptFreeFunc) GBXrefFree);
return MemFree(ptr);
}
@@ -1220,6 +1378,13 @@ GBFeatureAsnRead(AsnIoPtr aip, AsnTypePtr orig)
}
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == GBFEATURE_xrefs) {
+ ptr -> xrefs = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) GBXrefAsnRead, (AsnOptFreeFunc) GBXrefFree);
+ if (isError && ptr -> xrefs == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
if (AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -1291,6 +1456,7 @@ GBFeatureAsnWrite(GBFeaturePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
retval = AsnWrite(aip, GBFEATURE_partial3, &av);
}
AsnGenericUserSeqOfAsnWrite(ptr -> quals, (AsnWriteFunc) GBQualifierAsnWrite, aip, GBFEATURE_quals, GBFEATURE_quals_E);
+ AsnGenericUserSeqOfAsnWrite(ptr -> xrefs, (AsnWriteFunc) GBXrefAsnWrite, aip, GBFEATURE_xrefs, GBFEATURE_xrefs_E);
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
}
@@ -1305,14 +1471,14 @@ erret:
/**************************************************
*
-* GBXrefNew()
+* GBFeatureSetNew()
*
**************************************************/
NLM_EXTERN
-GBXrefPtr LIBCALL
-GBXrefNew(void)
+GBFeatureSetPtr LIBCALL
+GBFeatureSetNew(void)
{
- GBXrefPtr ptr = MemNew((size_t) sizeof(GBXref));
+ GBFeatureSetPtr ptr = MemNew((size_t) sizeof(GBFeatureSet));
return ptr;
@@ -1321,37 +1487,37 @@ GBXrefNew(void)
/**************************************************
*
-* GBXrefFree()
+* GBFeatureSetFree()
*
**************************************************/
NLM_EXTERN
-GBXrefPtr LIBCALL
-GBXrefFree(GBXrefPtr ptr)
+GBFeatureSetPtr LIBCALL
+GBFeatureSetFree(GBFeatureSetPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- MemFree(ptr -> dbname);
- MemFree(ptr -> id);
+ MemFree(ptr -> annot_source);
+ AsnGenericUserSeqOfFree(ptr -> features, (AsnOptFreeFunc) GBFeatureFree);
return MemFree(ptr);
}
/**************************************************
*
-* GBXrefAsnRead()
+* GBFeatureSetAsnRead()
*
**************************************************/
NLM_EXTERN
-GBXrefPtr LIBCALL
-GBXrefAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+GBFeatureSetPtr LIBCALL
+GBFeatureSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
Boolean isError = FALSE;
AsnReadFunc func;
- GBXrefPtr ptr;
+ GBFeatureSetPtr ptr;
if (! loaded)
{
@@ -1364,17 +1530,17 @@ GBXrefAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* GBXref ::= (self contained) */
- atp = AsnReadId(aip, amp, GBXREF);
+ if (orig == NULL) { /* GBFeatureSet ::= (self contained) */
+ atp = AsnReadId(aip, amp, GBFEATURESET);
} else {
- atp = AsnLinkType(orig, GBXREF);
+ atp = AsnLinkType(orig, GBFEATURESET);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- ptr = GBXrefNew();
+ ptr = GBFeatureSetNew();
if (ptr == NULL) {
goto erret;
}
@@ -1385,18 +1551,18 @@ GBXrefAsnRead(AsnIoPtr aip, AsnTypePtr orig)
atp = AsnReadId(aip,amp, atp);
func = NULL;
- if (atp == GBXREF_dbname) {
+ if (atp == GBFEATURESET_annot_source) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> dbname = av.ptrvalue;
+ ptr -> annot_source = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBXREF_id) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
+ if (atp == GBFEATURESET_features) {
+ ptr -> features = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) GBFeatureAsnRead, (AsnOptFreeFunc) GBFeatureFree);
+ if (isError && ptr -> features == NULL) {
goto erret;
}
- ptr -> id = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
@@ -1411,7 +1577,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = GBXrefFree(ptr);
+ ptr = GBFeatureSetFree(ptr);
goto ret;
}
@@ -1419,11 +1585,11 @@ erret:
/**************************************************
*
-* GBXrefAsnWrite()
+* GBFeatureSetAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-GBXrefAsnWrite(GBXrefPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+GBFeatureSetAsnWrite(GBFeatureSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -1440,7 +1606,7 @@ GBXrefAsnWrite(GBXrefPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, GBXREF); /* link local tree */
+ atp = AsnLinkType(orig, GBFEATURESET); /* link local tree */
if (atp == NULL) {
return FALSE;
}
@@ -1450,14 +1616,11 @@ GBXrefAsnWrite(GBXrefPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
- if (ptr -> dbname != NULL) {
- av.ptrvalue = ptr -> dbname;
- retval = AsnWrite(aip, GBXREF_dbname, &av);
- }
- if (ptr -> id != NULL) {
- av.ptrvalue = ptr -> id;
- retval = AsnWrite(aip, GBXREF_id, &av);
+ if (ptr -> annot_source != NULL) {
+ av.ptrvalue = ptr -> annot_source;
+ retval = AsnWrite(aip, GBFEATURESET_annot_source, &av);
}
+ AsnGenericUserSeqOfAsnWrite(ptr -> features, (AsnWriteFunc) GBFeatureAsnWrite, aip, GBFEATURESET_features, GBFEATURESET_features_E);
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
}
@@ -1472,36 +1635,53 @@ erret:
/**************************************************
*
-* GBTagsFree()
+* GBAltSeqDataNew()
+*
+**************************************************/
+NLM_EXTERN
+GBAltSeqDataPtr LIBCALL
+GBAltSeqDataNew(void)
+{
+ GBAltSeqDataPtr ptr = MemNew((size_t) sizeof(GBAltSeqData));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* GBAltSeqDataFree()
*
**************************************************/
NLM_EXTERN
-GBTagsPtr LIBCALL
-GBTagsFree(GBTagsPtr ptr)
+GBAltSeqDataPtr LIBCALL
+GBAltSeqDataFree(GBAltSeqDataPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- AsnGenericUserSeqOfFree(ptr, (AsnOptFreeFunc) GBTagFree);
- return NULL;
+ MemFree(ptr -> name);
+ AsnGenericUserSeqOfFree(ptr -> items, (AsnOptFreeFunc) GBAltSeqItemFree);
+ return MemFree(ptr);
}
/**************************************************
*
-* GBTagsAsnRead()
+* GBAltSeqDataAsnRead()
*
**************************************************/
NLM_EXTERN
-GBTagsPtr LIBCALL
-GBTagsAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+GBAltSeqDataPtr LIBCALL
+GBAltSeqDataAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
Boolean isError = FALSE;
AsnReadFunc func;
- GBTagsPtr ptr;
+ GBAltSeqDataPtr ptr;
if (! loaded)
{
@@ -1514,24 +1694,46 @@ GBTagsAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* GBTags ::= (self contained) */
- atp = AsnReadId(aip, amp, GBTAGS);
+ if (orig == NULL) { /* GBAltSeqData ::= (self contained) */
+ atp = AsnReadId(aip, amp, GBALTSEQDATA);
} else {
- atp = AsnLinkType(orig, GBTAGS);
+ atp = AsnLinkType(orig, GBALTSEQDATA);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- func = NULL;
-
- ptr = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) GBTagAsnRead, (AsnOptFreeFunc) GBTagFree);
- if (isError && ptr == NULL) {
+ ptr = GBAltSeqDataNew();
+ if (ptr == NULL) {
goto erret;
}
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+ if (atp == GBALTSEQDATA_name) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> name = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == GBALTSEQDATA_items) {
+ ptr -> items = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) GBAltSeqItemAsnRead, (AsnOptFreeFunc) GBAltSeqItemFree);
+ if (isError && ptr -> items == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
ret:
AsnUnlinkType(orig); /* unlink local tree */
@@ -1539,7 +1741,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = GBTagsFree(ptr);
+ ptr = GBAltSeqDataFree(ptr);
goto ret;
}
@@ -1547,11 +1749,11 @@ erret:
/**************************************************
*
-* GBTagsAsnWrite()
+* GBAltSeqDataAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-GBTagsAsnWrite(GBTagsPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+GBAltSeqDataAsnWrite(GBAltSeqDataPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -1568,13 +1770,24 @@ GBTagsAsnWrite(GBTagsPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, GBTAGS); /* link local tree */
+ atp = AsnLinkType(orig, GBALTSEQDATA); /* link local tree */
if (atp == NULL) {
return FALSE;
}
if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
- retval = AsnGenericUserSeqOfAsnWrite(ptr , (AsnWriteFunc) GBTagAsnWrite, aip, atp, GBTAGS_E);
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> name != NULL) {
+ av.ptrvalue = ptr -> name;
+ retval = AsnWrite(aip, GBALTSEQDATA_name, &av);
+ }
+ AsnGenericUserSeqOfAsnWrite(ptr -> items, (AsnWriteFunc) GBAltSeqItemAsnWrite, aip, GBALTSEQDATA_items, GBALTSEQDATA_items_E);
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
retval = TRUE;
erret:
@@ -1586,14 +1799,14 @@ erret:
/**************************************************
*
-* GBTagNew()
+* GBXrefNew()
*
**************************************************/
NLM_EXTERN
-GBTagPtr LIBCALL
-GBTagNew(void)
+GBXrefPtr LIBCALL
+GBXrefNew(void)
{
- GBTagPtr ptr = MemNew((size_t) sizeof(GBTag));
+ GBXrefPtr ptr = MemNew((size_t) sizeof(GBXref));
return ptr;
@@ -1602,38 +1815,36 @@ GBTagNew(void)
/**************************************************
*
-* GBTagFree()
+* GBXrefFree()
*
**************************************************/
NLM_EXTERN
-GBTagPtr LIBCALL
-GBTagFree(GBTagPtr ptr)
+GBXrefPtr LIBCALL
+GBXrefFree(GBXrefPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- MemFree(ptr -> name);
- MemFree(ptr -> value);
- MemFree(ptr -> unit);
+ MemFree(ptr -> dbname);
+ MemFree(ptr -> id);
return MemFree(ptr);
}
/**************************************************
*
-* GBTagAsnRead()
+* GBXrefAsnRead()
*
**************************************************/
NLM_EXTERN
-GBTagPtr LIBCALL
-GBTagAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+GBXrefPtr LIBCALL
+GBXrefAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
- Boolean isError = FALSE;
AsnReadFunc func;
- GBTagPtr ptr;
+ GBXrefPtr ptr;
if (! loaded)
{
@@ -1646,17 +1857,17 @@ GBTagAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* GBTag ::= (self contained) */
- atp = AsnReadId(aip, amp, GBTAG);
+ if (orig == NULL) { /* GBXref ::= (self contained) */
+ atp = AsnReadId(aip, amp, GBXREF);
} else {
- atp = AsnLinkType(orig, GBTAG);
+ atp = AsnLinkType(orig, GBXREF);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- ptr = GBTagNew();
+ ptr = GBXrefNew();
if (ptr == NULL) {
goto erret;
}
@@ -1667,25 +1878,18 @@ GBTagAsnRead(AsnIoPtr aip, AsnTypePtr orig)
atp = AsnReadId(aip,amp, atp);
func = NULL;
- if (atp == GBTAG_name) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
- goto erret;
- }
- ptr -> name = av.ptrvalue;
- atp = AsnReadId(aip,amp, atp);
- }
- if (atp == GBTAG_value) {
+ if (atp == GBXREF_dbname) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> value = av.ptrvalue;
+ ptr -> dbname = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBTAG_unit) {
+ if (atp == GBXREF_id) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> unit = av.ptrvalue;
+ ptr -> id = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
@@ -1700,7 +1904,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = GBTagFree(ptr);
+ ptr = GBXrefFree(ptr);
goto ret;
}
@@ -1708,11 +1912,11 @@ erret:
/**************************************************
*
-* GBTagAsnWrite()
+* GBXrefAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-GBTagAsnWrite(GBTagPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+GBXrefAsnWrite(GBXrefPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -1729,7 +1933,7 @@ GBTagAsnWrite(GBTagPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, GBTAG); /* link local tree */
+ atp = AsnLinkType(orig, GBXREF); /* link local tree */
if (atp == NULL) {
return FALSE;
}
@@ -1739,17 +1943,13 @@ GBTagAsnWrite(GBTagPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
- if (ptr -> name != NULL) {
- av.ptrvalue = ptr -> name;
- retval = AsnWrite(aip, GBTAG_name, &av);
- }
- if (ptr -> value != NULL) {
- av.ptrvalue = ptr -> value;
- retval = AsnWrite(aip, GBTAG_value, &av);
+ if (ptr -> dbname != NULL) {
+ av.ptrvalue = ptr -> dbname;
+ retval = AsnWrite(aip, GBXREF_dbname, &av);
}
- if (ptr -> unit != NULL) {
- av.ptrvalue = ptr -> unit;
- retval = AsnWrite(aip, GBTAG_unit, &av);
+ if (ptr -> id != NULL) {
+ av.ptrvalue = ptr -> id;
+ retval = AsnWrite(aip, GBXREF_id, &av);
}
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
@@ -1765,14 +1965,14 @@ erret:
/**************************************************
*
-* GBIntervalNew()
+* GBCommentParagraphNew()
*
**************************************************/
NLM_EXTERN
-GBIntervalPtr LIBCALL
-GBIntervalNew(void)
+GBCommentParagraphPtr LIBCALL
+GBCommentParagraphNew(void)
{
- GBIntervalPtr ptr = MemNew((size_t) sizeof(GBInterval));
+ GBCommentParagraphPtr ptr = MemNew((size_t) sizeof(GBCommentParagraph));
return ptr;
@@ -1781,36 +1981,36 @@ GBIntervalNew(void)
/**************************************************
*
-* GBIntervalFree()
+* GBCommentParagraphFree()
*
**************************************************/
NLM_EXTERN
-GBIntervalPtr LIBCALL
-GBIntervalFree(GBIntervalPtr ptr)
+GBCommentParagraphPtr LIBCALL
+GBCommentParagraphFree(GBCommentParagraphPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- MemFree(ptr -> accession);
+ AsnGenericUserSeqOfFree(ptr -> items, (AsnOptFreeFunc) GBCommentItemFree);
return MemFree(ptr);
}
/**************************************************
*
-* GBIntervalAsnRead()
+* GBCommentParagraphAsnRead()
*
**************************************************/
NLM_EXTERN
-GBIntervalPtr LIBCALL
-GBIntervalAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+GBCommentParagraphPtr LIBCALL
+GBCommentParagraphAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
Boolean isError = FALSE;
AsnReadFunc func;
- GBIntervalPtr ptr;
+ GBCommentParagraphPtr ptr;
if (! loaded)
{
@@ -1823,17 +2023,17 @@ GBIntervalAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* GBInterval ::= (self contained) */
- atp = AsnReadId(aip, amp, GBINTERVAL);
+ if (orig == NULL) { /* GBCommentParagraph ::= (self contained) */
+ atp = AsnReadId(aip, amp, GBCOMMENTPARAGRAPH);
} else {
- atp = AsnLinkType(orig, GBINTERVAL);
+ atp = AsnLinkType(orig, GBCOMMENTPARAGRAPH);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- ptr = GBIntervalNew();
+ ptr = GBCommentParagraphNew();
if (ptr == NULL) {
goto erret;
}
@@ -1844,51 +2044,169 @@ GBIntervalAsnRead(AsnIoPtr aip, AsnTypePtr orig)
atp = AsnReadId(aip,amp, atp);
func = NULL;
- if (atp == GBINTERVAL_from) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
+ if (atp == GBCOMMENTPARAGRAPH_items) {
+ ptr -> items = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) GBCommentItemAsnRead, (AsnOptFreeFunc) GBCommentItemFree);
+ if (isError && ptr -> items == NULL) {
goto erret;
}
- ptr -> from = av.intvalue;
- ptr -> OBbits__ |= 1<<0;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBINTERVAL_to) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
- goto erret;
- }
- ptr -> to = av.intvalue;
- ptr -> OBbits__ |= 1<<1;
- atp = AsnReadId(aip,amp, atp);
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
}
- if (atp == GBINTERVAL_point) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
- goto erret;
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = GBCommentParagraphFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* GBCommentParagraphAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+GBCommentParagraphAsnWrite(GBCommentParagraphPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! objgbseqAsnLoad()) {
+ return FALSE;
}
- ptr -> point = av.intvalue;
- ptr -> OBbits__ |= 1<<2;
- atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBINTERVAL_iscomp) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
- goto erret;
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, GBCOMMENTPARAGRAPH); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ AsnGenericUserSeqOfAsnWrite(ptr -> items, (AsnWriteFunc) GBCommentItemAsnWrite, aip, GBCOMMENTPARAGRAPH_items, GBCOMMENTPARAGRAPH_items_E);
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* GBCommentItemNew()
+*
+**************************************************/
+NLM_EXTERN
+GBCommentItemPtr LIBCALL
+GBCommentItemNew(void)
+{
+ GBCommentItemPtr ptr = MemNew((size_t) sizeof(GBCommentItem));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* GBCommentItemFree()
+*
+**************************************************/
+NLM_EXTERN
+GBCommentItemPtr LIBCALL
+GBCommentItemFree(GBCommentItemPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ MemFree(ptr -> value);
+ MemFree(ptr -> url);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* GBCommentItemAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+GBCommentItemPtr LIBCALL
+GBCommentItemAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ AsnReadFunc func;
+ GBCommentItemPtr ptr;
+
+ if (! loaded)
+ {
+ if (! objgbseqAsnLoad()) {
+ return NULL;
}
- ptr -> iscomp = av.boolvalue;
- ptr -> OBbits__ |= 1<<3;
- atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBINTERVAL_interbp) {
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* GBCommentItem ::= (self contained) */
+ atp = AsnReadId(aip, amp, GBCOMMENTITEM);
+ } else {
+ atp = AsnLinkType(orig, GBCOMMENTITEM);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = GBCommentItemNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == GBCOMMENTITEM_value) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> interbp = av.boolvalue;
- ptr -> OBbits__ |= 1<<4;
+ ptr -> value = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBINTERVAL_accession) {
+ if (atp == GBCOMMENTITEM_url) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> accession = av.ptrvalue;
+ ptr -> url = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
@@ -1903,7 +2221,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = GBIntervalFree(ptr);
+ ptr = GBCommentItemFree(ptr);
goto ret;
}
@@ -1911,11 +2229,11 @@ erret:
/**************************************************
*
-* GBIntervalAsnWrite()
+* GBCommentItemAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-GBIntervalAsnWrite(GBIntervalPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+GBCommentItemAsnWrite(GBCommentItemPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -1932,7 +2250,7 @@ GBIntervalAsnWrite(GBIntervalPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, GBINTERVAL); /* link local tree */
+ atp = AsnLinkType(orig, GBCOMMENTITEM); /* link local tree */
if (atp == NULL) {
return FALSE;
}
@@ -1942,24 +2260,13 @@ GBIntervalAsnWrite(GBIntervalPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
- if (ptr -> from || (ptr -> OBbits__ & (1<<0) )){ av.intvalue = ptr -> from;
- retval = AsnWrite(aip, GBINTERVAL_from, &av);
- }
- if (ptr -> to || (ptr -> OBbits__ & (1<<1) )){ av.intvalue = ptr -> to;
- retval = AsnWrite(aip, GBINTERVAL_to, &av);
- }
- if (ptr -> point || (ptr -> OBbits__ & (1<<2) )){ av.intvalue = ptr -> point;
- retval = AsnWrite(aip, GBINTERVAL_point, &av);
- }
- if (ptr -> iscomp || (ptr -> OBbits__ & (1<<3) )){ av.boolvalue = ptr -> iscomp;
- retval = AsnWrite(aip, GBINTERVAL_iscomp, &av);
- }
- if (ptr -> interbp || (ptr -> OBbits__ & (1<<4) )){ av.boolvalue = ptr -> interbp;
- retval = AsnWrite(aip, GBINTERVAL_interbp, &av);
+ if (ptr -> value != NULL) {
+ av.ptrvalue = ptr -> value;
+ retval = AsnWrite(aip, GBCOMMENTITEM_value, &av);
}
- if (ptr -> accession != NULL) {
- av.ptrvalue = ptr -> accession;
- retval = AsnWrite(aip, GBINTERVAL_accession, &av);
+ if (ptr -> url != NULL) {
+ av.ptrvalue = ptr -> url;
+ retval = AsnWrite(aip, GBCOMMENTITEM_url, &av);
}
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
@@ -1975,14 +2282,14 @@ erret:
/**************************************************
*
-* GBQualifierNew()
+* GBStrucCommentItemNew()
*
**************************************************/
NLM_EXTERN
-GBQualifierPtr LIBCALL
-GBQualifierNew(void)
+GBStrucCommentItemPtr LIBCALL
+GBStrucCommentItemNew(void)
{
- GBQualifierPtr ptr = MemNew((size_t) sizeof(GBQualifier));
+ GBStrucCommentItemPtr ptr = MemNew((size_t) sizeof(GBStrucCommentItem));
return ptr;
@@ -1991,37 +2298,37 @@ GBQualifierNew(void)
/**************************************************
*
-* GBQualifierFree()
+* GBStrucCommentItemFree()
*
**************************************************/
NLM_EXTERN
-GBQualifierPtr LIBCALL
-GBQualifierFree(GBQualifierPtr ptr)
+GBStrucCommentItemPtr LIBCALL
+GBStrucCommentItemFree(GBStrucCommentItemPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- MemFree(ptr -> name);
+ MemFree(ptr -> tag);
MemFree(ptr -> value);
+ MemFree(ptr -> url);
return MemFree(ptr);
}
/**************************************************
*
-* GBQualifierAsnRead()
+* GBStrucCommentItemAsnRead()
*
**************************************************/
NLM_EXTERN
-GBQualifierPtr LIBCALL
-GBQualifierAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+GBStrucCommentItemPtr LIBCALL
+GBStrucCommentItemAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
- Boolean isError = FALSE;
AsnReadFunc func;
- GBQualifierPtr ptr;
+ GBStrucCommentItemPtr ptr;
if (! loaded)
{
@@ -2034,17 +2341,17 @@ GBQualifierAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* GBQualifier ::= (self contained) */
- atp = AsnReadId(aip, amp, GBQUALIFIER);
+ if (orig == NULL) { /* GBStrucCommentItem ::= (self contained) */
+ atp = AsnReadId(aip, amp, GBSTRUCCOMMENTITEM);
} else {
- atp = AsnLinkType(orig, GBQUALIFIER);
+ atp = AsnLinkType(orig, GBSTRUCCOMMENTITEM);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- ptr = GBQualifierNew();
+ ptr = GBStrucCommentItemNew();
if (ptr == NULL) {
goto erret;
}
@@ -2055,20 +2362,27 @@ GBQualifierAsnRead(AsnIoPtr aip, AsnTypePtr orig)
atp = AsnReadId(aip,amp, atp);
func = NULL;
- if (atp == GBQUALIFIER_name) {
+ if (atp == GBSTRUCCOMMENTITEM_tag) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> name = av.ptrvalue;
+ ptr -> tag = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBQUALIFIER_value) {
+ if (atp == GBSTRUCCOMMENTITEM_value) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
ptr -> value = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == GBSTRUCCOMMENTITEM_url) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> url = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
if (AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -2081,7 +2395,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = GBQualifierFree(ptr);
+ ptr = GBStrucCommentItemFree(ptr);
goto ret;
}
@@ -2089,11 +2403,11 @@ erret:
/**************************************************
*
-* GBQualifierAsnWrite()
+* GBStrucCommentItemAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-GBQualifierAsnWrite(GBQualifierPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+GBStrucCommentItemAsnWrite(GBStrucCommentItemPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -2110,7 +2424,7 @@ GBQualifierAsnWrite(GBQualifierPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, GBQUALIFIER); /* link local tree */
+ atp = AsnLinkType(orig, GBSTRUCCOMMENTITEM); /* link local tree */
if (atp == NULL) {
return FALSE;
}
@@ -2120,13 +2434,17 @@ GBQualifierAsnWrite(GBQualifierPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
- if (ptr -> name != NULL) {
- av.ptrvalue = ptr -> name;
- retval = AsnWrite(aip, GBQUALIFIER_name, &av);
+ if (ptr -> tag != NULL) {
+ av.ptrvalue = ptr -> tag;
+ retval = AsnWrite(aip, GBSTRUCCOMMENTITEM_tag, &av);
}
if (ptr -> value != NULL) {
av.ptrvalue = ptr -> value;
- retval = AsnWrite(aip, GBQUALIFIER_value, &av);
+ retval = AsnWrite(aip, GBSTRUCCOMMENTITEM_value, &av);
+ }
+ if (ptr -> url != NULL) {
+ av.ptrvalue = ptr -> url;
+ retval = AsnWrite(aip, GBSTRUCCOMMENTITEM_url, &av);
}
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
@@ -2142,14 +2460,14 @@ erret:
/**************************************************
*
-* GBTagsetRulesNew()
+* GBIntervalNew()
*
**************************************************/
NLM_EXTERN
-GBTagsetRulesPtr LIBCALL
-GBTagsetRulesNew(void)
+GBIntervalPtr LIBCALL
+GBIntervalNew(void)
{
- GBTagsetRulesPtr ptr = MemNew((size_t) sizeof(GBTagsetRules));
+ GBIntervalPtr ptr = MemNew((size_t) sizeof(GBInterval));
return ptr;
@@ -2158,40 +2476,35 @@ GBTagsetRulesNew(void)
/**************************************************
*
-* GBTagsetRulesFree()
+* GBIntervalFree()
*
**************************************************/
NLM_EXTERN
-GBTagsetRulesPtr LIBCALL
-GBTagsetRulesFree(GBTagsetRulesPtr ptr)
+GBIntervalPtr LIBCALL
+GBIntervalFree(GBIntervalPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- MemFree(ptr -> authority);
- MemFree(ptr -> version);
- GBTagNamesFree(ptr -> mandatorytags);
- GBTagNamesFree(ptr -> optionaltags);
- GBTagNamesFree(ptr -> uniquetags);
+ MemFree(ptr -> accession);
return MemFree(ptr);
}
/**************************************************
*
-* GBTagsetRulesAsnRead()
+* GBIntervalAsnRead()
*
**************************************************/
NLM_EXTERN
-GBTagsetRulesPtr LIBCALL
-GBTagsetRulesAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+GBIntervalPtr LIBCALL
+GBIntervalAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
- Boolean isError = FALSE;
AsnReadFunc func;
- GBTagsetRulesPtr ptr;
+ GBIntervalPtr ptr;
if (! loaded)
{
@@ -2204,17 +2517,17 @@ GBTagsetRulesAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* GBTagsetRules ::= (self contained) */
- atp = AsnReadId(aip, amp, GBTAGSETRULES);
+ if (orig == NULL) { /* GBInterval ::= (self contained) */
+ atp = AsnReadId(aip, amp, GBINTERVAL);
} else {
- atp = AsnLinkType(orig, GBTAGSETRULES);
+ atp = AsnLinkType(orig, GBINTERVAL);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- ptr = GBTagsetRulesNew();
+ ptr = GBIntervalNew();
if (ptr == NULL) {
goto erret;
}
@@ -2225,47 +2538,51 @@ GBTagsetRulesAsnRead(AsnIoPtr aip, AsnTypePtr orig)
atp = AsnReadId(aip,amp, atp);
func = NULL;
- if (atp == GBTAGSETRULES_authority) {
+ if (atp == GBINTERVAL_from) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> authority = av.ptrvalue;
+ ptr -> from = av.intvalue;
+ ptr -> OBbits__ |= 1<<0;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBTAGSETRULES_version) {
+ if (atp == GBINTERVAL_to) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> version = av.ptrvalue;
+ ptr -> to = av.intvalue;
+ ptr -> OBbits__ |= 1<<1;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBTAGSETRULES_mandatorytags) {
- ptr -> mandatorytags = GBTagNamesAsnRead(aip, atp);
- if (aip -> io_failure) {
+ if (atp == GBINTERVAL_point) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
+ ptr -> point = av.intvalue;
+ ptr -> OBbits__ |= 1<<2;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBTAGSETRULES_optionaltags) {
- ptr -> optionaltags = GBTagNamesAsnRead(aip, atp);
- if (aip -> io_failure) {
+ if (atp == GBINTERVAL_iscomp) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
+ ptr -> iscomp = av.boolvalue;
+ ptr -> OBbits__ |= 1<<3;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBTAGSETRULES_uniquetags) {
- ptr -> uniquetags = GBTagNamesAsnRead(aip, atp);
- if (aip -> io_failure) {
+ if (atp == GBINTERVAL_interbp) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
+ ptr -> interbp = av.boolvalue;
+ ptr -> OBbits__ |= 1<<4;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == GBTAGSETRULES_extensible) {
+ if (atp == GBINTERVAL_accession) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> extensible = av.boolvalue;
- ptr -> OBbits__ |= 1<<0;
+ ptr -> accession = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
@@ -2280,7 +2597,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = GBTagsetRulesFree(ptr);
+ ptr = GBIntervalFree(ptr);
goto ret;
}
@@ -2288,11 +2605,11 @@ erret:
/**************************************************
*
-* GBTagsetRulesAsnWrite()
+* GBIntervalAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-GBTagsetRulesAsnWrite(GBTagsetRulesPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+GBIntervalAsnWrite(GBIntervalPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -2309,7 +2626,7 @@ GBTagsetRulesAsnWrite(GBTagsetRulesPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, GBTAGSETRULES); /* link local tree */
+ atp = AsnLinkType(orig, GBINTERVAL); /* link local tree */
if (atp == NULL) {
return FALSE;
}
@@ -2319,31 +2636,24 @@ GBTagsetRulesAsnWrite(GBTagsetRulesPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
- if (ptr -> authority != NULL) {
- av.ptrvalue = ptr -> authority;
- retval = AsnWrite(aip, GBTAGSETRULES_authority, &av);
+ if (ptr -> from || (ptr -> OBbits__ & (1<<0) )){ av.intvalue = ptr -> from;
+ retval = AsnWrite(aip, GBINTERVAL_from, &av);
}
- if (ptr -> version != NULL) {
- av.ptrvalue = ptr -> version;
- retval = AsnWrite(aip, GBTAGSETRULES_version, &av);
+ if (ptr -> to || (ptr -> OBbits__ & (1<<1) )){ av.intvalue = ptr -> to;
+ retval = AsnWrite(aip, GBINTERVAL_to, &av);
}
- if (ptr -> mandatorytags != NULL) {
- if ( ! GBTagNamesAsnWrite(ptr -> mandatorytags, aip, GBTAGSETRULES_mandatorytags)) {
- goto erret;
- }
+ if (ptr -> point || (ptr -> OBbits__ & (1<<2) )){ av.intvalue = ptr -> point;
+ retval = AsnWrite(aip, GBINTERVAL_point, &av);
}
- if (ptr -> optionaltags != NULL) {
- if ( ! GBTagNamesAsnWrite(ptr -> optionaltags, aip, GBTAGSETRULES_optionaltags)) {
- goto erret;
- }
+ if (ptr -> iscomp || (ptr -> OBbits__ & (1<<3) )){ av.boolvalue = ptr -> iscomp;
+ retval = AsnWrite(aip, GBINTERVAL_iscomp, &av);
}
- if (ptr -> uniquetags != NULL) {
- if ( ! GBTagNamesAsnWrite(ptr -> uniquetags, aip, GBTAGSETRULES_uniquetags)) {
- goto erret;
- }
+ if (ptr -> interbp || (ptr -> OBbits__ & (1<<4) )){ av.boolvalue = ptr -> interbp;
+ retval = AsnWrite(aip, GBINTERVAL_interbp, &av);
}
- if (ptr -> extensible || (ptr -> OBbits__ & (1<<0) )){ av.boolvalue = ptr -> extensible;
- retval = AsnWrite(aip, GBTAGSETRULES_extensible, &av);
+ if (ptr -> accession != NULL) {
+ av.ptrvalue = ptr -> accession;
+ retval = AsnWrite(aip, GBINTERVAL_accession, &av);
}
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
@@ -2359,36 +2669,52 @@ erret:
/**************************************************
*
-* GBTagNamesFree()
+* GBQualifierNew()
+*
+**************************************************/
+NLM_EXTERN
+GBQualifierPtr LIBCALL
+GBQualifierNew(void)
+{
+ GBQualifierPtr ptr = MemNew((size_t) sizeof(GBQualifier));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* GBQualifierFree()
*
**************************************************/
NLM_EXTERN
-GBTagNamesPtr LIBCALL
-GBTagNamesFree(GBTagNamesPtr ptr)
+GBQualifierPtr LIBCALL
+GBQualifierFree(GBQualifierPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- AsnGenericBaseSeqOfFree(ptr,ASNCODE_PTRVAL_SLOT);
- return NULL;
+ MemFree(ptr -> name);
+ MemFree(ptr -> value);
+ return MemFree(ptr);
}
/**************************************************
*
-* GBTagNamesAsnRead()
+* GBQualifierAsnRead()
*
**************************************************/
NLM_EXTERN
-GBTagNamesPtr LIBCALL
-GBTagNamesAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+GBQualifierPtr LIBCALL
+GBQualifierAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
- Boolean isError = FALSE;
AsnReadFunc func;
- GBTagNamesPtr ptr;
+ GBQualifierPtr ptr;
if (! loaded)
{
@@ -2401,24 +2727,46 @@ GBTagNamesAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* GBTagNames ::= (self contained) */
- atp = AsnReadId(aip, amp, GBTAGNAMES);
+ if (orig == NULL) { /* GBQualifier ::= (self contained) */
+ atp = AsnReadId(aip, amp, GBQUALIFIER);
} else {
- atp = AsnLinkType(orig, GBTAGNAMES);
+ atp = AsnLinkType(orig, GBQUALIFIER);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- func = NULL;
-
- ptr = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
- if (isError && ptr == NULL) {
+ ptr = GBQualifierNew();
+ if (ptr == NULL) {
goto erret;
}
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+ if (atp == GBQUALIFIER_name) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> name = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == GBQUALIFIER_value) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> value = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
ret:
AsnUnlinkType(orig); /* unlink local tree */
@@ -2426,7 +2774,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = GBTagNamesFree(ptr);
+ ptr = GBQualifierFree(ptr);
goto ret;
}
@@ -2434,11 +2782,11 @@ erret:
/**************************************************
*
-* GBTagNamesAsnWrite()
+* GBQualifierAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-GBTagNamesAsnWrite(GBTagNamesPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+GBQualifierAsnWrite(GBQualifierPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -2455,13 +2803,27 @@ GBTagNamesAsnWrite(GBTagNamesPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, GBTAGNAMES); /* link local tree */
+ atp = AsnLinkType(orig, GBQUALIFIER); /* link local tree */
if (atp == NULL) {
return FALSE;
}
if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
- retval = AsnGenericBaseSeqOfAsnWrite(ptr, ASNCODE_PTRVAL_SLOT, aip, atp, GBTAGNAMES_E);
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> name != NULL) {
+ av.ptrvalue = ptr -> name;
+ retval = AsnWrite(aip, GBQUALIFIER_name, &av);
+ }
+ if (ptr -> value != NULL) {
+ av.ptrvalue = ptr -> value;
+ retval = AsnWrite(aip, GBQUALIFIER_value, &av);
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
retval = TRUE;
erret:
@@ -2473,36 +2835,57 @@ erret:
/**************************************************
*
-* GBTagsetRuleSetFree()
+* GBAltSeqItemNew()
*
**************************************************/
NLM_EXTERN
-GBTagsetRuleSetPtr LIBCALL
-GBTagsetRuleSetFree(GBTagsetRuleSetPtr ptr)
+GBAltSeqItemPtr LIBCALL
+GBAltSeqItemNew(void)
+{
+ GBAltSeqItemPtr ptr = MemNew((size_t) sizeof(GBAltSeqItem));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* GBAltSeqItemFree()
+*
+**************************************************/
+NLM_EXTERN
+GBAltSeqItemPtr LIBCALL
+GBAltSeqItemFree(GBAltSeqItemPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- AsnGenericUserSeqOfFree(ptr, (AsnOptFreeFunc) GBTagsetRulesFree);
- return NULL;
+ GBIntervalFree(ptr -> interval);
+ MemFree(ptr -> gap_type);
+ MemFree(ptr -> gap_linkage);
+ MemFree(ptr -> gap_comment);
+ MemFree(ptr -> first_accn);
+ MemFree(ptr -> last_accn);
+ MemFree(ptr -> value);
+ return MemFree(ptr);
}
/**************************************************
*
-* GBTagsetRuleSetAsnRead()
+* GBAltSeqItemAsnRead()
*
**************************************************/
NLM_EXTERN
-GBTagsetRuleSetPtr LIBCALL
-GBTagsetRuleSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+GBAltSeqItemPtr LIBCALL
+GBAltSeqItemAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
- Boolean isError = FALSE;
AsnReadFunc func;
- GBTagsetRuleSetPtr ptr;
+ GBAltSeqItemPtr ptr;
if (! loaded)
{
@@ -2515,24 +2898,97 @@ GBTagsetRuleSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* GBTagsetRuleSet ::= (self contained) */
- atp = AsnReadId(aip, amp, GBTAGSETRULESET);
+ if (orig == NULL) { /* GBAltSeqItem ::= (self contained) */
+ atp = AsnReadId(aip, amp, GBALTSEQITEM);
} else {
- atp = AsnLinkType(orig, GBTAGSETRULESET);
+ atp = AsnLinkType(orig, GBALTSEQITEM);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- func = NULL;
-
- ptr = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) GBTagsetRulesAsnRead, (AsnOptFreeFunc) GBTagsetRulesFree);
- if (isError && ptr == NULL) {
+ ptr = GBAltSeqItemNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
goto erret;
}
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == GBALTSEQITEM_interval) {
+ ptr -> interval = GBIntervalAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == GBALTSEQITEM_isgap) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> isgap = av.boolvalue;
+ ptr -> OBbits__ |= 1<<0;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == GBALTSEQITEM_gap_length) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> gap_length = av.intvalue;
+ ptr -> OBbits__ |= 1<<1;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == GBALTSEQITEM_gap_type) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> gap_type = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == GBALTSEQITEM_gap_linkage) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> gap_linkage = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == GBALTSEQITEM_gap_comment) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> gap_comment = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == GBALTSEQITEM_first_accn) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> first_accn = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == GBALTSEQITEM_last_accn) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> last_accn = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == GBALTSEQITEM_value) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> value = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
ret:
AsnUnlinkType(orig); /* unlink local tree */
@@ -2540,7 +2996,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = GBTagsetRuleSetFree(ptr);
+ ptr = GBAltSeqItemFree(ptr);
goto ret;
}
@@ -2548,11 +3004,11 @@ erret:
/**************************************************
*
-* GBTagsetRuleSetAsnWrite()
+* GBAltSeqItemAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-GBTagsetRuleSetAsnWrite(GBTagsetRuleSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+GBAltSeqItemAsnWrite(GBAltSeqItemPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -2569,13 +3025,54 @@ GBTagsetRuleSetAsnWrite(GBTagsetRuleSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, GBTAGSETRULESET); /* link local tree */
+ atp = AsnLinkType(orig, GBALTSEQITEM); /* link local tree */
if (atp == NULL) {
return FALSE;
}
if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
- retval = AsnGenericUserSeqOfAsnWrite(ptr , (AsnWriteFunc) GBTagsetRulesAsnWrite, aip, atp, GBTAGSETRULESET_E);
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> interval != NULL) {
+ if ( ! GBIntervalAsnWrite(ptr -> interval, aip, GBALTSEQITEM_interval)) {
+ goto erret;
+ }
+ }
+ if (ptr -> isgap || (ptr -> OBbits__ & (1<<0) )){ av.boolvalue = ptr -> isgap;
+ retval = AsnWrite(aip, GBALTSEQITEM_isgap, &av);
+ }
+ if (ptr -> gap_length || (ptr -> OBbits__ & (1<<1) )){ av.intvalue = ptr -> gap_length;
+ retval = AsnWrite(aip, GBALTSEQITEM_gap_length, &av);
+ }
+ if (ptr -> gap_type != NULL) {
+ av.ptrvalue = ptr -> gap_type;
+ retval = AsnWrite(aip, GBALTSEQITEM_gap_type, &av);
+ }
+ if (ptr -> gap_linkage != NULL) {
+ av.ptrvalue = ptr -> gap_linkage;
+ retval = AsnWrite(aip, GBALTSEQITEM_gap_linkage, &av);
+ }
+ if (ptr -> gap_comment != NULL) {
+ av.ptrvalue = ptr -> gap_comment;
+ retval = AsnWrite(aip, GBALTSEQITEM_gap_comment, &av);
+ }
+ if (ptr -> first_accn != NULL) {
+ av.ptrvalue = ptr -> first_accn;
+ retval = AsnWrite(aip, GBALTSEQITEM_first_accn, &av);
+ }
+ if (ptr -> last_accn != NULL) {
+ av.ptrvalue = ptr -> last_accn;
+ retval = AsnWrite(aip, GBALTSEQITEM_last_accn, &av);
+ }
+ if (ptr -> value != NULL) {
+ av.ptrvalue = ptr -> value;
+ retval = AsnWrite(aip, GBALTSEQITEM_value, &av);
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
retval = TRUE;
erret:
diff --git a/object/objgbseq.h b/object/objgbseq.h
index b5be0dad..11e75a6d 100644
--- a/object/objgbseq.h
+++ b/object/objgbseq.h
@@ -17,7 +17,7 @@ extern "C" { /* } */
/**************************************************
*
* Generated objects for Module NCBI-GBSeq
-* Generated using ASNCODE Revision: 6.16 at Jan 15, 2009 2:16 PM
+* Generated using ASNCODE Revision: 6.17 at May 26, 2010 12:37 PM
*
**************************************************/
@@ -77,13 +77,16 @@ typedef struct struct_GBSeq {
CharPtr taxonomy;
struct struct_GBReference PNTR references;
CharPtr comment;
- struct struct_GBTagset PNTR tagset;
+ struct struct_GBComment PNTR comment_set;
+ struct struct_GBStrucComment PNTR struc_comments;
CharPtr primary;
CharPtr source_db;
CharPtr database_reference;
struct struct_GBFeature PNTR feature_table;
+ struct struct_GBFeatureSet PNTR feature_set;
CharPtr sequence;
CharPtr contig;
+ struct struct_GBAltSeqData PNTR alt_seq;
} GBSeq, PNTR GBSeqPtr;
@@ -125,22 +128,41 @@ NLM_EXTERN Boolean LIBCALL GBReferenceAsnWrite PROTO (( GBReferencePtr , AsnIoPt
/**************************************************
*
-* GBTagset
+* GBComment
*
**************************************************/
-typedef struct struct_GBTagset {
+typedef struct struct_GBComment {
+ struct struct_GBComment PNTR next;
Uint4 OBbits__;
- CharPtr authority;
- CharPtr version;
- CharPtr url;
- struct struct_GBTag PNTR tags;
-} GBTagset, PNTR GBTagsetPtr;
+ CharPtr type;
+ struct struct_GBCommentParagraph PNTR paragraphs;
+} GBComment, PNTR GBCommentPtr;
-NLM_EXTERN GBTagsetPtr LIBCALL GBTagsetFree PROTO ((GBTagsetPtr ));
-NLM_EXTERN GBTagsetPtr LIBCALL GBTagsetNew PROTO (( void ));
-NLM_EXTERN GBTagsetPtr LIBCALL GBTagsetAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
-NLM_EXTERN Boolean LIBCALL GBTagsetAsnWrite PROTO (( GBTagsetPtr , AsnIoPtr, AsnTypePtr));
+NLM_EXTERN GBCommentPtr LIBCALL GBCommentFree PROTO ((GBCommentPtr ));
+NLM_EXTERN GBCommentPtr LIBCALL GBCommentNew PROTO (( void ));
+NLM_EXTERN GBCommentPtr LIBCALL GBCommentAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL GBCommentAsnWrite PROTO (( GBCommentPtr , AsnIoPtr, AsnTypePtr));
+
+
+
+/**************************************************
+*
+* GBStrucComment
+*
+**************************************************/
+typedef struct struct_GBStrucComment {
+ struct struct_GBStrucComment PNTR next;
+ Uint4 OBbits__;
+ CharPtr name;
+ struct struct_GBStrucCommentItem PNTR items;
+} GBStrucComment, PNTR GBStrucCommentPtr;
+
+
+NLM_EXTERN GBStrucCommentPtr LIBCALL GBStrucCommentFree PROTO ((GBStrucCommentPtr ));
+NLM_EXTERN GBStrucCommentPtr LIBCALL GBStrucCommentNew PROTO (( void ));
+NLM_EXTERN GBStrucCommentPtr LIBCALL GBStrucCommentAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL GBStrucCommentAsnWrite PROTO (( GBStrucCommentPtr , AsnIoPtr, AsnTypePtr));
@@ -163,6 +185,7 @@ typedef struct struct_GBFeature {
Uint1 partial3;
struct struct_GBQualifier PNTR quals;
+ struct struct_GBXref PNTR xrefs;
} GBFeature, PNTR GBFeaturePtr;
@@ -175,6 +198,46 @@ NLM_EXTERN Boolean LIBCALL GBFeatureAsnWrite PROTO (( GBFeaturePtr , AsnIoPtr, A
/**************************************************
*
+* GBFeatureSet
+*
+**************************************************/
+typedef struct struct_GBFeatureSet {
+ struct struct_GBFeatureSet PNTR next;
+ Uint4 OBbits__;
+ CharPtr annot_source;
+ struct struct_GBFeature PNTR features;
+} GBFeatureSet, PNTR GBFeatureSetPtr;
+
+
+NLM_EXTERN GBFeatureSetPtr LIBCALL GBFeatureSetFree PROTO ((GBFeatureSetPtr ));
+NLM_EXTERN GBFeatureSetPtr LIBCALL GBFeatureSetNew PROTO (( void ));
+NLM_EXTERN GBFeatureSetPtr LIBCALL GBFeatureSetAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL GBFeatureSetAsnWrite PROTO (( GBFeatureSetPtr , AsnIoPtr, AsnTypePtr));
+
+
+
+/**************************************************
+*
+* GBAltSeqData
+*
+**************************************************/
+typedef struct struct_GBAltSeqData {
+ struct struct_GBAltSeqData PNTR next;
+ Uint4 OBbits__;
+ CharPtr name;
+ struct struct_GBAltSeqItem PNTR items;
+} GBAltSeqData, PNTR GBAltSeqDataPtr;
+
+
+NLM_EXTERN GBAltSeqDataPtr LIBCALL GBAltSeqDataFree PROTO ((GBAltSeqDataPtr ));
+NLM_EXTERN GBAltSeqDataPtr LIBCALL GBAltSeqDataNew PROTO (( void ));
+NLM_EXTERN GBAltSeqDataPtr LIBCALL GBAltSeqDataAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL GBAltSeqDataAsnWrite PROTO (( GBAltSeqDataPtr , AsnIoPtr, AsnTypePtr));
+
+
+
+/**************************************************
+*
* GBXref
*
**************************************************/
@@ -195,42 +258,61 @@ NLM_EXTERN Boolean LIBCALL GBXrefAsnWrite PROTO (( GBXrefPtr , AsnIoPtr, AsnType
/**************************************************
*
-* GBTags
+* GBCommentParagraph
*
**************************************************/
-typedef struct struct_GBTag GBTags;
-typedef struct struct_GBTag PNTR GBTagsPtr;
-#define GBTagsNew() GBTagNew()
+typedef struct struct_GBCommentParagraph {
+ struct struct_GBCommentParagraph PNTR next;
+ Uint4 OBbits__;
+ struct struct_GBCommentItem PNTR items;
+} GBCommentParagraph, PNTR GBCommentParagraphPtr;
-#ifdef NLM_GENERATED_CODE_PROTO
-NLM_EXTERN GBTagsPtr LIBCALL GBTagsFree PROTO ((GBTagsPtr ));
-NLM_EXTERN GBTagsPtr LIBCALL GBTagsNew PROTO (( void ));
-NLM_EXTERN GBTagsPtr LIBCALL GBTagsAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
-NLM_EXTERN Boolean LIBCALL GBTagsAsnWrite PROTO (( GBTagsPtr , AsnIoPtr, AsnTypePtr));
+NLM_EXTERN GBCommentParagraphPtr LIBCALL GBCommentParagraphFree PROTO ((GBCommentParagraphPtr ));
+NLM_EXTERN GBCommentParagraphPtr LIBCALL GBCommentParagraphNew PROTO (( void ));
+NLM_EXTERN GBCommentParagraphPtr LIBCALL GBCommentParagraphAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL GBCommentParagraphAsnWrite PROTO (( GBCommentParagraphPtr , AsnIoPtr, AsnTypePtr));
-#endif /* NLM_GENERATED_CODE_PROTO */
+
+
+/**************************************************
+*
+* GBCommentItem
+*
+**************************************************/
+typedef struct struct_GBCommentItem {
+ struct struct_GBCommentItem PNTR next;
+ Uint4 OBbits__;
+ CharPtr value;
+ CharPtr url;
+} GBCommentItem, PNTR GBCommentItemPtr;
+
+
+NLM_EXTERN GBCommentItemPtr LIBCALL GBCommentItemFree PROTO ((GBCommentItemPtr ));
+NLM_EXTERN GBCommentItemPtr LIBCALL GBCommentItemNew PROTO (( void ));
+NLM_EXTERN GBCommentItemPtr LIBCALL GBCommentItemAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL GBCommentItemAsnWrite PROTO (( GBCommentItemPtr , AsnIoPtr, AsnTypePtr));
/**************************************************
*
-* GBTag
+* GBStrucCommentItem
*
**************************************************/
-typedef struct struct_GBTag {
- struct struct_GBTag PNTR next;
+typedef struct struct_GBStrucCommentItem {
+ struct struct_GBStrucCommentItem PNTR next;
Uint4 OBbits__;
- CharPtr name;
+ CharPtr tag;
CharPtr value;
- CharPtr unit;
-} GBTag, PNTR GBTagPtr;
+ CharPtr url;
+} GBStrucCommentItem, PNTR GBStrucCommentItemPtr;
-NLM_EXTERN GBTagPtr LIBCALL GBTagFree PROTO ((GBTagPtr ));
-NLM_EXTERN GBTagPtr LIBCALL GBTagNew PROTO (( void ));
-NLM_EXTERN GBTagPtr LIBCALL GBTagAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
-NLM_EXTERN Boolean LIBCALL GBTagAsnWrite PROTO (( GBTagPtr , AsnIoPtr, AsnTypePtr));
+NLM_EXTERN GBStrucCommentItemPtr LIBCALL GBStrucCommentItemFree PROTO ((GBStrucCommentItemPtr ));
+NLM_EXTERN GBStrucCommentItemPtr LIBCALL GBStrucCommentItemNew PROTO (( void ));
+NLM_EXTERN GBStrucCommentItemPtr LIBCALL GBStrucCommentItemAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL GBStrucCommentItemAsnWrite PROTO (( GBStrucCommentItemPtr , AsnIoPtr, AsnTypePtr));
@@ -290,67 +372,32 @@ NLM_EXTERN Boolean LIBCALL GBQualifierAsnWrite PROTO (( GBQualifierPtr , AsnIoPt
/**************************************************
*
-* GBTagsetRules
+* GBAltSeqItem
*
**************************************************/
-typedef struct struct_GBTagsetRules {
- struct struct_GBTagsetRules PNTR next;
+typedef struct struct_GBAltSeqItem {
+ struct struct_GBAltSeqItem PNTR next;
Uint4 OBbits__;
- CharPtr authority;
- CharPtr version;
- ValNodePtr mandatorytags;
- ValNodePtr optionaltags;
- ValNodePtr uniquetags;
-#define OB__GBTagsetRules_extensible 0
-
- Uint1 extensible;
-} GBTagsetRules, PNTR GBTagsetRulesPtr;
-
-
-NLM_EXTERN GBTagsetRulesPtr LIBCALL GBTagsetRulesFree PROTO ((GBTagsetRulesPtr ));
-NLM_EXTERN GBTagsetRulesPtr LIBCALL GBTagsetRulesNew PROTO (( void ));
-NLM_EXTERN GBTagsetRulesPtr LIBCALL GBTagsetRulesAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
-NLM_EXTERN Boolean LIBCALL GBTagsetRulesAsnWrite PROTO (( GBTagsetRulesPtr , AsnIoPtr, AsnTypePtr));
-
-
-
-/**************************************************
-*
-* GBTagNames
-*
-**************************************************/
-typedef ValNode GBTagNames;
-typedef ValNodePtr GBTagNamesPtr;
-#define GBTagNamesNew() ValNodeNew(NULL)
-
-#ifdef NLM_GENERATED_CODE_PROTO
-
-NLM_EXTERN GBTagNamesPtr LIBCALL GBTagNamesFree PROTO ((GBTagNamesPtr ));
-NLM_EXTERN GBTagNamesPtr LIBCALL GBTagNamesNew PROTO (( void ));
-NLM_EXTERN GBTagNamesPtr LIBCALL GBTagNamesAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
-NLM_EXTERN Boolean LIBCALL GBTagNamesAsnWrite PROTO (( GBTagNamesPtr , AsnIoPtr, AsnTypePtr));
-
-#endif /* NLM_GENERATED_CODE_PROTO */
-
-
-
-/**************************************************
-*
-* GBTagsetRuleSet
-*
-**************************************************/
-typedef struct struct_GBTagsetRules GBTagsetRuleSet;
-typedef struct struct_GBTagsetRules PNTR GBTagsetRuleSetPtr;
-#define GBTagsetRuleSetNew() GBTagsetRulesNew()
-
-#ifdef NLM_GENERATED_CODE_PROTO
+ struct struct_GBInterval PNTR interval;
+#define OB__GBAltSeqItem_isgap 0
+
+ Uint1 isgap;
+#define OB__GBAltSeqItem_gap_length 1
+
+ Int4 gap_length;
+ CharPtr gap_type;
+ CharPtr gap_linkage;
+ CharPtr gap_comment;
+ CharPtr first_accn;
+ CharPtr last_accn;
+ CharPtr value;
+} GBAltSeqItem, PNTR GBAltSeqItemPtr;
-NLM_EXTERN GBTagsetRuleSetPtr LIBCALL GBTagsetRuleSetFree PROTO ((GBTagsetRuleSetPtr ));
-NLM_EXTERN GBTagsetRuleSetPtr LIBCALL GBTagsetRuleSetNew PROTO (( void ));
-NLM_EXTERN GBTagsetRuleSetPtr LIBCALL GBTagsetRuleSetAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
-NLM_EXTERN Boolean LIBCALL GBTagsetRuleSetAsnWrite PROTO (( GBTagsetRuleSetPtr , AsnIoPtr, AsnTypePtr));
-#endif /* NLM_GENERATED_CODE_PROTO */
+NLM_EXTERN GBAltSeqItemPtr LIBCALL GBAltSeqItemFree PROTO ((GBAltSeqItemPtr ));
+NLM_EXTERN GBAltSeqItemPtr LIBCALL GBAltSeqItemNew PROTO (( void ));
+NLM_EXTERN GBAltSeqItemPtr LIBCALL GBAltSeqItemAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL GBAltSeqItemAsnWrite PROTO (( GBAltSeqItemPtr , AsnIoPtr, AsnTypePtr));
#ifdef __cplusplus
/* { */ }
diff --git a/object/objgen.c b/object/objgen.c
index 86ef2e9b..b02d528c 100644
--- a/object/objgen.c
+++ b/object/objgen.c
@@ -29,7 +29,7 @@
*
* Version Creation Date: 1/1/91
*
-* $Revision: 6.16 $
+* $Revision: 6.17 $
*
* File Description: Object manager for module NCBI-General
*
@@ -42,77 +42,6 @@
* (because it cannot be exported from ncbitime.c when
* it is linked as a DLL).
*
-* $Log: objgen.c,v $
-* Revision 6.16 2008/12/30 19:58:39 bollin
-* corrected crash bug in DatePrint when month exceeds 12 (an error condition)
-*
-* Revision 6.15 2008/09/10 15:22:46 bollin
-* Added DbtagMatchEx and ObjectIdMatchEx, which are optionally case sensitive or case insensitive.
-*
-* Revision 6.14 2008/01/25 15:24:21 kans
-* in UserFieldAsnRead, finished implementing ints, reals, oss as list, does not need num in advance
-*
-* Revision 6.13 2008/01/24 23:05:55 kans
-* User-field.strs stores strings as list, does not need num supplied in advance - have not done ints, reals, oss yet
-*
-* Revision 6.12 2005/05/18 17:30:16 bollin
-* added NameStdMatch and PersonIdMatch functions
-*
-* Revision 6.11 2004/04/01 13:43:08 lavr
-* Spell "occurred", "occurrence", and "occurring"
-*
-* Revision 6.10 2002/07/23 21:47:18 kans
-* label function for pid choice 5 consortium
-*
-* Revision 6.9 2002/07/22 19:56:49 kans
-* added support for PERSON_ID_Consortium
-*
-* Revision 6.8 2000/01/20 17:04:27 beloslyu
-* new function DateClean to properly clean the date was added
-*
-* Revision 6.7 2000/01/20 15:13:16 ostell
-* added hour/minute/second fields to Date
-* added DateTimeCurr()
-*
-* Revision 6.6 1999/11/03 17:58:26 kans
-* added SeqDescrAddPointer
-*
-* Revision 6.5 1999/10/05 17:24:14 kans
-* added SeqDescrAdd
-*
-* Revision 6.4 1999/09/28 14:56:00 kans
-* rename ObjValNodeNew to SeqDescrNew
-*
-* Revision 6.3 1999/09/23 00:07:45 kans
-* ObjValNodeNew implemented
-*
-* Revision 6.2 1998/08/24 18:28:04 kans
-* removed solaris -v -fd warnings
-*
-* Revision 6.1 1998/08/17 23:05:00 kans
-* user object asn read needed to set choices 11 and 12
-*
-* Revision 6.0 1997/08/25 18:49:56 madden
-* Revision changed to 6.0
-*
-* Revision 4.3 1997/06/19 18:41:23 vakatov
-* [WIN32,MSVC++] Adopted for the "NCBIOBJ.LIB" DLL'ization
-*
-* Revision 4.2 1997/03/18 15:27:53 ostell
-* made DbtagMatch and ObjectIdMatch case insensitive
-*
- * Revision 4.1 1997/01/06 21:38:30 vakatov
- * Removed local(static) NCBI_months[12] -- use that from the "ncbitime.[ch]"
- *
- * Revision 4.0 1995/07/26 13:48:06 ostell
- * force revision to 4.0
- *
- * Revision 3.4 1995/05/15 21:22:00 ostell
- * added Log line
- *
-*
-*
-*
* ==========================================================================
*/
#include <asngen.h> /* the AsnTool header */
@@ -746,6 +675,58 @@ NLM_EXTERN Int2 LIBCALL DateCheck (DatePtr dp)
return 0;
}
+NLM_EXTERN DatePtr LIBCALL DateParse (CharPtr str)
+
+{
+ Int4 day = -1, month = -1, year = -1;
+ DatePtr dp;
+ CharPtr ptr;
+ Char tmp [64];
+ long int val;
+
+ if (StringHasNoText (str)) return NULL;
+
+ StringNCpy_0 (tmp, str, sizeof (tmp));
+ ptr = StringChr (tmp, '/');
+ if (ptr == NULL) {
+ ptr = StringChr (tmp, '-');
+ }
+ if (ptr != NULL) {
+ *ptr = '\0';
+ ptr++;
+ if (sscanf (tmp, "%ld", &val) == 1) {
+ month = (Int4) val;
+ }
+ str = StringChr (ptr, '/');
+ if (str == NULL) {
+ str = StringChr (ptr, '-');
+ }
+ if (str != NULL) {
+ *str = '\0';
+ str++;
+ if (sscanf (ptr, "%ld", &val) == 1) {
+ day = (Int4) val;
+ }
+ if (sscanf (str, "%ld", &val) == 1) {
+ year = (Int4) val;
+ }
+ }
+ }
+
+ if (month < 0 || day < 0 || year < 2000) return NULL;
+ if (month > 12 || day > 31 || year > 2099) return NULL;
+
+ dp = DateNew ();
+ if (dp == NULL) return NULL;
+
+ dp->data [0] = 1;
+ dp->data [1] = (Uint1) (year - 1900);
+ dp->data [2] = (Uint1) month;
+ dp->data [3] = (Uint1) day;
+
+ return dp;
+}
+
/*****************************************************************************
*
* DbtagNew()
diff --git a/object/objgen.h b/object/objgen.h
index 664296a9..8a00f2b9 100644
--- a/object/objgen.h
+++ b/object/objgen.h
@@ -29,7 +29,7 @@
*
* Version Creation Date: 1/1/91
*
-* $Revision: 6.14 $
+* $Revision: 6.15 $
*
* File Description: Object manager interface for module NCBI-General
*
@@ -38,65 +38,6 @@
* Date Name Description of modification
* ------- ---------- -----------------------------------------------------
*
-*
-* $Log: objgen.h,v $
-* Revision 6.14 2008/09/10 15:22:46 bollin
-* Added DbtagMatchEx and ObjectIdMatchEx, which are optionally case sensitive or case insensitive.
-*
-* Revision 6.13 2005/07/08 18:18:31 kans
-* added scratch pointer to EXTRA_OBJMGR_FIELDS
-*
-* Revision 6.12 2005/05/18 17:30:16 bollin
-* added NameStdMatch and PersonIdMatch functions
-*
-* Revision 6.11 2002/07/22 20:02:16 kans
-* document person-id.consortium choice
-*
-* Revision 6.10 2002/05/08 18:57:24 kans
-* itemID is Uint4
-*
-* Revision 6.9 2000/01/20 17:04:27 beloslyu
-* new function DateClean to properly clean the date was added
-*
-* Revision 6.8 2000/01/20 15:13:16 ostell
-* added hour/minute/second fields to Date
-* added DateTimeCurr()
-*
-* Revision 6.7 1999/11/03 17:58:26 kans
-* added SeqDescrAddPointer
-*
-* Revision 6.6 1999/10/05 17:24:14 kans
-* added SeqDescrAdd
-*
-* Revision 6.5 1999/09/28 14:56:00 kans
-* rename ObjValNodeNew to SeqDescrNew
-*
-* Revision 6.4 1999/09/27 17:48:38 kans
-* using GatherIndex structure
-*
-* Revision 6.3 1999/09/24 23:09:23 kans
-* adds EXTRA_OBJMGR_FIELDS to several objects
-*
-* Revision 6.2 1999/09/23 00:07:44 kans
-* ObjValNodeNew implemented
-*
-* Revision 6.1 1999/09/22 23:37:18 kans
-* added EXTRA_OBJMGR_FIELDS and ObjValNode
-*
-* Revision 6.0 1997/08/25 18:50:00 madden
-* Revision changed to 6.0
-*
-* Revision 4.1 1997/06/19 18:41:26 vakatov
-* [WIN32,MSVC++] Adopted for the "NCBIOBJ.LIB" DLL'ization
-*
-* Revision 4.0 1995/07/26 13:48:06 ostell
-* force revision to 4.0
-*
- * Revision 3.3 1995/05/15 21:22:00 ostell
- * added Log line
- *
-*
-*
* ==========================================================================
*/
@@ -199,6 +140,8 @@ NLM_EXTERN NCBI_DatePtr LIBCALL DateDup PROTO((NCBI_DatePtr dp));
NLM_EXTERN Boolean LIBCALL DateAsnWrite PROTO((NCBI_DatePtr dp, AsnIoPtr aip, AsnTypePtr atp));
NLM_EXTERN NCBI_DatePtr LIBCALL DateAsnRead PROTO((AsnIoPtr aip, AsnTypePtr atp));
NLM_EXTERN Int2 LIBCALL DateMatch PROTO((DatePtr a, DatePtr b, Boolean all));
+NLM_EXTERN DatePtr LIBCALL DateParse (CharPtr str);
+
/*****************************************************************************
*
* DateCheck (dp)
diff --git a/object/objinsdseq.c b/object/objinsdseq.c
index b753fcf2..b617c8d8 100644
--- a/object/objinsdseq.c
+++ b/object/objinsdseq.c
@@ -31,7 +31,7 @@ objinsdseqAsnLoad(void)
/**************************************************
* Generated object loaders for Module INSD-INSDSeq
-* Generated using ASNCODE Revision: 6.16 at Jan 15, 2009 2:16 PM
+* Generated using ASNCODE Revision: 6.17 at May 26, 2010 12:38 PM
*
**************************************************/
@@ -63,7 +63,6 @@ NLM_EXTERN
INSDSetPtr LIBCALL
INSDSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
- DataVal av;
AsnTypePtr atp;
Boolean isError = FALSE;
AsnReadFunc func;
@@ -119,7 +118,6 @@ erret:
NLM_EXTERN Boolean LIBCALL
INSDSetAsnWrite(INSDSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
- DataVal av;
AsnTypePtr atp;
Boolean retval = FALSE;
@@ -202,13 +200,16 @@ INSDSeqFree(INSDSeqPtr ptr)
MemFree(ptr -> taxonomy);
AsnGenericUserSeqOfFree(ptr -> references, (AsnOptFreeFunc) INSDReferenceFree);
MemFree(ptr -> comment);
- INSDTagsetFree(ptr -> tagset);
+ AsnGenericUserSeqOfFree(ptr -> comment_set, (AsnOptFreeFunc) INSDCommentFree);
+ AsnGenericUserSeqOfFree(ptr -> struc_comments, (AsnOptFreeFunc) INSDStrucCommentFree);
MemFree(ptr -> primary);
MemFree(ptr -> source_db);
MemFree(ptr -> database_reference);
AsnGenericUserSeqOfFree(ptr -> feature_table, (AsnOptFreeFunc) INSDFeatureFree);
+ AsnGenericUserSeqOfFree(ptr -> feature_set, (AsnOptFreeFunc) INSDFeatureSetFree);
MemFree(ptr -> sequence);
MemFree(ptr -> contig);
+ AsnGenericUserSeqOfFree(ptr -> alt_seq, (AsnOptFreeFunc) INSDAltSeqDataFree);
return MemFree(ptr);
}
@@ -428,9 +429,16 @@ INSDSeqAsnRead(AsnIoPtr aip, AsnTypePtr orig)
ptr -> comment = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDSEQ_tagset) {
- ptr -> tagset = INSDTagsetAsnRead(aip, atp);
- if (aip -> io_failure) {
+ if (atp == INSDSEQ_comment_set) {
+ ptr -> comment_set = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) INSDCommentAsnRead, (AsnOptFreeFunc) INSDCommentFree);
+ if (isError && ptr -> comment_set == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == INSDSEQ_struc_comments) {
+ ptr -> struc_comments = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) INSDStrucCommentAsnRead, (AsnOptFreeFunc) INSDStrucCommentFree);
+ if (isError && ptr -> struc_comments == NULL) {
goto erret;
}
atp = AsnReadId(aip,amp, atp);
@@ -463,6 +471,13 @@ INSDSeqAsnRead(AsnIoPtr aip, AsnTypePtr orig)
}
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == INSDSEQ_feature_set) {
+ ptr -> feature_set = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) INSDFeatureSetAsnRead, (AsnOptFreeFunc) INSDFeatureSetFree);
+ if (isError && ptr -> feature_set == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
if (atp == INSDSEQ_sequence) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -477,6 +492,13 @@ INSDSeqAsnRead(AsnIoPtr aip, AsnTypePtr orig)
ptr -> contig = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == INSDSEQ_alt_seq) {
+ ptr -> alt_seq = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) INSDAltSeqDataAsnRead, (AsnOptFreeFunc) INSDAltSeqDataFree);
+ if (isError && ptr -> alt_seq == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
if (AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -610,11 +632,8 @@ INSDSeqAsnWrite(INSDSeqPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
av.ptrvalue = ptr -> comment;
retval = AsnWrite(aip, INSDSEQ_comment, &av);
}
- if (ptr -> tagset != NULL) {
- if ( ! INSDTagsetAsnWrite(ptr -> tagset, aip, INSDSEQ_tagset)) {
- goto erret;
- }
- }
+ AsnGenericUserSeqOfAsnWrite(ptr -> comment_set, (AsnWriteFunc) INSDCommentAsnWrite, aip, INSDSEQ_comment_set, INSDSEQ_comment_set_E);
+ AsnGenericUserSeqOfAsnWrite(ptr -> struc_comments, (AsnWriteFunc) INSDStrucCommentAsnWrite, aip, INSDSEQ_struc_comments, INSDSEQ_struc_comments_E);
if (ptr -> primary != NULL) {
av.ptrvalue = ptr -> primary;
retval = AsnWrite(aip, INSDSEQ_primary, &av);
@@ -628,6 +647,7 @@ INSDSeqAsnWrite(INSDSeqPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
retval = AsnWrite(aip, INSDSEQ_database_reference, &av);
}
AsnGenericUserSeqOfAsnWrite(ptr -> feature_table, (AsnWriteFunc) INSDFeatureAsnWrite, aip, INSDSEQ_feature_table, INSDSEQ_feature_table_E);
+ AsnGenericUserSeqOfAsnWrite(ptr -> feature_set, (AsnWriteFunc) INSDFeatureSetAsnWrite, aip, INSDSEQ_feature_set, INSDSEQ_feature_set_E);
if (ptr -> sequence != NULL) {
av.ptrvalue = ptr -> sequence;
retval = AsnWrite(aip, INSDSEQ_sequence, &av);
@@ -636,6 +656,7 @@ INSDSeqAsnWrite(INSDSeqPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
av.ptrvalue = ptr -> contig;
retval = AsnWrite(aip, INSDSEQ_contig, &av);
}
+ AsnGenericUserSeqOfAsnWrite(ptr -> alt_seq, (AsnWriteFunc) INSDAltSeqDataAsnWrite, aip, INSDSEQ_alt_seq, INSDSEQ_alt_seq_E);
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
}
@@ -894,14 +915,14 @@ erret:
/**************************************************
*
-* INSDTagsetNew()
+* INSDCommentNew()
*
**************************************************/
NLM_EXTERN
-INSDTagsetPtr LIBCALL
-INSDTagsetNew(void)
+INSDCommentPtr LIBCALL
+INSDCommentNew(void)
{
- INSDTagsetPtr ptr = MemNew((size_t) sizeof(INSDTagset));
+ INSDCommentPtr ptr = MemNew((size_t) sizeof(INSDComment));
return ptr;
@@ -910,39 +931,37 @@ INSDTagsetNew(void)
/**************************************************
*
-* INSDTagsetFree()
+* INSDCommentFree()
*
**************************************************/
NLM_EXTERN
-INSDTagsetPtr LIBCALL
-INSDTagsetFree(INSDTagsetPtr ptr)
+INSDCommentPtr LIBCALL
+INSDCommentFree(INSDCommentPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- MemFree(ptr -> authority);
- MemFree(ptr -> version);
- MemFree(ptr -> url);
- INSDTagsFree(ptr -> tags);
+ MemFree(ptr -> type);
+ AsnGenericUserSeqOfFree(ptr -> paragraphs, (AsnOptFreeFunc) INSDCommentParagraphFree);
return MemFree(ptr);
}
/**************************************************
*
-* INSDTagsetAsnRead()
+* INSDCommentAsnRead()
*
**************************************************/
NLM_EXTERN
-INSDTagsetPtr LIBCALL
-INSDTagsetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+INSDCommentPtr LIBCALL
+INSDCommentAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
Boolean isError = FALSE;
AsnReadFunc func;
- INSDTagsetPtr ptr;
+ INSDCommentPtr ptr;
if (! loaded)
{
@@ -955,17 +974,17 @@ INSDTagsetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* INSDTagset ::= (self contained) */
- atp = AsnReadId(aip, amp, INSDTAGSET);
+ if (orig == NULL) { /* INSDComment ::= (self contained) */
+ atp = AsnReadId(aip, amp, INSDCOMMENT);
} else {
- atp = AsnLinkType(orig, INSDTAGSET);
+ atp = AsnLinkType(orig, INSDCOMMENT);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- ptr = INSDTagsetNew();
+ ptr = INSDCommentNew();
if (ptr == NULL) {
goto erret;
}
@@ -976,30 +995,180 @@ INSDTagsetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
atp = AsnReadId(aip,amp, atp);
func = NULL;
- if (atp == INSDTAGSET_authority) {
+ if (atp == INSDCOMMENT_type) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> authority = av.ptrvalue;
+ ptr -> type = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDTAGSET_version) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
+ if (atp == INSDCOMMENT_paragraphs) {
+ ptr -> paragraphs = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) INSDCommentParagraphAsnRead, (AsnOptFreeFunc) INSDCommentParagraphFree);
+ if (isError && ptr -> paragraphs == NULL) {
goto erret;
}
- ptr -> version = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDTAGSET_url) {
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = INSDCommentFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* INSDCommentAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+INSDCommentAsnWrite(INSDCommentPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! objinsdseqAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, INSDCOMMENT); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> type != NULL) {
+ av.ptrvalue = ptr -> type;
+ retval = AsnWrite(aip, INSDCOMMENT_type, &av);
+ }
+ AsnGenericUserSeqOfAsnWrite(ptr -> paragraphs, (AsnWriteFunc) INSDCommentParagraphAsnWrite, aip, INSDCOMMENT_paragraphs, INSDCOMMENT_paragraphs_E);
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* INSDStrucCommentNew()
+*
+**************************************************/
+NLM_EXTERN
+INSDStrucCommentPtr LIBCALL
+INSDStrucCommentNew(void)
+{
+ INSDStrucCommentPtr ptr = MemNew((size_t) sizeof(INSDStrucComment));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* INSDStrucCommentFree()
+*
+**************************************************/
+NLM_EXTERN
+INSDStrucCommentPtr LIBCALL
+INSDStrucCommentFree(INSDStrucCommentPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ MemFree(ptr -> name);
+ AsnGenericUserSeqOfFree(ptr -> items, (AsnOptFreeFunc) INSDStrucCommentItemFree);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* INSDStrucCommentAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+INSDStrucCommentPtr LIBCALL
+INSDStrucCommentAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean isError = FALSE;
+ AsnReadFunc func;
+ INSDStrucCommentPtr ptr;
+
+ if (! loaded)
+ {
+ if (! objinsdseqAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* INSDStrucComment ::= (self contained) */
+ atp = AsnReadId(aip, amp, INSDSTRUCCOMMENT);
+ } else {
+ atp = AsnLinkType(orig, INSDSTRUCCOMMENT);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = INSDStrucCommentNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == INSDSTRUCCOMMENT_name) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> url = av.ptrvalue;
+ ptr -> name = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDTAGSET_tags) {
- ptr -> tags = INSDTagsAsnRead(aip, atp);
- if (aip -> io_failure) {
+ if (atp == INSDSTRUCCOMMENT_items) {
+ ptr -> items = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) INSDStrucCommentItemAsnRead, (AsnOptFreeFunc) INSDStrucCommentItemFree);
+ if (isError && ptr -> items == NULL) {
goto erret;
}
atp = AsnReadId(aip,amp, atp);
@@ -1016,7 +1185,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = INSDTagsetFree(ptr);
+ ptr = INSDStrucCommentFree(ptr);
goto ret;
}
@@ -1024,11 +1193,11 @@ erret:
/**************************************************
*
-* INSDTagsetAsnWrite()
+* INSDStrucCommentAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-INSDTagsetAsnWrite(INSDTagsetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+INSDStrucCommentAsnWrite(INSDStrucCommentPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -1045,7 +1214,7 @@ INSDTagsetAsnWrite(INSDTagsetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, INSDTAGSET); /* link local tree */
+ atp = AsnLinkType(orig, INSDSTRUCCOMMENT); /* link local tree */
if (atp == NULL) {
return FALSE;
}
@@ -1055,23 +1224,11 @@ INSDTagsetAsnWrite(INSDTagsetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
- if (ptr -> authority != NULL) {
- av.ptrvalue = ptr -> authority;
- retval = AsnWrite(aip, INSDTAGSET_authority, &av);
- }
- if (ptr -> version != NULL) {
- av.ptrvalue = ptr -> version;
- retval = AsnWrite(aip, INSDTAGSET_version, &av);
- }
- if (ptr -> url != NULL) {
- av.ptrvalue = ptr -> url;
- retval = AsnWrite(aip, INSDTAGSET_url, &av);
- }
- if (ptr -> tags != NULL) {
- if ( ! INSDTagsAsnWrite(ptr -> tags, aip, INSDTAGSET_tags)) {
- goto erret;
- }
+ if (ptr -> name != NULL) {
+ av.ptrvalue = ptr -> name;
+ retval = AsnWrite(aip, INSDSTRUCCOMMENT_name, &av);
}
+ AsnGenericUserSeqOfAsnWrite(ptr -> items, (AsnWriteFunc) INSDStrucCommentItemAsnWrite, aip, INSDSTRUCCOMMENT_items, INSDSTRUCCOMMENT_items_E);
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
}
@@ -1118,6 +1275,7 @@ INSDFeatureFree(INSDFeaturePtr ptr)
AsnGenericUserSeqOfFree(ptr -> intervals, (AsnOptFreeFunc) INSDIntervalFree);
MemFree(ptr -> operator__);
AsnGenericUserSeqOfFree(ptr -> quals, (AsnOptFreeFunc) INSDQualifierFree);
+ AsnGenericUserSeqOfFree(ptr -> xrefs, (AsnOptFreeFunc) INSDXrefFree);
return MemFree(ptr);
}
@@ -1220,6 +1378,13 @@ INSDFeatureAsnRead(AsnIoPtr aip, AsnTypePtr orig)
}
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == INSDFEATURE_xrefs) {
+ ptr -> xrefs = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) INSDXrefAsnRead, (AsnOptFreeFunc) INSDXrefFree);
+ if (isError && ptr -> xrefs == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
if (AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -1291,6 +1456,7 @@ INSDFeatureAsnWrite(INSDFeaturePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
retval = AsnWrite(aip, INSDFEATURE_partial3, &av);
}
AsnGenericUserSeqOfAsnWrite(ptr -> quals, (AsnWriteFunc) INSDQualifierAsnWrite, aip, INSDFEATURE_quals, INSDFEATURE_quals_E);
+ AsnGenericUserSeqOfAsnWrite(ptr -> xrefs, (AsnWriteFunc) INSDXrefAsnWrite, aip, INSDFEATURE_xrefs, INSDFEATURE_xrefs_E);
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
}
@@ -1305,14 +1471,14 @@ erret:
/**************************************************
*
-* INSDXrefNew()
+* INSDFeatureSetNew()
*
**************************************************/
NLM_EXTERN
-INSDXrefPtr LIBCALL
-INSDXrefNew(void)
+INSDFeatureSetPtr LIBCALL
+INSDFeatureSetNew(void)
{
- INSDXrefPtr ptr = MemNew((size_t) sizeof(INSDXref));
+ INSDFeatureSetPtr ptr = MemNew((size_t) sizeof(INSDFeatureSet));
return ptr;
@@ -1321,37 +1487,37 @@ INSDXrefNew(void)
/**************************************************
*
-* INSDXrefFree()
+* INSDFeatureSetFree()
*
**************************************************/
NLM_EXTERN
-INSDXrefPtr LIBCALL
-INSDXrefFree(INSDXrefPtr ptr)
+INSDFeatureSetPtr LIBCALL
+INSDFeatureSetFree(INSDFeatureSetPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- MemFree(ptr -> dbname);
- MemFree(ptr -> id);
+ MemFree(ptr -> annot_source);
+ AsnGenericUserSeqOfFree(ptr -> features, (AsnOptFreeFunc) INSDFeatureFree);
return MemFree(ptr);
}
/**************************************************
*
-* INSDXrefAsnRead()
+* INSDFeatureSetAsnRead()
*
**************************************************/
NLM_EXTERN
-INSDXrefPtr LIBCALL
-INSDXrefAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+INSDFeatureSetPtr LIBCALL
+INSDFeatureSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
Boolean isError = FALSE;
AsnReadFunc func;
- INSDXrefPtr ptr;
+ INSDFeatureSetPtr ptr;
if (! loaded)
{
@@ -1364,17 +1530,17 @@ INSDXrefAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* INSDXref ::= (self contained) */
- atp = AsnReadId(aip, amp, INSDXREF);
+ if (orig == NULL) { /* INSDFeatureSet ::= (self contained) */
+ atp = AsnReadId(aip, amp, INSDFEATURESET);
} else {
- atp = AsnLinkType(orig, INSDXREF);
+ atp = AsnLinkType(orig, INSDFEATURESET);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- ptr = INSDXrefNew();
+ ptr = INSDFeatureSetNew();
if (ptr == NULL) {
goto erret;
}
@@ -1385,18 +1551,18 @@ INSDXrefAsnRead(AsnIoPtr aip, AsnTypePtr orig)
atp = AsnReadId(aip,amp, atp);
func = NULL;
- if (atp == INSDXREF_dbname) {
+ if (atp == INSDFEATURESET_annot_source) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> dbname = av.ptrvalue;
+ ptr -> annot_source = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDXREF_id) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
+ if (atp == INSDFEATURESET_features) {
+ ptr -> features = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) INSDFeatureAsnRead, (AsnOptFreeFunc) INSDFeatureFree);
+ if (isError && ptr -> features == NULL) {
goto erret;
}
- ptr -> id = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
@@ -1411,7 +1577,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = INSDXrefFree(ptr);
+ ptr = INSDFeatureSetFree(ptr);
goto ret;
}
@@ -1419,11 +1585,11 @@ erret:
/**************************************************
*
-* INSDXrefAsnWrite()
+* INSDFeatureSetAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-INSDXrefAsnWrite(INSDXrefPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+INSDFeatureSetAsnWrite(INSDFeatureSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -1440,7 +1606,7 @@ INSDXrefAsnWrite(INSDXrefPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, INSDXREF); /* link local tree */
+ atp = AsnLinkType(orig, INSDFEATURESET); /* link local tree */
if (atp == NULL) {
return FALSE;
}
@@ -1450,14 +1616,11 @@ INSDXrefAsnWrite(INSDXrefPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
- if (ptr -> dbname != NULL) {
- av.ptrvalue = ptr -> dbname;
- retval = AsnWrite(aip, INSDXREF_dbname, &av);
- }
- if (ptr -> id != NULL) {
- av.ptrvalue = ptr -> id;
- retval = AsnWrite(aip, INSDXREF_id, &av);
+ if (ptr -> annot_source != NULL) {
+ av.ptrvalue = ptr -> annot_source;
+ retval = AsnWrite(aip, INSDFEATURESET_annot_source, &av);
}
+ AsnGenericUserSeqOfAsnWrite(ptr -> features, (AsnWriteFunc) INSDFeatureAsnWrite, aip, INSDFEATURESET_features, INSDFEATURESET_features_E);
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
}
@@ -1472,36 +1635,53 @@ erret:
/**************************************************
*
-* INSDTagsFree()
+* INSDAltSeqDataNew()
+*
+**************************************************/
+NLM_EXTERN
+INSDAltSeqDataPtr LIBCALL
+INSDAltSeqDataNew(void)
+{
+ INSDAltSeqDataPtr ptr = MemNew((size_t) sizeof(INSDAltSeqData));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* INSDAltSeqDataFree()
*
**************************************************/
NLM_EXTERN
-INSDTagsPtr LIBCALL
-INSDTagsFree(INSDTagsPtr ptr)
+INSDAltSeqDataPtr LIBCALL
+INSDAltSeqDataFree(INSDAltSeqDataPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- AsnGenericUserSeqOfFree(ptr, (AsnOptFreeFunc) INSDTagFree);
- return NULL;
+ MemFree(ptr -> name);
+ AsnGenericUserSeqOfFree(ptr -> items, (AsnOptFreeFunc) INSDAltSeqItemFree);
+ return MemFree(ptr);
}
/**************************************************
*
-* INSDTagsAsnRead()
+* INSDAltSeqDataAsnRead()
*
**************************************************/
NLM_EXTERN
-INSDTagsPtr LIBCALL
-INSDTagsAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+INSDAltSeqDataPtr LIBCALL
+INSDAltSeqDataAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
Boolean isError = FALSE;
AsnReadFunc func;
- INSDTagsPtr ptr;
+ INSDAltSeqDataPtr ptr;
if (! loaded)
{
@@ -1514,24 +1694,46 @@ INSDTagsAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* INSDTags ::= (self contained) */
- atp = AsnReadId(aip, amp, INSDTAGS);
+ if (orig == NULL) { /* INSDAltSeqData ::= (self contained) */
+ atp = AsnReadId(aip, amp, INSDALTSEQDATA);
} else {
- atp = AsnLinkType(orig, INSDTAGS);
+ atp = AsnLinkType(orig, INSDALTSEQDATA);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- func = NULL;
-
- ptr = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) INSDTagAsnRead, (AsnOptFreeFunc) INSDTagFree);
- if (isError && ptr == NULL) {
+ ptr = INSDAltSeqDataNew();
+ if (ptr == NULL) {
goto erret;
}
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+ if (atp == INSDALTSEQDATA_name) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> name = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == INSDALTSEQDATA_items) {
+ ptr -> items = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) INSDAltSeqItemAsnRead, (AsnOptFreeFunc) INSDAltSeqItemFree);
+ if (isError && ptr -> items == NULL) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
ret:
AsnUnlinkType(orig); /* unlink local tree */
@@ -1539,7 +1741,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = INSDTagsFree(ptr);
+ ptr = INSDAltSeqDataFree(ptr);
goto ret;
}
@@ -1547,11 +1749,11 @@ erret:
/**************************************************
*
-* INSDTagsAsnWrite()
+* INSDAltSeqDataAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-INSDTagsAsnWrite(INSDTagsPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+INSDAltSeqDataAsnWrite(INSDAltSeqDataPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -1568,13 +1770,24 @@ INSDTagsAsnWrite(INSDTagsPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, INSDTAGS); /* link local tree */
+ atp = AsnLinkType(orig, INSDALTSEQDATA); /* link local tree */
if (atp == NULL) {
return FALSE;
}
if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
- retval = AsnGenericUserSeqOfAsnWrite(ptr , (AsnWriteFunc) INSDTagAsnWrite, aip, atp, INSDTAGS_E);
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> name != NULL) {
+ av.ptrvalue = ptr -> name;
+ retval = AsnWrite(aip, INSDALTSEQDATA_name, &av);
+ }
+ AsnGenericUserSeqOfAsnWrite(ptr -> items, (AsnWriteFunc) INSDAltSeqItemAsnWrite, aip, INSDALTSEQDATA_items, INSDALTSEQDATA_items_E);
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
retval = TRUE;
erret:
@@ -1586,14 +1799,14 @@ erret:
/**************************************************
*
-* INSDTagNew()
+* INSDXrefNew()
*
**************************************************/
NLM_EXTERN
-INSDTagPtr LIBCALL
-INSDTagNew(void)
+INSDXrefPtr LIBCALL
+INSDXrefNew(void)
{
- INSDTagPtr ptr = MemNew((size_t) sizeof(INSDTag));
+ INSDXrefPtr ptr = MemNew((size_t) sizeof(INSDXref));
return ptr;
@@ -1602,38 +1815,36 @@ INSDTagNew(void)
/**************************************************
*
-* INSDTagFree()
+* INSDXrefFree()
*
**************************************************/
NLM_EXTERN
-INSDTagPtr LIBCALL
-INSDTagFree(INSDTagPtr ptr)
+INSDXrefPtr LIBCALL
+INSDXrefFree(INSDXrefPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- MemFree(ptr -> name);
- MemFree(ptr -> value);
- MemFree(ptr -> unit);
+ MemFree(ptr -> dbname);
+ MemFree(ptr -> id);
return MemFree(ptr);
}
/**************************************************
*
-* INSDTagAsnRead()
+* INSDXrefAsnRead()
*
**************************************************/
NLM_EXTERN
-INSDTagPtr LIBCALL
-INSDTagAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+INSDXrefPtr LIBCALL
+INSDXrefAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
- Boolean isError = FALSE;
AsnReadFunc func;
- INSDTagPtr ptr;
+ INSDXrefPtr ptr;
if (! loaded)
{
@@ -1646,17 +1857,17 @@ INSDTagAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* INSDTag ::= (self contained) */
- atp = AsnReadId(aip, amp, INSDTAG);
+ if (orig == NULL) { /* INSDXref ::= (self contained) */
+ atp = AsnReadId(aip, amp, INSDXREF);
} else {
- atp = AsnLinkType(orig, INSDTAG);
+ atp = AsnLinkType(orig, INSDXREF);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- ptr = INSDTagNew();
+ ptr = INSDXrefNew();
if (ptr == NULL) {
goto erret;
}
@@ -1667,25 +1878,18 @@ INSDTagAsnRead(AsnIoPtr aip, AsnTypePtr orig)
atp = AsnReadId(aip,amp, atp);
func = NULL;
- if (atp == INSDTAG_name) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
- goto erret;
- }
- ptr -> name = av.ptrvalue;
- atp = AsnReadId(aip,amp, atp);
- }
- if (atp == INSDTAG_value) {
+ if (atp == INSDXREF_dbname) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> value = av.ptrvalue;
+ ptr -> dbname = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDTAG_unit) {
+ if (atp == INSDXREF_id) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> unit = av.ptrvalue;
+ ptr -> id = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
@@ -1700,7 +1904,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = INSDTagFree(ptr);
+ ptr = INSDXrefFree(ptr);
goto ret;
}
@@ -1708,11 +1912,11 @@ erret:
/**************************************************
*
-* INSDTagAsnWrite()
+* INSDXrefAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-INSDTagAsnWrite(INSDTagPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+INSDXrefAsnWrite(INSDXrefPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -1729,7 +1933,7 @@ INSDTagAsnWrite(INSDTagPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, INSDTAG); /* link local tree */
+ atp = AsnLinkType(orig, INSDXREF); /* link local tree */
if (atp == NULL) {
return FALSE;
}
@@ -1739,17 +1943,13 @@ INSDTagAsnWrite(INSDTagPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
- if (ptr -> name != NULL) {
- av.ptrvalue = ptr -> name;
- retval = AsnWrite(aip, INSDTAG_name, &av);
- }
- if (ptr -> value != NULL) {
- av.ptrvalue = ptr -> value;
- retval = AsnWrite(aip, INSDTAG_value, &av);
+ if (ptr -> dbname != NULL) {
+ av.ptrvalue = ptr -> dbname;
+ retval = AsnWrite(aip, INSDXREF_dbname, &av);
}
- if (ptr -> unit != NULL) {
- av.ptrvalue = ptr -> unit;
- retval = AsnWrite(aip, INSDTAG_unit, &av);
+ if (ptr -> id != NULL) {
+ av.ptrvalue = ptr -> id;
+ retval = AsnWrite(aip, INSDXREF_id, &av);
}
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
@@ -1765,14 +1965,14 @@ erret:
/**************************************************
*
-* INSDIntervalNew()
+* INSDCommentParagraphNew()
*
**************************************************/
NLM_EXTERN
-INSDIntervalPtr LIBCALL
-INSDIntervalNew(void)
+INSDCommentParagraphPtr LIBCALL
+INSDCommentParagraphNew(void)
{
- INSDIntervalPtr ptr = MemNew((size_t) sizeof(INSDInterval));
+ INSDCommentParagraphPtr ptr = MemNew((size_t) sizeof(INSDCommentParagraph));
return ptr;
@@ -1781,36 +1981,36 @@ INSDIntervalNew(void)
/**************************************************
*
-* INSDIntervalFree()
+* INSDCommentParagraphFree()
*
**************************************************/
NLM_EXTERN
-INSDIntervalPtr LIBCALL
-INSDIntervalFree(INSDIntervalPtr ptr)
+INSDCommentParagraphPtr LIBCALL
+INSDCommentParagraphFree(INSDCommentParagraphPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- MemFree(ptr -> accession);
+ AsnGenericUserSeqOfFree(ptr -> items, (AsnOptFreeFunc) INSDCommentItemFree);
return MemFree(ptr);
}
/**************************************************
*
-* INSDIntervalAsnRead()
+* INSDCommentParagraphAsnRead()
*
**************************************************/
NLM_EXTERN
-INSDIntervalPtr LIBCALL
-INSDIntervalAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+INSDCommentParagraphPtr LIBCALL
+INSDCommentParagraphAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
Boolean isError = FALSE;
AsnReadFunc func;
- INSDIntervalPtr ptr;
+ INSDCommentParagraphPtr ptr;
if (! loaded)
{
@@ -1823,17 +2023,17 @@ INSDIntervalAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* INSDInterval ::= (self contained) */
- atp = AsnReadId(aip, amp, INSDINTERVAL);
+ if (orig == NULL) { /* INSDCommentParagraph ::= (self contained) */
+ atp = AsnReadId(aip, amp, INSDCOMMENTPARAGRAPH);
} else {
- atp = AsnLinkType(orig, INSDINTERVAL);
+ atp = AsnLinkType(orig, INSDCOMMENTPARAGRAPH);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- ptr = INSDIntervalNew();
+ ptr = INSDCommentParagraphNew();
if (ptr == NULL) {
goto erret;
}
@@ -1844,51 +2044,169 @@ INSDIntervalAsnRead(AsnIoPtr aip, AsnTypePtr orig)
atp = AsnReadId(aip,amp, atp);
func = NULL;
- if (atp == INSDINTERVAL_from) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
+ if (atp == INSDCOMMENTPARAGRAPH_items) {
+ ptr -> items = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) INSDCommentItemAsnRead, (AsnOptFreeFunc) INSDCommentItemFree);
+ if (isError && ptr -> items == NULL) {
goto erret;
}
- ptr -> from = av.intvalue;
- ptr -> OBbits__ |= 1<<0;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDINTERVAL_to) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
- goto erret;
- }
- ptr -> to = av.intvalue;
- ptr -> OBbits__ |= 1<<1;
- atp = AsnReadId(aip,amp, atp);
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
}
- if (atp == INSDINTERVAL_point) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
- goto erret;
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = INSDCommentParagraphFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* INSDCommentParagraphAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+INSDCommentParagraphAsnWrite(INSDCommentParagraphPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! objinsdseqAsnLoad()) {
+ return FALSE;
}
- ptr -> point = av.intvalue;
- ptr -> OBbits__ |= 1<<2;
- atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDINTERVAL_iscomp) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
- goto erret;
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, INSDCOMMENTPARAGRAPH); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ AsnGenericUserSeqOfAsnWrite(ptr -> items, (AsnWriteFunc) INSDCommentItemAsnWrite, aip, INSDCOMMENTPARAGRAPH_items, INSDCOMMENTPARAGRAPH_items_E);
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* INSDCommentItemNew()
+*
+**************************************************/
+NLM_EXTERN
+INSDCommentItemPtr LIBCALL
+INSDCommentItemNew(void)
+{
+ INSDCommentItemPtr ptr = MemNew((size_t) sizeof(INSDCommentItem));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* INSDCommentItemFree()
+*
+**************************************************/
+NLM_EXTERN
+INSDCommentItemPtr LIBCALL
+INSDCommentItemFree(INSDCommentItemPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ MemFree(ptr -> value);
+ MemFree(ptr -> url);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* INSDCommentItemAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+INSDCommentItemPtr LIBCALL
+INSDCommentItemAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ AsnReadFunc func;
+ INSDCommentItemPtr ptr;
+
+ if (! loaded)
+ {
+ if (! objinsdseqAsnLoad()) {
+ return NULL;
}
- ptr -> iscomp = av.boolvalue;
- ptr -> OBbits__ |= 1<<3;
- atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDINTERVAL_interbp) {
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* INSDCommentItem ::= (self contained) */
+ atp = AsnReadId(aip, amp, INSDCOMMENTITEM);
+ } else {
+ atp = AsnLinkType(orig, INSDCOMMENTITEM);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = INSDCommentItemNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == INSDCOMMENTITEM_value) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> interbp = av.boolvalue;
- ptr -> OBbits__ |= 1<<4;
+ ptr -> value = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDINTERVAL_accession) {
+ if (atp == INSDCOMMENTITEM_url) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> accession = av.ptrvalue;
+ ptr -> url = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
@@ -1903,7 +2221,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = INSDIntervalFree(ptr);
+ ptr = INSDCommentItemFree(ptr);
goto ret;
}
@@ -1911,11 +2229,11 @@ erret:
/**************************************************
*
-* INSDIntervalAsnWrite()
+* INSDCommentItemAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-INSDIntervalAsnWrite(INSDIntervalPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+INSDCommentItemAsnWrite(INSDCommentItemPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -1932,7 +2250,7 @@ INSDIntervalAsnWrite(INSDIntervalPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, INSDINTERVAL); /* link local tree */
+ atp = AsnLinkType(orig, INSDCOMMENTITEM); /* link local tree */
if (atp == NULL) {
return FALSE;
}
@@ -1942,24 +2260,13 @@ INSDIntervalAsnWrite(INSDIntervalPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
- if (ptr -> from || (ptr -> OBbits__ & (1<<0) )){ av.intvalue = ptr -> from;
- retval = AsnWrite(aip, INSDINTERVAL_from, &av);
- }
- if (ptr -> to || (ptr -> OBbits__ & (1<<1) )){ av.intvalue = ptr -> to;
- retval = AsnWrite(aip, INSDINTERVAL_to, &av);
- }
- if (ptr -> point || (ptr -> OBbits__ & (1<<2) )){ av.intvalue = ptr -> point;
- retval = AsnWrite(aip, INSDINTERVAL_point, &av);
- }
- if (ptr -> iscomp || (ptr -> OBbits__ & (1<<3) )){ av.boolvalue = ptr -> iscomp;
- retval = AsnWrite(aip, INSDINTERVAL_iscomp, &av);
- }
- if (ptr -> interbp || (ptr -> OBbits__ & (1<<4) )){ av.boolvalue = ptr -> interbp;
- retval = AsnWrite(aip, INSDINTERVAL_interbp, &av);
+ if (ptr -> value != NULL) {
+ av.ptrvalue = ptr -> value;
+ retval = AsnWrite(aip, INSDCOMMENTITEM_value, &av);
}
- if (ptr -> accession != NULL) {
- av.ptrvalue = ptr -> accession;
- retval = AsnWrite(aip, INSDINTERVAL_accession, &av);
+ if (ptr -> url != NULL) {
+ av.ptrvalue = ptr -> url;
+ retval = AsnWrite(aip, INSDCOMMENTITEM_url, &av);
}
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
@@ -1975,14 +2282,14 @@ erret:
/**************************************************
*
-* INSDQualifierNew()
+* INSDStrucCommentItemNew()
*
**************************************************/
NLM_EXTERN
-INSDQualifierPtr LIBCALL
-INSDQualifierNew(void)
+INSDStrucCommentItemPtr LIBCALL
+INSDStrucCommentItemNew(void)
{
- INSDQualifierPtr ptr = MemNew((size_t) sizeof(INSDQualifier));
+ INSDStrucCommentItemPtr ptr = MemNew((size_t) sizeof(INSDStrucCommentItem));
return ptr;
@@ -1991,37 +2298,37 @@ INSDQualifierNew(void)
/**************************************************
*
-* INSDQualifierFree()
+* INSDStrucCommentItemFree()
*
**************************************************/
NLM_EXTERN
-INSDQualifierPtr LIBCALL
-INSDQualifierFree(INSDQualifierPtr ptr)
+INSDStrucCommentItemPtr LIBCALL
+INSDStrucCommentItemFree(INSDStrucCommentItemPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- MemFree(ptr -> name);
+ MemFree(ptr -> tag);
MemFree(ptr -> value);
+ MemFree(ptr -> url);
return MemFree(ptr);
}
/**************************************************
*
-* INSDQualifierAsnRead()
+* INSDStrucCommentItemAsnRead()
*
**************************************************/
NLM_EXTERN
-INSDQualifierPtr LIBCALL
-INSDQualifierAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+INSDStrucCommentItemPtr LIBCALL
+INSDStrucCommentItemAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
- Boolean isError = FALSE;
AsnReadFunc func;
- INSDQualifierPtr ptr;
+ INSDStrucCommentItemPtr ptr;
if (! loaded)
{
@@ -2034,17 +2341,17 @@ INSDQualifierAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* INSDQualifier ::= (self contained) */
- atp = AsnReadId(aip, amp, INSDQUALIFIER);
+ if (orig == NULL) { /* INSDStrucCommentItem ::= (self contained) */
+ atp = AsnReadId(aip, amp, INSDSTRUCCOMMENTITEM);
} else {
- atp = AsnLinkType(orig, INSDQUALIFIER);
+ atp = AsnLinkType(orig, INSDSTRUCCOMMENTITEM);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- ptr = INSDQualifierNew();
+ ptr = INSDStrucCommentItemNew();
if (ptr == NULL) {
goto erret;
}
@@ -2055,20 +2362,27 @@ INSDQualifierAsnRead(AsnIoPtr aip, AsnTypePtr orig)
atp = AsnReadId(aip,amp, atp);
func = NULL;
- if (atp == INSDQUALIFIER_name) {
+ if (atp == INSDSTRUCCOMMENTITEM_tag) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> name = av.ptrvalue;
+ ptr -> tag = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDQUALIFIER_value) {
+ if (atp == INSDSTRUCCOMMENTITEM_value) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
ptr -> value = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == INSDSTRUCCOMMENTITEM_url) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> url = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
if (AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -2081,7 +2395,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = INSDQualifierFree(ptr);
+ ptr = INSDStrucCommentItemFree(ptr);
goto ret;
}
@@ -2089,11 +2403,11 @@ erret:
/**************************************************
*
-* INSDQualifierAsnWrite()
+* INSDStrucCommentItemAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-INSDQualifierAsnWrite(INSDQualifierPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+INSDStrucCommentItemAsnWrite(INSDStrucCommentItemPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -2110,7 +2424,7 @@ INSDQualifierAsnWrite(INSDQualifierPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, INSDQUALIFIER); /* link local tree */
+ atp = AsnLinkType(orig, INSDSTRUCCOMMENTITEM); /* link local tree */
if (atp == NULL) {
return FALSE;
}
@@ -2120,13 +2434,17 @@ INSDQualifierAsnWrite(INSDQualifierPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
- if (ptr -> name != NULL) {
- av.ptrvalue = ptr -> name;
- retval = AsnWrite(aip, INSDQUALIFIER_name, &av);
+ if (ptr -> tag != NULL) {
+ av.ptrvalue = ptr -> tag;
+ retval = AsnWrite(aip, INSDSTRUCCOMMENTITEM_tag, &av);
}
if (ptr -> value != NULL) {
av.ptrvalue = ptr -> value;
- retval = AsnWrite(aip, INSDQUALIFIER_value, &av);
+ retval = AsnWrite(aip, INSDSTRUCCOMMENTITEM_value, &av);
+ }
+ if (ptr -> url != NULL) {
+ av.ptrvalue = ptr -> url;
+ retval = AsnWrite(aip, INSDSTRUCCOMMENTITEM_url, &av);
}
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
@@ -2142,14 +2460,14 @@ erret:
/**************************************************
*
-* INSDTagsetRulesNew()
+* INSDIntervalNew()
*
**************************************************/
NLM_EXTERN
-INSDTagsetRulesPtr LIBCALL
-INSDTagsetRulesNew(void)
+INSDIntervalPtr LIBCALL
+INSDIntervalNew(void)
{
- INSDTagsetRulesPtr ptr = MemNew((size_t) sizeof(INSDTagsetRules));
+ INSDIntervalPtr ptr = MemNew((size_t) sizeof(INSDInterval));
return ptr;
@@ -2158,40 +2476,35 @@ INSDTagsetRulesNew(void)
/**************************************************
*
-* INSDTagsetRulesFree()
+* INSDIntervalFree()
*
**************************************************/
NLM_EXTERN
-INSDTagsetRulesPtr LIBCALL
-INSDTagsetRulesFree(INSDTagsetRulesPtr ptr)
+INSDIntervalPtr LIBCALL
+INSDIntervalFree(INSDIntervalPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- MemFree(ptr -> authority);
- MemFree(ptr -> version);
- INSDTagNamesFree(ptr -> mandatorytags);
- INSDTagNamesFree(ptr -> optionaltags);
- INSDTagNamesFree(ptr -> uniquetags);
+ MemFree(ptr -> accession);
return MemFree(ptr);
}
/**************************************************
*
-* INSDTagsetRulesAsnRead()
+* INSDIntervalAsnRead()
*
**************************************************/
NLM_EXTERN
-INSDTagsetRulesPtr LIBCALL
-INSDTagsetRulesAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+INSDIntervalPtr LIBCALL
+INSDIntervalAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
- Boolean isError = FALSE;
AsnReadFunc func;
- INSDTagsetRulesPtr ptr;
+ INSDIntervalPtr ptr;
if (! loaded)
{
@@ -2204,17 +2517,17 @@ INSDTagsetRulesAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* INSDTagsetRules ::= (self contained) */
- atp = AsnReadId(aip, amp, INSDTAGSETRULES);
+ if (orig == NULL) { /* INSDInterval ::= (self contained) */
+ atp = AsnReadId(aip, amp, INSDINTERVAL);
} else {
- atp = AsnLinkType(orig, INSDTAGSETRULES);
+ atp = AsnLinkType(orig, INSDINTERVAL);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- ptr = INSDTagsetRulesNew();
+ ptr = INSDIntervalNew();
if (ptr == NULL) {
goto erret;
}
@@ -2225,47 +2538,51 @@ INSDTagsetRulesAsnRead(AsnIoPtr aip, AsnTypePtr orig)
atp = AsnReadId(aip,amp, atp);
func = NULL;
- if (atp == INSDTAGSETRULES_authority) {
+ if (atp == INSDINTERVAL_from) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> authority = av.ptrvalue;
+ ptr -> from = av.intvalue;
+ ptr -> OBbits__ |= 1<<0;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDTAGSETRULES_version) {
+ if (atp == INSDINTERVAL_to) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> version = av.ptrvalue;
+ ptr -> to = av.intvalue;
+ ptr -> OBbits__ |= 1<<1;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDTAGSETRULES_mandatorytags) {
- ptr -> mandatorytags = INSDTagNamesAsnRead(aip, atp);
- if (aip -> io_failure) {
+ if (atp == INSDINTERVAL_point) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
+ ptr -> point = av.intvalue;
+ ptr -> OBbits__ |= 1<<2;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDTAGSETRULES_optionaltags) {
- ptr -> optionaltags = INSDTagNamesAsnRead(aip, atp);
- if (aip -> io_failure) {
+ if (atp == INSDINTERVAL_iscomp) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
+ ptr -> iscomp = av.boolvalue;
+ ptr -> OBbits__ |= 1<<3;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDTAGSETRULES_uniquetags) {
- ptr -> uniquetags = INSDTagNamesAsnRead(aip, atp);
- if (aip -> io_failure) {
+ if (atp == INSDINTERVAL_interbp) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
+ ptr -> interbp = av.boolvalue;
+ ptr -> OBbits__ |= 1<<4;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == INSDTAGSETRULES_extensible) {
+ if (atp == INSDINTERVAL_accession) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
}
- ptr -> extensible = av.boolvalue;
- ptr -> OBbits__ |= 1<<0;
+ ptr -> accession = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
@@ -2280,7 +2597,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = INSDTagsetRulesFree(ptr);
+ ptr = INSDIntervalFree(ptr);
goto ret;
}
@@ -2288,11 +2605,11 @@ erret:
/**************************************************
*
-* INSDTagsetRulesAsnWrite()
+* INSDIntervalAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-INSDTagsetRulesAsnWrite(INSDTagsetRulesPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+INSDIntervalAsnWrite(INSDIntervalPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -2309,7 +2626,7 @@ INSDTagsetRulesAsnWrite(INSDTagsetRulesPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, INSDTAGSETRULES); /* link local tree */
+ atp = AsnLinkType(orig, INSDINTERVAL); /* link local tree */
if (atp == NULL) {
return FALSE;
}
@@ -2319,31 +2636,24 @@ INSDTagsetRulesAsnWrite(INSDTagsetRulesPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
- if (ptr -> authority != NULL) {
- av.ptrvalue = ptr -> authority;
- retval = AsnWrite(aip, INSDTAGSETRULES_authority, &av);
+ if (ptr -> from || (ptr -> OBbits__ & (1<<0) )){ av.intvalue = ptr -> from;
+ retval = AsnWrite(aip, INSDINTERVAL_from, &av);
}
- if (ptr -> version != NULL) {
- av.ptrvalue = ptr -> version;
- retval = AsnWrite(aip, INSDTAGSETRULES_version, &av);
+ if (ptr -> to || (ptr -> OBbits__ & (1<<1) )){ av.intvalue = ptr -> to;
+ retval = AsnWrite(aip, INSDINTERVAL_to, &av);
}
- if (ptr -> mandatorytags != NULL) {
- if ( ! INSDTagNamesAsnWrite(ptr -> mandatorytags, aip, INSDTAGSETRULES_mandatorytags)) {
- goto erret;
- }
+ if (ptr -> point || (ptr -> OBbits__ & (1<<2) )){ av.intvalue = ptr -> point;
+ retval = AsnWrite(aip, INSDINTERVAL_point, &av);
}
- if (ptr -> optionaltags != NULL) {
- if ( ! INSDTagNamesAsnWrite(ptr -> optionaltags, aip, INSDTAGSETRULES_optionaltags)) {
- goto erret;
- }
+ if (ptr -> iscomp || (ptr -> OBbits__ & (1<<3) )){ av.boolvalue = ptr -> iscomp;
+ retval = AsnWrite(aip, INSDINTERVAL_iscomp, &av);
}
- if (ptr -> uniquetags != NULL) {
- if ( ! INSDTagNamesAsnWrite(ptr -> uniquetags, aip, INSDTAGSETRULES_uniquetags)) {
- goto erret;
- }
+ if (ptr -> interbp || (ptr -> OBbits__ & (1<<4) )){ av.boolvalue = ptr -> interbp;
+ retval = AsnWrite(aip, INSDINTERVAL_interbp, &av);
}
- if (ptr -> extensible || (ptr -> OBbits__ & (1<<0) )){ av.boolvalue = ptr -> extensible;
- retval = AsnWrite(aip, INSDTAGSETRULES_extensible, &av);
+ if (ptr -> accession != NULL) {
+ av.ptrvalue = ptr -> accession;
+ retval = AsnWrite(aip, INSDINTERVAL_accession, &av);
}
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
@@ -2359,36 +2669,52 @@ erret:
/**************************************************
*
-* INSDTagNamesFree()
+* INSDQualifierNew()
+*
+**************************************************/
+NLM_EXTERN
+INSDQualifierPtr LIBCALL
+INSDQualifierNew(void)
+{
+ INSDQualifierPtr ptr = MemNew((size_t) sizeof(INSDQualifier));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* INSDQualifierFree()
*
**************************************************/
NLM_EXTERN
-INSDTagNamesPtr LIBCALL
-INSDTagNamesFree(INSDTagNamesPtr ptr)
+INSDQualifierPtr LIBCALL
+INSDQualifierFree(INSDQualifierPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- AsnGenericBaseSeqOfFree(ptr,ASNCODE_PTRVAL_SLOT);
- return NULL;
+ MemFree(ptr -> name);
+ MemFree(ptr -> value);
+ return MemFree(ptr);
}
/**************************************************
*
-* INSDTagNamesAsnRead()
+* INSDQualifierAsnRead()
*
**************************************************/
NLM_EXTERN
-INSDTagNamesPtr LIBCALL
-INSDTagNamesAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+INSDQualifierPtr LIBCALL
+INSDQualifierAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
- Boolean isError = FALSE;
AsnReadFunc func;
- INSDTagNamesPtr ptr;
+ INSDQualifierPtr ptr;
if (! loaded)
{
@@ -2401,24 +2727,46 @@ INSDTagNamesAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* INSDTagNames ::= (self contained) */
- atp = AsnReadId(aip, amp, INSDTAGNAMES);
+ if (orig == NULL) { /* INSDQualifier ::= (self contained) */
+ atp = AsnReadId(aip, amp, INSDQUALIFIER);
} else {
- atp = AsnLinkType(orig, INSDTAGNAMES);
+ atp = AsnLinkType(orig, INSDQUALIFIER);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- func = NULL;
-
- ptr = AsnGenericBaseSeqOfAsnRead(aip, amp, atp, ASNCODE_PTRVAL_SLOT, &isError);
- if (isError && ptr == NULL) {
+ ptr = INSDQualifierNew();
+ if (ptr == NULL) {
goto erret;
}
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+ if (atp == INSDQUALIFIER_name) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> name = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == INSDQUALIFIER_value) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> value = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
ret:
AsnUnlinkType(orig); /* unlink local tree */
@@ -2426,7 +2774,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = INSDTagNamesFree(ptr);
+ ptr = INSDQualifierFree(ptr);
goto ret;
}
@@ -2434,11 +2782,11 @@ erret:
/**************************************************
*
-* INSDTagNamesAsnWrite()
+* INSDQualifierAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-INSDTagNamesAsnWrite(INSDTagNamesPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+INSDQualifierAsnWrite(INSDQualifierPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -2455,13 +2803,27 @@ INSDTagNamesAsnWrite(INSDTagNamesPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
return FALSE;
}
- atp = AsnLinkType(orig, INSDTAGNAMES); /* link local tree */
+ atp = AsnLinkType(orig, INSDQUALIFIER); /* link local tree */
if (atp == NULL) {
return FALSE;
}
if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
- retval = AsnGenericBaseSeqOfAsnWrite(ptr, ASNCODE_PTRVAL_SLOT, aip, atp, INSDTAGNAMES_E);
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> name != NULL) {
+ av.ptrvalue = ptr -> name;
+ retval = AsnWrite(aip, INSDQUALIFIER_name, &av);
+ }
+ if (ptr -> value != NULL) {
+ av.ptrvalue = ptr -> value;
+ retval = AsnWrite(aip, INSDQUALIFIER_value, &av);
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
retval = TRUE;
erret:
@@ -2473,36 +2835,57 @@ erret:
/**************************************************
*
-* INSDTagsetRuleSetFree()
+* INSDAltSeqItemNew()
*
**************************************************/
NLM_EXTERN
-INSDTagsetRuleSetPtr LIBCALL
-INSDTagsetRuleSetFree(INSDTagsetRuleSetPtr ptr)
+INSDAltSeqItemPtr LIBCALL
+INSDAltSeqItemNew(void)
+{
+ INSDAltSeqItemPtr ptr = MemNew((size_t) sizeof(INSDAltSeqItem));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* INSDAltSeqItemFree()
+*
+**************************************************/
+NLM_EXTERN
+INSDAltSeqItemPtr LIBCALL
+INSDAltSeqItemFree(INSDAltSeqItemPtr ptr)
{
if(ptr == NULL) {
return NULL;
}
- AsnGenericUserSeqOfFree(ptr, (AsnOptFreeFunc) INSDTagsetRulesFree);
- return NULL;
+ INSDIntervalFree(ptr -> interval);
+ MemFree(ptr -> gap_type);
+ MemFree(ptr -> gap_linkage);
+ MemFree(ptr -> gap_comment);
+ MemFree(ptr -> first_accn);
+ MemFree(ptr -> last_accn);
+ MemFree(ptr -> value);
+ return MemFree(ptr);
}
/**************************************************
*
-* INSDTagsetRuleSetAsnRead()
+* INSDAltSeqItemAsnRead()
*
**************************************************/
NLM_EXTERN
-INSDTagsetRuleSetPtr LIBCALL
-INSDTagsetRuleSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+INSDAltSeqItemPtr LIBCALL
+INSDAltSeqItemAsnRead(AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
- Boolean isError = FALSE;
AsnReadFunc func;
- INSDTagsetRuleSetPtr ptr;
+ INSDAltSeqItemPtr ptr;
if (! loaded)
{
@@ -2515,24 +2898,97 @@ INSDTagsetRuleSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
return NULL;
}
- if (orig == NULL) { /* INSDTagsetRuleSet ::= (self contained) */
- atp = AsnReadId(aip, amp, INSDTAGSETRULESET);
+ if (orig == NULL) { /* INSDAltSeqItem ::= (self contained) */
+ atp = AsnReadId(aip, amp, INSDALTSEQITEM);
} else {
- atp = AsnLinkType(orig, INSDTAGSETRULESET);
+ atp = AsnLinkType(orig, INSDALTSEQITEM);
}
/* link in local tree */
if (atp == NULL) {
return NULL;
}
- func = NULL;
-
- ptr = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) INSDTagsetRulesAsnRead, (AsnOptFreeFunc) INSDTagsetRulesFree);
- if (isError && ptr == NULL) {
+ ptr = INSDAltSeqItemNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
goto erret;
}
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == INSDALTSEQITEM_interval) {
+ ptr -> interval = INSDIntervalAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == INSDALTSEQITEM_isgap) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> isgap = av.boolvalue;
+ ptr -> OBbits__ |= 1<<0;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == INSDALTSEQITEM_gap_length) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> gap_length = av.intvalue;
+ ptr -> OBbits__ |= 1<<1;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == INSDALTSEQITEM_gap_type) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> gap_type = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == INSDALTSEQITEM_gap_linkage) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> gap_linkage = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == INSDALTSEQITEM_gap_comment) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> gap_comment = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == INSDALTSEQITEM_first_accn) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> first_accn = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == INSDALTSEQITEM_last_accn) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> last_accn = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == INSDALTSEQITEM_value) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> value = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
ret:
AsnUnlinkType(orig); /* unlink local tree */
@@ -2540,7 +2996,7 @@ ret:
erret:
aip -> io_failure = TRUE;
- ptr = INSDTagsetRuleSetFree(ptr);
+ ptr = INSDAltSeqItemFree(ptr);
goto ret;
}
@@ -2548,11 +3004,11 @@ erret:
/**************************************************
*
-* INSDTagsetRuleSetAsnWrite()
+* INSDAltSeqItemAsnWrite()
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
-INSDTagsetRuleSetAsnWrite(INSDTagsetRuleSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+INSDAltSeqItemAsnWrite(INSDAltSeqItemPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
AsnTypePtr atp;
@@ -2569,13 +3025,54 @@ INSDTagsetRuleSetAsnWrite(INSDTagsetRuleSetPtr ptr, AsnIoPtr aip, AsnTypePtr ori
return FALSE;
}
- atp = AsnLinkType(orig, INSDTAGSETRULESET); /* link local tree */
+ atp = AsnLinkType(orig, INSDALTSEQITEM); /* link local tree */
if (atp == NULL) {
return FALSE;
}
if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
- retval = AsnGenericUserSeqOfAsnWrite(ptr , (AsnWriteFunc) INSDTagsetRulesAsnWrite, aip, atp, INSDTAGSETRULESET_E);
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> interval != NULL) {
+ if ( ! INSDIntervalAsnWrite(ptr -> interval, aip, INSDALTSEQITEM_interval)) {
+ goto erret;
+ }
+ }
+ if (ptr -> isgap || (ptr -> OBbits__ & (1<<0) )){ av.boolvalue = ptr -> isgap;
+ retval = AsnWrite(aip, INSDALTSEQITEM_isgap, &av);
+ }
+ if (ptr -> gap_length || (ptr -> OBbits__ & (1<<1) )){ av.intvalue = ptr -> gap_length;
+ retval = AsnWrite(aip, INSDALTSEQITEM_gap_length, &av);
+ }
+ if (ptr -> gap_type != NULL) {
+ av.ptrvalue = ptr -> gap_type;
+ retval = AsnWrite(aip, INSDALTSEQITEM_gap_type, &av);
+ }
+ if (ptr -> gap_linkage != NULL) {
+ av.ptrvalue = ptr -> gap_linkage;
+ retval = AsnWrite(aip, INSDALTSEQITEM_gap_linkage, &av);
+ }
+ if (ptr -> gap_comment != NULL) {
+ av.ptrvalue = ptr -> gap_comment;
+ retval = AsnWrite(aip, INSDALTSEQITEM_gap_comment, &av);
+ }
+ if (ptr -> first_accn != NULL) {
+ av.ptrvalue = ptr -> first_accn;
+ retval = AsnWrite(aip, INSDALTSEQITEM_first_accn, &av);
+ }
+ if (ptr -> last_accn != NULL) {
+ av.ptrvalue = ptr -> last_accn;
+ retval = AsnWrite(aip, INSDALTSEQITEM_last_accn, &av);
+ }
+ if (ptr -> value != NULL) {
+ av.ptrvalue = ptr -> value;
+ retval = AsnWrite(aip, INSDALTSEQITEM_value, &av);
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
retval = TRUE;
erret:
diff --git a/object/objinsdseq.h b/object/objinsdseq.h
index f7e3b1e2..f35ab766 100644
--- a/object/objinsdseq.h
+++ b/object/objinsdseq.h
@@ -17,7 +17,7 @@ extern "C" { /* } */
/**************************************************
*
* Generated objects for Module INSD-INSDSeq
-* Generated using ASNCODE Revision: 6.16 at Jan 15, 2009 2:16 PM
+* Generated using ASNCODE Revision: 6.17 at May 26, 2010 12:38 PM
*
**************************************************/
@@ -77,13 +77,16 @@ typedef struct struct_INSDSeq {
CharPtr taxonomy;
struct struct_INSDReference PNTR references;
CharPtr comment;
- struct struct_INSDTagset PNTR tagset;
+ struct struct_INSDComment PNTR comment_set;
+ struct struct_INSDStrucComment PNTR struc_comments;
CharPtr primary;
CharPtr source_db;
CharPtr database_reference;
struct struct_INSDFeature PNTR feature_table;
+ struct struct_INSDFeatureSet PNTR feature_set;
CharPtr sequence;
CharPtr contig;
+ struct struct_INSDAltSeqData PNTR alt_seq;
} INSDSeq, PNTR INSDSeqPtr;
@@ -125,22 +128,41 @@ NLM_EXTERN Boolean LIBCALL INSDReferenceAsnWrite PROTO (( INSDReferencePtr , Asn
/**************************************************
*
-* INSDTagset
+* INSDComment
*
**************************************************/
-typedef struct struct_INSDTagset {
+typedef struct struct_INSDComment {
+ struct struct_INSDComment PNTR next;
Uint4 OBbits__;
- CharPtr authority;
- CharPtr version;
- CharPtr url;
- struct struct_INSDTag PNTR tags;
-} INSDTagset, PNTR INSDTagsetPtr;
+ CharPtr type;
+ struct struct_INSDCommentParagraph PNTR paragraphs;
+} INSDComment, PNTR INSDCommentPtr;
-NLM_EXTERN INSDTagsetPtr LIBCALL INSDTagsetFree PROTO ((INSDTagsetPtr ));
-NLM_EXTERN INSDTagsetPtr LIBCALL INSDTagsetNew PROTO (( void ));
-NLM_EXTERN INSDTagsetPtr LIBCALL INSDTagsetAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
-NLM_EXTERN Boolean LIBCALL INSDTagsetAsnWrite PROTO (( INSDTagsetPtr , AsnIoPtr, AsnTypePtr));
+NLM_EXTERN INSDCommentPtr LIBCALL INSDCommentFree PROTO ((INSDCommentPtr ));
+NLM_EXTERN INSDCommentPtr LIBCALL INSDCommentNew PROTO (( void ));
+NLM_EXTERN INSDCommentPtr LIBCALL INSDCommentAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL INSDCommentAsnWrite PROTO (( INSDCommentPtr , AsnIoPtr, AsnTypePtr));
+
+
+
+/**************************************************
+*
+* INSDStrucComment
+*
+**************************************************/
+typedef struct struct_INSDStrucComment {
+ struct struct_INSDStrucComment PNTR next;
+ Uint4 OBbits__;
+ CharPtr name;
+ struct struct_INSDStrucCommentItem PNTR items;
+} INSDStrucComment, PNTR INSDStrucCommentPtr;
+
+
+NLM_EXTERN INSDStrucCommentPtr LIBCALL INSDStrucCommentFree PROTO ((INSDStrucCommentPtr ));
+NLM_EXTERN INSDStrucCommentPtr LIBCALL INSDStrucCommentNew PROTO (( void ));
+NLM_EXTERN INSDStrucCommentPtr LIBCALL INSDStrucCommentAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL INSDStrucCommentAsnWrite PROTO (( INSDStrucCommentPtr , AsnIoPtr, AsnTypePtr));
@@ -163,6 +185,7 @@ typedef struct struct_INSDFeature {
Uint1 partial3;
struct struct_INSDQualifier PNTR quals;
+ struct struct_INSDXref PNTR xrefs;
} INSDFeature, PNTR INSDFeaturePtr;
@@ -175,6 +198,46 @@ NLM_EXTERN Boolean LIBCALL INSDFeatureAsnWrite PROTO (( INSDFeaturePtr , AsnIoPt
/**************************************************
*
+* INSDFeatureSet
+*
+**************************************************/
+typedef struct struct_INSDFeatureSet {
+ struct struct_INSDFeatureSet PNTR next;
+ Uint4 OBbits__;
+ CharPtr annot_source;
+ struct struct_INSDFeature PNTR features;
+} INSDFeatureSet, PNTR INSDFeatureSetPtr;
+
+
+NLM_EXTERN INSDFeatureSetPtr LIBCALL INSDFeatureSetFree PROTO ((INSDFeatureSetPtr ));
+NLM_EXTERN INSDFeatureSetPtr LIBCALL INSDFeatureSetNew PROTO (( void ));
+NLM_EXTERN INSDFeatureSetPtr LIBCALL INSDFeatureSetAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL INSDFeatureSetAsnWrite PROTO (( INSDFeatureSetPtr , AsnIoPtr, AsnTypePtr));
+
+
+
+/**************************************************
+*
+* INSDAltSeqData
+*
+**************************************************/
+typedef struct struct_INSDAltSeqData {
+ struct struct_INSDAltSeqData PNTR next;
+ Uint4 OBbits__;
+ CharPtr name;
+ struct struct_INSDAltSeqItem PNTR items;
+} INSDAltSeqData, PNTR INSDAltSeqDataPtr;
+
+
+NLM_EXTERN INSDAltSeqDataPtr LIBCALL INSDAltSeqDataFree PROTO ((INSDAltSeqDataPtr ));
+NLM_EXTERN INSDAltSeqDataPtr LIBCALL INSDAltSeqDataNew PROTO (( void ));
+NLM_EXTERN INSDAltSeqDataPtr LIBCALL INSDAltSeqDataAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL INSDAltSeqDataAsnWrite PROTO (( INSDAltSeqDataPtr , AsnIoPtr, AsnTypePtr));
+
+
+
+/**************************************************
+*
* INSDXref
*
**************************************************/
@@ -195,42 +258,61 @@ NLM_EXTERN Boolean LIBCALL INSDXrefAsnWrite PROTO (( INSDXrefPtr , AsnIoPtr, Asn
/**************************************************
*
-* INSDTags
+* INSDCommentParagraph
*
**************************************************/
-typedef struct struct_INSDTag INSDTags;
-typedef struct struct_INSDTag PNTR INSDTagsPtr;
-#define INSDTagsNew() INSDTagNew()
+typedef struct struct_INSDCommentParagraph {
+ struct struct_INSDCommentParagraph PNTR next;
+ Uint4 OBbits__;
+ struct struct_INSDCommentItem PNTR items;
+} INSDCommentParagraph, PNTR INSDCommentParagraphPtr;
-#ifdef NLM_GENERATED_CODE_PROTO
-NLM_EXTERN INSDTagsPtr LIBCALL INSDTagsFree PROTO ((INSDTagsPtr ));
-NLM_EXTERN INSDTagsPtr LIBCALL INSDTagsNew PROTO (( void ));
-NLM_EXTERN INSDTagsPtr LIBCALL INSDTagsAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
-NLM_EXTERN Boolean LIBCALL INSDTagsAsnWrite PROTO (( INSDTagsPtr , AsnIoPtr, AsnTypePtr));
+NLM_EXTERN INSDCommentParagraphPtr LIBCALL INSDCommentParagraphFree PROTO ((INSDCommentParagraphPtr ));
+NLM_EXTERN INSDCommentParagraphPtr LIBCALL INSDCommentParagraphNew PROTO (( void ));
+NLM_EXTERN INSDCommentParagraphPtr LIBCALL INSDCommentParagraphAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL INSDCommentParagraphAsnWrite PROTO (( INSDCommentParagraphPtr , AsnIoPtr, AsnTypePtr));
-#endif /* NLM_GENERATED_CODE_PROTO */
+
+
+/**************************************************
+*
+* INSDCommentItem
+*
+**************************************************/
+typedef struct struct_INSDCommentItem {
+ struct struct_INSDCommentItem PNTR next;
+ Uint4 OBbits__;
+ CharPtr value;
+ CharPtr url;
+} INSDCommentItem, PNTR INSDCommentItemPtr;
+
+
+NLM_EXTERN INSDCommentItemPtr LIBCALL INSDCommentItemFree PROTO ((INSDCommentItemPtr ));
+NLM_EXTERN INSDCommentItemPtr LIBCALL INSDCommentItemNew PROTO (( void ));
+NLM_EXTERN INSDCommentItemPtr LIBCALL INSDCommentItemAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL INSDCommentItemAsnWrite PROTO (( INSDCommentItemPtr , AsnIoPtr, AsnTypePtr));
/**************************************************
*
-* INSDTag
+* INSDStrucCommentItem
*
**************************************************/
-typedef struct struct_INSDTag {
- struct struct_INSDTag PNTR next;
+typedef struct struct_INSDStrucCommentItem {
+ struct struct_INSDStrucCommentItem PNTR next;
Uint4 OBbits__;
- CharPtr name;
+ CharPtr tag;
CharPtr value;
- CharPtr unit;
-} INSDTag, PNTR INSDTagPtr;
+ CharPtr url;
+} INSDStrucCommentItem, PNTR INSDStrucCommentItemPtr;
-NLM_EXTERN INSDTagPtr LIBCALL INSDTagFree PROTO ((INSDTagPtr ));
-NLM_EXTERN INSDTagPtr LIBCALL INSDTagNew PROTO (( void ));
-NLM_EXTERN INSDTagPtr LIBCALL INSDTagAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
-NLM_EXTERN Boolean LIBCALL INSDTagAsnWrite PROTO (( INSDTagPtr , AsnIoPtr, AsnTypePtr));
+NLM_EXTERN INSDStrucCommentItemPtr LIBCALL INSDStrucCommentItemFree PROTO ((INSDStrucCommentItemPtr ));
+NLM_EXTERN INSDStrucCommentItemPtr LIBCALL INSDStrucCommentItemNew PROTO (( void ));
+NLM_EXTERN INSDStrucCommentItemPtr LIBCALL INSDStrucCommentItemAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL INSDStrucCommentItemAsnWrite PROTO (( INSDStrucCommentItemPtr , AsnIoPtr, AsnTypePtr));
@@ -290,67 +372,32 @@ NLM_EXTERN Boolean LIBCALL INSDQualifierAsnWrite PROTO (( INSDQualifierPtr , Asn
/**************************************************
*
-* INSDTagsetRules
+* INSDAltSeqItem
*
**************************************************/
-typedef struct struct_INSDTagsetRules {
- struct struct_INSDTagsetRules PNTR next;
+typedef struct struct_INSDAltSeqItem {
+ struct struct_INSDAltSeqItem PNTR next;
Uint4 OBbits__;
- CharPtr authority;
- CharPtr version;
- ValNodePtr mandatorytags;
- ValNodePtr optionaltags;
- ValNodePtr uniquetags;
-#define OB__INSDTagsetRules_extensible 0
-
- Uint1 extensible;
-} INSDTagsetRules, PNTR INSDTagsetRulesPtr;
-
-
-NLM_EXTERN INSDTagsetRulesPtr LIBCALL INSDTagsetRulesFree PROTO ((INSDTagsetRulesPtr ));
-NLM_EXTERN INSDTagsetRulesPtr LIBCALL INSDTagsetRulesNew PROTO (( void ));
-NLM_EXTERN INSDTagsetRulesPtr LIBCALL INSDTagsetRulesAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
-NLM_EXTERN Boolean LIBCALL INSDTagsetRulesAsnWrite PROTO (( INSDTagsetRulesPtr , AsnIoPtr, AsnTypePtr));
-
-
-
-/**************************************************
-*
-* INSDTagNames
-*
-**************************************************/
-typedef ValNode INSDTagNames;
-typedef ValNodePtr INSDTagNamesPtr;
-#define INSDTagNamesNew() ValNodeNew(NULL)
-
-#ifdef NLM_GENERATED_CODE_PROTO
-
-NLM_EXTERN INSDTagNamesPtr LIBCALL INSDTagNamesFree PROTO ((INSDTagNamesPtr ));
-NLM_EXTERN INSDTagNamesPtr LIBCALL INSDTagNamesNew PROTO (( void ));
-NLM_EXTERN INSDTagNamesPtr LIBCALL INSDTagNamesAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
-NLM_EXTERN Boolean LIBCALL INSDTagNamesAsnWrite PROTO (( INSDTagNamesPtr , AsnIoPtr, AsnTypePtr));
-
-#endif /* NLM_GENERATED_CODE_PROTO */
-
-
-
-/**************************************************
-*
-* INSDTagsetRuleSet
-*
-**************************************************/
-typedef struct struct_INSDTagsetRules INSDTagsetRuleSet;
-typedef struct struct_INSDTagsetRules PNTR INSDTagsetRuleSetPtr;
-#define INSDTagsetRuleSetNew() INSDTagsetRulesNew()
-
-#ifdef NLM_GENERATED_CODE_PROTO
+ struct struct_INSDInterval PNTR interval;
+#define OB__INSDAltSeqItem_isgap 0
+
+ Uint1 isgap;
+#define OB__INSDAltSeqItem_gap_length 1
+
+ Int4 gap_length;
+ CharPtr gap_type;
+ CharPtr gap_linkage;
+ CharPtr gap_comment;
+ CharPtr first_accn;
+ CharPtr last_accn;
+ CharPtr value;
+} INSDAltSeqItem, PNTR INSDAltSeqItemPtr;
-NLM_EXTERN INSDTagsetRuleSetPtr LIBCALL INSDTagsetRuleSetFree PROTO ((INSDTagsetRuleSetPtr ));
-NLM_EXTERN INSDTagsetRuleSetPtr LIBCALL INSDTagsetRuleSetNew PROTO (( void ));
-NLM_EXTERN INSDTagsetRuleSetPtr LIBCALL INSDTagsetRuleSetAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
-NLM_EXTERN Boolean LIBCALL INSDTagsetRuleSetAsnWrite PROTO (( INSDTagsetRuleSetPtr , AsnIoPtr, AsnTypePtr));
-#endif /* NLM_GENERATED_CODE_PROTO */
+NLM_EXTERN INSDAltSeqItemPtr LIBCALL INSDAltSeqItemFree PROTO ((INSDAltSeqItemPtr ));
+NLM_EXTERN INSDAltSeqItemPtr LIBCALL INSDAltSeqItemNew PROTO (( void ));
+NLM_EXTERN INSDAltSeqItemPtr LIBCALL INSDAltSeqItemAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL INSDAltSeqItemAsnWrite PROTO (( INSDAltSeqItemPtr , AsnIoPtr, AsnTypePtr));
#ifdef __cplusplus
/* { */ }
diff --git a/object/objmacro.c b/object/objmacro.c
index b2c23b88..e7dd29f8 100755
--- a/object/objmacro.c
+++ b/object/objmacro.c
@@ -31,7 +31,7 @@ objmacroAsnLoad(void)
/**************************************************
* Generated object loaders for Module NCBI-Macro
-* Generated using ASNCODE Revision: 6.16 at May 12, 2009 9:09 AM
+* Generated using ASNCODE Revision: 6.17 at Jul 26, 2010 2:39 PM
*
**************************************************/
@@ -737,6 +737,191 @@ erret:
/**************************************************
*
+* LocationPosConstraintFree()
+*
+**************************************************/
+NLM_EXTERN
+LocationPosConstraintPtr LIBCALL
+LocationPosConstraintFree(ValNodePtr anp)
+{
+ Pointer pnt;
+
+ if (anp == NULL) {
+ return NULL;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ default:
+ break;
+ }
+ return MemFree(anp);
+}
+
+
+/**************************************************
+*
+* LocationPosConstraintAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+LocationPosConstraintPtr LIBCALL
+LocationPosConstraintAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ ValNodePtr anp;
+ Uint1 choice;
+ Boolean isError = FALSE;
+ Boolean nullIsError = FALSE;
+ AsnReadFunc func;
+
+ if (! loaded)
+ {
+ if (! objmacroAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* LocationPosConstraint ::= (self contained) */
+ atp = AsnReadId(aip, amp, LOCATION_POS_CONSTRAINT);
+ } else {
+ atp = AsnLinkType(orig, LOCATION_POS_CONSTRAINT); /* link in local tree */
+ }
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ anp = ValNodeNew(NULL);
+ if (anp == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
+ goto erret;
+ }
+
+ func = NULL;
+
+ atp = AsnReadId(aip, amp, atp); /* find the choice */
+ if (atp == NULL) {
+ goto erret;
+ }
+ if (atp == POS_CONSTRAINT_dist_from_end) {
+ choice = LocationPosConstraint_dist_from_end;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.intvalue = av.intvalue;
+ }
+ else if (atp == CONSTRAINT_max_dist_from_end) {
+ choice = LocationPosConstraint_max_dist_from_end;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.intvalue = av.intvalue;
+ }
+ else if (atp == CONSTRAINT_min_dist_from_end) {
+ choice = LocationPosConstraint_min_dist_from_end;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.intvalue = av.intvalue;
+ }
+ anp->choice = choice;
+ if (func != NULL)
+ {
+ anp->data.ptrvalue = (* func)(aip, atp);
+ if (aip -> io_failure) goto erret;
+
+ if (nullIsError && anp->data.ptrvalue == NULL) {
+ goto erret;
+ }
+ }
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return anp;
+
+erret:
+ anp = MemFree(anp);
+ aip -> io_failure = TRUE;
+ goto ret;
+}
+
+
+/**************************************************
+*
+* LocationPosConstraintAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+LocationPosConstraintAsnWrite(LocationPosConstraintPtr anp, AsnIoPtr aip, AsnTypePtr orig)
+
+{
+ DataVal av;
+ AsnTypePtr atp, writetype = NULL;
+ Pointer pnt;
+ AsnWriteFunc func = NULL;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! objmacroAsnLoad())
+ return FALSE;
+ }
+
+ if (aip == NULL)
+ return FALSE;
+
+ atp = AsnLinkType(orig, LOCATION_POS_CONSTRAINT); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+
+ av.ptrvalue = (Pointer)anp;
+ if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
+ goto erret;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ case LocationPosConstraint_dist_from_end:
+ av.intvalue = anp->data.intvalue;
+ retval = AsnWrite(aip, POS_CONSTRAINT_dist_from_end, &av);
+ break;
+ case LocationPosConstraint_max_dist_from_end:
+ av.intvalue = anp->data.intvalue;
+ retval = AsnWrite(aip, CONSTRAINT_max_dist_from_end, &av);
+ break;
+ case LocationPosConstraint_min_dist_from_end:
+ av.intvalue = anp->data.intvalue;
+ retval = AsnWrite(aip, CONSTRAINT_min_dist_from_end, &av);
+ break;
+ }
+ if (writetype != NULL) {
+ retval = (* func)(pnt, aip, writetype); /* write it out */
+ }
+ if (!retval) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+/**************************************************
+*
* LocationConstraintNew()
*
**************************************************/
@@ -750,6 +935,7 @@ LocationConstraintNew(void)
ptr -> seq_type = 0;
ptr -> partial5 = 0;
ptr -> partial3 = 0;
+ ptr -> location_type = 0;
return ptr;
}
@@ -768,6 +954,8 @@ LocationConstraintFree(LocationConstraintPtr ptr)
if(ptr == NULL) {
return NULL;
}
+ LocationPosConstraintFree(ptr -> end5);
+ LocationPosConstraintFree(ptr -> end3);
return MemFree(ptr);
}
@@ -847,6 +1035,27 @@ LocationConstraintAsnRead(AsnIoPtr aip, AsnTypePtr orig)
ptr -> partial3 = av.intvalue;
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == CONSTRAINT_location_type) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> location_type = av.intvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == LOCATION_CONSTRAINT_end5) {
+ ptr -> end5 = LocationPosConstraintAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == LOCATION_CONSTRAINT_end3) {
+ ptr -> end3 = LocationPosConstraintAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
if (AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -906,6 +1115,18 @@ LocationConstraintAsnWrite(LocationConstraintPtr ptr, AsnIoPtr aip, AsnTypePtr o
retval = AsnWrite(aip, LOCATION_CONSTRAINT_partial5, &av);
av.intvalue = ptr -> partial3;
retval = AsnWrite(aip, LOCATION_CONSTRAINT_partial3, &av);
+ av.intvalue = ptr -> location_type;
+ retval = AsnWrite(aip, CONSTRAINT_location_type, &av);
+ if (ptr -> end5 != NULL) {
+ if ( ! LocationPosConstraintAsnWrite(ptr -> end5, aip, LOCATION_CONSTRAINT_end5)) {
+ goto erret;
+ }
+ }
+ if (ptr -> end3 != NULL) {
+ if ( ! LocationPosConstraintAsnWrite(ptr -> end3, aip, LOCATION_CONSTRAINT_end3)) {
+ goto erret;
+ }
+ }
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
}
@@ -5662,6 +5883,356 @@ erret:
/**************************************************
*
+* PubFieldSpecialConstraintTypeFree()
+*
+**************************************************/
+NLM_EXTERN
+PubFieldSpecialConstraintTypePtr LIBCALL
+PubFieldSpecialConstraintTypeFree(ValNodePtr anp)
+{
+ Pointer pnt;
+
+ if (anp == NULL) {
+ return NULL;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ default:
+ break;
+ }
+ return MemFree(anp);
+}
+
+
+/**************************************************
+*
+* PubFieldSpecialConstraintTypeAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+PubFieldSpecialConstraintTypePtr LIBCALL
+PubFieldSpecialConstraintTypeAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ ValNodePtr anp;
+ Uint1 choice;
+ Boolean isError = FALSE;
+ Boolean nullIsError = FALSE;
+ AsnReadFunc func;
+
+ if (! loaded)
+ {
+ if (! objmacroAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* PubFieldSpecialConstraintType ::= (self contained) */
+ atp = AsnReadId(aip, amp, FIELD_SPECIAL_CONSTRAINT_TYPE);
+ } else {
+ atp = AsnLinkType(orig, FIELD_SPECIAL_CONSTRAINT_TYPE); /* link in local tree */
+ }
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ anp = ValNodeNew(NULL);
+ if (anp == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
+ goto erret;
+ }
+
+ func = NULL;
+
+ atp = AsnReadId(aip, amp, atp); /* find the choice */
+ if (atp == NULL) {
+ goto erret;
+ }
+ if (atp == CONSTRAINT_TYPE_is_present) {
+ choice = PubFieldSpecialConstraintType_is_present;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == CONSTRAINT_TYPE_is_not_present) {
+ choice = PubFieldSpecialConstraintType_is_not_present;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == CONSTRAINT_TYPE_is_all_caps) {
+ choice = PubFieldSpecialConstraintType_is_all_caps;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ anp->choice = choice;
+ if (func != NULL)
+ {
+ anp->data.ptrvalue = (* func)(aip, atp);
+ if (aip -> io_failure) goto erret;
+
+ if (nullIsError && anp->data.ptrvalue == NULL) {
+ goto erret;
+ }
+ }
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return anp;
+
+erret:
+ anp = MemFree(anp);
+ aip -> io_failure = TRUE;
+ goto ret;
+}
+
+
+/**************************************************
+*
+* PubFieldSpecialConstraintTypeAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+PubFieldSpecialConstraintTypeAsnWrite(PubFieldSpecialConstraintTypePtr anp, AsnIoPtr aip, AsnTypePtr orig)
+
+{
+ DataVal av;
+ AsnTypePtr atp, writetype = NULL;
+ Pointer pnt;
+ AsnWriteFunc func = NULL;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! objmacroAsnLoad())
+ return FALSE;
+ }
+
+ if (aip == NULL)
+ return FALSE;
+
+ atp = AsnLinkType(orig, FIELD_SPECIAL_CONSTRAINT_TYPE); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+
+ av.ptrvalue = (Pointer)anp;
+ if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
+ goto erret;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ case PubFieldSpecialConstraintType_is_present:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, CONSTRAINT_TYPE_is_present, &av);
+ break;
+ case PubFieldSpecialConstraintType_is_not_present:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, CONSTRAINT_TYPE_is_not_present, &av);
+ break;
+ case PubFieldSpecialConstraintType_is_all_caps:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, CONSTRAINT_TYPE_is_all_caps, &av);
+ break;
+ }
+ if (writetype != NULL) {
+ retval = (* func)(pnt, aip, writetype); /* write it out */
+ }
+ if (!retval) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+/**************************************************
+*
+* PubFieldSpecialConstraintNew()
+*
+**************************************************/
+NLM_EXTERN
+PubFieldSpecialConstraintPtr LIBCALL
+PubFieldSpecialConstraintNew(void)
+{
+ PubFieldSpecialConstraintPtr ptr = MemNew((size_t) sizeof(PubFieldSpecialConstraint));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* PubFieldSpecialConstraintFree()
+*
+**************************************************/
+NLM_EXTERN
+PubFieldSpecialConstraintPtr LIBCALL
+PubFieldSpecialConstraintFree(PubFieldSpecialConstraintPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ PubFieldSpecialConstraintTypeFree(ptr -> constraint);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* PubFieldSpecialConstraintAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+PubFieldSpecialConstraintPtr LIBCALL
+PubFieldSpecialConstraintAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean isError = FALSE;
+ AsnReadFunc func;
+ PubFieldSpecialConstraintPtr ptr;
+
+ if (! loaded)
+ {
+ if (! objmacroAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* PubFieldSpecialConstraint ::= (self contained) */
+ atp = AsnReadId(aip, amp, PUB_FIELD_SPECIAL_CONSTRAINT);
+ } else {
+ atp = AsnLinkType(orig, PUB_FIELD_SPECIAL_CONSTRAINT);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = PubFieldSpecialConstraintNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == FIELD_SPECIAL_CONSTRAINT_field) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> field = av.intvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == SPECIAL_CONSTRAINT_constraint) {
+ ptr -> constraint = PubFieldSpecialConstraintTypeAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = PubFieldSpecialConstraintFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* PubFieldSpecialConstraintAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+PubFieldSpecialConstraintAsnWrite(PubFieldSpecialConstraintPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! objmacroAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, PUB_FIELD_SPECIAL_CONSTRAINT); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ av.intvalue = ptr -> field;
+ retval = AsnWrite(aip, FIELD_SPECIAL_CONSTRAINT_field, &av);
+ if (ptr -> constraint != NULL) {
+ if ( ! PubFieldSpecialConstraintTypeAsnWrite(ptr -> constraint, aip, SPECIAL_CONSTRAINT_constraint)) {
+ goto erret;
+ }
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
* PublicationConstraintNew()
*
**************************************************/
@@ -5690,6 +6261,7 @@ PublicationConstraintFree(PublicationConstraintPtr ptr)
return NULL;
}
PubFieldConstraintFree(ptr -> field);
+ PubFieldSpecialConstraintFree(ptr -> special_field);
return MemFree(ptr);
}
@@ -5755,6 +6327,13 @@ PublicationConstraintAsnRead(AsnIoPtr aip, AsnTypePtr orig)
}
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == CONSTRAINT_special_field) {
+ ptr -> special_field = PubFieldSpecialConstraintAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
if (AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -5813,6 +6392,11 @@ PublicationConstraintAsnWrite(PublicationConstraintPtr ptr, AsnIoPtr aip, AsnTyp
goto erret;
}
}
+ if (ptr -> special_field != NULL) {
+ if ( ! PubFieldSpecialConstraintAsnWrite(ptr -> special_field, aip, CONSTRAINT_special_field)) {
+ goto erret;
+ }
+ }
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
}
@@ -7141,6 +7725,191 @@ erret:
/**************************************************
*
+* QuantityConstraintFree()
+*
+**************************************************/
+NLM_EXTERN
+QuantityConstraintPtr LIBCALL
+QuantityConstraintFree(ValNodePtr anp)
+{
+ Pointer pnt;
+
+ if (anp == NULL) {
+ return NULL;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ default:
+ break;
+ }
+ return MemFree(anp);
+}
+
+
+/**************************************************
+*
+* QuantityConstraintAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+QuantityConstraintPtr LIBCALL
+QuantityConstraintAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ ValNodePtr anp;
+ Uint1 choice;
+ Boolean isError = FALSE;
+ Boolean nullIsError = FALSE;
+ AsnReadFunc func;
+
+ if (! loaded)
+ {
+ if (! objmacroAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* QuantityConstraint ::= (self contained) */
+ atp = AsnReadId(aip, amp, QUANTITY_CONSTRAINT);
+ } else {
+ atp = AsnLinkType(orig, QUANTITY_CONSTRAINT); /* link in local tree */
+ }
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ anp = ValNodeNew(NULL);
+ if (anp == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
+ goto erret;
+ }
+
+ func = NULL;
+
+ atp = AsnReadId(aip, amp, atp); /* find the choice */
+ if (atp == NULL) {
+ goto erret;
+ }
+ if (atp == QUANTITY_CONSTRAINT_equals) {
+ choice = QuantityConstraint_equals;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.intvalue = av.intvalue;
+ }
+ else if (atp == CONSTRAINT_greater_than) {
+ choice = QuantityConstraint_greater_than;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.intvalue = av.intvalue;
+ }
+ else if (atp == QUANTITY_CONSTRAINT_less_than) {
+ choice = QuantityConstraint_less_than;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.intvalue = av.intvalue;
+ }
+ anp->choice = choice;
+ if (func != NULL)
+ {
+ anp->data.ptrvalue = (* func)(aip, atp);
+ if (aip -> io_failure) goto erret;
+
+ if (nullIsError && anp->data.ptrvalue == NULL) {
+ goto erret;
+ }
+ }
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return anp;
+
+erret:
+ anp = MemFree(anp);
+ aip -> io_failure = TRUE;
+ goto ret;
+}
+
+
+/**************************************************
+*
+* QuantityConstraintAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+QuantityConstraintAsnWrite(QuantityConstraintPtr anp, AsnIoPtr aip, AsnTypePtr orig)
+
+{
+ DataVal av;
+ AsnTypePtr atp, writetype = NULL;
+ Pointer pnt;
+ AsnWriteFunc func = NULL;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! objmacroAsnLoad())
+ return FALSE;
+ }
+
+ if (aip == NULL)
+ return FALSE;
+
+ atp = AsnLinkType(orig, QUANTITY_CONSTRAINT); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+
+ av.ptrvalue = (Pointer)anp;
+ if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
+ goto erret;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ case QuantityConstraint_equals:
+ av.intvalue = anp->data.intvalue;
+ retval = AsnWrite(aip, QUANTITY_CONSTRAINT_equals, &av);
+ break;
+ case QuantityConstraint_greater_than:
+ av.intvalue = anp->data.intvalue;
+ retval = AsnWrite(aip, CONSTRAINT_greater_than, &av);
+ break;
+ case QuantityConstraint_less_than:
+ av.intvalue = anp->data.intvalue;
+ retval = AsnWrite(aip, QUANTITY_CONSTRAINT_less_than, &av);
+ break;
+ }
+ if (writetype != NULL) {
+ retval = (* func)(pnt, aip, writetype); /* write it out */
+ }
+ if (!retval) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+/**************************************************
+*
* SequenceConstraintNew()
*
**************************************************/
@@ -7170,6 +7939,7 @@ SequenceConstraintFree(SequenceConstraintPtr ptr)
}
SequenceConstraintMolTypeConstraintFree(ptr -> seqtype);
StringConstraintFree(ptr -> id);
+ QuantityConstraintFree(ptr -> num_features);
return MemFree(ptr);
}
@@ -7242,6 +8012,13 @@ SequenceConstraintAsnRead(AsnIoPtr aip, AsnTypePtr orig)
ptr -> feature = av.intvalue;
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == CONSTRAINT_num_features) {
+ ptr -> num_features = QuantityConstraintAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
if (AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -7305,6 +8082,11 @@ SequenceConstraintAsnWrite(SequenceConstraintPtr ptr, AsnIoPtr aip, AsnTypePtr o
}
av.intvalue = ptr -> feature;
retval = AsnWrite(aip, SEQUENCE_CONSTRAINT_feature, &av);
+ if (ptr -> num_features != NULL) {
+ if ( ! QuantityConstraintAsnWrite(ptr -> num_features, aip, CONSTRAINT_num_features)) {
+ goto erret;
+ }
+ }
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
}
@@ -7673,6 +8455,194 @@ erret:
/**************************************************
*
+* TextMarkerFree()
+*
+**************************************************/
+NLM_EXTERN
+TextMarkerPtr LIBCALL
+TextMarkerFree(ValNodePtr anp)
+{
+ Pointer pnt;
+
+ if (anp == NULL) {
+ return NULL;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ default:
+ break;
+ case TextMarker_free_text:
+ MemFree(anp -> data.ptrvalue);
+ break;
+ }
+ return MemFree(anp);
+}
+
+
+/**************************************************
+*
+* TextMarkerAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+TextMarkerPtr LIBCALL
+TextMarkerAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ ValNodePtr anp;
+ Uint1 choice;
+ Boolean isError = FALSE;
+ Boolean nullIsError = FALSE;
+ AsnReadFunc func;
+
+ if (! loaded)
+ {
+ if (! objmacroAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* TextMarker ::= (self contained) */
+ atp = AsnReadId(aip, amp, TEXT_MARKER);
+ } else {
+ atp = AsnLinkType(orig, TEXT_MARKER); /* link in local tree */
+ }
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ anp = ValNodeNew(NULL);
+ if (anp == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the CHOICE or OpenStruct value (nothing) */
+ goto erret;
+ }
+
+ func = NULL;
+
+ atp = AsnReadId(aip, amp, atp); /* find the choice */
+ if (atp == NULL) {
+ goto erret;
+ }
+ if (atp == TEXT_MARKER_free_text) {
+ choice = TextMarker_free_text;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.ptrvalue = av.ptrvalue;
+ }
+ else if (atp == TEXT_MARKER_digits) {
+ choice = TextMarker_digits;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == TEXT_MARKER_letters) {
+ choice = TextMarker_letters;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ anp->choice = choice;
+ if (func != NULL)
+ {
+ anp->data.ptrvalue = (* func)(aip, atp);
+ if (aip -> io_failure) goto erret;
+
+ if (nullIsError && anp->data.ptrvalue == NULL) {
+ goto erret;
+ }
+ }
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return anp;
+
+erret:
+ anp = MemFree(anp);
+ aip -> io_failure = TRUE;
+ goto ret;
+}
+
+
+/**************************************************
+*
+* TextMarkerAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+TextMarkerAsnWrite(TextMarkerPtr anp, AsnIoPtr aip, AsnTypePtr orig)
+
+{
+ DataVal av;
+ AsnTypePtr atp, writetype = NULL;
+ Pointer pnt;
+ AsnWriteFunc func = NULL;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! objmacroAsnLoad())
+ return FALSE;
+ }
+
+ if (aip == NULL)
+ return FALSE;
+
+ atp = AsnLinkType(orig, TEXT_MARKER); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (anp == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+
+ av.ptrvalue = (Pointer)anp;
+ if (! AsnWriteChoice(aip, atp, (Int2)anp->choice, &av)) {
+ goto erret;
+ }
+
+ pnt = anp->data.ptrvalue;
+ switch (anp->choice)
+ {
+ case TextMarker_free_text:
+ av.ptrvalue = anp->data.ptrvalue;
+ retval = AsnWrite(aip, TEXT_MARKER_free_text, &av);
+ break;
+ case TextMarker_digits:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, TEXT_MARKER_digits, &av);
+ break;
+ case TextMarker_letters:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, TEXT_MARKER_letters, &av);
+ break;
+ }
+ if (writetype != NULL) {
+ retval = (* func)(pnt, aip, writetype); /* write it out */
+ }
+ if (!retval) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+/**************************************************
+*
* TextPortionNew()
*
**************************************************/
@@ -7702,8 +8672,8 @@ TextPortionFree(TextPortionPtr ptr)
if(ptr == NULL) {
return NULL;
}
- MemFree(ptr -> left_text);
- MemFree(ptr -> right_text);
+ TextMarkerFree(ptr -> left_marker);
+ TextMarkerFree(ptr -> right_marker);
return MemFree(ptr);
}
@@ -7755,11 +8725,11 @@ TextPortionAsnRead(AsnIoPtr aip, AsnTypePtr orig)
atp = AsnReadId(aip,amp, atp);
func = NULL;
- if (atp == TEXT_PORTION_left_text) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
+ if (atp == TEXT_PORTION_left_marker) {
+ ptr -> left_marker = TextMarkerAsnRead(aip, atp);
+ if (aip -> io_failure) {
goto erret;
}
- ptr -> left_text = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
if (atp == TEXT_PORTION_include_left) {
@@ -7769,11 +8739,11 @@ TextPortionAsnRead(AsnIoPtr aip, AsnTypePtr orig)
ptr -> include_left = av.boolvalue;
atp = AsnReadId(aip,amp, atp);
}
- if (atp == TEXT_PORTION_right_text) {
- if ( AsnReadVal(aip, atp, &av) <= 0) {
+ if (atp == TEXT_PORTION_right_marker) {
+ ptr -> right_marker = TextMarkerAsnRead(aip, atp);
+ if (aip -> io_failure) {
goto erret;
}
- ptr -> right_text = av.ptrvalue;
atp = AsnReadId(aip,amp, atp);
}
if (atp == TEXT_PORTION_include_right) {
@@ -7855,15 +8825,17 @@ TextPortionAsnWrite(TextPortionPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
- if (ptr -> left_text != NULL) {
- av.ptrvalue = ptr -> left_text;
- retval = AsnWrite(aip, TEXT_PORTION_left_text, &av);
+ if (ptr -> left_marker != NULL) {
+ if ( ! TextMarkerAsnWrite(ptr -> left_marker, aip, TEXT_PORTION_left_marker)) {
+ goto erret;
+ }
}
av.boolvalue = ptr -> include_left;
retval = AsnWrite(aip, TEXT_PORTION_include_left, &av);
- if (ptr -> right_text != NULL) {
- av.ptrvalue = ptr -> right_text;
- retval = AsnWrite(aip, TEXT_PORTION_right_text, &av);
+ if (ptr -> right_marker != NULL) {
+ if ( ! TextMarkerAsnWrite(ptr -> right_marker, aip, TEXT_PORTION_right_marker)) {
+ goto erret;
+ }
}
av.boolvalue = ptr -> include_right;
retval = AsnWrite(aip, TEXT_PORTION_include_right, &av);
@@ -8639,6 +9611,7 @@ ConvertActionNew(void)
ptr -> strip_name = 0;
ptr -> keep_original = 0;
+ ptr -> capitalization = 0;
return ptr;
}
@@ -8730,6 +9703,13 @@ ConvertActionAsnRead(AsnIoPtr aip, AsnTypePtr orig)
ptr -> keep_original = av.boolvalue;
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == CONVERT_ACTION_capitalization) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> capitalization = av.intvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
if (atp == CONVERT_ACTION_existing_text) {
if ( AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -8797,6 +9777,8 @@ ConvertActionAsnWrite(ConvertActionPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
retval = AsnWrite(aip, CONVERT_ACTION_strip_name, &av);
av.boolvalue = ptr -> keep_original;
retval = AsnWrite(aip, CONVERT_ACTION_keep_original, &av);
+ av.intvalue = ptr -> capitalization;
+ retval = AsnWrite(aip, CONVERT_ACTION_capitalization, &av);
av.intvalue = ptr -> existing_text;
retval = AsnWrite(aip, CONVERT_ACTION_existing_text, &av);
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
@@ -10948,6 +11930,13 @@ LocationChoiceAsnRead(AsnIoPtr aip, AsnTypePtr orig)
}
anp->data.boolvalue = av.boolvalue;
}
+ else if (atp == LOCATION_CHOICE_point) {
+ choice = LocationChoice_point;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.intvalue = av.intvalue;
+ }
anp->choice = choice;
if (func != NULL)
{
@@ -11017,6 +12006,10 @@ LocationChoiceAsnWrite(LocationChoicePtr anp, AsnIoPtr aip, AsnTypePtr orig)
av.boolvalue = anp->data.boolvalue;
retval = AsnWrite(aip, LOCATION_CHOICE_whole_sequence, &av);
break;
+ case LocationChoice_point:
+ av.intvalue = anp->data.intvalue;
+ retval = AsnWrite(aip, LOCATION_CHOICE_point, &av);
+ break;
}
if (writetype != NULL) {
retval = (* func)(pnt, aip, writetype); /* write it out */
@@ -13264,6 +14257,20 @@ LocationEditTypeAsnRead(AsnIoPtr aip, AsnTypePtr orig)
}
anp->data.intvalue = av.intvalue;
}
+ else if (atp == LOCATION_EDIT_TYPE_extend_5) {
+ choice = LocationEditType_extend_5;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == LOCATION_EDIT_TYPE_extend_3) {
+ choice = LocationEditType_extend_3;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
anp->choice = choice;
if (func != NULL)
{
@@ -13349,6 +14356,14 @@ LocationEditTypeAsnWrite(LocationEditTypePtr anp, AsnIoPtr aip, AsnTypePtr orig)
av.intvalue = anp->data.intvalue;
retval = AsnWrite(aip, LOCATION_EDIT_TYPE_convert, &av);
break;
+ case LocationEditType_extend_5:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, LOCATION_EDIT_TYPE_extend_5, &av);
+ break;
+ case LocationEditType_extend_3:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, LOCATION_EDIT_TYPE_extend_3, &av);
+ break;
}
if (writetype != NULL) {
retval = (* func)(pnt, aip, writetype); /* write it out */
@@ -14052,6 +15067,189 @@ erret:
/**************************************************
*
+* FixPubCapsActionNew()
+*
+**************************************************/
+NLM_EXTERN
+FixPubCapsActionPtr LIBCALL
+FixPubCapsActionNew(void)
+{
+ FixPubCapsActionPtr ptr = MemNew((size_t) sizeof(FixPubCapsAction));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* FixPubCapsActionFree()
+*
+**************************************************/
+NLM_EXTERN
+FixPubCapsActionPtr LIBCALL
+FixPubCapsActionFree(FixPubCapsActionPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ ConstraintChoiceSetFree(ptr -> constraint);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* FixPubCapsActionAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+FixPubCapsActionPtr LIBCALL
+FixPubCapsActionAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean isError = FALSE;
+ AsnReadFunc func;
+ FixPubCapsActionPtr ptr;
+
+ if (! loaded)
+ {
+ if (! objmacroAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* FixPubCapsAction ::= (self contained) */
+ atp = AsnReadId(aip, amp, FIX_PUB_CAPS_ACTION);
+ } else {
+ atp = AsnLinkType(orig, FIX_PUB_CAPS_ACTION);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = FixPubCapsActionNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == FIX_PUB_CAPS_ACTION_title) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> title = av.boolvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == FIX_PUB_CAPS_ACTION_authors) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> authors = av.boolvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == FIX_PUB_CAPS_ACTION_affiliation) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> affiliation = av.boolvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == FIX_PUB_CAPS_ACTION_constraint) {
+ ptr -> constraint = ConstraintChoiceSetAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = FixPubCapsActionFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* FixPubCapsActionAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+FixPubCapsActionAsnWrite(FixPubCapsActionPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! objmacroAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, FIX_PUB_CAPS_ACTION); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ av.boolvalue = ptr -> title;
+ retval = AsnWrite(aip, FIX_PUB_CAPS_ACTION_title, &av);
+ av.boolvalue = ptr -> authors;
+ retval = AsnWrite(aip, FIX_PUB_CAPS_ACTION_authors, &av);
+ av.boolvalue = ptr -> affiliation;
+ retval = AsnWrite(aip, FIX_PUB_CAPS_ACTION_affiliation, &av);
+ if (ptr -> constraint != NULL) {
+ if ( ! ConstraintChoiceSetAsnWrite(ptr -> constraint, aip, FIX_PUB_CAPS_ACTION_constraint)) {
+ goto erret;
+ }
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
* MacroActionChoiceFree()
*
**************************************************/
@@ -14094,6 +15292,9 @@ MacroActionChoiceFree(ValNodePtr anp)
case MacroActionChoice_autodef:
AutodefActionFree(anp -> data.ptrvalue);
break;
+ case MacroActionChoice_fix_pub_caps:
+ FixPubCapsActionFree(anp -> data.ptrvalue);
+ break;
}
return MemFree(anp);
}
@@ -14182,6 +15383,59 @@ MacroActionChoiceAsnRead(AsnIoPtr aip, AsnTypePtr orig)
choice = MacroActionChoice_autodef;
func = (AsnReadFunc) AutodefActionAsnRead;
}
+ else if (atp == MACRO_ACTION_CHOICE_removesets) {
+ choice = MacroActionChoice_removesets;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == trim_junk_from_primer_seq) {
+ choice = MacroActionChoice_trim_junk_from_primer_seq;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == trim_stop_from_complete_cds) {
+ choice = MacroActionChoice_trim_stop_from_complete_cds;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == CHOICE_fix_usa_and_states) {
+ choice = MacroActionChoice_fix_usa_and_states;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == synchronize_cds_partials) {
+ choice = MacroActionChoice_synchronize_cds_partials;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == adjust_for_consensus_splice) {
+ choice = MacroActionChoice_adjust_for_consensus_splice;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
+ else if (atp == ACTION_CHOICE_fix_pub_caps) {
+ choice = MacroActionChoice_fix_pub_caps;
+ func = (AsnReadFunc) FixPubCapsActionAsnRead;
+ }
+ else if (atp == ACTION_CHOICE_remove_seg_gaps) {
+ choice = MacroActionChoice_remove_seg_gaps;
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ anp->data.boolvalue = av.boolvalue;
+ }
anp->choice = choice;
if (func != NULL)
{
@@ -14275,6 +15529,38 @@ MacroActionChoiceAsnWrite(MacroActionChoicePtr anp, AsnIoPtr aip, AsnTypePtr ori
writetype = MACRO_ACTION_CHOICE_autodef;
func = (AsnWriteFunc) AutodefActionAsnWrite;
break;
+ case MacroActionChoice_removesets:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, MACRO_ACTION_CHOICE_removesets, &av);
+ break;
+ case MacroActionChoice_trim_junk_from_primer_seq:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, trim_junk_from_primer_seq, &av);
+ break;
+ case MacroActionChoice_trim_stop_from_complete_cds:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, trim_stop_from_complete_cds, &av);
+ break;
+ case MacroActionChoice_fix_usa_and_states:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, CHOICE_fix_usa_and_states, &av);
+ break;
+ case MacroActionChoice_synchronize_cds_partials:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, synchronize_cds_partials, &av);
+ break;
+ case MacroActionChoice_adjust_for_consensus_splice:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, adjust_for_consensus_splice, &av);
+ break;
+ case MacroActionChoice_fix_pub_caps:
+ writetype = ACTION_CHOICE_fix_pub_caps;
+ func = (AsnWriteFunc) FixPubCapsActionAsnWrite;
+ break;
+ case MacroActionChoice_remove_seg_gaps:
+ av.boolvalue = anp->data.boolvalue;
+ retval = AsnWrite(aip, ACTION_CHOICE_remove_seg_gaps, &av);
+ break;
}
if (writetype != NULL) {
retval = (* func)(pnt, aip, writetype); /* write it out */
diff --git a/object/objmacro.h b/object/objmacro.h
index 0888ba6e..44d4b4f4 100755
--- a/object/objmacro.h
+++ b/object/objmacro.h
@@ -17,7 +17,7 @@ extern "C" { /* } */
/**************************************************
*
* Generated objects for Module NCBI-Macro
-* Generated using ASNCODE Revision: 6.16 at May 12, 2009 9:09 AM
+* Generated using ASNCODE Revision: 6.17 at Jul 26, 2010 2:39 PM
*
**************************************************/
@@ -127,6 +127,23 @@ NLM_EXTERN Boolean LIBCALL StringConstraintAsnWrite PROTO (( StringConstraintPtr
#define Partial_constraint_partial 1
#define Partial_constraint_complete 2
+/* following #defines are for enumerated type, not used by object loaders */
+#define Location_type_constraint_any 0
+#define Location_type_constraint_single_interval 1
+#define Location_type_constraint_joined 2
+#define Location_type_constraint_ordered 3
+
+typedef ValNodePtr LocationPosConstraintPtr;
+typedef ValNode LocationPosConstraint;
+#define LocationPosConstraint_dist_from_end 1
+#define LocationPosConstraint_max_dist_from_end 2
+#define LocationPosConstraint_min_dist_from_end 3
+
+
+NLM_EXTERN LocationPosConstraintPtr LIBCALL LocationPosConstraintFree PROTO ((LocationPosConstraintPtr ));
+NLM_EXTERN LocationPosConstraintPtr LIBCALL LocationPosConstraintAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL LocationPosConstraintAsnWrite PROTO (( LocationPosConstraintPtr , AsnIoPtr, AsnTypePtr));
+
/**************************************************
@@ -139,6 +156,9 @@ typedef struct struct_Location_constraint {
Uint2 seq_type;
Uint2 partial5;
Uint2 partial3;
+ Uint2 location_type;
+ ValNodePtr end5;
+ ValNodePtr end3;
} LocationConstraint, PNTR LocationConstraintPtr;
@@ -316,6 +336,8 @@ NLM_EXTERN Boolean LIBCALL LocationConstraintAsnWrite PROTO (( LocationConstrain
#define Feat_qual_legal_satellite 65
#define Feat_qual_legal_satellite_type 66
#define Feat_qual_legal_satellite_name 67
+#define Feat_qual_legal_location 68
+#define Feat_qual_legal_tag_peptide 69
@@ -457,6 +479,7 @@ NLM_EXTERN Boolean LIBCALL RnaFeatTypeAsnWrite PROTO (( RnaFeatTypePtr , AsnIoPt
#define Rna_field_gene_locus_tag 10
#define Rna_field_gene_synonym 11
#define Rna_field_gene_comment 12
+#define Rna_field_tag_peptide 13
@@ -1066,6 +1089,35 @@ NLM_EXTERN PubFieldConstraintPtr LIBCALL PubFieldConstraintNew PROTO (( void ));
NLM_EXTERN PubFieldConstraintPtr LIBCALL PubFieldConstraintAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
NLM_EXTERN Boolean LIBCALL PubFieldConstraintAsnWrite PROTO (( PubFieldConstraintPtr , AsnIoPtr, AsnTypePtr));
+typedef ValNodePtr PubFieldSpecialConstraintTypePtr;
+typedef ValNode PubFieldSpecialConstraintType;
+#define PubFieldSpecialConstraintType_is_present 1
+#define PubFieldSpecialConstraintType_is_not_present 2
+#define PubFieldSpecialConstraintType_is_all_caps 3
+
+
+NLM_EXTERN PubFieldSpecialConstraintTypePtr LIBCALL PubFieldSpecialConstraintTypeFree PROTO ((PubFieldSpecialConstraintTypePtr ));
+NLM_EXTERN PubFieldSpecialConstraintTypePtr LIBCALL PubFieldSpecialConstraintTypeAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL PubFieldSpecialConstraintTypeAsnWrite PROTO (( PubFieldSpecialConstraintTypePtr , AsnIoPtr, AsnTypePtr));
+
+
+
+/**************************************************
+*
+* PubFieldSpecialConstraint
+*
+**************************************************/
+typedef struct struct_Pub_field_special_constraint {
+ Uint2 field;
+ ValNodePtr constraint;
+} PubFieldSpecialConstraint, PNTR PubFieldSpecialConstraintPtr;
+
+
+NLM_EXTERN PubFieldSpecialConstraintPtr LIBCALL PubFieldSpecialConstraintFree PROTO ((PubFieldSpecialConstraintPtr ));
+NLM_EXTERN PubFieldSpecialConstraintPtr LIBCALL PubFieldSpecialConstraintNew PROTO (( void ));
+NLM_EXTERN PubFieldSpecialConstraintPtr LIBCALL PubFieldSpecialConstraintAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL PubFieldSpecialConstraintAsnWrite PROTO (( PubFieldSpecialConstraintPtr , AsnIoPtr, AsnTypePtr));
+
/**************************************************
@@ -1076,6 +1128,7 @@ NLM_EXTERN Boolean LIBCALL PubFieldConstraintAsnWrite PROTO (( PubFieldConstrain
typedef struct struct_Publication_constraint {
Uint2 type;
struct struct_Pub_field_constraint PNTR field;
+ struct struct_Pub_field_special_constraint PNTR special_field;
} PublicationConstraint, PNTR PublicationConstraintPtr;
@@ -1218,6 +1271,17 @@ NLM_EXTERN SequenceConstraintMolTypeConstraintPtr LIBCALL SequenceConstraintMolT
NLM_EXTERN SequenceConstraintMolTypeConstraintPtr LIBCALL SequenceConstraintMolTypeConstraintAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
NLM_EXTERN Boolean LIBCALL SequenceConstraintMolTypeConstraintAsnWrite PROTO (( SequenceConstraintMolTypeConstraintPtr , AsnIoPtr, AsnTypePtr));
+typedef ValNodePtr QuantityConstraintPtr;
+typedef ValNode QuantityConstraint;
+#define QuantityConstraint_equals 1
+#define QuantityConstraint_greater_than 2
+#define QuantityConstraint_less_than 3
+
+
+NLM_EXTERN QuantityConstraintPtr LIBCALL QuantityConstraintFree PROTO ((QuantityConstraintPtr ));
+NLM_EXTERN QuantityConstraintPtr LIBCALL QuantityConstraintAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL QuantityConstraintAsnWrite PROTO (( QuantityConstraintPtr , AsnIoPtr, AsnTypePtr));
+
/**************************************************
@@ -1229,6 +1293,7 @@ typedef struct struct_Sequence_constraint {
ValNodePtr seqtype;
struct struct_String_constraint PNTR id;
Uint2 feature;
+ ValNodePtr num_features;
} SequenceConstraint, PNTR SequenceConstraintPtr;
@@ -1273,6 +1338,17 @@ NLM_EXTERN Boolean LIBCALL ConstraintChoiceSetAsnWrite PROTO (( ConstraintChoice
#endif /* NLM_GENERATED_CODE_PROTO */
+typedef ValNodePtr TextMarkerPtr;
+typedef ValNode TextMarker;
+#define TextMarker_free_text 1
+#define TextMarker_digits 2
+#define TextMarker_letters 3
+
+
+NLM_EXTERN TextMarkerPtr LIBCALL TextMarkerFree PROTO ((TextMarkerPtr ));
+NLM_EXTERN TextMarkerPtr LIBCALL TextMarkerAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL TextMarkerAsnWrite PROTO (( TextMarkerPtr , AsnIoPtr, AsnTypePtr));
+
/**************************************************
@@ -1281,9 +1357,9 @@ NLM_EXTERN Boolean LIBCALL ConstraintChoiceSetAsnWrite PROTO (( ConstraintChoice
*
**************************************************/
typedef struct struct_Text_portion {
- CharPtr left_text;
+ ValNodePtr left_marker;
Uint1 include_left;
- CharPtr right_text;
+ ValNodePtr right_marker;
Uint1 include_right;
Uint1 inside;
Uint1 case_sensitive;
@@ -1386,6 +1462,13 @@ NLM_EXTERN EditActionPtr LIBCALL EditActionNew PROTO (( void ));
NLM_EXTERN EditActionPtr LIBCALL EditActionAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
NLM_EXTERN Boolean LIBCALL EditActionAsnWrite PROTO (( EditActionPtr , AsnIoPtr, AsnTypePtr));
+/* following #defines are for enumerated type, not used by object loaders */
+#define Cap_change_none 0
+#define Cap_change_tolower 1
+#define Cap_change_toupper 2
+#define Cap_change_firstcap 3
+#define Cap_change_firstcaprestnochange 4
+
/**************************************************
@@ -1397,6 +1480,7 @@ typedef struct struct_Convert_action {
ValNodePtr fields;
Uint1 strip_name;
Uint1 keep_original;
+ Uint2 capitalization;
Uint2 existing_text;
} ConvertAction, PNTR ConvertActionPtr;
@@ -1496,12 +1580,6 @@ NLM_EXTERN ActionChoicePtr LIBCALL ActionChoiceFree PROTO ((ActionChoicePtr ));
NLM_EXTERN ActionChoicePtr LIBCALL ActionChoiceAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
NLM_EXTERN Boolean LIBCALL ActionChoiceAsnWrite PROTO (( ActionChoicePtr , AsnIoPtr, AsnTypePtr));
-/* following #defines are for enumerated type, not used by object loaders */
-#define Cap_change_none 0
-#define Cap_change_tolower 1
-#define Cap_change_toupper 2
-#define Cap_change_firstcap 3
-
typedef ValNodePtr ParseSrcOrgChoicePtr;
typedef ValNode ParseSrcOrgChoice;
#define ParseSrcOrgChoice_source_qual 1
@@ -1599,6 +1677,7 @@ typedef ValNodePtr LocationChoicePtr;
typedef ValNode LocationChoice;
#define LocationChoice_interval 1
#define LocationChoice_whole_sequence 2
+#define LocationChoice_point 3
NLM_EXTERN LocationChoicePtr LIBCALL LocationChoiceFree PROTO ((LocationChoicePtr ));
@@ -1899,6 +1978,8 @@ typedef ValNode LocationEditType;
#define LocationEditType_set_3_partial 4
#define LocationEditType_clear_3_partial 5
#define LocationEditType_convert 6
+#define LocationEditType_extend_5 7
+#define LocationEditType_extend_3 8
NLM_EXTERN LocationEditTypePtr LIBCALL LocationEditTypeFree PROTO ((LocationEditTypePtr ));
@@ -1998,6 +2079,26 @@ NLM_EXTERN AutodefActionPtr LIBCALL AutodefActionNew PROTO (( void ));
NLM_EXTERN AutodefActionPtr LIBCALL AutodefActionAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
NLM_EXTERN Boolean LIBCALL AutodefActionAsnWrite PROTO (( AutodefActionPtr , AsnIoPtr, AsnTypePtr));
+
+
+/**************************************************
+*
+* FixPubCapsAction
+*
+**************************************************/
+typedef struct struct_Fix_pub_caps_action {
+ Uint1 title;
+ Uint1 authors;
+ Uint1 affiliation;
+ ValNodePtr constraint;
+} FixPubCapsAction, PNTR FixPubCapsActionPtr;
+
+
+NLM_EXTERN FixPubCapsActionPtr LIBCALL FixPubCapsActionFree PROTO ((FixPubCapsActionPtr ));
+NLM_EXTERN FixPubCapsActionPtr LIBCALL FixPubCapsActionNew PROTO (( void ));
+NLM_EXTERN FixPubCapsActionPtr LIBCALL FixPubCapsActionAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL FixPubCapsActionAsnWrite PROTO (( FixPubCapsActionPtr , AsnIoPtr, AsnTypePtr));
+
typedef ValNodePtr MacroActionChoicePtr;
typedef ValNode MacroActionChoice;
#define MacroActionChoice_aecr 1
@@ -2008,6 +2109,14 @@ typedef ValNode MacroActionChoice;
#define MacroActionChoice_edit_location 6
#define MacroActionChoice_remove_descriptor 7
#define MacroActionChoice_autodef 8
+#define MacroActionChoice_removesets 9
+#define MacroActionChoice_trim_junk_from_primer_seq 10
+#define MacroActionChoice_trim_stop_from_complete_cds 11
+#define MacroActionChoice_fix_usa_and_states 12
+#define MacroActionChoice_synchronize_cds_partials 13
+#define MacroActionChoice_adjust_for_consensus_splice 14
+#define MacroActionChoice_fix_pub_caps 15
+#define MacroActionChoice_remove_seg_gaps 16
NLM_EXTERN MacroActionChoicePtr LIBCALL MacroActionChoiceFree PROTO ((MacroActionChoicePtr ));
diff --git a/object/objmedli.c b/object/objmedli.c
index 3f085a2b..0333dfa0 100644
--- a/object/objmedli.c
+++ b/object/objmedli.c
@@ -29,7 +29,7 @@
*
* Version Creation Date: 1/1/91
*
-* $Revision: 6.4 $
+* $Revision: 6.5 $
*
* File Description: Object manager for module NCBI-Medline
*
@@ -41,6 +41,9 @@
*
*
* $Log: objmedli.c,v $
+* Revision 6.5 2009/10/02 19:44:49 kans
+* address clang static analyzer warnings
+*
* Revision 6.4 1998/08/26 17:43:17 kans
* fixed -v -fd warnings in label functions
*
@@ -223,7 +226,7 @@ NLM_EXTERN MedlineMeshPtr LIBCALL MedlineMeshAsnRead (AsnIoPtr aip, AsnTypePtr o
MedlineMeshPtr mmp=NULL;
DataVal av;
AsnTypePtr atp, oldatp;
- ValNodePtr first, anp;
+ ValNodePtr first, anp = NULL;
if (! loaded)
{
@@ -740,7 +743,7 @@ NLM_EXTERN MedlineEntryPtr LIBCALL MedlineEntryAsnRead (AsnIoPtr aip, AsnTypePtr
if (anp == NULL) goto erret;
if (mep->xref == NULL)
mep->xref = anp;
- else
+ else if (anplast != NULL)
anplast->next = anp;
anplast = anp;
}
diff --git a/object/objpub.c b/object/objpub.c
index e6ad239c..08315288 100644
--- a/object/objpub.c
+++ b/object/objpub.c
@@ -29,7 +29,7 @@
*
* Version Creation Date: 4/1/91
*
-* $Revision: 6.7 $
+* $Revision: 6.9 $
*
* File Description: Object manager for module NCBI-Pub
*
@@ -41,6 +41,12 @@
*
*
* $Log: objpub.c,v $
+* Revision 6.9 2010/03/09 16:56:39 bollin
+* Include Medline/PMID in Medline article formatting.
+*
+* Revision 6.8 2009/10/02 19:44:49 kans
+* address clang static analyzer warnings
+*
* Revision 6.7 2005/12/29 13:46:18 bollin
* added PubdescContentMatch function
*
@@ -536,8 +542,8 @@ NLM_EXTERN ValNodePtr LIBCALL PubAsnRead (AsnIoPtr aip, AsnTypePtr orig)
DataVal av;
AsnTypePtr atp;
ValNodePtr anp=NULL;
- Uint1 choice;
- AsnReadFunc func;
+ Uint1 choice = 0;
+ AsnReadFunc func = NULL;
if (! loaded)
{
@@ -628,7 +634,7 @@ NLM_EXTERN ValNodePtr LIBCALL PubAsnRead (AsnIoPtr aip, AsnTypePtr orig)
}
anp->choice = choice;
- if ((choice != 4) && (choice != 13))
+ if ((choice != 4) && (choice != 13) && func != NULL)
{
anp->data.ptrvalue = (* func)(aip, atp);
if (anp->data.ptrvalue == NULL) goto erret;
@@ -685,10 +691,10 @@ NLM_EXTERN ValNodePtr LIBCALL PubSetFree (ValNodePtr anp)
NLM_EXTERN Boolean LIBCALL PubSetAsnWrite (ValNodePtr anp, AsnIoPtr aip, AsnTypePtr orig)
{
DataVal av;
- AsnTypePtr atp, settype, elementtype;
+ AsnTypePtr atp, settype = NULL, elementtype;
Pointer pnt;
Uint1 choice;
- AsnWriteFunc func;
+ AsnWriteFunc func = NULL;
ValNodePtr oldanp;
Boolean retval = FALSE;
@@ -760,7 +766,9 @@ NLM_EXTERN Boolean LIBCALL PubSetAsnWrite (ValNodePtr anp, AsnIoPtr aip, AsnType
pnt = (Pointer)anp;
else
pnt = anp->data.ptrvalue;
- if (! (*func)(pnt, aip, elementtype)) goto erret;
+ if (func != NULL) {
+ if (! (*func)(pnt, aip, elementtype)) goto erret;
+ }
anp = anp->next;
}
@@ -1458,7 +1466,7 @@ NLM_EXTERN Int2 LIBCALL PubLabelUnique (ValNodePtr pub, CharPtr buf, Int2 buflen
else
sprintf(tbuf, "NLM%ld", (long)(mep->uid));
diff = LabelCopyExtra(buf, tbuf, buflen, NULL, " ");
- buflen -= diff;
+ buflen -= diff; buf += diff;
cap = mep->cit;
goto cit_art;
case PUB_Article:
diff --git a/object/objvalid.c b/object/objvalid.c
index 76ab1377..8428a510 100644
--- a/object/objvalid.c
+++ b/object/objvalid.c
@@ -31,7 +31,7 @@ objvalidAsnLoad(void)
/**************************************************
* Generated object loaders for Module NCBI-Structured-comment-validation
-* Generated using ASNCODE Revision: 6.16 at Apr 7, 2009 1:38 PM
+* Generated using ASNCODE Revision: 6.16 at Dec 11, 2009 7:16 AM
*
**************************************************/
@@ -48,6 +48,7 @@ FieldRuleNew(void)
FieldRulePtr ptr = MemNew((size_t) sizeof(FieldRule));
ptr -> required = 0;
+ ptr -> severity = 2;
return ptr;
}
@@ -140,6 +141,13 @@ FieldRuleAsnRead(AsnIoPtr aip, AsnTypePtr orig)
ptr -> required = av.boolvalue;
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == FIELD_RULE_severity) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> severity = av.intvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
if (AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -201,6 +209,8 @@ FieldRuleAsnWrite(FieldRulePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
}
av.boolvalue = ptr -> required;
retval = AsnWrite(aip, FIELD_RULE_required, &av);
+ av.intvalue = ptr -> severity;
+ retval = AsnWrite(aip, FIELD_RULE_severity, &av);
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
}
@@ -329,6 +339,313 @@ erret:
/**************************************************
*
+* DependentFieldRuleNew()
+*
+**************************************************/
+NLM_EXTERN
+DependentFieldRulePtr LIBCALL
+DependentFieldRuleNew(void)
+{
+ DependentFieldRulePtr ptr = MemNew((size_t) sizeof(DependentFieldRule));
+
+ return ptr;
+
+}
+
+
+/**************************************************
+*
+* DependentFieldRuleFree()
+*
+**************************************************/
+NLM_EXTERN
+DependentFieldRulePtr LIBCALL
+DependentFieldRuleFree(DependentFieldRulePtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ MemFree(ptr -> match_name);
+ MemFree(ptr -> value_constraint);
+ FieldSetFree(ptr -> other_fields);
+ FieldSetFree(ptr -> disallowed_fields);
+ return MemFree(ptr);
+}
+
+
+/**************************************************
+*
+* DependentFieldRuleAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+DependentFieldRulePtr LIBCALL
+DependentFieldRuleAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean isError = FALSE;
+ AsnReadFunc func;
+ DependentFieldRulePtr ptr;
+
+ if (! loaded)
+ {
+ if (! objvalidAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* DependentFieldRule ::= (self contained) */
+ atp = AsnReadId(aip, amp, DEPENDENT_FIELD_RULE);
+ } else {
+ atp = AsnLinkType(orig, DEPENDENT_FIELD_RULE);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ ptr = DependentFieldRuleNew();
+ if (ptr == NULL) {
+ goto erret;
+ }
+ if (AsnReadVal(aip, atp, &av) <= 0) { /* read the start struct */
+ goto erret;
+ }
+
+ atp = AsnReadId(aip,amp, atp);
+ func = NULL;
+
+ if (atp == DEPENDENT_FIELD_RULE_match_name) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> match_name = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == FIELD_RULE_value_constraint) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> value_constraint = av.ptrvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == FIELD_RULE_other_fields) {
+ ptr -> other_fields = FieldSetAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == FIELD_RULE_disallowed_fields) {
+ ptr -> disallowed_fields = FieldSetAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
+
+ if (AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ /* end struct */
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = DependentFieldRuleFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* DependentFieldRuleAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+DependentFieldRuleAsnWrite(DependentFieldRulePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! objvalidAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, DEPENDENT_FIELD_RULE); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ if (! AsnOpenStruct(aip, atp, (Pointer) ptr)) {
+ goto erret;
+ }
+
+ if (ptr -> match_name != NULL) {
+ av.ptrvalue = ptr -> match_name;
+ retval = AsnWrite(aip, DEPENDENT_FIELD_RULE_match_name, &av);
+ }
+ if (ptr -> value_constraint != NULL) {
+ av.ptrvalue = ptr -> value_constraint;
+ retval = AsnWrite(aip, FIELD_RULE_value_constraint, &av);
+ }
+ if (ptr -> other_fields != NULL) {
+ if ( ! FieldSetAsnWrite(ptr -> other_fields, aip, FIELD_RULE_other_fields)) {
+ goto erret;
+ }
+ }
+ if (ptr -> disallowed_fields != NULL) {
+ if ( ! FieldSetAsnWrite(ptr -> disallowed_fields, aip, FIELD_RULE_disallowed_fields)) {
+ goto erret;
+ }
+ }
+ if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
+ goto erret;
+ }
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
+* DependentFieldSetFree()
+*
+**************************************************/
+NLM_EXTERN
+DependentFieldSetPtr LIBCALL
+DependentFieldSetFree(DependentFieldSetPtr ptr)
+{
+
+ if(ptr == NULL) {
+ return NULL;
+ }
+ AsnGenericUserSeqOfFree(ptr, (AsnOptFreeFunc) DependentFieldRuleFree);
+ return NULL;
+}
+
+
+/**************************************************
+*
+* DependentFieldSetAsnRead()
+*
+**************************************************/
+NLM_EXTERN
+DependentFieldSetPtr LIBCALL
+DependentFieldSetAsnRead(AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean isError = FALSE;
+ AsnReadFunc func;
+ DependentFieldSetPtr ptr;
+
+ if (! loaded)
+ {
+ if (! objvalidAsnLoad()) {
+ return NULL;
+ }
+ }
+
+ if (aip == NULL) {
+ return NULL;
+ }
+
+ if (orig == NULL) { /* DependentFieldSet ::= (self contained) */
+ atp = AsnReadId(aip, amp, DEPENDENT_FIELD_SET);
+ } else {
+ atp = AsnLinkType(orig, DEPENDENT_FIELD_SET);
+ }
+ /* link in local tree */
+ if (atp == NULL) {
+ return NULL;
+ }
+
+ func = NULL;
+
+ ptr = AsnGenericUserSeqOfAsnRead(aip, amp, atp, &isError, (AsnReadFunc) DependentFieldRuleAsnRead, (AsnOptFreeFunc) DependentFieldRuleFree);
+ if (isError && ptr == NULL) {
+ goto erret;
+ }
+
+
+
+ret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return ptr;
+
+erret:
+ aip -> io_failure = TRUE;
+ ptr = DependentFieldSetFree(ptr);
+ goto ret;
+}
+
+
+
+/**************************************************
+*
+* DependentFieldSetAsnWrite()
+*
+**************************************************/
+NLM_EXTERN Boolean LIBCALL
+DependentFieldSetAsnWrite(DependentFieldSetPtr ptr, AsnIoPtr aip, AsnTypePtr orig)
+{
+ DataVal av;
+ AsnTypePtr atp;
+ Boolean retval = FALSE;
+
+ if (! loaded)
+ {
+ if (! objvalidAsnLoad()) {
+ return FALSE;
+ }
+ }
+
+ if (aip == NULL) {
+ return FALSE;
+ }
+
+ atp = AsnLinkType(orig, DEPENDENT_FIELD_SET); /* link local tree */
+ if (atp == NULL) {
+ return FALSE;
+ }
+
+ if (ptr == NULL) { AsnNullValueMsg(aip, atp); goto erret; }
+ retval = AsnGenericUserSeqOfAsnWrite(ptr , (AsnWriteFunc) DependentFieldRuleAsnWrite, aip, atp, DEPENDENT_FIELD_SET_E);
+ retval = TRUE;
+
+erret:
+ AsnUnlinkType(orig); /* unlink local tree */
+ return retval;
+}
+
+
+
+/**************************************************
+*
* CommentRuleNew()
*
**************************************************/
@@ -339,6 +656,8 @@ CommentRuleNew(void)
CommentRulePtr ptr = MemNew((size_t) sizeof(CommentRule));
ptr -> updated = 0;
+ ptr -> require_order = 1;
+ ptr -> allow_unlisted = 0;
return ptr;
}
@@ -359,6 +678,7 @@ CommentRuleFree(CommentRulePtr ptr)
}
MemFree(ptr -> prefix);
FieldSetFree(ptr -> fields);
+ DependentFieldSetFree(ptr -> dependent_rules);
return MemFree(ptr);
}
@@ -431,6 +751,27 @@ CommentRuleAsnRead(AsnIoPtr aip, AsnTypePtr orig)
}
atp = AsnReadId(aip,amp, atp);
}
+ if (atp == COMMENT_RULE_require_order) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> require_order = av.boolvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == COMMENT_RULE_allow_unlisted) {
+ if ( AsnReadVal(aip, atp, &av) <= 0) {
+ goto erret;
+ }
+ ptr -> allow_unlisted = av.boolvalue;
+ atp = AsnReadId(aip,amp, atp);
+ }
+ if (atp == COMMENT_RULE_dependent_rules) {
+ ptr -> dependent_rules = DependentFieldSetAsnRead(aip, atp);
+ if (aip -> io_failure) {
+ goto erret;
+ }
+ atp = AsnReadId(aip,amp, atp);
+ }
if (AsnReadVal(aip, atp, &av) <= 0) {
goto erret;
@@ -493,6 +834,15 @@ CommentRuleAsnWrite(CommentRulePtr ptr, AsnIoPtr aip, AsnTypePtr orig)
goto erret;
}
}
+ av.boolvalue = ptr -> require_order;
+ retval = AsnWrite(aip, COMMENT_RULE_require_order, &av);
+ av.boolvalue = ptr -> allow_unlisted;
+ retval = AsnWrite(aip, COMMENT_RULE_allow_unlisted, &av);
+ if (ptr -> dependent_rules != NULL) {
+ if ( ! DependentFieldSetAsnWrite(ptr -> dependent_rules, aip, COMMENT_RULE_dependent_rules)) {
+ goto erret;
+ }
+ }
if (! AsnCloseStruct(aip, atp, (Pointer)ptr)) {
goto erret;
}
diff --git a/object/objvalid.h b/object/objvalid.h
index 49b9ff61..d8160b9b 100644
--- a/object/objvalid.h
+++ b/object/objvalid.h
@@ -17,12 +17,20 @@ extern "C" { /* } */
/**************************************************
*
* Generated objects for Module NCBI-Structured-comment-validation
-* Generated using ASNCODE Revision: 6.16 at Apr 7, 2009 1:38 PM
+* Generated using ASNCODE Revision: 6.16 at Dec 11, 2009 7:16 AM
*
**************************************************/
NLM_EXTERN Boolean LIBCALL
objvalidAsnLoad PROTO((void));
+/* following #defines are for enumerated type, not used by object loaders */
+#define Severity_level_none 0
+#define Severity_level_info 1
+#define Severity_level_warning 2
+#define Severity_level_error 3
+#define Severity_level_reject 4
+#define Severity_level_fatal 5
+
/**************************************************
@@ -35,6 +43,7 @@ typedef struct struct_Field_rule {
CharPtr field_name;
CharPtr match_expression;
Uint1 required;
+ Uint2 severity;
} FieldRule, PNTR FieldRulePtr;
@@ -67,6 +76,47 @@ NLM_EXTERN Boolean LIBCALL FieldSetAsnWrite PROTO (( FieldSetPtr , AsnIoPtr, Asn
/**************************************************
*
+* DependentFieldRule
+*
+**************************************************/
+typedef struct struct_Dependent_field_rule {
+ struct struct_Dependent_field_rule PNTR next;
+ CharPtr match_name;
+ CharPtr value_constraint;
+ struct struct_Field_rule PNTR other_fields;
+ struct struct_Field_rule PNTR disallowed_fields;
+} DependentFieldRule, PNTR DependentFieldRulePtr;
+
+
+NLM_EXTERN DependentFieldRulePtr LIBCALL DependentFieldRuleFree PROTO ((DependentFieldRulePtr ));
+NLM_EXTERN DependentFieldRulePtr LIBCALL DependentFieldRuleNew PROTO (( void ));
+NLM_EXTERN DependentFieldRulePtr LIBCALL DependentFieldRuleAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL DependentFieldRuleAsnWrite PROTO (( DependentFieldRulePtr , AsnIoPtr, AsnTypePtr));
+
+
+
+/**************************************************
+*
+* DependentFieldSet
+*
+**************************************************/
+typedef struct struct_Dependent_field_rule DependentFieldSet;
+typedef struct struct_Dependent_field_rule PNTR DependentFieldSetPtr;
+#define DependentFieldSetNew() Dependent_field_ruleNew()
+
+#ifdef NLM_GENERATED_CODE_PROTO
+
+NLM_EXTERN DependentFieldSetPtr LIBCALL DependentFieldSetFree PROTO ((DependentFieldSetPtr ));
+NLM_EXTERN DependentFieldSetPtr LIBCALL DependentFieldSetNew PROTO (( void ));
+NLM_EXTERN DependentFieldSetPtr LIBCALL DependentFieldSetAsnRead PROTO (( AsnIoPtr, AsnTypePtr));
+NLM_EXTERN Boolean LIBCALL DependentFieldSetAsnWrite PROTO (( DependentFieldSetPtr , AsnIoPtr, AsnTypePtr));
+
+#endif /* NLM_GENERATED_CODE_PROTO */
+
+
+
+/**************************************************
+*
* CommentRule
*
**************************************************/
@@ -75,6 +125,9 @@ typedef struct struct_Comment_rule {
CharPtr prefix;
Uint1 updated;
struct struct_Field_rule PNTR fields;
+ Uint1 require_order;
+ Uint1 allow_unlisted;
+ struct struct_Dependent_field_rule PNTR dependent_rules;
} CommentRule, PNTR CommentRulePtr;
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-29 12:22:55 +0000