e70152e44cc66cc599ff6b699eb8adc07f3e656a kent Sat May 24 21:09:34 2014 -0700 Adding Copyright NNNN Regents of the University of California to all files I believe with reasonable certainty were developed under UCSC employ or as part of Genome Browser copyright assignment. diff --git src/hg/blastToPsl/ncbiBlast.h src/hg/blastToPsl/ncbiBlast.h index a770acc..28b4e39 100644 --- src/hg/blastToPsl/ncbiBlast.h +++ src/hg/blastToPsl/ncbiBlast.h @@ -1,1484 +1,1487 @@ /* ncbiBlast.h autoXml generated file */ + +/* Copyright (C) 2010 The Regents of the University of California + * See README in this or parent directory for licensing information. */ #ifndef NCBIBLAST_H #define NCBIBLAST_H #ifndef XAP_H #include "xap.h" #endif /* The start and end handlers here are used with routines defined in xap.h. * In particular if you want to read just parts of the XML file into memory * call xapOpen() with these, and then xapNext() with the name of the tag * you want to load. */ void *ncbiBlastStartHandler(struct xap *xp, char *name, char **atts); /* Called by xap with start tag. Does most of the parsing work. */ void ncbiBlastEndHandler(struct xap *xp, char *name); /* Called by xap with end tag. Checks all required children are loaded. */ struct ncbiBlastBlastOutput { struct ncbiBlastBlastOutput *next; struct ncbiBlastBlastOutputProgram *ncbiBlastBlastOutputProgram; /** Single instance required. **/ struct ncbiBlastBlastOutputVersion *ncbiBlastBlastOutputVersion; /** Single instance required. **/ struct ncbiBlastBlastOutputReference *ncbiBlastBlastOutputReference; /** Single instance required. **/ struct ncbiBlastBlastOutputDb *ncbiBlastBlastOutputDb; /** Single instance required. **/ struct ncbiBlastBlastOutputQueryID *ncbiBlastBlastOutputQueryID; /** Single instance required. **/ struct ncbiBlastBlastOutputQueryDef *ncbiBlastBlastOutputQueryDef; /** Single instance required. **/ struct ncbiBlastBlastOutputQueryLen *ncbiBlastBlastOutputQueryLen; /** Single instance required. **/ struct ncbiBlastBlastOutputQuerySeq *ncbiBlastBlastOutputQuerySeq; /** Optional (may be NULL). **/ struct ncbiBlastBlastOutputParam *ncbiBlastBlastOutputParam; /** Single instance required. **/ struct ncbiBlastBlastOutputIterations *ncbiBlastBlastOutputIterations; /** Single instance required. **/ struct ncbiBlastBlastOutputMbstat *ncbiBlastBlastOutputMbstat; /** Optional (may be NULL). **/ }; void ncbiBlastBlastOutputFree(struct ncbiBlastBlastOutput **pObj); /* Free up ncbiBlastBlastOutput. */ void ncbiBlastBlastOutputFreeList(struct ncbiBlastBlastOutput **pList); /* Free up list of ncbiBlastBlastOutput. */ void ncbiBlastBlastOutputSave(struct ncbiBlastBlastOutput *obj, int indent, FILE *f); /* Save ncbiBlastBlastOutput to file. */ struct ncbiBlastBlastOutput *ncbiBlastBlastOutputLoad(char *fileName); /* Load ncbiBlastBlastOutput from XML file where it is root element. */ struct ncbiBlastBlastOutput *ncbiBlastBlastOutputLoadNext(struct xap *xap); /* Load next ncbiBlastBlastOutput element. Use xapOpen to get xap. */ struct ncbiBlastBlastOutputProgram { struct ncbiBlastBlastOutputProgram *next; char *text; }; void ncbiBlastBlastOutputProgramFree(struct ncbiBlastBlastOutputProgram **pObj); /* Free up ncbiBlastBlastOutputProgram. */ void ncbiBlastBlastOutputProgramFreeList(struct ncbiBlastBlastOutputProgram **pList); /* Free up list of ncbiBlastBlastOutputProgram. */ void ncbiBlastBlastOutputProgramSave(struct ncbiBlastBlastOutputProgram *obj, int indent, FILE *f); /* Save ncbiBlastBlastOutputProgram to file. */ struct ncbiBlastBlastOutputProgram *ncbiBlastBlastOutputProgramLoad(char *fileName); /* Load ncbiBlastBlastOutputProgram from XML file where it is root element. */ struct ncbiBlastBlastOutputProgram *ncbiBlastBlastOutputProgramLoadNext(struct xap *xap); /* Load next ncbiBlastBlastOutputProgram element. Use xapOpen to get xap. */ struct ncbiBlastBlastOutputVersion { struct ncbiBlastBlastOutputVersion *next; char *text; }; void ncbiBlastBlastOutputVersionFree(struct ncbiBlastBlastOutputVersion **pObj); /* Free up ncbiBlastBlastOutputVersion. */ void ncbiBlastBlastOutputVersionFreeList(struct ncbiBlastBlastOutputVersion **pList); /* Free up list of ncbiBlastBlastOutputVersion. */ void ncbiBlastBlastOutputVersionSave(struct ncbiBlastBlastOutputVersion *obj, int indent, FILE *f); /* Save ncbiBlastBlastOutputVersion to file. */ struct ncbiBlastBlastOutputVersion *ncbiBlastBlastOutputVersionLoad(char *fileName); /* Load ncbiBlastBlastOutputVersion from XML file where it is root element. */ struct ncbiBlastBlastOutputVersion *ncbiBlastBlastOutputVersionLoadNext(struct xap *xap); /* Load next ncbiBlastBlastOutputVersion element. Use xapOpen to get xap. */ struct ncbiBlastBlastOutputReference { struct ncbiBlastBlastOutputReference *next; char *text; }; void ncbiBlastBlastOutputReferenceFree(struct ncbiBlastBlastOutputReference **pObj); /* Free up ncbiBlastBlastOutputReference. */ void ncbiBlastBlastOutputReferenceFreeList(struct ncbiBlastBlastOutputReference **pList); /* Free up list of ncbiBlastBlastOutputReference. */ void ncbiBlastBlastOutputReferenceSave(struct ncbiBlastBlastOutputReference *obj, int indent, FILE *f); /* Save ncbiBlastBlastOutputReference to file. */ struct ncbiBlastBlastOutputReference *ncbiBlastBlastOutputReferenceLoad(char *fileName); /* Load ncbiBlastBlastOutputReference from XML file where it is root element. */ struct ncbiBlastBlastOutputReference *ncbiBlastBlastOutputReferenceLoadNext(struct xap *xap); /* Load next ncbiBlastBlastOutputReference element. Use xapOpen to get xap. */ struct ncbiBlastBlastOutputDb { struct ncbiBlastBlastOutputDb *next; char *text; }; void ncbiBlastBlastOutputDbFree(struct ncbiBlastBlastOutputDb **pObj); /* Free up ncbiBlastBlastOutputDb. */ void ncbiBlastBlastOutputDbFreeList(struct ncbiBlastBlastOutputDb **pList); /* Free up list of ncbiBlastBlastOutputDb. */ void ncbiBlastBlastOutputDbSave(struct ncbiBlastBlastOutputDb *obj, int indent, FILE *f); /* Save ncbiBlastBlastOutputDb to file. */ struct ncbiBlastBlastOutputDb *ncbiBlastBlastOutputDbLoad(char *fileName); /* Load ncbiBlastBlastOutputDb from XML file where it is root element. */ struct ncbiBlastBlastOutputDb *ncbiBlastBlastOutputDbLoadNext(struct xap *xap); /* Load next ncbiBlastBlastOutputDb element. Use xapOpen to get xap. */ struct ncbiBlastBlastOutputQueryID { struct ncbiBlastBlastOutputQueryID *next; char *text; }; void ncbiBlastBlastOutputQueryIDFree(struct ncbiBlastBlastOutputQueryID **pObj); /* Free up ncbiBlastBlastOutputQueryID. */ void ncbiBlastBlastOutputQueryIDFreeList(struct ncbiBlastBlastOutputQueryID **pList); /* Free up list of ncbiBlastBlastOutputQueryID. */ void ncbiBlastBlastOutputQueryIDSave(struct ncbiBlastBlastOutputQueryID *obj, int indent, FILE *f); /* Save ncbiBlastBlastOutputQueryID to file. */ struct ncbiBlastBlastOutputQueryID *ncbiBlastBlastOutputQueryIDLoad(char *fileName); /* Load ncbiBlastBlastOutputQueryID from XML file where it is root element. */ struct ncbiBlastBlastOutputQueryID *ncbiBlastBlastOutputQueryIDLoadNext(struct xap *xap); /* Load next ncbiBlastBlastOutputQueryID element. Use xapOpen to get xap. */ struct ncbiBlastBlastOutputQueryDef { struct ncbiBlastBlastOutputQueryDef *next; char *text; }; void ncbiBlastBlastOutputQueryDefFree(struct ncbiBlastBlastOutputQueryDef **pObj); /* Free up ncbiBlastBlastOutputQueryDef. */ void ncbiBlastBlastOutputQueryDefFreeList(struct ncbiBlastBlastOutputQueryDef **pList); /* Free up list of ncbiBlastBlastOutputQueryDef. */ void ncbiBlastBlastOutputQueryDefSave(struct ncbiBlastBlastOutputQueryDef *obj, int indent, FILE *f); /* Save ncbiBlastBlastOutputQueryDef to file. */ struct ncbiBlastBlastOutputQueryDef *ncbiBlastBlastOutputQueryDefLoad(char *fileName); /* Load ncbiBlastBlastOutputQueryDef from XML file where it is root element. */ struct ncbiBlastBlastOutputQueryDef *ncbiBlastBlastOutputQueryDefLoadNext(struct xap *xap); /* Load next ncbiBlastBlastOutputQueryDef element. Use xapOpen to get xap. */ struct ncbiBlastBlastOutputQueryLen { struct ncbiBlastBlastOutputQueryLen *next; int text; }; void ncbiBlastBlastOutputQueryLenFree(struct ncbiBlastBlastOutputQueryLen **pObj); /* Free up ncbiBlastBlastOutputQueryLen. */ void ncbiBlastBlastOutputQueryLenFreeList(struct ncbiBlastBlastOutputQueryLen **pList); /* Free up list of ncbiBlastBlastOutputQueryLen. */ void ncbiBlastBlastOutputQueryLenSave(struct ncbiBlastBlastOutputQueryLen *obj, int indent, FILE *f); /* Save ncbiBlastBlastOutputQueryLen to file. */ struct ncbiBlastBlastOutputQueryLen *ncbiBlastBlastOutputQueryLenLoad(char *fileName); /* Load ncbiBlastBlastOutputQueryLen from XML file where it is root element. */ struct ncbiBlastBlastOutputQueryLen *ncbiBlastBlastOutputQueryLenLoadNext(struct xap *xap); /* Load next ncbiBlastBlastOutputQueryLen element. Use xapOpen to get xap. */ struct ncbiBlastBlastOutputQuerySeq { struct ncbiBlastBlastOutputQuerySeq *next; char *text; }; void ncbiBlastBlastOutputQuerySeqFree(struct ncbiBlastBlastOutputQuerySeq **pObj); /* Free up ncbiBlastBlastOutputQuerySeq. */ void ncbiBlastBlastOutputQuerySeqFreeList(struct ncbiBlastBlastOutputQuerySeq **pList); /* Free up list of ncbiBlastBlastOutputQuerySeq. */ void ncbiBlastBlastOutputQuerySeqSave(struct ncbiBlastBlastOutputQuerySeq *obj, int indent, FILE *f); /* Save ncbiBlastBlastOutputQuerySeq to file. */ struct ncbiBlastBlastOutputQuerySeq *ncbiBlastBlastOutputQuerySeqLoad(char *fileName); /* Load ncbiBlastBlastOutputQuerySeq from XML file where it is root element. */ struct ncbiBlastBlastOutputQuerySeq *ncbiBlastBlastOutputQuerySeqLoadNext(struct xap *xap); /* Load next ncbiBlastBlastOutputQuerySeq element. Use xapOpen to get xap. */ struct ncbiBlastBlastOutputParam { struct ncbiBlastBlastOutputParam *next; struct ncbiBlastParameters *ncbiBlastParameters; /** Single instance required. **/ }; void ncbiBlastBlastOutputParamFree(struct ncbiBlastBlastOutputParam **pObj); /* Free up ncbiBlastBlastOutputParam. */ void ncbiBlastBlastOutputParamFreeList(struct ncbiBlastBlastOutputParam **pList); /* Free up list of ncbiBlastBlastOutputParam. */ void ncbiBlastBlastOutputParamSave(struct ncbiBlastBlastOutputParam *obj, int indent, FILE *f); /* Save ncbiBlastBlastOutputParam to file. */ struct ncbiBlastBlastOutputParam *ncbiBlastBlastOutputParamLoad(char *fileName); /* Load ncbiBlastBlastOutputParam from XML file where it is root element. */ struct ncbiBlastBlastOutputParam *ncbiBlastBlastOutputParamLoadNext(struct xap *xap); /* Load next ncbiBlastBlastOutputParam element. Use xapOpen to get xap. */ struct ncbiBlastBlastOutputIterations { struct ncbiBlastBlastOutputIterations *next; struct ncbiBlastIteration *ncbiBlastIteration; /** Possibly empty list. **/ }; void ncbiBlastBlastOutputIterationsFree(struct ncbiBlastBlastOutputIterations **pObj); /* Free up ncbiBlastBlastOutputIterations. */ void ncbiBlastBlastOutputIterationsFreeList(struct ncbiBlastBlastOutputIterations **pList); /* Free up list of ncbiBlastBlastOutputIterations. */ void ncbiBlastBlastOutputIterationsSave(struct ncbiBlastBlastOutputIterations *obj, int indent, FILE *f); /* Save ncbiBlastBlastOutputIterations to file. */ struct ncbiBlastBlastOutputIterations *ncbiBlastBlastOutputIterationsLoad(char *fileName); /* Load ncbiBlastBlastOutputIterations from XML file where it is root element. */ struct ncbiBlastBlastOutputIterations *ncbiBlastBlastOutputIterationsLoadNext(struct xap *xap); /* Load next ncbiBlastBlastOutputIterations element. Use xapOpen to get xap. */ struct ncbiBlastBlastOutputMbstat { struct ncbiBlastBlastOutputMbstat *next; struct ncbiBlastStatistics *ncbiBlastStatistics; /** Single instance required. **/ }; void ncbiBlastBlastOutputMbstatFree(struct ncbiBlastBlastOutputMbstat **pObj); /* Free up ncbiBlastBlastOutputMbstat. */ void ncbiBlastBlastOutputMbstatFreeList(struct ncbiBlastBlastOutputMbstat **pList); /* Free up list of ncbiBlastBlastOutputMbstat. */ void ncbiBlastBlastOutputMbstatSave(struct ncbiBlastBlastOutputMbstat *obj, int indent, FILE *f); /* Save ncbiBlastBlastOutputMbstat to file. */ struct ncbiBlastBlastOutputMbstat *ncbiBlastBlastOutputMbstatLoad(char *fileName); /* Load ncbiBlastBlastOutputMbstat from XML file where it is root element. */ struct ncbiBlastBlastOutputMbstat *ncbiBlastBlastOutputMbstatLoadNext(struct xap *xap); /* Load next ncbiBlastBlastOutputMbstat element. Use xapOpen to get xap. */ struct ncbiBlastIteration { struct ncbiBlastIteration *next; struct ncbiBlastIterationIterNum *ncbiBlastIterationIterNum; /** Single instance required. **/ struct ncbiBlastIterationQueryID *ncbiBlastIterationQueryID; /** Optional (may be NULL). **/ struct ncbiBlastIterationQueryDef *ncbiBlastIterationQueryDef; /** Optional (may be NULL). **/ struct ncbiBlastIterationQueryLen *ncbiBlastIterationQueryLen; /** Optional (may be NULL). **/ struct ncbiBlastIterationHits *ncbiBlastIterationHits; /** Optional (may be NULL). **/ struct ncbiBlastIterationStat *ncbiBlastIterationStat; /** Optional (may be NULL). **/ struct ncbiBlastIterationMessage *ncbiBlastIterationMessage; /** Optional (may be NULL). **/ }; void ncbiBlastIterationFree(struct ncbiBlastIteration **pObj); /* Free up ncbiBlastIteration. */ void ncbiBlastIterationFreeList(struct ncbiBlastIteration **pList); /* Free up list of ncbiBlastIteration. */ void ncbiBlastIterationSave(struct ncbiBlastIteration *obj, int indent, FILE *f); /* Save ncbiBlastIteration to file. */ struct ncbiBlastIteration *ncbiBlastIterationLoad(char *fileName); /* Load ncbiBlastIteration from XML file where it is root element. */ struct ncbiBlastIteration *ncbiBlastIterationLoadNext(struct xap *xap); /* Load next ncbiBlastIteration element. Use xapOpen to get xap. */ struct ncbiBlastIterationIterNum { struct ncbiBlastIterationIterNum *next; int text; }; void ncbiBlastIterationIterNumFree(struct ncbiBlastIterationIterNum **pObj); /* Free up ncbiBlastIterationIterNum. */ void ncbiBlastIterationIterNumFreeList(struct ncbiBlastIterationIterNum **pList); /* Free up list of ncbiBlastIterationIterNum. */ void ncbiBlastIterationIterNumSave(struct ncbiBlastIterationIterNum *obj, int indent, FILE *f); /* Save ncbiBlastIterationIterNum to file. */ struct ncbiBlastIterationIterNum *ncbiBlastIterationIterNumLoad(char *fileName); /* Load ncbiBlastIterationIterNum from XML file where it is root element. */ struct ncbiBlastIterationIterNum *ncbiBlastIterationIterNumLoadNext(struct xap *xap); /* Load next ncbiBlastIterationIterNum element. Use xapOpen to get xap. */ struct ncbiBlastIterationQueryID { struct ncbiBlastIterationQueryID *next; char *text; }; void ncbiBlastIterationQueryIDFree(struct ncbiBlastIterationQueryID **pObj); /* Free up ncbiBlastIterationQueryID. */ void ncbiBlastIterationQueryIDFreeList(struct ncbiBlastIterationQueryID **pList); /* Free up list of ncbiBlastIterationQueryID. */ void ncbiBlastIterationQueryIDSave(struct ncbiBlastIterationQueryID *obj, int indent, FILE *f); /* Save ncbiBlastIterationQueryID to file. */ struct ncbiBlastIterationQueryID *ncbiBlastIterationQueryIDLoad(char *fileName); /* Load ncbiBlastIterationQueryID from XML file where it is root element. */ struct ncbiBlastIterationQueryID *ncbiBlastIterationQueryIDLoadNext(struct xap *xap); /* Load next ncbiBlastIterationQueryID element. Use xapOpen to get xap. */ struct ncbiBlastIterationQueryDef { struct ncbiBlastIterationQueryDef *next; char *text; }; void ncbiBlastIterationQueryDefFree(struct ncbiBlastIterationQueryDef **pObj); /* Free up ncbiBlastIterationQueryDef. */ void ncbiBlastIterationQueryDefFreeList(struct ncbiBlastIterationQueryDef **pList); /* Free up list of ncbiBlastIterationQueryDef. */ void ncbiBlastIterationQueryDefSave(struct ncbiBlastIterationQueryDef *obj, int indent, FILE *f); /* Save ncbiBlastIterationQueryDef to file. */ struct ncbiBlastIterationQueryDef *ncbiBlastIterationQueryDefLoad(char *fileName); /* Load ncbiBlastIterationQueryDef from XML file where it is root element. */ struct ncbiBlastIterationQueryDef *ncbiBlastIterationQueryDefLoadNext(struct xap *xap); /* Load next ncbiBlastIterationQueryDef element. Use xapOpen to get xap. */ struct ncbiBlastIterationQueryLen { struct ncbiBlastIterationQueryLen *next; int text; }; void ncbiBlastIterationQueryLenFree(struct ncbiBlastIterationQueryLen **pObj); /* Free up ncbiBlastIterationQueryLen. */ void ncbiBlastIterationQueryLenFreeList(struct ncbiBlastIterationQueryLen **pList); /* Free up list of ncbiBlastIterationQueryLen. */ void ncbiBlastIterationQueryLenSave(struct ncbiBlastIterationQueryLen *obj, int indent, FILE *f); /* Save ncbiBlastIterationQueryLen to file. */ struct ncbiBlastIterationQueryLen *ncbiBlastIterationQueryLenLoad(char *fileName); /* Load ncbiBlastIterationQueryLen from XML file where it is root element. */ struct ncbiBlastIterationQueryLen *ncbiBlastIterationQueryLenLoadNext(struct xap *xap); /* Load next ncbiBlastIterationQueryLen element. Use xapOpen to get xap. */ struct ncbiBlastIterationHits { struct ncbiBlastIterationHits *next; struct ncbiBlastHit *ncbiBlastHit; /** Possibly empty list. **/ }; void ncbiBlastIterationHitsFree(struct ncbiBlastIterationHits **pObj); /* Free up ncbiBlastIterationHits. */ void ncbiBlastIterationHitsFreeList(struct ncbiBlastIterationHits **pList); /* Free up list of ncbiBlastIterationHits. */ void ncbiBlastIterationHitsSave(struct ncbiBlastIterationHits *obj, int indent, FILE *f); /* Save ncbiBlastIterationHits to file. */ struct ncbiBlastIterationHits *ncbiBlastIterationHitsLoad(char *fileName); /* Load ncbiBlastIterationHits from XML file where it is root element. */ struct ncbiBlastIterationHits *ncbiBlastIterationHitsLoadNext(struct xap *xap); /* Load next ncbiBlastIterationHits element. Use xapOpen to get xap. */ struct ncbiBlastIterationStat { struct ncbiBlastIterationStat *next; struct ncbiBlastStatistics *ncbiBlastStatistics; /** Single instance required. **/ }; void ncbiBlastIterationStatFree(struct ncbiBlastIterationStat **pObj); /* Free up ncbiBlastIterationStat. */ void ncbiBlastIterationStatFreeList(struct ncbiBlastIterationStat **pList); /* Free up list of ncbiBlastIterationStat. */ void ncbiBlastIterationStatSave(struct ncbiBlastIterationStat *obj, int indent, FILE *f); /* Save ncbiBlastIterationStat to file. */ struct ncbiBlastIterationStat *ncbiBlastIterationStatLoad(char *fileName); /* Load ncbiBlastIterationStat from XML file where it is root element. */ struct ncbiBlastIterationStat *ncbiBlastIterationStatLoadNext(struct xap *xap); /* Load next ncbiBlastIterationStat element. Use xapOpen to get xap. */ struct ncbiBlastIterationMessage { struct ncbiBlastIterationMessage *next; char *text; }; void ncbiBlastIterationMessageFree(struct ncbiBlastIterationMessage **pObj); /* Free up ncbiBlastIterationMessage. */ void ncbiBlastIterationMessageFreeList(struct ncbiBlastIterationMessage **pList); /* Free up list of ncbiBlastIterationMessage. */ void ncbiBlastIterationMessageSave(struct ncbiBlastIterationMessage *obj, int indent, FILE *f); /* Save ncbiBlastIterationMessage to file. */ struct ncbiBlastIterationMessage *ncbiBlastIterationMessageLoad(char *fileName); /* Load ncbiBlastIterationMessage from XML file where it is root element. */ struct ncbiBlastIterationMessage *ncbiBlastIterationMessageLoadNext(struct xap *xap); /* Load next ncbiBlastIterationMessage element. Use xapOpen to get xap. */ struct ncbiBlastParameters { struct ncbiBlastParameters *next; struct ncbiBlastParametersMatrix *ncbiBlastParametersMatrix; /** Optional (may be NULL). **/ struct ncbiBlastParametersExpect *ncbiBlastParametersExpect; /** Single instance required. **/ struct ncbiBlastParametersInclude *ncbiBlastParametersInclude; /** Optional (may be NULL). **/ struct ncbiBlastParametersScMatch *ncbiBlastParametersScMatch; /** Optional (may be NULL). **/ struct ncbiBlastParametersScMismatch *ncbiBlastParametersScMismatch; /** Optional (may be NULL). **/ struct ncbiBlastParametersGapOpen *ncbiBlastParametersGapOpen; /** Single instance required. **/ struct ncbiBlastParametersGapExtend *ncbiBlastParametersGapExtend; /** Single instance required. **/ struct ncbiBlastParametersFilter *ncbiBlastParametersFilter; /** Optional (may be NULL). **/ struct ncbiBlastParametersPattern *ncbiBlastParametersPattern; /** Optional (may be NULL). **/ struct ncbiBlastParametersEntrezQuery *ncbiBlastParametersEntrezQuery; /** Optional (may be NULL). **/ }; void ncbiBlastParametersFree(struct ncbiBlastParameters **pObj); /* Free up ncbiBlastParameters. */ void ncbiBlastParametersFreeList(struct ncbiBlastParameters **pList); /* Free up list of ncbiBlastParameters. */ void ncbiBlastParametersSave(struct ncbiBlastParameters *obj, int indent, FILE *f); /* Save ncbiBlastParameters to file. */ struct ncbiBlastParameters *ncbiBlastParametersLoad(char *fileName); /* Load ncbiBlastParameters from XML file where it is root element. */ struct ncbiBlastParameters *ncbiBlastParametersLoadNext(struct xap *xap); /* Load next ncbiBlastParameters element. Use xapOpen to get xap. */ struct ncbiBlastParametersMatrix { struct ncbiBlastParametersMatrix *next; char *text; }; void ncbiBlastParametersMatrixFree(struct ncbiBlastParametersMatrix **pObj); /* Free up ncbiBlastParametersMatrix. */ void ncbiBlastParametersMatrixFreeList(struct ncbiBlastParametersMatrix **pList); /* Free up list of ncbiBlastParametersMatrix. */ void ncbiBlastParametersMatrixSave(struct ncbiBlastParametersMatrix *obj, int indent, FILE *f); /* Save ncbiBlastParametersMatrix to file. */ struct ncbiBlastParametersMatrix *ncbiBlastParametersMatrixLoad(char *fileName); /* Load ncbiBlastParametersMatrix from XML file where it is root element. */ struct ncbiBlastParametersMatrix *ncbiBlastParametersMatrixLoadNext(struct xap *xap); /* Load next ncbiBlastParametersMatrix element. Use xapOpen to get xap. */ struct ncbiBlastParametersExpect { struct ncbiBlastParametersExpect *next; double text; }; void ncbiBlastParametersExpectFree(struct ncbiBlastParametersExpect **pObj); /* Free up ncbiBlastParametersExpect. */ void ncbiBlastParametersExpectFreeList(struct ncbiBlastParametersExpect **pList); /* Free up list of ncbiBlastParametersExpect. */ void ncbiBlastParametersExpectSave(struct ncbiBlastParametersExpect *obj, int indent, FILE *f); /* Save ncbiBlastParametersExpect to file. */ struct ncbiBlastParametersExpect *ncbiBlastParametersExpectLoad(char *fileName); /* Load ncbiBlastParametersExpect from XML file where it is root element. */ struct ncbiBlastParametersExpect *ncbiBlastParametersExpectLoadNext(struct xap *xap); /* Load next ncbiBlastParametersExpect element. Use xapOpen to get xap. */ struct ncbiBlastParametersInclude { struct ncbiBlastParametersInclude *next; double text; }; void ncbiBlastParametersIncludeFree(struct ncbiBlastParametersInclude **pObj); /* Free up ncbiBlastParametersInclude. */ void ncbiBlastParametersIncludeFreeList(struct ncbiBlastParametersInclude **pList); /* Free up list of ncbiBlastParametersInclude. */ void ncbiBlastParametersIncludeSave(struct ncbiBlastParametersInclude *obj, int indent, FILE *f); /* Save ncbiBlastParametersInclude to file. */ struct ncbiBlastParametersInclude *ncbiBlastParametersIncludeLoad(char *fileName); /* Load ncbiBlastParametersInclude from XML file where it is root element. */ struct ncbiBlastParametersInclude *ncbiBlastParametersIncludeLoadNext(struct xap *xap); /* Load next ncbiBlastParametersInclude element. Use xapOpen to get xap. */ struct ncbiBlastParametersScMatch { struct ncbiBlastParametersScMatch *next; int text; }; void ncbiBlastParametersScMatchFree(struct ncbiBlastParametersScMatch **pObj); /* Free up ncbiBlastParametersScMatch. */ void ncbiBlastParametersScMatchFreeList(struct ncbiBlastParametersScMatch **pList); /* Free up list of ncbiBlastParametersScMatch. */ void ncbiBlastParametersScMatchSave(struct ncbiBlastParametersScMatch *obj, int indent, FILE *f); /* Save ncbiBlastParametersScMatch to file. */ struct ncbiBlastParametersScMatch *ncbiBlastParametersScMatchLoad(char *fileName); /* Load ncbiBlastParametersScMatch from XML file where it is root element. */ struct ncbiBlastParametersScMatch *ncbiBlastParametersScMatchLoadNext(struct xap *xap); /* Load next ncbiBlastParametersScMatch element. Use xapOpen to get xap. */ struct ncbiBlastParametersScMismatch { struct ncbiBlastParametersScMismatch *next; int text; }; void ncbiBlastParametersScMismatchFree(struct ncbiBlastParametersScMismatch **pObj); /* Free up ncbiBlastParametersScMismatch. */ void ncbiBlastParametersScMismatchFreeList(struct ncbiBlastParametersScMismatch **pList); /* Free up list of ncbiBlastParametersScMismatch. */ void ncbiBlastParametersScMismatchSave(struct ncbiBlastParametersScMismatch *obj, int indent, FILE *f); /* Save ncbiBlastParametersScMismatch to file. */ struct ncbiBlastParametersScMismatch *ncbiBlastParametersScMismatchLoad(char *fileName); /* Load ncbiBlastParametersScMismatch from XML file where it is root element. */ struct ncbiBlastParametersScMismatch *ncbiBlastParametersScMismatchLoadNext(struct xap *xap); /* Load next ncbiBlastParametersScMismatch element. Use xapOpen to get xap. */ struct ncbiBlastParametersGapOpen { struct ncbiBlastParametersGapOpen *next; int text; }; void ncbiBlastParametersGapOpenFree(struct ncbiBlastParametersGapOpen **pObj); /* Free up ncbiBlastParametersGapOpen. */ void ncbiBlastParametersGapOpenFreeList(struct ncbiBlastParametersGapOpen **pList); /* Free up list of ncbiBlastParametersGapOpen. */ void ncbiBlastParametersGapOpenSave(struct ncbiBlastParametersGapOpen *obj, int indent, FILE *f); /* Save ncbiBlastParametersGapOpen to file. */ struct ncbiBlastParametersGapOpen *ncbiBlastParametersGapOpenLoad(char *fileName); /* Load ncbiBlastParametersGapOpen from XML file where it is root element. */ struct ncbiBlastParametersGapOpen *ncbiBlastParametersGapOpenLoadNext(struct xap *xap); /* Load next ncbiBlastParametersGapOpen element. Use xapOpen to get xap. */ struct ncbiBlastParametersGapExtend { struct ncbiBlastParametersGapExtend *next; int text; }; void ncbiBlastParametersGapExtendFree(struct ncbiBlastParametersGapExtend **pObj); /* Free up ncbiBlastParametersGapExtend. */ void ncbiBlastParametersGapExtendFreeList(struct ncbiBlastParametersGapExtend **pList); /* Free up list of ncbiBlastParametersGapExtend. */ void ncbiBlastParametersGapExtendSave(struct ncbiBlastParametersGapExtend *obj, int indent, FILE *f); /* Save ncbiBlastParametersGapExtend to file. */ struct ncbiBlastParametersGapExtend *ncbiBlastParametersGapExtendLoad(char *fileName); /* Load ncbiBlastParametersGapExtend from XML file where it is root element. */ struct ncbiBlastParametersGapExtend *ncbiBlastParametersGapExtendLoadNext(struct xap *xap); /* Load next ncbiBlastParametersGapExtend element. Use xapOpen to get xap. */ struct ncbiBlastParametersFilter { struct ncbiBlastParametersFilter *next; char *text; }; void ncbiBlastParametersFilterFree(struct ncbiBlastParametersFilter **pObj); /* Free up ncbiBlastParametersFilter. */ void ncbiBlastParametersFilterFreeList(struct ncbiBlastParametersFilter **pList); /* Free up list of ncbiBlastParametersFilter. */ void ncbiBlastParametersFilterSave(struct ncbiBlastParametersFilter *obj, int indent, FILE *f); /* Save ncbiBlastParametersFilter to file. */ struct ncbiBlastParametersFilter *ncbiBlastParametersFilterLoad(char *fileName); /* Load ncbiBlastParametersFilter from XML file where it is root element. */ struct ncbiBlastParametersFilter *ncbiBlastParametersFilterLoadNext(struct xap *xap); /* Load next ncbiBlastParametersFilter element. Use xapOpen to get xap. */ struct ncbiBlastParametersPattern { struct ncbiBlastParametersPattern *next; char *text; }; void ncbiBlastParametersPatternFree(struct ncbiBlastParametersPattern **pObj); /* Free up ncbiBlastParametersPattern. */ void ncbiBlastParametersPatternFreeList(struct ncbiBlastParametersPattern **pList); /* Free up list of ncbiBlastParametersPattern. */ void ncbiBlastParametersPatternSave(struct ncbiBlastParametersPattern *obj, int indent, FILE *f); /* Save ncbiBlastParametersPattern to file. */ struct ncbiBlastParametersPattern *ncbiBlastParametersPatternLoad(char *fileName); /* Load ncbiBlastParametersPattern from XML file where it is root element. */ struct ncbiBlastParametersPattern *ncbiBlastParametersPatternLoadNext(struct xap *xap); /* Load next ncbiBlastParametersPattern element. Use xapOpen to get xap. */ struct ncbiBlastParametersEntrezQuery { struct ncbiBlastParametersEntrezQuery *next; char *text; }; void ncbiBlastParametersEntrezQueryFree(struct ncbiBlastParametersEntrezQuery **pObj); /* Free up ncbiBlastParametersEntrezQuery. */ void ncbiBlastParametersEntrezQueryFreeList(struct ncbiBlastParametersEntrezQuery **pList); /* Free up list of ncbiBlastParametersEntrezQuery. */ void ncbiBlastParametersEntrezQuerySave(struct ncbiBlastParametersEntrezQuery *obj, int indent, FILE *f); /* Save ncbiBlastParametersEntrezQuery to file. */ struct ncbiBlastParametersEntrezQuery *ncbiBlastParametersEntrezQueryLoad(char *fileName); /* Load ncbiBlastParametersEntrezQuery from XML file where it is root element. */ struct ncbiBlastParametersEntrezQuery *ncbiBlastParametersEntrezQueryLoadNext(struct xap *xap); /* Load next ncbiBlastParametersEntrezQuery element. Use xapOpen to get xap. */ struct ncbiBlastStatistics { struct ncbiBlastStatistics *next; struct ncbiBlastStatisticsDbNum *ncbiBlastStatisticsDbNum; /** Single instance required. **/ struct ncbiBlastStatisticsDbLen *ncbiBlastStatisticsDbLen; /** Single instance required. **/ struct ncbiBlastStatisticsHspLen *ncbiBlastStatisticsHspLen; /** Single instance required. **/ struct ncbiBlastStatisticsEffSpace *ncbiBlastStatisticsEffSpace; /** Single instance required. **/ struct ncbiBlastStatisticsKappa *ncbiBlastStatisticsKappa; /** Single instance required. **/ struct ncbiBlastStatisticsLambda *ncbiBlastStatisticsLambda; /** Single instance required. **/ struct ncbiBlastStatisticsEntropy *ncbiBlastStatisticsEntropy; /** Single instance required. **/ }; void ncbiBlastStatisticsFree(struct ncbiBlastStatistics **pObj); /* Free up ncbiBlastStatistics. */ void ncbiBlastStatisticsFreeList(struct ncbiBlastStatistics **pList); /* Free up list of ncbiBlastStatistics. */ void ncbiBlastStatisticsSave(struct ncbiBlastStatistics *obj, int indent, FILE *f); /* Save ncbiBlastStatistics to file. */ struct ncbiBlastStatistics *ncbiBlastStatisticsLoad(char *fileName); /* Load ncbiBlastStatistics from XML file where it is root element. */ struct ncbiBlastStatistics *ncbiBlastStatisticsLoadNext(struct xap *xap); /* Load next ncbiBlastStatistics element. Use xapOpen to get xap. */ struct ncbiBlastStatisticsDbNum { struct ncbiBlastStatisticsDbNum *next; int text; }; void ncbiBlastStatisticsDbNumFree(struct ncbiBlastStatisticsDbNum **pObj); /* Free up ncbiBlastStatisticsDbNum. */ void ncbiBlastStatisticsDbNumFreeList(struct ncbiBlastStatisticsDbNum **pList); /* Free up list of ncbiBlastStatisticsDbNum. */ void ncbiBlastStatisticsDbNumSave(struct ncbiBlastStatisticsDbNum *obj, int indent, FILE *f); /* Save ncbiBlastStatisticsDbNum to file. */ struct ncbiBlastStatisticsDbNum *ncbiBlastStatisticsDbNumLoad(char *fileName); /* Load ncbiBlastStatisticsDbNum from XML file where it is root element. */ struct ncbiBlastStatisticsDbNum *ncbiBlastStatisticsDbNumLoadNext(struct xap *xap); /* Load next ncbiBlastStatisticsDbNum element. Use xapOpen to get xap. */ struct ncbiBlastStatisticsDbLen { struct ncbiBlastStatisticsDbLen *next; int text; }; void ncbiBlastStatisticsDbLenFree(struct ncbiBlastStatisticsDbLen **pObj); /* Free up ncbiBlastStatisticsDbLen. */ void ncbiBlastStatisticsDbLenFreeList(struct ncbiBlastStatisticsDbLen **pList); /* Free up list of ncbiBlastStatisticsDbLen. */ void ncbiBlastStatisticsDbLenSave(struct ncbiBlastStatisticsDbLen *obj, int indent, FILE *f); /* Save ncbiBlastStatisticsDbLen to file. */ struct ncbiBlastStatisticsDbLen *ncbiBlastStatisticsDbLenLoad(char *fileName); /* Load ncbiBlastStatisticsDbLen from XML file where it is root element. */ struct ncbiBlastStatisticsDbLen *ncbiBlastStatisticsDbLenLoadNext(struct xap *xap); /* Load next ncbiBlastStatisticsDbLen element. Use xapOpen to get xap. */ struct ncbiBlastStatisticsHspLen { struct ncbiBlastStatisticsHspLen *next; int text; }; void ncbiBlastStatisticsHspLenFree(struct ncbiBlastStatisticsHspLen **pObj); /* Free up ncbiBlastStatisticsHspLen. */ void ncbiBlastStatisticsHspLenFreeList(struct ncbiBlastStatisticsHspLen **pList); /* Free up list of ncbiBlastStatisticsHspLen. */ void ncbiBlastStatisticsHspLenSave(struct ncbiBlastStatisticsHspLen *obj, int indent, FILE *f); /* Save ncbiBlastStatisticsHspLen to file. */ struct ncbiBlastStatisticsHspLen *ncbiBlastStatisticsHspLenLoad(char *fileName); /* Load ncbiBlastStatisticsHspLen from XML file where it is root element. */ struct ncbiBlastStatisticsHspLen *ncbiBlastStatisticsHspLenLoadNext(struct xap *xap); /* Load next ncbiBlastStatisticsHspLen element. Use xapOpen to get xap. */ struct ncbiBlastStatisticsEffSpace { struct ncbiBlastStatisticsEffSpace *next; double text; }; void ncbiBlastStatisticsEffSpaceFree(struct ncbiBlastStatisticsEffSpace **pObj); /* Free up ncbiBlastStatisticsEffSpace. */ void ncbiBlastStatisticsEffSpaceFreeList(struct ncbiBlastStatisticsEffSpace **pList); /* Free up list of ncbiBlastStatisticsEffSpace. */ void ncbiBlastStatisticsEffSpaceSave(struct ncbiBlastStatisticsEffSpace *obj, int indent, FILE *f); /* Save ncbiBlastStatisticsEffSpace to file. */ struct ncbiBlastStatisticsEffSpace *ncbiBlastStatisticsEffSpaceLoad(char *fileName); /* Load ncbiBlastStatisticsEffSpace from XML file where it is root element. */ struct ncbiBlastStatisticsEffSpace *ncbiBlastStatisticsEffSpaceLoadNext(struct xap *xap); /* Load next ncbiBlastStatisticsEffSpace element. Use xapOpen to get xap. */ struct ncbiBlastStatisticsKappa { struct ncbiBlastStatisticsKappa *next; double text; }; void ncbiBlastStatisticsKappaFree(struct ncbiBlastStatisticsKappa **pObj); /* Free up ncbiBlastStatisticsKappa. */ void ncbiBlastStatisticsKappaFreeList(struct ncbiBlastStatisticsKappa **pList); /* Free up list of ncbiBlastStatisticsKappa. */ void ncbiBlastStatisticsKappaSave(struct ncbiBlastStatisticsKappa *obj, int indent, FILE *f); /* Save ncbiBlastStatisticsKappa to file. */ struct ncbiBlastStatisticsKappa *ncbiBlastStatisticsKappaLoad(char *fileName); /* Load ncbiBlastStatisticsKappa from XML file where it is root element. */ struct ncbiBlastStatisticsKappa *ncbiBlastStatisticsKappaLoadNext(struct xap *xap); /* Load next ncbiBlastStatisticsKappa element. Use xapOpen to get xap. */ struct ncbiBlastStatisticsLambda { struct ncbiBlastStatisticsLambda *next; double text; }; void ncbiBlastStatisticsLambdaFree(struct ncbiBlastStatisticsLambda **pObj); /* Free up ncbiBlastStatisticsLambda. */ void ncbiBlastStatisticsLambdaFreeList(struct ncbiBlastStatisticsLambda **pList); /* Free up list of ncbiBlastStatisticsLambda. */ void ncbiBlastStatisticsLambdaSave(struct ncbiBlastStatisticsLambda *obj, int indent, FILE *f); /* Save ncbiBlastStatisticsLambda to file. */ struct ncbiBlastStatisticsLambda *ncbiBlastStatisticsLambdaLoad(char *fileName); /* Load ncbiBlastStatisticsLambda from XML file where it is root element. */ struct ncbiBlastStatisticsLambda *ncbiBlastStatisticsLambdaLoadNext(struct xap *xap); /* Load next ncbiBlastStatisticsLambda element. Use xapOpen to get xap. */ struct ncbiBlastStatisticsEntropy { struct ncbiBlastStatisticsEntropy *next; double text; }; void ncbiBlastStatisticsEntropyFree(struct ncbiBlastStatisticsEntropy **pObj); /* Free up ncbiBlastStatisticsEntropy. */ void ncbiBlastStatisticsEntropyFreeList(struct ncbiBlastStatisticsEntropy **pList); /* Free up list of ncbiBlastStatisticsEntropy. */ void ncbiBlastStatisticsEntropySave(struct ncbiBlastStatisticsEntropy *obj, int indent, FILE *f); /* Save ncbiBlastStatisticsEntropy to file. */ struct ncbiBlastStatisticsEntropy *ncbiBlastStatisticsEntropyLoad(char *fileName); /* Load ncbiBlastStatisticsEntropy from XML file where it is root element. */ struct ncbiBlastStatisticsEntropy *ncbiBlastStatisticsEntropyLoadNext(struct xap *xap); /* Load next ncbiBlastStatisticsEntropy element. Use xapOpen to get xap. */ struct ncbiBlastHit { struct ncbiBlastHit *next; struct ncbiBlastHitNum *ncbiBlastHitNum; /** Single instance required. **/ struct ncbiBlastHitId *ncbiBlastHitId; /** Single instance required. **/ struct ncbiBlastHitDef *ncbiBlastHitDef; /** Single instance required. **/ struct ncbiBlastHitAccession *ncbiBlastHitAccession; /** Single instance required. **/ struct ncbiBlastHitLen *ncbiBlastHitLen; /** Single instance required. **/ struct ncbiBlastHitHsps *ncbiBlastHitHsps; /** Optional (may be NULL). **/ }; void ncbiBlastHitFree(struct ncbiBlastHit **pObj); /* Free up ncbiBlastHit. */ void ncbiBlastHitFreeList(struct ncbiBlastHit **pList); /* Free up list of ncbiBlastHit. */ void ncbiBlastHitSave(struct ncbiBlastHit *obj, int indent, FILE *f); /* Save ncbiBlastHit to file. */ struct ncbiBlastHit *ncbiBlastHitLoad(char *fileName); /* Load ncbiBlastHit from XML file where it is root element. */ struct ncbiBlastHit *ncbiBlastHitLoadNext(struct xap *xap); /* Load next ncbiBlastHit element. Use xapOpen to get xap. */ struct ncbiBlastHitNum { struct ncbiBlastHitNum *next; int text; }; void ncbiBlastHitNumFree(struct ncbiBlastHitNum **pObj); /* Free up ncbiBlastHitNum. */ void ncbiBlastHitNumFreeList(struct ncbiBlastHitNum **pList); /* Free up list of ncbiBlastHitNum. */ void ncbiBlastHitNumSave(struct ncbiBlastHitNum *obj, int indent, FILE *f); /* Save ncbiBlastHitNum to file. */ struct ncbiBlastHitNum *ncbiBlastHitNumLoad(char *fileName); /* Load ncbiBlastHitNum from XML file where it is root element. */ struct ncbiBlastHitNum *ncbiBlastHitNumLoadNext(struct xap *xap); /* Load next ncbiBlastHitNum element. Use xapOpen to get xap. */ struct ncbiBlastHitId { struct ncbiBlastHitId *next; char *text; }; void ncbiBlastHitIdFree(struct ncbiBlastHitId **pObj); /* Free up ncbiBlastHitId. */ void ncbiBlastHitIdFreeList(struct ncbiBlastHitId **pList); /* Free up list of ncbiBlastHitId. */ void ncbiBlastHitIdSave(struct ncbiBlastHitId *obj, int indent, FILE *f); /* Save ncbiBlastHitId to file. */ struct ncbiBlastHitId *ncbiBlastHitIdLoad(char *fileName); /* Load ncbiBlastHitId from XML file where it is root element. */ struct ncbiBlastHitId *ncbiBlastHitIdLoadNext(struct xap *xap); /* Load next ncbiBlastHitId element. Use xapOpen to get xap. */ struct ncbiBlastHitDef { struct ncbiBlastHitDef *next; char *text; }; void ncbiBlastHitDefFree(struct ncbiBlastHitDef **pObj); /* Free up ncbiBlastHitDef. */ void ncbiBlastHitDefFreeList(struct ncbiBlastHitDef **pList); /* Free up list of ncbiBlastHitDef. */ void ncbiBlastHitDefSave(struct ncbiBlastHitDef *obj, int indent, FILE *f); /* Save ncbiBlastHitDef to file. */ struct ncbiBlastHitDef *ncbiBlastHitDefLoad(char *fileName); /* Load ncbiBlastHitDef from XML file where it is root element. */ struct ncbiBlastHitDef *ncbiBlastHitDefLoadNext(struct xap *xap); /* Load next ncbiBlastHitDef element. Use xapOpen to get xap. */ struct ncbiBlastHitAccession { struct ncbiBlastHitAccession *next; char *text; }; void ncbiBlastHitAccessionFree(struct ncbiBlastHitAccession **pObj); /* Free up ncbiBlastHitAccession. */ void ncbiBlastHitAccessionFreeList(struct ncbiBlastHitAccession **pList); /* Free up list of ncbiBlastHitAccession. */ void ncbiBlastHitAccessionSave(struct ncbiBlastHitAccession *obj, int indent, FILE *f); /* Save ncbiBlastHitAccession to file. */ struct ncbiBlastHitAccession *ncbiBlastHitAccessionLoad(char *fileName); /* Load ncbiBlastHitAccession from XML file where it is root element. */ struct ncbiBlastHitAccession *ncbiBlastHitAccessionLoadNext(struct xap *xap); /* Load next ncbiBlastHitAccession element. Use xapOpen to get xap. */ struct ncbiBlastHitLen { struct ncbiBlastHitLen *next; int text; }; void ncbiBlastHitLenFree(struct ncbiBlastHitLen **pObj); /* Free up ncbiBlastHitLen. */ void ncbiBlastHitLenFreeList(struct ncbiBlastHitLen **pList); /* Free up list of ncbiBlastHitLen. */ void ncbiBlastHitLenSave(struct ncbiBlastHitLen *obj, int indent, FILE *f); /* Save ncbiBlastHitLen to file. */ struct ncbiBlastHitLen *ncbiBlastHitLenLoad(char *fileName); /* Load ncbiBlastHitLen from XML file where it is root element. */ struct ncbiBlastHitLen *ncbiBlastHitLenLoadNext(struct xap *xap); /* Load next ncbiBlastHitLen element. Use xapOpen to get xap. */ struct ncbiBlastHitHsps { struct ncbiBlastHitHsps *next; struct ncbiBlastHsp *ncbiBlastHsp; /** Possibly empty list. **/ }; void ncbiBlastHitHspsFree(struct ncbiBlastHitHsps **pObj); /* Free up ncbiBlastHitHsps. */ void ncbiBlastHitHspsFreeList(struct ncbiBlastHitHsps **pList); /* Free up list of ncbiBlastHitHsps. */ void ncbiBlastHitHspsSave(struct ncbiBlastHitHsps *obj, int indent, FILE *f); /* Save ncbiBlastHitHsps to file. */ struct ncbiBlastHitHsps *ncbiBlastHitHspsLoad(char *fileName); /* Load ncbiBlastHitHsps from XML file where it is root element. */ struct ncbiBlastHitHsps *ncbiBlastHitHspsLoadNext(struct xap *xap); /* Load next ncbiBlastHitHsps element. Use xapOpen to get xap. */ struct ncbiBlastHsp { struct ncbiBlastHsp *next; struct ncbiBlastHspNum *ncbiBlastHspNum; /** Single instance required. **/ struct ncbiBlastHspBitScore *ncbiBlastHspBitScore; /** Single instance required. **/ struct ncbiBlastHspScore *ncbiBlastHspScore; /** Single instance required. **/ struct ncbiBlastHspEvalue *ncbiBlastHspEvalue; /** Single instance required. **/ struct ncbiBlastHspQueryFrom *ncbiBlastHspQueryFrom; /** Single instance required. **/ struct ncbiBlastHspQueryTo *ncbiBlastHspQueryTo; /** Single instance required. **/ struct ncbiBlastHspHitFrom *ncbiBlastHspHitFrom; /** Single instance required. **/ struct ncbiBlastHspHitTo *ncbiBlastHspHitTo; /** Single instance required. **/ struct ncbiBlastHspPatternFrom *ncbiBlastHspPatternFrom; /** Optional (may be NULL). **/ struct ncbiBlastHspPatternTo *ncbiBlastHspPatternTo; /** Optional (may be NULL). **/ struct ncbiBlastHspQueryFrame *ncbiBlastHspQueryFrame; /** Optional (may be NULL). **/ struct ncbiBlastHspHitFrame *ncbiBlastHspHitFrame; /** Optional (may be NULL). **/ struct ncbiBlastHspIdentity *ncbiBlastHspIdentity; /** Optional (may be NULL). **/ struct ncbiBlastHspPositive *ncbiBlastHspPositive; /** Optional (may be NULL). **/ struct ncbiBlastHspGaps *ncbiBlastHspGaps; /** Optional (may be NULL). **/ struct ncbiBlastHspAlignLen *ncbiBlastHspAlignLen; /** Optional (may be NULL). **/ struct ncbiBlastHspDensity *ncbiBlastHspDensity; /** Optional (may be NULL). **/ struct ncbiBlastHspQseq *ncbiBlastHspQseq; /** Single instance required. **/ struct ncbiBlastHspHseq *ncbiBlastHspHseq; /** Single instance required. **/ struct ncbiBlastHspMidline *ncbiBlastHspMidline; /** Optional (may be NULL). **/ }; void ncbiBlastHspFree(struct ncbiBlastHsp **pObj); /* Free up ncbiBlastHsp. */ void ncbiBlastHspFreeList(struct ncbiBlastHsp **pList); /* Free up list of ncbiBlastHsp. */ void ncbiBlastHspSave(struct ncbiBlastHsp *obj, int indent, FILE *f); /* Save ncbiBlastHsp to file. */ struct ncbiBlastHsp *ncbiBlastHspLoad(char *fileName); /* Load ncbiBlastHsp from XML file where it is root element. */ struct ncbiBlastHsp *ncbiBlastHspLoadNext(struct xap *xap); /* Load next ncbiBlastHsp element. Use xapOpen to get xap. */ struct ncbiBlastHspNum { struct ncbiBlastHspNum *next; int text; }; void ncbiBlastHspNumFree(struct ncbiBlastHspNum **pObj); /* Free up ncbiBlastHspNum. */ void ncbiBlastHspNumFreeList(struct ncbiBlastHspNum **pList); /* Free up list of ncbiBlastHspNum. */ void ncbiBlastHspNumSave(struct ncbiBlastHspNum *obj, int indent, FILE *f); /* Save ncbiBlastHspNum to file. */ struct ncbiBlastHspNum *ncbiBlastHspNumLoad(char *fileName); /* Load ncbiBlastHspNum from XML file where it is root element. */ struct ncbiBlastHspNum *ncbiBlastHspNumLoadNext(struct xap *xap); /* Load next ncbiBlastHspNum element. Use xapOpen to get xap. */ struct ncbiBlastHspBitScore { struct ncbiBlastHspBitScore *next; double text; }; void ncbiBlastHspBitScoreFree(struct ncbiBlastHspBitScore **pObj); /* Free up ncbiBlastHspBitScore. */ void ncbiBlastHspBitScoreFreeList(struct ncbiBlastHspBitScore **pList); /* Free up list of ncbiBlastHspBitScore. */ void ncbiBlastHspBitScoreSave(struct ncbiBlastHspBitScore *obj, int indent, FILE *f); /* Save ncbiBlastHspBitScore to file. */ struct ncbiBlastHspBitScore *ncbiBlastHspBitScoreLoad(char *fileName); /* Load ncbiBlastHspBitScore from XML file where it is root element. */ struct ncbiBlastHspBitScore *ncbiBlastHspBitScoreLoadNext(struct xap *xap); /* Load next ncbiBlastHspBitScore element. Use xapOpen to get xap. */ struct ncbiBlastHspScore { struct ncbiBlastHspScore *next; double text; }; void ncbiBlastHspScoreFree(struct ncbiBlastHspScore **pObj); /* Free up ncbiBlastHspScore. */ void ncbiBlastHspScoreFreeList(struct ncbiBlastHspScore **pList); /* Free up list of ncbiBlastHspScore. */ void ncbiBlastHspScoreSave(struct ncbiBlastHspScore *obj, int indent, FILE *f); /* Save ncbiBlastHspScore to file. */ struct ncbiBlastHspScore *ncbiBlastHspScoreLoad(char *fileName); /* Load ncbiBlastHspScore from XML file where it is root element. */ struct ncbiBlastHspScore *ncbiBlastHspScoreLoadNext(struct xap *xap); /* Load next ncbiBlastHspScore element. Use xapOpen to get xap. */ struct ncbiBlastHspEvalue { struct ncbiBlastHspEvalue *next; double text; }; void ncbiBlastHspEvalueFree(struct ncbiBlastHspEvalue **pObj); /* Free up ncbiBlastHspEvalue. */ void ncbiBlastHspEvalueFreeList(struct ncbiBlastHspEvalue **pList); /* Free up list of ncbiBlastHspEvalue. */ void ncbiBlastHspEvalueSave(struct ncbiBlastHspEvalue *obj, int indent, FILE *f); /* Save ncbiBlastHspEvalue to file. */ struct ncbiBlastHspEvalue *ncbiBlastHspEvalueLoad(char *fileName); /* Load ncbiBlastHspEvalue from XML file where it is root element. */ struct ncbiBlastHspEvalue *ncbiBlastHspEvalueLoadNext(struct xap *xap); /* Load next ncbiBlastHspEvalue element. Use xapOpen to get xap. */ struct ncbiBlastHspQueryFrom { struct ncbiBlastHspQueryFrom *next; int text; }; void ncbiBlastHspQueryFromFree(struct ncbiBlastHspQueryFrom **pObj); /* Free up ncbiBlastHspQueryFrom. */ void ncbiBlastHspQueryFromFreeList(struct ncbiBlastHspQueryFrom **pList); /* Free up list of ncbiBlastHspQueryFrom. */ void ncbiBlastHspQueryFromSave(struct ncbiBlastHspQueryFrom *obj, int indent, FILE *f); /* Save ncbiBlastHspQueryFrom to file. */ struct ncbiBlastHspQueryFrom *ncbiBlastHspQueryFromLoad(char *fileName); /* Load ncbiBlastHspQueryFrom from XML file where it is root element. */ struct ncbiBlastHspQueryFrom *ncbiBlastHspQueryFromLoadNext(struct xap *xap); /* Load next ncbiBlastHspQueryFrom element. Use xapOpen to get xap. */ struct ncbiBlastHspQueryTo { struct ncbiBlastHspQueryTo *next; int text; }; void ncbiBlastHspQueryToFree(struct ncbiBlastHspQueryTo **pObj); /* Free up ncbiBlastHspQueryTo. */ void ncbiBlastHspQueryToFreeList(struct ncbiBlastHspQueryTo **pList); /* Free up list of ncbiBlastHspQueryTo. */ void ncbiBlastHspQueryToSave(struct ncbiBlastHspQueryTo *obj, int indent, FILE *f); /* Save ncbiBlastHspQueryTo to file. */ struct ncbiBlastHspQueryTo *ncbiBlastHspQueryToLoad(char *fileName); /* Load ncbiBlastHspQueryTo from XML file where it is root element. */ struct ncbiBlastHspQueryTo *ncbiBlastHspQueryToLoadNext(struct xap *xap); /* Load next ncbiBlastHspQueryTo element. Use xapOpen to get xap. */ struct ncbiBlastHspHitFrom { struct ncbiBlastHspHitFrom *next; int text; }; void ncbiBlastHspHitFromFree(struct ncbiBlastHspHitFrom **pObj); /* Free up ncbiBlastHspHitFrom. */ void ncbiBlastHspHitFromFreeList(struct ncbiBlastHspHitFrom **pList); /* Free up list of ncbiBlastHspHitFrom. */ void ncbiBlastHspHitFromSave(struct ncbiBlastHspHitFrom *obj, int indent, FILE *f); /* Save ncbiBlastHspHitFrom to file. */ struct ncbiBlastHspHitFrom *ncbiBlastHspHitFromLoad(char *fileName); /* Load ncbiBlastHspHitFrom from XML file where it is root element. */ struct ncbiBlastHspHitFrom *ncbiBlastHspHitFromLoadNext(struct xap *xap); /* Load next ncbiBlastHspHitFrom element. Use xapOpen to get xap. */ struct ncbiBlastHspHitTo { struct ncbiBlastHspHitTo *next; int text; }; void ncbiBlastHspHitToFree(struct ncbiBlastHspHitTo **pObj); /* Free up ncbiBlastHspHitTo. */ void ncbiBlastHspHitToFreeList(struct ncbiBlastHspHitTo **pList); /* Free up list of ncbiBlastHspHitTo. */ void ncbiBlastHspHitToSave(struct ncbiBlastHspHitTo *obj, int indent, FILE *f); /* Save ncbiBlastHspHitTo to file. */ struct ncbiBlastHspHitTo *ncbiBlastHspHitToLoad(char *fileName); /* Load ncbiBlastHspHitTo from XML file where it is root element. */ struct ncbiBlastHspHitTo *ncbiBlastHspHitToLoadNext(struct xap *xap); /* Load next ncbiBlastHspHitTo element. Use xapOpen to get xap. */ struct ncbiBlastHspPatternFrom { struct ncbiBlastHspPatternFrom *next; int text; }; void ncbiBlastHspPatternFromFree(struct ncbiBlastHspPatternFrom **pObj); /* Free up ncbiBlastHspPatternFrom. */ void ncbiBlastHspPatternFromFreeList(struct ncbiBlastHspPatternFrom **pList); /* Free up list of ncbiBlastHspPatternFrom. */ void ncbiBlastHspPatternFromSave(struct ncbiBlastHspPatternFrom *obj, int indent, FILE *f); /* Save ncbiBlastHspPatternFrom to file. */ struct ncbiBlastHspPatternFrom *ncbiBlastHspPatternFromLoad(char *fileName); /* Load ncbiBlastHspPatternFrom from XML file where it is root element. */ struct ncbiBlastHspPatternFrom *ncbiBlastHspPatternFromLoadNext(struct xap *xap); /* Load next ncbiBlastHspPatternFrom element. Use xapOpen to get xap. */ struct ncbiBlastHspPatternTo { struct ncbiBlastHspPatternTo *next; int text; }; void ncbiBlastHspPatternToFree(struct ncbiBlastHspPatternTo **pObj); /* Free up ncbiBlastHspPatternTo. */ void ncbiBlastHspPatternToFreeList(struct ncbiBlastHspPatternTo **pList); /* Free up list of ncbiBlastHspPatternTo. */ void ncbiBlastHspPatternToSave(struct ncbiBlastHspPatternTo *obj, int indent, FILE *f); /* Save ncbiBlastHspPatternTo to file. */ struct ncbiBlastHspPatternTo *ncbiBlastHspPatternToLoad(char *fileName); /* Load ncbiBlastHspPatternTo from XML file where it is root element. */ struct ncbiBlastHspPatternTo *ncbiBlastHspPatternToLoadNext(struct xap *xap); /* Load next ncbiBlastHspPatternTo element. Use xapOpen to get xap. */ struct ncbiBlastHspQueryFrame { struct ncbiBlastHspQueryFrame *next; int text; }; void ncbiBlastHspQueryFrameFree(struct ncbiBlastHspQueryFrame **pObj); /* Free up ncbiBlastHspQueryFrame. */ void ncbiBlastHspQueryFrameFreeList(struct ncbiBlastHspQueryFrame **pList); /* Free up list of ncbiBlastHspQueryFrame. */ void ncbiBlastHspQueryFrameSave(struct ncbiBlastHspQueryFrame *obj, int indent, FILE *f); /* Save ncbiBlastHspQueryFrame to file. */ struct ncbiBlastHspQueryFrame *ncbiBlastHspQueryFrameLoad(char *fileName); /* Load ncbiBlastHspQueryFrame from XML file where it is root element. */ struct ncbiBlastHspQueryFrame *ncbiBlastHspQueryFrameLoadNext(struct xap *xap); /* Load next ncbiBlastHspQueryFrame element. Use xapOpen to get xap. */ struct ncbiBlastHspHitFrame { struct ncbiBlastHspHitFrame *next; int text; }; void ncbiBlastHspHitFrameFree(struct ncbiBlastHspHitFrame **pObj); /* Free up ncbiBlastHspHitFrame. */ void ncbiBlastHspHitFrameFreeList(struct ncbiBlastHspHitFrame **pList); /* Free up list of ncbiBlastHspHitFrame. */ void ncbiBlastHspHitFrameSave(struct ncbiBlastHspHitFrame *obj, int indent, FILE *f); /* Save ncbiBlastHspHitFrame to file. */ struct ncbiBlastHspHitFrame *ncbiBlastHspHitFrameLoad(char *fileName); /* Load ncbiBlastHspHitFrame from XML file where it is root element. */ struct ncbiBlastHspHitFrame *ncbiBlastHspHitFrameLoadNext(struct xap *xap); /* Load next ncbiBlastHspHitFrame element. Use xapOpen to get xap. */ struct ncbiBlastHspIdentity { struct ncbiBlastHspIdentity *next; int text; }; void ncbiBlastHspIdentityFree(struct ncbiBlastHspIdentity **pObj); /* Free up ncbiBlastHspIdentity. */ void ncbiBlastHspIdentityFreeList(struct ncbiBlastHspIdentity **pList); /* Free up list of ncbiBlastHspIdentity. */ void ncbiBlastHspIdentitySave(struct ncbiBlastHspIdentity *obj, int indent, FILE *f); /* Save ncbiBlastHspIdentity to file. */ struct ncbiBlastHspIdentity *ncbiBlastHspIdentityLoad(char *fileName); /* Load ncbiBlastHspIdentity from XML file where it is root element. */ struct ncbiBlastHspIdentity *ncbiBlastHspIdentityLoadNext(struct xap *xap); /* Load next ncbiBlastHspIdentity element. Use xapOpen to get xap. */ struct ncbiBlastHspPositive { struct ncbiBlastHspPositive *next; int text; }; void ncbiBlastHspPositiveFree(struct ncbiBlastHspPositive **pObj); /* Free up ncbiBlastHspPositive. */ void ncbiBlastHspPositiveFreeList(struct ncbiBlastHspPositive **pList); /* Free up list of ncbiBlastHspPositive. */ void ncbiBlastHspPositiveSave(struct ncbiBlastHspPositive *obj, int indent, FILE *f); /* Save ncbiBlastHspPositive to file. */ struct ncbiBlastHspPositive *ncbiBlastHspPositiveLoad(char *fileName); /* Load ncbiBlastHspPositive from XML file where it is root element. */ struct ncbiBlastHspPositive *ncbiBlastHspPositiveLoadNext(struct xap *xap); /* Load next ncbiBlastHspPositive element. Use xapOpen to get xap. */ struct ncbiBlastHspGaps { struct ncbiBlastHspGaps *next; int text; }; void ncbiBlastHspGapsFree(struct ncbiBlastHspGaps **pObj); /* Free up ncbiBlastHspGaps. */ void ncbiBlastHspGapsFreeList(struct ncbiBlastHspGaps **pList); /* Free up list of ncbiBlastHspGaps. */ void ncbiBlastHspGapsSave(struct ncbiBlastHspGaps *obj, int indent, FILE *f); /* Save ncbiBlastHspGaps to file. */ struct ncbiBlastHspGaps *ncbiBlastHspGapsLoad(char *fileName); /* Load ncbiBlastHspGaps from XML file where it is root element. */ struct ncbiBlastHspGaps *ncbiBlastHspGapsLoadNext(struct xap *xap); /* Load next ncbiBlastHspGaps element. Use xapOpen to get xap. */ struct ncbiBlastHspAlignLen { struct ncbiBlastHspAlignLen *next; int text; }; void ncbiBlastHspAlignLenFree(struct ncbiBlastHspAlignLen **pObj); /* Free up ncbiBlastHspAlignLen. */ void ncbiBlastHspAlignLenFreeList(struct ncbiBlastHspAlignLen **pList); /* Free up list of ncbiBlastHspAlignLen. */ void ncbiBlastHspAlignLenSave(struct ncbiBlastHspAlignLen *obj, int indent, FILE *f); /* Save ncbiBlastHspAlignLen to file. */ struct ncbiBlastHspAlignLen *ncbiBlastHspAlignLenLoad(char *fileName); /* Load ncbiBlastHspAlignLen from XML file where it is root element. */ struct ncbiBlastHspAlignLen *ncbiBlastHspAlignLenLoadNext(struct xap *xap); /* Load next ncbiBlastHspAlignLen element. Use xapOpen to get xap. */ struct ncbiBlastHspDensity { struct ncbiBlastHspDensity *next; int text; }; void ncbiBlastHspDensityFree(struct ncbiBlastHspDensity **pObj); /* Free up ncbiBlastHspDensity. */ void ncbiBlastHspDensityFreeList(struct ncbiBlastHspDensity **pList); /* Free up list of ncbiBlastHspDensity. */ void ncbiBlastHspDensitySave(struct ncbiBlastHspDensity *obj, int indent, FILE *f); /* Save ncbiBlastHspDensity to file. */ struct ncbiBlastHspDensity *ncbiBlastHspDensityLoad(char *fileName); /* Load ncbiBlastHspDensity from XML file where it is root element. */ struct ncbiBlastHspDensity *ncbiBlastHspDensityLoadNext(struct xap *xap); /* Load next ncbiBlastHspDensity element. Use xapOpen to get xap. */ struct ncbiBlastHspQseq { struct ncbiBlastHspQseq *next; char *text; }; void ncbiBlastHspQseqFree(struct ncbiBlastHspQseq **pObj); /* Free up ncbiBlastHspQseq. */ void ncbiBlastHspQseqFreeList(struct ncbiBlastHspQseq **pList); /* Free up list of ncbiBlastHspQseq. */ void ncbiBlastHspQseqSave(struct ncbiBlastHspQseq *obj, int indent, FILE *f); /* Save ncbiBlastHspQseq to file. */ struct ncbiBlastHspQseq *ncbiBlastHspQseqLoad(char *fileName); /* Load ncbiBlastHspQseq from XML file where it is root element. */ struct ncbiBlastHspQseq *ncbiBlastHspQseqLoadNext(struct xap *xap); /* Load next ncbiBlastHspQseq element. Use xapOpen to get xap. */ struct ncbiBlastHspHseq { struct ncbiBlastHspHseq *next; char *text; }; void ncbiBlastHspHseqFree(struct ncbiBlastHspHseq **pObj); /* Free up ncbiBlastHspHseq. */ void ncbiBlastHspHseqFreeList(struct ncbiBlastHspHseq **pList); /* Free up list of ncbiBlastHspHseq. */ void ncbiBlastHspHseqSave(struct ncbiBlastHspHseq *obj, int indent, FILE *f); /* Save ncbiBlastHspHseq to file. */ struct ncbiBlastHspHseq *ncbiBlastHspHseqLoad(char *fileName); /* Load ncbiBlastHspHseq from XML file where it is root element. */ struct ncbiBlastHspHseq *ncbiBlastHspHseqLoadNext(struct xap *xap); /* Load next ncbiBlastHspHseq element. Use xapOpen to get xap. */ struct ncbiBlastHspMidline { struct ncbiBlastHspMidline *next; char *text; }; void ncbiBlastHspMidlineFree(struct ncbiBlastHspMidline **pObj); /* Free up ncbiBlastHspMidline. */ void ncbiBlastHspMidlineFreeList(struct ncbiBlastHspMidline **pList); /* Free up list of ncbiBlastHspMidline. */ void ncbiBlastHspMidlineSave(struct ncbiBlastHspMidline *obj, int indent, FILE *f); /* Save ncbiBlastHspMidline to file. */ struct ncbiBlastHspMidline *ncbiBlastHspMidlineLoad(char *fileName); /* Load ncbiBlastHspMidline from XML file where it is root element. */ struct ncbiBlastHspMidline *ncbiBlastHspMidlineLoadNext(struct xap *xap); /* Load next ncbiBlastHspMidline element. Use xapOpen to get xap. */ #endif /* NCBIBLAST_H */