ID AcdEStage
TY public
MO ajacd
LB acd
XX
DE ACD level of parsing
XX
VN QUAL_STAGE
VD Qualifier parsing
VX
VN APPL_STAGE
VD Application parsing
VX
VN VAR_STAGE
VD Variable parsing
VX
VN REL_STAGE
VD Relation parsing
VX
VN SEC_STAGE
VD Section parsing
VX
VN ENDSEC_STAGE
VD End section parsing
VX
VN BAD_STAGE
VD Stage parsing error
VX
VN NO_STAGE
VD No parsing nstage defined
VX
//
typedef enum
{
QUAL_STAGE, APPL_STAGE, VAR_STAGE, REL_STAGE,
SEC_STAGE, ENDSEC_STAGE, BAD_STAGE, NO_STAGE
} AcdEStage;
ID AcdELevel
TY public
MO ajacd
LB acd
XX
DE ACD item level as defined in the ACD structure
XX
VN ACD_APPL
VD Application
VX
VN ACD_PARAM
VD Positonal parameter
VX
VN ACD_QUAL
VD Qualifier
VX
VN ACD_VAR
VD Internal variable
VX
VN ACD_RELATION
VD Standalone relation
VX
VN ACD_SEC
VD Section
VX
VN ACD_ENDSEC
VD End of section
VX
//
typedef enum
{
ACD_APPL,
ACD_PARAM,
ACD_QUAL,
ACD_VAR,
ACD_RELATION,
ACD_SEC,
ACD_ENDSEC
} AcdELevel;
ID AcdPAttrAlias
TY static
MO ajacd
LB acd
XX
DE ACD attribute old names and their new equivalents
DE
DE Commonly used abbreviations of the old names are also included.
XX
TN AcdSAttrAlias
TD
TX
TN AcdOAttrAlias
TD
TX
AN OldName
AT const char*
AD Attribute name in a previous EMBOSS/AJAX release
AX
AN NewName
AT const char*
AD Current attribute name
AX
//
typedef struct AcdSAttrAlias
{
const char* OldName;
const char* NewName;
} AcdOAttrAlias;
#define AcdPAttrAlias AcdOAttrAlias*
ID AcdPAttr
TY static
MO ajacd
LB acd
XX
DE ACD attribute definition structure
XX
TN AcdSAttr
TD
TX
TN AcdOAttr
TD
TX
AN Name
AT const char*
AD Attribute name
AX
AN Type
AT enum AcdEValtype
AD Type code
AX
AN Multiple
AT AjBool
AD True if multiple values are allowed
AX
AN Default
AT const char*
AD Default value as a string for help
AD and documentation
AX
AN Help
AT const char*
AD Descriptive short text for documentation
AX
//
typedef struct AcdSAttr
{
const char* Name;
enum AcdEValtype Type;
AjBool Multiple;
const char* Default;
const char* Help;
} AcdOAttr;
#define AcdPAttr AcdOAttr*
ID AcdPQual
TY static
MO ajacd
LB acd
XX
DE ACD qualifier definition structure
XX
TN AcdSQual
TD
TX
TN AcdOQual
TD
TX
AN Name
AT const char*
AD Qualifier name
AX
AN Default
AT const char*
AD Default value as a string for help
AD and documentation
AX
AN Type
AT const char*
AD Type boolean, integer, float or string
AX
AN Help
AT const char*
AD Help text for documentation and for -help output
AX
//
typedef struct AcdSQual
{
const char* Name;
const char* Default;
const char* Type;
const char* Help;
} AcdOQual;
#define AcdPQual AcdOQual*
ID AcdPTableItem
TY static
MO ajacd
LB acd
XX
DE Help table structure
XX
TN AcdSTableItem
TD
TX
TN AcdOTableItem
TD
TX
AN Qual
AT AjPStr
AD Qualifier name
AX
AN Type
AT AjPStr
AD Qualifier type
AX
AN Help
AT AjPStr
AD Help text
AX
AN Valid
AT AjPStr
AD Valid input
AX
AN Expect
AT AjPStr
AD Expected value(s)
AX
AN Title
AT AjPStr
AD Section title
AX
//
typedef struct AcdSTableItem
{
AjPStr Qual;
AjPStr Type;
AjPStr Help;
AjPStr Valid;
AjPStr Expect;
AjPStr Title;
} AcdOTableItem;
#define AcdPTableItem AcdOTableItem*
ID AcdPXsdItem
TY static
MO ajacd
LB acd
XX
DE XSD data structure
XX
TN AcdSXsdItem
TD
TX
TN AcdOXsdItem
TD
TX
AN Qual
AT AjPStr
AD Qualifier name
AX
AN Type
AT AjPStr
AD Qualifier type
AX
AN Annotation
AT AjPStr
AD Annotation text
AX
AN Relation
AT AjPStr
AD Relation attributes text
AX
AN Valid
AT AjPStr
AD Valid input
AX
AN Expect
AT AjPStr
AD Expected value(s)
AX
AN Required
AT AjBool
AD True if a required value
AX
AN Optional
AT AjBool
AD True if an optional value
AX
//
typedef struct AcdSXsdItem
{
AjPStr Qual;
AjPStr Type;
AjPStr Annotation;
AjPStr Relation;
AjPStr Valid;
AjPStr Expect;
AjBool Required;
AjBool Optional;
} AcdOXsdItem;
#define AcdPXsdItem AcdOXsdItem*
ID AcdPGalaxyItem
TY static
MO ajacd
LB acd
XX
DE Galaxy data structure
XX
TN AcdSGalaxyItem
TD
TX
TN AcdOGalaxyItem
TD
TX
AN Qual
AT AjPStr
AD Qualifier name
AX
AN Type
AT AjPStr
AD Qualifier type
AX
AN Prompt
AT AjPStr
AD Prompt text
AX
AN Annotation
AT AjPStr
AD Annotation text
AX
AN Relation
AT AjPStr
AD Relation attributes text
AX
AN Valid
AT AjPStr
AD Valid input
AX
AN Expect
AT AjPStr
AD Expected value(s)
AX
AN Required
AT AjBool
AD True if a required value
AX
AN Optional
AT AjBool
AD True if an optional value
AX
//
typedef struct AcdSGalaxyItem
{
AjPStr Qual;
AjPStr Type;
AjPStr Prompt;
AjPStr Annotation;
AjPStr Relation;
AjPStr Valid;
AjPStr Expect;
AjBool Required;
AjBool Optional;
} AcdOGalaxyItem;
#define AcdPGalaxyItem AcdOGalaxyItem*
ID AcdPAcd
TY static
MO ajacd
LB acd
XX
DE AJAX Command Definition item data.
DE
DE ACDs are built as an ACD file is parsed, and are processed as a
DE list in sequential order.
DE
DE ACDs contain type information. Some functions will only work on certain
DE types of ACDs.
DE
DE All ACD items are in a list. The base ACD item points to the next,
DE and so on until the Next pointer is NULL.
DE
DE There is currently no destructor. No need for one at present.
XX
NN acdNewQual
ND Creates a qualifier ACD
NX
NN acdNewQualQual
ND Creates an associated qualifier ACD
NX
NN acdNewAppl
ND Creates an ACD application
NX
NN acdNewVar
ND Creates an ACD variable
NX
NN acdNewAcd
ND General constructor
NX
AN Next
AT struct AcdSAcd*
AD Pointer to next ACD item
AX
AN Name
AT AjPStr
AD ACD item name
AX
AN Token
AT AjPStr
AD Command line qualifier (usually the same as Name)
AX
AN PNum
AT ajint
AD Parameter number, or zero if not a parameter
AX
AN Level
AT AcdELevel
AD ACD type class (qual/param, var, appl, etc.)
AX
AN Type
AT ajint
AD Index into acdType or acdKeywords
AX
AN NAttr
AT ajint
AD Number of ACD type-specific attributes
AX
AN AttrStr
AT AjPStr*
AD Definitions of ACD type-specific attributes
AX
AN SetAttr
AT AcdPAttr
AD Definitions of calculated attributes
AX
AN SetStr
AT AjPPStr
AD Values for the calculated attributes (SetAttr)
AX
AN DefStr
AT AjPPStr
AD Values for the default attributes
AX
AN Defined
AT AjBool
AD Set when a value is defined on the commandline
AD or by an associated qualifier ACD attribute
AX
AN UserDefined
AT AjBool
AD Set when a value is defined by the user
AD including replies to prompts
AX
AN UserSetNull
AT AjBool
AD Set when a value is undefined by the user
AD with -no before a qualifier name
AX
AN Used
AT ajint
AD Use count, saved for a possible diagnostic message to
AD catch ACD items declared and never referenced by the
AD calling program.
AX
AN RefPassed
AT ajint
AD Enumerated value for reference 0= not passed,
AD 1= values only passed,
AD 2= values and reference passed
AX
AN LineNum
AT ajint
AD Source file line number of definition start,
AD saved for use in diagnostic messages
AX
AN SAttr
AT ajint
AD Number of calculated attributes for this ACD type
AX
AN Assoc
AT AjBool
AD ajTrue if this is an associated qualifier, listed
AD in the AssocQuals structure of another ACD item
AX
AN AssocQuals
AT struct AcdSAcd*
AD Associated qualifiers list, or
AD NULL if there are none for this ACD type
AX
AN StdPrompt
AT AjPStr
AD Standard prompt set for some types by
AD an acdPrompt function
AX
AN OrigStr
AT AjPStr
AD Original string saved for later processing
AX
AN ValStr
AT AjPStr
AD Value as a string for printing
AX
AN Value
AT void*
AD Value as a pointer to the native object to be
AD returned by an ajAcdGet function call
AX
//
typedef struct AcdSAcd
{
struct AcdSAcd* Next;
AjPStr Name;
AjPStr Token;
ajint PNum;
AcdELevel Level;
ajint Type;
ajint NAttr;
AjPStr* AttrStr;
AcdPAttr SetAttr;
AjPPStr SetStr;
AjPPStr DefStr;
AjBool Defined;
AjBool UserDefined;
AjBool UserSetNull;
ajint Used;
ajint RefPassed;
ajint LineNum;
ajint SAttr;
AjBool Assoc;
struct AcdSAcd* AssocQuals;
AjPStr StdPrompt;
AjPStr OrigStr;
AjPStr ValStr;
void* Value;
} AcdOAcd;
#define AcdPAcd AcdOAcd*
ID AcdPSection
TY static
MO ajacd
LB acd
XX
DE ACD section definition
XX
TN AcdSSection
TD
TX
TN AcdOSection
TD
TX
AN Name
AT const char*
AD Section name
AX
AN Description
AT const char*
AD Section description
AX
AN Type
AT const char*
AD Section type "page"
AX
//
typedef struct AcdSSection
{
const char* Name;
const char* Description;
const char* Type;
} AcdOSection;
#define AcdPSection AcdOSection*
ID AcdPType
TY static
MO ajacd
LB acd
XX
DE ACD data type structure
XX
TN AcdSType
TD
TX
TN AcdOType
TD
TX
AN Name
AT const char*
AD Attribute type name
AX
AN Group
AT const char*
AD Attribute group name
AX
AN Section
AT AcdPSection
AD Expected section
AX
AN Attr
AT AcdPAttr
AD Type-specific attributes
AX
AN Quals
AT AcdPQual
AD Type-specific associated qualifiers
AX
AN TypeSet
AT void function
AD Function to set value and prompt user
AX
AN HelpSet
AT void function
AD Function to set help text
AX
AN TypeDel
AT void function
AD Function to delete value
AX
AN PassByRef
AT AjBool
AD Pass by reference - so caller owns the object
AX
AN Stdprompt
AT AjBool
AD Expect a standard prompt
AX
AN Prompt
AT const AjPStr function
AD Function to set standard prompt
AX
AN UseCount
AT ajint*
AD Number of times this type has been used
AX
AN UseClassCount
AT ajint*
AD Number of times this class of types
AD has been used
AX
AN Valid
AT const char*
AD Valid data help message and description for
AD documentation
AX
//
typedef struct AcdSType
{
const char* Name;
const char* Group;
AcdPSection Section;
AcdPAttr Attr;
AcdPQual Quals;
void (*TypeSet)(AcdPAcd thys);
void (*HelpSet)(const AcdPAcd thys, AjPStr* msg);
void (*TypeDel)(void**);
AjBool PassByRef;
AjBool Stdprompt;
const AjPStr (*Prompt)(AcdPAcd thys);
ajint* UseCount;
ajint* UseClassCount;
const char* Valid;
} AcdOType;
#define AcdPType AcdOType*
ID AcdPExpList
TY static
MO ajacd
LB acd
XX
DE Exression list structure for named expressions XX
TN AcdSExpList
TD
TX
TN AcdOExpList
TD
TX
AN Name
AT const char*
AD Expression name
AX
AN Func
AT AjBool function
AD Function to evaluate expression
AX
//
typedef struct AcdSExpList
{
const char* Name;
AjBool (*Func) (AjPStr *result, const AjPStr str);
} AcdOExpList;
#define AcdPExpList AcdOExpList*
ID AcdPKey
TY static
MO ajacd
LB acd
XX
DE Keywords data structure for non-ACD types (application, variable, section,
DE endsection) data
XX
TN AcdSKey
TD
TX
TN AcdOKey
TD
TX
AN Name
AT const char*
AD Keyword name
AX
AN Stage
AT AcdEStage
AD Enumerated stage
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
AN Attr
AT AcdPAttr
AD Type-specific attributes
AX
AN KeySet
AT void function
AD Function to set value and prompt user
AX
//
typedef struct AcdSKey
{
const char* Name;
AcdEStage Stage;
ajint Padding;
AcdPAttr Attr;
void (*KeySet)(AcdPAcd thys);
} AcdOKey;
#define AcdPKey AcdOKey*
ID AcdPOuttype
TY static
MO ajacd
LB acd
XX
DE Output types data structure for utput data types and format validation
XX
TN AcdSOuttype
TD
TX
TN AcdOouttype
TD
TX
AN Name
AT const char*
AD Output type name
AX
AN Format
AT const char*
AD Default format (needs to be stored elsewhere)
AX
AN Type
AT AjEOutfileType
AD AJAX Output File enumeration
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
AN Prompt
AT const AjPStr function
AD Function to define standard prompt
AX
AN Outformat
AT AjBool function
AD Function to test output format
AX
//
typedef struct AcdSOuttype
{
const char* Name;
const char* Format;
AjEOutfileType Type;
ajint Padding;
const AjPStr (*Prompt)(AcdPAcd thys);
AjBool (*Outformat)(const AjPStr format, ajint* iformat);
} AcdOOuttype;
#define AcdPOuttype AcdOOuttype*
/* @funclist acdOuttype *******************************************************
**
** Processing output types and their formats
**
******************************************************************************/
AcdOOuttype acdOuttype[] =
{
/* Name Format Type Padding
Prompt Outformat */
{"outassembly", "bam", ajEOutfileTypeAssembly, 0,
acdPromptOutassembly, ajAssemoutformatFind},
{"outcodon", "cut", ajEOutfileTypeCodon, 0,
acdPromptOutcodon, ajCodoutformatFind},
{"outcpdb", "cpdb", ajEOutfileTypeCPDB, 0,
acdPromptOutcpdb, acdOutFormatCpdb},
{"outdata", "text", ajEOutfileTypeUnknown, 0,
acdPromptOutdata, acdOutFormatData},
{"outdiscrete", "phylip", ajEOutfileTypeDiscrete, 0,
acdPromptOutdiscrete, acdOutFormatDiscrete},
{"outdistance", "phylip", ajEOutfileTypeDistance, 0,
acdPromptOutdistance, acdOutFormatDistance},
{"outfreq", "phylip", ajEOutfileTypeFrequency, 0,
acdPromptOutfreq, acdOutFormatFreq},
{"outmatrix", "emboss", ajEOutfileTypeMatrix, 0,
acdPromptOutmatrix, acdOutFormatMatrix},
{"outmatrixf", "emboss", ajEOutfileTypeMatrixF, 0,
acdPromptOutmatrix, acdOutFormatMatrixf},
{"outobo", "obo", ajEOutfileTypeOBO, 0,
acdPromptOutobo, ajObooutformatFind},
{"outproperties", "phylip", ajEOutfileTypeProperties, 0,
acdPromptOutproperties, acdOutFormatProperties},
{"outrefseq", "embl", ajEOutfileTypeRefseq, 0,
acdPromptOutrefseq, ajRefseqoutformatFind},
{"outresource", "drcat", ajEOutfileTypeResource, 0,
acdPromptOutresource, ajResourceoutformatFind},
{"outscop", "scop", ajEOutfileTypeSCOP, 0,
acdPromptOutscop, acdOutFormatScop},
{"outtaxon", "tax", ajEOutfileTypeTaxon, 0,
acdPromptOuttaxon, ajTaxoutformatFind},
{"outtext", "text", ajEOutfileTypeText, 0,
acdPromptOuttext, ajTextoutformatFind},
{"outtree", "phylip", ajEOutfileTypeTree, 0,
acdPromptOuttree, acdOutFormatTree},
{"outurl", "url", ajEOutfileTypeURL, 0,
acdPromptOuturl, ajUrloutformatFind},
{"outvariation", "vcf", ajEOutfileTypeVariation, 0,
acdPromptOutvariation, ajVaroutformatFind},
{NULL, NULL, ajEOutfileTypeUnknown, 0, NULL, NULL}
};
ID AcdPValid
TY static
MO ajacd
LB acd
XX
DE ACD valid input structure. For each ACD type, stores functions
DE that reports on valid input and expected values
XX
TN AcdSValid
TD
TX
TN AcdOValid
TD
TX
AN Name
AT const char*
AD ACD type name
AX
AN Valid
AT void function
AD Function to report valid values in general
AX
AN Expect
AT void function
AD Function to report expected values
AD for this definition
AX
//
typedef struct AcdSValid
{
const char* Name;
void (*Valid) (const AcdPAcd thys, AjBool table, AjPStr* str);
void (*Expect) (const AcdPAcd thys, AjBool table, AjPStr* str);
} AcdOValid;
#define AcdPValid AcdOValid*
ID AlignPData
TY static
MO ajalign
LB core
XX
DE Ajax Align Data object.
DE
DE Holds definition of feature alignment data. Stored in AjPAlign structure as
DE an AjPList.
XX
TN AlignSData
TD
TX
TN AlignOData
TD
TX
AN Start
AT ajint*
AD Start position for each sequence
AX
AN End
AT ajint*
AD End position for each sequence
AX
AN Len
AT ajint*
AD Original length for each sequence
AX
AN Offset
AT ajint*
AD Offset for numbering start of each sequence
AX
AN Offend
AT ajint*
AD Offset for numbering end of each sequence
AX
AN SubOffset
AT ajint*
AD Offset of used subsequence within given sequence
AD generally for cases where SeqExternal is set
AD in the AjPAlign object that includes this
AD AlignPData object. Used for fetching the
AD actual sequence from the stored sequence,
AD but ignored when calculating position.
AX
AN Rev
AT AjBool*
AD Reverse each sequence (so far not used)
AX
AN RealSeq
AT AjPSeq*
AD Sequences usually as copies of data from the
AD application unless SeqExternal in the AjPAlign
AD object is true
AX
AN Seq
AT const AjPSeq*
AD Pointer to sequence in RealSeq
AD unless SeqExternal in the AjPAlign
AD object is true when pointer is to
AD sequence elsewhere
AX
AN LenAli
AT ajint
AD Length of the alignment
AX
AN NumId
AT ajint
AD Number of identical positions, usually calculated
AX
AN NumSim
AT ajint
AD Number of similar positions, usually calculated
AX
AN NumGap
AT ajint
AD Number of gap positions, usually calculated
AX
AN Score
AT AjPStr
AD Score to be reported - stored as a string for output
AD set by functions using ajint or float input
AX
AN Nseqs
AT ajint
AD Number of sequences, size of each array. This is
AD duplicated in the AjPAlign object but is useful
AD here for constructor and destructor efficiency.
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AlignSData
{
ajint* Start;
ajint* End;
ajint* Len;
ajint* Offset;
ajint* Offend;
ajint* SubOffset;
AjBool* Rev;
AjPSeq* RealSeq;
const AjPSeq* Seq;
ajint LenAli;
ajint NumId;
ajint NumSim;
ajint NumGap;
AjPStr Score;
ajint Nseqs;
char Padding[4];
} AlignOData;
#define AlignPData AlignOData*
ID AlignPFormat
TY static
MO ajalign
LB core
XX
DE Ajax Align Formats
DE
DE List of alignment output formats available
XX
TN AlignSFormat
TD
TX
TN AlignOFormat
TD
TX
AN Name
AT const char*
AD format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Alias
AT AjBool
AD Name is an alias for an identical definition
AX
AN Nucleotide
AT AjBool
AD ajTrue if format can use nucleotide sequences
AX
AN Protein
AT AjBool
AD ajTrue if format can use protein sequences
AX
AN Showheader
AT AjBool
AD ajTrue if header appears in output
AX
AN Showseqs
AT AjBool
AD ajTrue if sequences appear in output
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
AN Minseq
AT ajint
AD Minimum number of sequences, 2 for pairwise
AX
AN Maxseq
AT ajint
AD Maximum number of sequences, 2 for pairwise
AX
AN Write
AT void function
AD Function to write alignment
AX
//
typedef struct AlignSFormat
{
const char *Name;
const char *Desc;
AjBool Alias;
AjBool Nucleotide;
AjBool Protein;
AjBool Showheader;
AjBool Showseqs;
ajint Padding;
ajint Minseq;
ajint Maxseq;
void (*Write) (AjPAlign thys);
} AlignOFormat;
#define AlignPFormat AlignOFormat*
ID AssemPInFormat
TY static
MO ajassemread
LB core
XX
DE Assembly input formats data structure
XX
TN AssemSInFormat
TD
TX
TN AssemOInFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Obo
AT const char*
AD Ontology term id from EDAM
AX
AN Desc
AT const char*
AD Format description
AX
AN Alias
AT AjBool
AD Name is an alias for an identical definition
AX
AN Try
AT AjBool
AD If true, try for an unknown input. Duplicate names
AD and read-anything formats are set false
AX
AN Binary
AT AjBool
AD Binary file format
AX
AN Padding
AT AjBool
AD Padding to alignment boundary
AX
AN Load
AT AjBool function
AD Input load function, returns ajTrue on success
AX
//
typedef struct AssemSInFormat
{
const char *Name;
const char *Obo;
const char *Desc;
AjBool Alias;
AjBool Try;
AjBool Binary;
AjBool Padding;
AjBool (*Load) (AjPAssemin thys, AjPAssem assem);
} AssemOInFormat;
#define AssemPInFormat AssemOInFormat*
ID AssemPOutFormat
TY static
MO ajassemwrite
LB core
XX
DE Assembly output formats data structure
XX
TN AssemSoutFormat
TD
TX
TN AssemOOutFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Write
AT AjBool function
AD Output function, returns ajTrue on success
AX
AN WriteNext
AT AjBool function
AD Partial output function
AX
AN Cleanup
AT void function
AD Function to write remaining lines on closing
AX
//
typedef struct AssemSOutFormat
{
const char *Name;
const char *Desc;
AjBool (*Write) (AjPFile outf, const AjPAssem assem);
AjBool (*WriteNext) (AjPOutfile outfile, const AjPAssem assem);
void (*Cleanup) (AjPOutfile outf);
} AssemOOutFormat;
#define AssemPOutFormat AssemOOutFormat*
ID BasePIub
TY static
MO ajbase
LB core
XX
DE Base codes
XX
TN BaseSIub
TD
TX
TN BaseOIub
TD
TX
AN code
AT AjPStr
AD Code
AX
AN list
AT AjPStr
AD List
AX
AN mnemonic
AT AjPStr
AD Mnemonic
AX
//
typedef struct BaseSIub
{
AjPStr code;
AjPStr list;
AjPStr mnemonic;
} BaseOIub;
#define BasePIub BaseOIub*
ID CodPInFormat
TY static
MO ajcod
LB core
XX
DE Codon usage input formats data structure
XX
TN CodSInFormat
TD
TX
TN CodOInFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Try
AT AjBool
AD If true, try for an unknown input. Duplicate names
AD and read-anything formats are set false
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
AN Desc
AT const char*
AD Format description
AX
AN Read
AT AjBool function
AD Input function, returns ajTrue on success
AX
AN Comment
AT const char*
AD Format comments
AX
//
typedef struct CodSInFormat
{
const char *Name;
AjBool Try;
ajint Padding;
const char *Desc;
AjBool (*Read) (AjPCod thys, AjPFilebuff inbuff);
const char *Comment;
} CodOInFormat;
#define CodPInFormat CodOInFormat*
ID CodPOutFormat
TY static
MO ajcod
LB core
XX
DE Codon usage output formats data structure
XX
TN CodSOutFormat
TD
TX
TN CodOOutFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Write
AT void function
AD Output function
AX
//
typedef struct CodSOutFormat
{
const char *Name;
const char *Desc;
void (*Write) (const AjPCod thys, AjPFile outfile);
} CodOOutFormat;
#define CodPOutFormat CodOOutFormat*
ID AjPScopcla
TY static
MO ajdomain
LB core
XX
DE Private Scopcla object.
DE
DE Holds scop database data from raw file (dir.cla.scop.txt from SCOP authors)
DE
DE AjPScopcla is implemented as a pointer to a C data structure.
XX
TN AjSScopcla
TD
TX
TN AjOScopcla
TD
TX
AN Entry
AT AjPStr
AD Domain identifier code.
AX
AN Pdb
AT AjPStr
AD Corresponding pdb identifier code.
AX
AN Sccs
AT AjPStr
AD Scop compact classification string.
AX
AN Class
AT ajint
AD SCOP sunid for class
AX
AN Fold
AT ajint
AD SCOP sunid for fold
AX
AN Superfamily
AT ajint
AD SCOP sunid for superfamily
AX
AN Family
AT ajint
AD SCOP sunid for family
AX
AN Domain
AT ajint
AD SCOP sunid for domain
AX
AN Source
AT ajint
AD SCOP sunid for species
AX
AN Domdat
AT ajint
AD SCOP sunid for domain data
AX
AN Number
AT ajuint
AD Number of chains from which this domain is comprised
AX
AN Chain
AT char*
AD Chain identifiers
AX
AN Start
AT AjPStr*
AD PDB residue number of first residue in domain
AX
AN End
AT AjPStr*
AD PDB residue number of last residue in domain
AX
//
typedef struct AjSScopcla
{
AjPStr Entry;
AjPStr Pdb;
AjPStr Sccs;
ajint Class;
ajint Fold;
ajint Superfamily;
ajint Family;
ajint Domain;
ajint Source;
ajint Domdat;
ajuint Number;
char *Chain;
AjPStr *Start;
AjPStr *End;
} AjOScopcla, *AjPScopcla;
ID AjPScopdes
TY static
MO ajdomain
LB core
XX
DE AJAX Scopdes object.
DE
DE Holds SCOP database data from raw file (dir.des.scop.txt from SCOP authors)
DE
DE AjPScopdes is implemented as a pointer to a C data structure.
XX
TN AjSScopdes
TD
TX
TN AjOScopdes
TD
TX
AN Type
AT AjPStr
AD Type of node, either 'px' (domain data), 'cl' (class),
AD 'cf' (fold), 'sf' (superfamily), 'fa' (family), 'dm'
AD (domain) or 'sp' (species).
AX
AN Sccs
AT AjPStr
AD Scop compact classification string.
AX
AN Entry
AT AjPStr
AD Domain identifier code (or '-' if Type!='px').
AX
AN Desc
AT AjPStr
AD Description in English of the node.
AX
AN Sunid
AT ajint
AD SCOP sunid for node.
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSScopdes
{
AjPStr Type;
AjPStr Sccs;
AjPStr Entry;
AjPStr Desc;
ajint Sunid;
char Padding[4];
} AjOScopdes;
#define AjPScopdes AjOScopdes*
ID AjPCathDom
TY static
MO ajdomain
LB core
XX
DE AJAX CathDom object
DE
DE Holds CATH database data from domlist.v2.4. This file only contains
DE domain information for proteins that have 2 or more domains.
DE
DE AjPCathDom is implemented as a pointer to a C data structure.
XX
TN AjSCathDom
TD
TX
TN AjOCathDom
TD
TX
AN DomainID
AT AjPStr
AD ID for protein containing 2 or more domains
AX
AN Start
AT AjPStr*
AD PDB residue number of first residue in segment
AX
AN End
AT AjPStr*
AD PDB residue number of last residue in segment
AX
AN NSegment
AT ajuint
AD Number of chain segments domain is comprised of
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSCathDom
{
AjPStr DomainID;
AjPStr *Start;
AjPStr *End;
ajuint NSegment;
char Padding[4];
} AjOCathDom;
#define AjPCathDom AjOCathDom*
ID AjPCathName
TY static
MO ajdomain
LB core
XX
DE AJAX CathName object
DE
DE Holds CATH database data from CAT.names.all.v2.4. This file contains
DE a description of each level in the CATH hierarchy.
DE
DE AjPCathName is implemented as a pointer to a C data structure.
XX
TN AjSCathName
TD
TX
TN AjOCathName
TD
TX
AN Id
AT AjPStr
AD Classification Id
AX
AN Desc
AT AjPStr
AD Description of level in CATH hierarchy
AX
//
typedef struct AjSCathName
{
AjPStr Id;
AjPStr Desc;
} AjOCathName;
#define AjPCathName AjOCathName*
ID FeatPVocab
TY static
MO ajfeat
LB core
XX
DE Feature vocabularies
XX
TN FeatSVocab
TD
TX
TN FeatOVocab
TD
TX
AN Name
AT const char*
AD Vocabulary name
AX
AN Truename
AT const char*
AD Vocabulary true name used for definition files
AX
AN Nucleotide
AT AjBool
AD True if suitable for nucleotide data
AX
AN Protein
AT AjBool
AD True if suitable for protein data
AX
AN Typetable
AT AjPTable*
AD Type table
AX
AN Tagstable
AT AjPTable*
AD Tags table
AX
AN Desc
AT const char*
AD Description
AX
AN Alias
AT AjBool
AD True if name is an alias for an identical definition
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
//
typedef struct FeatSVocab
{
const char* Name;
const char* Truename;
AjBool Nucleotide;
AjBool Protein;
AjPTable* Typetable;
AjPTable* Tagstable;
const char* Desc;
AjBool Alias;
ajint Padding;
} FeatOVocab;
#define FeatPVocab FeatOVocab*
ID FeatPCategory
TY static
MO ajfeat
LB core
XX
DE Feature output types
XX
TN FeatSCategory
TD
TX
TN FeatOCategory
TD
TX
AN Name
AT const char*
AD Specified name
AX
AN Desc
AT const char*
AD Description
AX
AN Types
AT const char*
AD Internal type names in this category
AX
//
typedef struct FeatSCategory
{
const char* Name;
const char* Desc;
const char* Types;
} FeatOCategory;
#define FeatPCategory FeatOCategory*
ID FeatPCdDiv
TY static
MO ajfeatdb
LB ajaxdb
XX
DE EMBLCD division file record structure
XX
TN FeatSCdDiv
TD
TX
TN FeatOCdDiv
TD
TX
AN FileName
AT AjPStr
AD Filename(s)
AX
AN DivCode
AT ajuint
AD Division code
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct FeatSCdDiv
{
AjPStr FileName;
ajuint DivCode;
char Padding[4];
} FeatOCdDiv;
#define FeatPCdDiv FeatOCdDiv*
ID FeatPCdEntry
TY static
MO ajfeatdb
LB ajaxdb
XX
DE EMBLCD entrynam.idx file record structure
XX
TN FeatSCdEntry
TD
TX
TN FeatOCdEntry
TD
TX
AN div
AT ajuint
AD division file record
AX
AN annoff
AT ajuint
AD data file offset
AX
AN seqoff
AT ajuint
AD sequence file offset (if any)
AX
//
typedef struct FeatSCdEntry
{
ajuint div;
ajuint annoff;
ajuint seqoff;
} FeatOCdEntry;
#define FeatPCdEntry FeatOCdEntry*
ID FeatPCdFHeader
TY static
MO ajfeatdb
LB ajaxdb
XX
DE EMBLCD index file header structure, same for all index files.
XX
TN FeatSCdFHeader
TD
TX
TN FeatOCdFHeader
TD
TX
AN FileSize
AT ajuint
AD Index file size
AX
AN NRecords
AT ajuint
AD Index record count
AX
AN IdSize
AT ajuint
AD Index string length
AX
AN RelDay
AT ajuint
AD Release date - day
AX
AN RelMonth
AT ajuint
AD Release date - month
AX
AN RelYear
AT ajuint
AD Release date - year
AX
AN RecSize
AT short
AD Record size
AX
AN SPadding
AT short
AD Padding to alignment boundary
AX
AN DbName
AT char[24]
AD Database name
AX
AN Release
AT char[12]
AD Release name/number
AX
AN Date
AT char[4]
AD Date as three integers.
AX
//
typedef struct FeatSCdFHeader
{
ajuint FileSize;
ajuint NRecords;
ajuint IdSize;
ajuint RelDay;
ajuint RelMonth;
ajuint RelYear;
short RecSize;
short SPadding;
char DbName[24];
char Release[12];
char Date[4];
} FeatOCdFHeader;
#define FeatPCdFHeader FeatOCdFHeader*
ID FeatPCdFile
TY static
MO ajfeatdb
LB ajaxdb
XX
DE EMBLCD file data structure
XX
TN FeatSCdFile
TD
TX
TN FeatOCdFile
TD
TX
AN Header
AT FeatPCdFHeader
AD Header data
AX
AN File
AT AjPFile
AD File
AX
AN NRecords
AT ajuint
AD Number of records
AX
AN RecSize
AT ajuint
AD Record length (for calculating record offsets)
AX
//
typedef struct FeatSCdFile
{
FeatPCdFHeader Header;
AjPFile File;
ajuint NRecords;
ajuint RecSize;
} FeatOCdFile;
#define FeatPCdFile FeatOCdFile*
ID FeatPCdHit
TY static
MO ajfeatdb
LB ajaxdb
XX
DE EMBLCD hit file record structure
XX
TN FeatSCdHit
TD
TX
TN FeatOCdHit
TD
TX
AN HitList
AT ajuint*
AD Array of hits, as record numbers in the
AD entrynam.idx file
AX
AN NHits
AT ajuint
AD Number of hits in HitList array
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct FeatSCdHit
{
ajuint* HitList;
ajuint NHits;
char Padding[4];
} FeatOCdHit;
#define FeatPCdHit FeatOCdHit*
ID FeatPCdIdx
TY static
MO ajfeatdb
LB ajaxdb
XX
DE EMBLCD entryname index file record structure
XX
TN FeatSCdIdx
TD
TX
TN FeatOCdIdx
TD
TX
AN AnnOffset
AT ajuint
AD Data file offset (see DivCode)
AX
AN SeqOffset
AT ajuint
AD Sequence file offset (if any) (see DivCode)
AX
AN EntryName
AT AjPStr
AD Entry ID - the file is sorted by these
AX
AN DivCode
AT ajushort
AD Division file record
AX
AN Padding
AT char[6]
AD Padding to alignment boundary
AX
//
typedef struct FeatSCdIdx
{
ajuint AnnOffset;
ajuint SeqOffset;
AjPStr EntryName;
ajushort DivCode;
char Padding[6];
} FeatOCdIdx;
#define FeatPCdIdx FeatOCdIdx*
ID FeatPCdTrg
TY static
MO ajfeatdb
LB ajaxdb
XX
DE EMBLCD target (.trg) file record structure
XX
TN FeatSCdTrg
TD
TX
TN FeatOCdTrg
TD
TX
AN FirstHit
AT ajuint
AD First hit record in .hit file
AX
AN NHits
AT ajuint
AD Number of hit records in .hit file
AX
AN Target
AT AjPStr
AD Indexed target string (the file is sorted by these)
AX
//
typedef struct FeatSCdTrg
{
ajuint FirstHit;
ajuint NHits;
AjPStr Target;
} FeatOCdTrg;
#define FeatPCdTrg FeatOCdTrg*
ID FeatPCdQry
TY static
MO ajfeatdb
LB ajaxdb
XX
DE EMBLCD query structure
XX
TN FeatSCdQry
TD
TX
TN FeatOCdQry
TD
TX
AN divfile
AT AjPStr
AD division.lkp
AX
AN idxfile
AT AjPStr
AD entryname.idx
AX
AN datfile
AT AjPStr
AD main data reference
AX
AN seqfile
AT AjPStr
AD sequence
AX
AN tblfile
AT AjPStr
AD BLAST table
AX
AN srcfile
AT AjPStr
AD BLAST FASTA source data
AX
AN dfp
AT FeatPCdFile
AD division.lkp
AX
AN ifp
AT FeatPCdFile
AD entryname.idx
AX
AN trgfp
AT FeatPCdFile
AD acnum.trg
AX
AN hitfp
AT FeatPCdFile
AD acnum.hit
AX
AN trgLine
AT FeatPCdTrg
AD acnum input line
AX
AN name
AT char*
AD filename from division.lkp
AX
AN nameSize
AT ajuint
AD division.lkp filename length
AX
AN div
AT ajuint
AD current division number
AX
AN maxdiv
AT ajuint
AD max division number
AX
AN type
AT ajuint
AD BLAST type
AX
AN libr
AT AjPFile
AD main data reference or BLAST header
AX
AN libs
AT AjPFile
AD sequence or BLAST compressed sequence
AX
AN libt
AT AjPFile
AD blast table
AX
AN libf
AT AjPFile
AD blast FASTA source data
AX
AN idnum
AT ajuint
AD current BLAST entry offset
AX
AN TopHdr
AT ajuint
AD BLAST table headers offset
AX
AN TopCmp
AT ajuint
AD BLAST table sequence offset
AX
AN TopAmb
AT ajuint
AD BLAST table ambiguities offset
AX
AN TopSrc
AT ajuint
AD BLAST table FASTA source offset
AX
AN Size
AT ajuint
AD BLAST database size
AX
AN Skip
AT AjBool*
AD skip file(s) in division.lkp
AX
AN idxLine
AT FeatPCdIdx
AD entryname.idx input line
AX
AN Samefile
AT AjBool
AD true if the same file is passed to
AD ajFilebuffReopenFile
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct FeatSCdQry
{
AjPStr divfile;
AjPStr idxfile;
AjPStr datfile;
AjPStr seqfile;
AjPStr tblfile;
AjPStr srcfile;
FeatPCdFile dfp;
FeatPCdFile ifp;
FeatPCdFile trgfp;
FeatPCdFile hitfp;
FeatPCdTrg trgLine;
char* name;
ajuint nameSize;
ajuint div;
ajuint maxdiv;
ajuint type;
AjPFile libr;
AjPFile libs;
AjPFile libt;
AjPFile libf;
ajuint idnum;
ajuint TopHdr;
ajuint TopCmp;
ajuint TopAmb;
ajuint TopSrc;
ajuint Size;
AjBool* Skip;
FeatPCdIdx idxLine;
AjBool Samefile;
char Padding[4];
} FeatOCdQry;
#define FeatPCdQry FeatOCdQry*
ID FeatPEmbossQry
TY static
MO ajfeatdb
LB ajaxdb
XX
DE Btree 'emboss' query structure
XX
TN FeatSEmbossQry
TD
TX
TN FeatOEmbossQry
TD
TX
AN idcache
AT AjPBtcache
AD ID cache
AX
AN Caches
AT AjPList
AD Caches for each query field
AX
AN files
AT AjPStr*
AD database filenames
AX
AN reffiles
AT AjPStr**
AD database reference filenames
AX
AN Skip
AT AjBool*
AD files numbers to exclude
AX
AN List
AT AjPList
AD List of files
AX
AN libs
AT AjPFile
AD Primary (database source) file
AX
AN libr
AT AjPFile
AD Secondary (database bibliographic source) file
AX
AN div
AT ajuint
AD division number of currently open database file
AX
AN refcount
AT ajuint
AD number of reference file(s) per entry
AX
AN nentries
AT ajint
AD number of entries in the filename array(s)
AD -1 when done
AX
AN Samefile
AT AjBool
AD true if the same file is passed to
AD ajFilebuffReopenFile
AX
//
typedef struct FeatSEmbossQry
{
AjPBtcache idcache;
AjPList Caches;
AjPStr *files;
AjPStr **reffiles;
AjBool *Skip;
AjPList List;
AjPFile libs;
AjPFile libr;
ajuint div;
ajuint refcount;
ajint nentries;
AjBool Samefile;
} FeatOEmbossQry;
#define FeatPEmbossQry FeatOEmbossQry*
ID FeatPListUfo
TY static
MO ajfeatread
LB core
XX
DE Usa processing list of UFOs from a list file.
DE
DE Includes data from the original UFO (XX
TN FeatSListUfo
TD
TX
TN FeatOListUfo
TD
TX
AN Begin
AT ajint
AD Begin if defined in original UFO
AX
AN End
AT ajint
AD End if defined in original UFO
AX
AN Rev
AT AjBool
AD Reverse if defined in original UFO
AX
AN Format
AT ajuint
AD Format number from original UFO
AX
AN Formatstr
AT AjPStr
AD Format name from original UFO
AX
AN Ufo
AT AjPStr
AD Current UFO
AX
AN Fpos
AT ajulong
AD Start position offset
AX
AN Features
AT AjBool
AD if true, process features
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct FeatSListUfo
{
ajint Begin;
ajint End;
AjBool Rev;
ajuint Format;
AjPStr Formatstr;
AjPStr Ufo;
ajulong Fpos;
AjBool Features;
char Padding[4];
} FeatOListUfo;
#define FeatPListUfo FeatOListUfo*
ID FeatPInformat
TY static
MO ajfeatread
LB core
XX
DE Feature input format definition
XX
TN FeatSInformat
TD
TX
TN FeatOInformat
TD
TX
AN Name
AT const char*
AD Input format name
AX
AN Obo
AT const char*
AD Ontology term id from EDAM
AX
AN Alias
AT AjBool
AD True if name is an alias for an identical definition
AX
AN Try
AT AjBool
AD If true, try for an unknown input. Duplicate names
AD and read-anything formats are set false
AX
AN Nucleotide
AT AjBool
AD True if suitable for nucleotide data
AX
AN Protein
AT AjBool
AD True if suitable for protein data
AX
AN Used
AT AjBool
AD True if already used (initialised)
AX
AN Padding
AT AjBool
AD Padding to alignment boundary
AX
AN Read
AT AjBool function
AD Function to read feature data
AX
AN InitReg
AT AjBool function
AD Function to initialise regular expressions
AX
AN DelReg
AT AjBool function
AD Function to clean up regular expressions
AX
AN Desc
AT const char*
AD Description
AX
//
typedef struct FeatSInformat
{
const char *Name;
const char *Obo;
AjBool Alias;
AjBool Try;
AjBool Nucleotide;
AjBool Protein;
AjBool Used;
AjBool Padding;
AjBool (*Read) (AjPFeattabin thys, AjPFeattable ftable);
AjBool (*InitReg) (void);
AjBool (*DelReg) (void);
const char *Desc;
} FeatOInformat;
#define FeatPInformat FeatOInformat*
ID FeatPTypein
TY static
MO ajfeatread
LB core
XX
DE feature input types
XX
TN FeatSTypein
TD
TX
TN FeatOTypein
TD
TX
AN Name
AT const char*
AD Specified name
AX
AN Value
AT const char*
AD Internal type "P" or "N"
AX
//
typedef struct FeatSTypein
{
const char* Name;
const char* Value;
} FeatOTypein;
#define FeatPTypein FeatOTypein*
ID FeatPOutFormat
TY static
MO ajfeatwrite
LB core
XX
DE Feature output formats
XX
TN FeatSOutFormat
TD
TX
TN FeatOOutFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Nucleotide
AT AjBool
AD True if suitable for nucleotide data
AX
AN Protein
AT AjBool
AD True if suitable for protein data
AX
AN Write
AT AjBool function
AD Function to write data
AX
AN Desc
AT const char*
AD Description
AX
AN Alias
AT AjBool
AD True if name is an alias for an identical definition
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
//
typedef struct FeatSOutFormat
{
const char* Name;
AjBool Nucleotide;
AjBool Protein;
AjBool (*Write) (AjPFeattabOut ftout, const AjPFeattable thys);
const char* Desc;
AjBool Alias;
ajint Padding;
} FeatOOutFormat;
#define FeatPOutFormat FeatOOutFormat*
ID FeatPTypeOut
TY static
MO ajfeatwrite
LB core
XX
DE Feature output types
XX
TN FeatSTypeOut
TD
TX
TN FeatOTypeOut
TD
TX
AN Name
AT const char*
AD Specified name
AX
AN Value
AT const char*
AD Internal type "P" or "N"
AX
//
typedef struct FeatSTypeOut
{
const char* Name;
const char* Value;
} FeatOTypeOut;
#define FeatPTypeOut FeatOTypeOut*
ID FmtPBuf
TY static
MO ajfmt
LB core
XX
DE Format definitions
XX
TN FmtSVuf
TD
TX
TN FmtOBuf
TD
TX
AN buf
AT char*
AD buffer to write
AX
AN bp
AT char*
AD next position in buffer
AX
AN size
AT size_t
AD size of buffer from malloc
AX
AN fixed
AT AjBool
AD if ajTrue, cannot reallocate
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct FmtSBuf
{
char *buf;
char *bp;
size_t size;
AjBool fixed;
ajuint Padding;
} FmtOBuf;
#define FmtPBuf FmtOBuf*
ID GraphPType
TY static
MO ajgraph
LB graphics
XX
DE Graph type definition structure
XX
TN GraphSType
TD
TX
TN GraphOType
TD
TX
AN Name
AT const char*
AD Name used by Ajax
AX
AN Device
AT const char*
AD Name used by plplot library
AX
AN Ext
AT const char*
AD File extension for output file if any
AX
AN Width
AT ajint
AD Default width within the driver, 0 if not a plot
AX
AN Height
AT ajint
AD Default height within the driver, 0 if not a plot
AX
AN Plplot
AT AjBool
AD true if using PlPlot data and library calls
AX
AN Alias
AT AjBool
AD ajTrue if this name is a user alias for another
AD entry with the same Device name.
AX
AN Screen
AT AjBool
AD true if plplot writes to the screen
AX
AN Onefile
AT AjBool
AD true if plplot can write multiple pages to one file
AD (for example, postscript output)
AX
AN Fixedsize
AT AjBool
AD true if plplot fixes the plot window size,
AD ignoring user settings
AX
AN Interactive
AT AjBool
AD true if plplot can interact with the device
AX
AN XYDisplay
AT void function
AD Function to display an XY graph
AX
AN GOpen
AT void function
AD Function to display a general graph
AX
AN Desc
AT const char*
AD Description
AX
//
typedef struct GraphSType
{
const char* Name;
const char* Device;
const char* Ext;
ajint Width;
ajint Height;
AjBool Plplot;
AjBool Alias;
AjBool Screen;
AjBool Onefile;
AjBool Fixedsize;
AjBool Interactive;
void (*XYDisplay) (AjPGraph thys, AjBool closeit, const char *ext);
void (*GOpen) (AjPGraph thys, const char *ext);
const char* Desc;
} GraphOType;
#define GraphPType GraphOType*
ID BtreeSField
TY static
MO ajindex
LB core
XX
DE Index field data
XX
TN BtreeOField
TD
TX
TN BtreePField
TD
TX
AN Name
AT AjPStr
AD Name
AX
AN Extension
AT AjPStr
AD Extension
AX
AN Secondary
AT AjBool
AD True for primary/secondary ID index
AD False for Identifier/fileposition index
AX
AN Len
AT ajuint
AD Index field maximum length
AX
//
typedef struct BtreeSField
{
AjPStr Name;
AjPStr Extension;
AjBool Secondary;
ajuint Len;
} BtreeOField;
#define BtreePField BtreeOField*
ID BtreeSFielddef
TY static
MO ajindex
LB core
XX
DE Known index fields
XX
TN BtreeOFielddef
TD
TX
TN BtreePFielddef
TD
TX
AN Name
AT const char*
AD Name
AX
AN Extension
AT const char*
AD Extension
AX
AN Secondary
AT AjBool
AD True for primary/secondary ID index
AD False for Identifier/fileposition index
AX
AN Len
AT ajuint
AD Index field maximum length
AX
//
typedef struct BtreeSFielddef
{
const char* Name;
const char* Extension;
AjBool Secondary;
ajuint Len;
} BtreeOFielddef;
#define BtreePFielddef BtreeOFielddef*
ID MessPErrorInfo
TY static
MO ajmess
LB core
XX
DE Message error information
XX
TN MessSErrorInfo
TD
TX
TN MessOErrorInfo
TD
TX
AN progname
AT char*
AD Name of executable reporting error
AX
AN filename
AT char*
AD Filename where error was reported
AX
AN line_num
AT ajint
AD line number of file where error was reported.
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct MessSErrorInfo
{
char* progname;
char* filename;
ajint line_num;
char Padding[4];
} MessOErrorInfo;
#define MessPErrorInfo MessOErrorInfo*
ID NamPAttr
TY static
MO ajnam
LB core
XX
DE Resource attribute definition structure
XX
TN NamSAttr
TD
TX
TN NamOAttr
TD
TX
AN Name
AT const char*
AD Attribute name
AX
AN Type
AT enum NamEAttrtype
AD Type of value
AX
AN Defval
AT const char*
AD Default value, usually an empty string
AX
AN Comment
AT const char*
AD Comment for documentation purposes
AX
//
typedef struct NamSAttr
{
const char* Name;
enum NamEAttrtype Type;
const char* Defval;
const char* Comment;
} NamOAttr;
#define NamPAttr NamOAttr*
ID NamPValid
TY static
MO ajnam
LB core
XX
DE Resource attribute validation structure
XX
TN NamSValid
TD
TX
TN NamOValid
TD
TX
AN Name
AT const char*
AD Attribute name
AX
AN Comment
AT const char*
AD Comment for documentation purposes
AX
//
typedef struct NamSValid
{
const char* Name;
const char* Comment;
} NamOValid;
#define NamPValid NamOValid*
ID NamPType
TY static
MO ajnam
LB core
XX
DE Resource attribute validation structure
XX
TN NamSType
TD
TX
TN NamOType
TD
TX
AN Name
AT const char*
AD Type name
AX
AN Scope
AT const char*
AD Type scope
AX
AN Comment
AT const char*
AD Comment for documentation purposes
AX
AN DataType
AT ajuint
AD Enumerated datatype matching scope
AX
//
typedef struct NamSType
{
const char* Name;
const char* Scope;
const char* Comment;
ajuint DataType;
} NamOType;
#define NamPType NamOType*
ID NamPEntry
TY static
MO ajnam
LB core
XX
DE Internal database standard structure
XX
TN NamSEntry
TD
TX
TN NamOEntry
TD
TX
AN name
AT AjPStr
AD token name
AX
AN value
AT AjPStr
AD token value for variables
AX
AN file
AT AjPStr
AD Short name for definitions file
AX
AN data
AT void*
AD Attribute names and values for databases
AX
//
typedef struct NamSEntry
{
AjPStr name;
AjPStr value;
AjPStr file;
void* data;
} NamOEntry;
#define NamPEntry NamOEntry*
ID tagtype
TY public
MO ajoboread
LB core
XX
DE OBO tag value type
XX
VN TAG_ANY
VD Any
VX
VN TAG_BOOL
VD Boolean
VX
VN TAG_QTEXT
VD Quoted text
VX
VN TAG_DBX
VD Database cross-reference
VX
VN TAG_QXREF
VD Quoted cross-reference
VX
VN TAG_ID
VD Identifier
VX
VN TAG_NAME
VD Name
VX
//
enum tagtype {
TAG_ANY, TAG_BOOL, TAG_QTEXT, TAG_DBX, TAG_QXREF, TAG_ID, TAG_NAME
};
ID OboOTagdef
TY static
MO ajoboread
LB core
XX
DE Tag definitions for OBO format
XX
AN Tag
AT const char*
AD Tag name
AX
AN Type
AT ajint
AD Enumerated type
AX
AN Min
AT ajint
AD Minimum unmber
AX
AN Count
AT ajint
AD Maximum number
AX
AN Padding
AT ajint
AD Padding
AX
AN Obsolete
AT const char*
AD Obsolete form of tag name
AX
//
typedef struct OboSTagdef
{
const char* Tag;
ajint Type;
ajint Min;
ajint Count;
ajint Padding;
const char* Obsolete;
} OboOTagdef;
#define OboPTagdef OboOTagdef*
ID OboPInFormat
TY static
MO ajoboread
LB core
XX
DE Obo input formats data structure
XX
TN OboSInFormat
TD
TX
TN OboOInFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Obo
AT const char*
AD Ontology term id from EDAM
AX
AN Desc
AT const char*
AD Format description
AX
AN Alias
AT AjBool
AD Name is an alias for an identical definition
AX
AN Try
AT AjBool
AD If true, try for an unknown input. Duplicate names
AD and read-anything formats are set false
AX
AN Read
AT AjBool function
AD Input function, returns ajTrue on success
AX
//
typedef struct OboSInFormat
{
const char *Name;
const char *Obo;
const char *Desc;
AjBool Alias;
AjBool Try;
AjBool (*Read) (AjPOboin thys, AjPObo obo);
} OboOInFormat;
#define OboPInFormat OboOInFormat*
ID OboPOutFormat
TY static
MO ajobowrite
LB core
XX
DE Obo output formats data structure
XX
TN OboSoutFormat
TD
TX
TN OboOOutFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Write
AT AjBool function
AD Output function, returns ajTrue on success
AX
//
typedef struct OboSOutFormat
{
const char *Name;
const char *Desc;
AjBool (*Write) (AjPFile outf, const AjPObo obo);
} OboOOutFormat;
#define OboPOutFormat OboOOutFormat*
ID PatPRegTypes
TY static
MO ajpat
LB core
XX
DE Regular expression pattern types
XX
TN PatSTypes
TD
TX
TN PatOTypes
TD
TX
AN Name
AT const char*
AD Type name
AX
AN Desc
AT const char*
AD Type description
AX
//
typedef struct PatSRegTypes
{
const char *Name;
const char *Desc;
} PatORegTypes;
#define PatPRegTypes PatORegTypes*
ID PatPRegInformat
TY static
MO ajpat
LB core
XX
DE Regular expression pattern file formats
XX
TN PatSRegInformat
TD
TX
TN PatORegInformat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
//
typedef struct PatSRegInformat
{
const char *Name;
const char *Desc;
} PatORegInformat;
#define PatPRegInformat PatORegInformat*
ID PatPSeqInformat
TY static
MO ajpat
LB core
XX
DE Sequence pattern file formats
XX
TN PatSSeqInformat
TD
TX
TN PatOSeqInformat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
//
typedef struct PatSSeqInformat
{
const char *Name;
const char *Desc;
} PatOSeqInformat;
#define PatPSeqInformat PatOSeqInformat*
ID PdbfileELinetype
TY public
MO ajpdbio
LB core
XX
DE AJAX PDB File Line Type enumeration for writing in PDB format
XX
VN pdbfileELinetypeIgnore
VD Ignore this line when parsing coordinates
VX
VN pdbfileELinetypeCoordinate
VD Coordinate line
VX
VN pdbfileELinetypeHeterogen
VD Coordinate line for non-protein atoms
VX
VN pdbfileELinetypeTER
VD TER record Chain terminator.
VX
VN pdbfileELinetypeMODEL
VD MODEL record Specification of model number for multiple structures in a
TD single coordinate entry.
VX
VN pdbfileELinetypeGroups
VD Coordinate line for groups that could not be associated with a SEQRES chain
VX
VN pdbfileELinetypeWater
VD Coordinate line for water
VX
VN pdbfileELinetypeENDMDL
VD ENDMDL record End-of-model record for multiple structures in a single
TD coordinate entry.
VX
//
typedef enum PdbfileOLinetype
{
pdbfileELinetypeIgnore,
pdbfileELinetypeCoordinate,
pdbfileELinetypeHeterogen,
pdbfileELinetypeTER,
pdbfileELinetypeMODEL,
pdbfileELinetypeGroups,
pdbfileELinetypeWater,
pdbfileELinetypeENDMDL
} PdbfileELinetype;
ID AjPElement
TY static
MO ajpdbio
LB core
XX
DE Nucleus Element object.
DE
DE Object for holding a single secondary structure element when parsing PDB.
DE
DE AjPElement is implemented as a pointer to a C data structure.
XX
TN AjSElement
TD
TX
TN AjOElement
TD
TX
AN elementId
AT AjPStr
AD Element identifier (columns 12 - 14)
AD SHEET ('E') or TURN ('T')
AX
AN initResName
AT AjPStr
AD Name of first residue in each element (columns
AD 16 - 18 (HELIX & TURN) or 18 - 20 (SHEET) )
AX
AN initSeqNum
AT AjPStr
AD Residue number (including insertion code)
AD of first residue in each element
AD (columns 22 - 26 (HELIX), 23 - 27 (SHEET)
AD or 21 - 25 (TURN) )
AX
AN endResName
AT AjPStr
AD Name of last residue in each element
AD (columns 28 - 30 (HELIX), 29 - 31 (SHEET)
AD or 27 - 29 (TURN) )
AX
AN endSeqNum
AT AjPStr
AD Residue number (including insertion code) of
AD last residue in each element
AD (columns 34 - 38 (HELIX and SHEET)
AD or 32 - 36 (TURN) )
AX
AN helixClass
AT ajint
AD Classes of helices (columns 39 - 40),
AD an int from 1-10 from
AX
AN elementNum
AT ajint
AD Serial number of the element (columns 8 - 10)
AX
AN elementType
AT char
AD Element type COIL ('C'), HELIX ('H'),
AX
AN chainId
AT char
AD Chain identifiers for chains containing the
AD elements (column 20 (HELIX & TURN)
AD or 22 (SHEET) )
AX
AN Padding
AT char[6]
AD Padding to alignment boundary
AD
AD http://www.rcsb.org/pdb/docs/format/pdbguide2.2/guide2.2_frame.html
AD
AD TYPE OF HELIX CLASS NUMBER (COLUMNS 39 - 40)
AD --------------------------------------------------------------
AD Right-handed alpha (default) 1
AD Right-handed omega 2
AD Right-handed pi 3
AD Right-handed gamma 4
AD Right-handed 310 5
AD Left-handed alpha 6
AD Left-handed omega 7
AD Left-handed gamma 8
AD 27 ribbon/helix 9
AD Polyproline 10
AX
//
typedef struct AjSElement
{
AjPStr elementId;
AjPStr initResName;
AjPStr initSeqNum;
AjPStr endResName;
AjPStr endSeqNum;
ajint helixClass;
ajint elementNum;
char elementType;
char chainId;
char Padding[6];
} AjOElement;
#define AjPElement AjOElement*
ID AjPElements
TY static
MO ajpdbio
LB core
XX
DE Nucleus Elements object.
DE
DE Object for holding secondary structure elements from a PDB file
DE
DE AjPElements is implemented as a pointer to a C data structure.
XX
TN AjSElements
TD
TX
TN AjOElements
TD
TX
AN elms
AT AjPElement*
AD Secondary structure element array
AX
AN n
AT ajuint
AD Total no. of secondary structure elements
AD (helices, strands or turns)
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSElements
{
AjPElement *elms;
ajuint n;
char Padding[4];
} AjOElements;
#define AjPElements AjOElements*
ID AjPPdbfile
TY static
MO ajpdbio
LB core
XX
DE Nucleus Pdbfile object.
DE
DE Holds a pdb file for parsing.
DE
DE AjPPdbfile is implemented as a pointer to a C data structure.
XX
TN AjSPdbfile
TD
TX
TN AjOPdbfile
TD
TX
AN pdbid
AT AjPStr
AD 4 character pdb id code
AX
AN tercnt
AT ajuint
AD The number of TER records in the pdb file
AX
AN toofewter
AT AjBool
AD True if the file contained too few TER records
AX
AN modcnt
AT ajuint
AD The number of MODEL records in the pdb file
AD (does not count duplicate MODEL records
AD that are masked out)
AX
AN nomod
AT AjBool
AD True if the file contained no MODEL records
AX
AN compnd
AT AjPStr
AD Text from COMPND records
AX
AN source
AT AjPStr
AD Text from SOURCE records
AX
AN reso
AT float
AD Resolution of structure
AX
AN method
AT AjEPdbMethod
AD AJAX PDB Method enumeration
AX
AN gpid
AT AjPChar
AD Array of chain (group) id's for groups that
AD cannot be associated with a chain in the SEQRES
AD section
AX
AN idxfirst
AT ajuint
AD Index in of first ATOM, HETATM or MODEL
AD line
AX
AN nchains
AT ajuint
AD Number of chains (from SEQRES record)
AD for sizes of following attribute arrays
AX
AN seqres
AT AjPStr*
AD Array of sequences taken from the SEQRES records
AX
AN seqresful
AT AjPStr*
AD Array of sequences using 3 letter codes taken
AD from the SEQRES records
AX
AN nres
AT ajint*
AD Number of residues in each chain
AX
AN chainok
AT AjBool*
AD Array of flags which are True if a chain in the
AD SEQRES record contains >= minimum no. of amino
AD acids and has a unique chain identifier
AX
AN resn1ok
AT AjBool*
AD Bool's for each chain which are TRUE if resn1
AD was used to derive resni, i.e. gave correct
AD alignment to seqres sequence.
AD If False then resn2 was used.
AX
AN nligands
AT ajint*
AD Number of ligands for each chain. A ligand is a
AD non-protein group associated with a chain
AD in the SEQRES section.
AX
AN numHelices
AT ajint*
AD No. of helices in each chain
AX
AN numStrands
AT ajint*
AD No. of strands in each chain
AX
AN numSheets
AT ajint*
AD No. of sheets in each chain
AX
AN numTurns
AT ajint*
AD No. of turns in each chain
AX
AN chid
AT AjPChar
AD Array of chain id's for chains from SEQRES
AD records
AX
AN lines
AT AjPStr*
AD Array of lines in the pdb file
AX
AN linetype
AT PdbfileELinetype*
AD Array of int's describing the lines, have values
AD of pdbfileELinetypeIgnore (do not consider this line
AD when parsing coordinates from the file),
AD pdbfileELinetypeCoordinate (coordinate line
AD (ATOM or HETATM record) for protein atoms,
AD pdbfileELinetypeHeterogen (coordinate line for
AD non-protein atoms), pdbfileELinetypeGroups
AD (coordinate line for groups that could not be
AD associated with a SEQRES chain),
AD pdbfileELinetypeWater (coordinate line for
AD water), pdbfileELinetypeTER (it is a TER record) or
AD pdbfileELinetypeMODEL (it is a MODEL record).
AX
AN chnn
AT ajint*
AD Array of chain numbers for each
AD pdbfileELinetypeCoordinate &
AD pdbfileELinetypeHeterogen line.
AX
AN gpn
AT ajint*
AD Array of group numbers for each line. Each group
AD (heterogen) is given a group number, that is
AD either relative to a chain or the whole file
AD (for groups that could not be associated with
AD a chain from the SEQRES records)
AX
AN modn
AT ajuint*
AD Array of model numbers for each
AD pdbfileELinetypeCoordinate line
AX
AN resni
AT ajint*
AD Residue numbers for each pdbfileELinetypeCoordinate
AD line. These give the correct index into the
AD 'seqres' sequences
AX
AN resn1
AT ajint*
AD Array of residue numbers for each
AD pdbfileELinetypeCoordinate line. This is pdbn
AD converted to a sequential integer where
AD alternative residue numbering is presumed for
AD lines where line[26] is used (residues for which
AD oddnum == True are considered).
AX
AN resn2
AT ajint*
AD Array of residue numbers for each
AD pdbfileELinetypeCoordinate line. This is pdbn
AD converted to a sequential integer where
AD heterogeneity is presumed for lines where
AD line[26] is used (residues where oddnum == True
AD are ignored).
AX
AN pdbn
AT AjPStr*
AD Array with a residue number for each line
AD for which 'coord' == ajTrue. This is the
AD original residue number string (including
AD insertion code) from the pdb file
AX
AN oddnum
AT AjBool*
AD Bool's for each line which are TRUE for
AD duplicate residues of heterogenous positions
AD (e.g. if 2 different residues are both numbered
AD '8' or one is '8' and the other '8A'
AD for example then would be set True for
AD the second residue. Heterogeneity is indicated
AD by a character in position lines[26] (the same
AD position used to indicate alternative residue
AD numbering schemes).
AX
AN atype
AT AjPStr*
AD Atom type for each line
AX
AN rtype
AT AjPStr*
AD Residue type for each line
AX
AN x
AT float*
AD x-coordinate for each line
AX
AN y
AT float*
AD y-coordinate for each line
AX
AN z
AT float*
AD z-coordinate for each line
AX
AN o
AT float*
AD occupancy for each line
AX
AN b
AT float*
AD thermal factor for each line
AX
AN elementNum
AT ajint*
AD Serial number of the secondary structure element
AD (columns 8 - 10)
AX
AN elementId
AT AjPStr*
AD Secondary structure element identifier (columns
AD 12 - 14)
AX
AN elementType
AT char*
AD Secondary structure element type COIL ('C'),
AD HELIX ('H'), SHEET ('E') or TURN ('T')
AX
AN helixClass
AT ajint*
AD Classes of helices (columns 39 - 40) from
AD http://www.rcsb.org/pdb/docs/format/pdbguide2.2/guide2.2_frame.html
AD (see below). Has a value of 0 (printed out as
AD '.') for non-helical elements.
AX
AN nlines
AT ajuint
AD Number of lines in the pdb file and size of the
AD following arrays
AX
AN ngroups
AT ajuint
AD Number of groups (non-protein groups that
AD could not be associated with a chain in the
AD SEQRES section
AX
//
typedef struct AjSPdbfile
{
AjPStr pdbid;
ajuint tercnt;
AjBool toofewter;
ajuint modcnt;
AjBool nomod;
AjPStr compnd;
AjPStr source;
float reso;
AjEPdbMethod method;
AjPChar gpid;
ajuint idxfirst;
ajuint nchains;
AjPStr *seqres;
AjPStr *seqresful;
ajint *nres;
AjBool *chainok;
AjBool *resn1ok;
ajint *nligands;
ajint *numHelices;
ajint *numStrands;
ajint *numSheets;
ajint *numTurns;
AjPChar chid;
AjPStr *lines;
PdbfileELinetype *linetype;
ajint *chnn;
ajint *gpn;
ajuint *modn;
ajint *resni;
ajint *resn1;
ajint *resn2;
AjPStr *pdbn;
AjBool *oddnum;
AjPStr *atype;
AjPStr *rtype;
float *x;
float *y;
float *z;
float *o;
float *b;
ajint *elementNum;
AjPStr *elementId;
char *elementType;
ajint *helixClass;
ajuint nlines;
ajuint ngroups;
} AjOPdbfile;
#define AjPPdbfile AjOPdbfile*
ID RefseqPInFormat
TY static
MO ajrefseqread
LB core
XX
DE Reference sequence input formats data structure
XX
TN RefseqSInFormat
TD
TX
TN RefseqOInFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Obo
AT const char*
AD Ontology term id from EDAM
AX
AN Desc
AT const char*
AD Format description
AX
AN Alias
AT AjBool
AD Name is an alias for an identical definition
AX
AN Try
AT AjBool
AD If true, try for an unknown input. Duplicate names
AD and read-anything formats are set false
AX
AN Read
AT AjBool function
AD Input function, returns ajTrue on success
AX
//
typedef struct RefseqSInFormat
{
const char *Name;
const char *Obo;
const char *Desc;
AjBool Alias;
AjBool Try;
AjBool (*Read) (AjPRefseqin thys, AjPRefseq refseq);
} RefseqOInFormat;
#define RefseqPInFormat RefseqOInFormat*
ID RefseqPOutFormat
TY static
MO ajrefseqwrite
LB core
XX
DE Reference sequence output formats data structure
XX
TN RefseqSoutFormat
TD
TX
TN RefseqOOutFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Write
AT AjBool function
AD Output function, returns ajTrue on success
AX
//
typedef struct RefseqSOutFormat
{
const char *Name;
const char *Desc;
AjBool (*Write) (AjPFile outf, const AjPRefseq refseq);
} RefseqOOutFormat;
#define RefseqPOutFormat RefseqOOutFormat*
ID ReportPFormat
TY static
MO ajreport
LB core
XX
DE Ajax feature report formats
XX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Alias
AT AjBool
AD Name is an alias for an identical definition
AX
AN Mintags
AT ajuint
AD Minimum number of special tags needed
AX
AN Showseq
AT AjBool
AD ajTrue if sequence is to be included
AX
AN Nucleotide
AT AjBool
AD ajTrue if format can work with nucleotide sequences
AX
AN Protein
AT AjBool
AD ajTrue if format can work with protein sequences
AX
AN Showheader
AT AjBool
AD ajTrue if header appears in output
AX
AN Write
AT void function
AD Function to write report
AX
//
typedef struct ReportSFormat
{
const char *Name;
const char *Desc;
AjBool Alias;
ajuint Mintags;
AjBool Showseq;
AjBool Nucleotide;
AjBool Protein;
AjBool Showheader;
void (*Write) (AjPReport outrpt,
const AjPFeattable ftable, const AjPSeq seq);
} ReportOFormat;
#define ReportPFormat ReportOFormat*
ID ResourcePInFormat
TY static
MO ajresourceread
LB core
XX
DE Data input formats data structure
XX
TN ResourceSInFormat
TD
TX
TN ResourceOInFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Alias
AT AjBool
AD Name is an alias for an identical definition
AX
AN Try
AT AjBool
AD If true, try for an unknown input. Duplicate names
AD and read-anything formats are set false
AX
AN Read
AT AjBool function
AD Input function, returns ajTrue on success
AX
//
typedef struct ResourceSInFormat
{
const char *Name;
const char *Desc;
AjBool Alias;
AjBool Try;
AjBool (*Read) (AjPResourcein thys, AjPResource resource);
} ResourceOInFormat;
#define ResourcePInFormat ResourceOInFormat*
ID ResourcePOutFormat
TY static
MO ajresourcewrite
LB core
XX
DE Data output formats data structure
XX
TN ResourceSoutFormat
TD
TX
TN ResourceOOutFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Write
AT AjBool function
AD Output function, returns ajTrue on success
AX
//
typedef struct ResourceSOutFormat
{
const char *Name;
const char *Desc;
AjBool (*Write) (AjPFile outf, const AjPResource resource);
} ResourceOOutFormat;
#define ResourcePOutFormat ResourceOOutFormat*
ID SeqOClass
TY static
MO ajseq
LB core
XX
DE Classes of entries in the sequence databases
DE
DE Reference for this is
DE http://www.ncbi.nlm.nih.gov/HTGS/table1.html
XX
AN Name
AT const char*
AD Name used internally
AX
AN Embl
AT const char*
AD Name in EMBL
AX
AN Ddbj
AT const char*
AD Name in DDBJ
AX
AN Genbank
AT const char*
AD Name in Genbank
AX
AN Desc
AT const char*
AD Description
AX
//
typedef struct SeqSClass
{
const char* Name;
const char* Embl;
const char* Ddbj;
const char* Genbank;
const char* Desc;
} SeqOClass;
ID SeqODivision
TY static
MO ajseq
LB core
XX
DE Taxonomic divisions in the sequence databases
DE
DE Reference for this is
DE http://www.ncbi.nlm.nih.gov/HTGS/table1.html
XX
AN Name
AT const char*
AD Name used internally
AX
AN Embl
AT const char*
AD Name in EMBL
AX
AN Ddbj
AT const char*
AD Name in DDBJ
AX
AN Genbank
AT const char*
AD Name in Genbank
AX
AN Desc
AT const char*
AD Description
AX
//
typedef struct SeqSDivision
{
const char* Name;
const char* Embl;
const char* Ddbj;
const char* Genbank;
const char* Desc;
} SeqODivision;
ID SeqOMolecule
TY static
MO ajseq
LB core
XX
DE Molecule types in the sequence databases
DE
DE For EMBL and EMBOSS internal, see the
DE feature source qualifier /mol_type values in
DE http://www.ebi.ac.uk/embl/WebFeat/index.html
XX
AN Name
AT const char*
AD Name used internally
AX
AN Embl
AT const char*
AD Name in EMBL
AX
AN Ddbj
AT const char*
AD Name in DDBJ
AX
AN Genbank
AT const char*
AD Name in Genbank
AX
AN Desc
AT const char*
AD Description
AX
//
typedef struct SeqSMolecule
{
const char* Name;
const char* Embl;
const char* Ddbj;
const char* Genbank;
const char* Desc;
} SeqOMolecule;
ID SeqOTaxon
TY static
MO ajseq
LB core
XX
DE Known major taxa in the sequence databases
DE
DE Reference for this is
DE http://www.ncbi.nlm.nih.gov/Taxonomy/
XX
AN Taxid
AT ajuint
AD NCBI taxon id
AX
AN Standard
AT AjBool
AD Standard known taxon
AX
AN Name
AT const char*
AD Common name
AX
//
typedef struct SeqSTaxon
{
ajuint Taxid;
AjBool Standard;
const char* Name;
} SeqOTaxon;
ID BamPHeaderTag
TY static
MO ajseqbam
LB core
XX
DE BAM header tag
XX
AN value
AT char*
AD Value
AX
AN key
AT char[2]
AD Key
AX
AN Padding
AT char[6]
AD Padding for alignment
AX
//
typedef struct BamSHeaderTag
{
char *value;
char key[2];
char Padding[6];
} BamOHeaderTag;
#define BamPHeaderTag BamOHeaderTag*
ID BamPHeaderLine
TY static
MO ajseqbam
LB core
XX
DE BAM header line
XX
AN tags
AT AjPList
AD List of tags
AX
AN type
AT char[2]
AD Type
AX
AN Padding
AT char[6]
AD Padding for alignment
AX
//
typedef struct BamSHeaderLine
{
AjPList tags;
char type[2];
char Padding[6];
} BamOHeaderLine;
#define BamPHeaderLine BamOHeaderLine*
ID BamPCache
TY static
MO ajseqbam
LB core
XX
DE BAM block cache
XX
TN BamSCache
TD
TX
TN BamOCache
TD
TX
AN block
AT unsigned char*
AD Block data
AX
AN end_offset
AT ajlong
AD End offset
AX
AN size
AT int
AD Block size
AX
AN padding
AT int
AD To alignment boundary
AX
//
typedef struct BamSCache
{
unsigned char *block;
ajlong end_offset;
int size;
int padding;
} BamOCache;
#define BamPCache BamOCache*
VN AJSEQBAM_DEFAULT_BLOCK_SIZE
VD [int] Default block size of 64k
VX
VN AJSEQBAM_MAX_BLOCK_SIZE
VD [int] Maximum block size also 64k
VX
VN AJSEQBAM_BLOCK_FOOTER_LENGTH
VD [int] Block footer length
VX
VN AJSEQBAM_GZIP_ID1
VD [int] Gzip magic id 1
VX
VN AJSEQBAM_GZIP_ID2
VD [int] Gzip magic id 2
VX
VN AJSEQBAM_CM_DEFLATE
VD [int] CM deflate
VX
VN AJSEQBAM_FLG_FEXTRA
VD [int] Fextra flag
VX
VN AJSEQBAM_OS_UNKNOWN
VD [int] Unkown OS value
VX
VN AJSEQBAM_BGZF_ID1
VD [int] Bgfz magic id 1 'B'
VX
VN AJSEQBAM_BGZF_ID2
VD [int] Bgfz magic id 2 'C'
VX
VN AJSEQBAM_BGZF_LEN
VD [int] Bgzf length
VX
VN AJSEQBAM_BGZF_XLEN
VD [int] Bgzf xlength (length plus 4)
VX
VN AJSEQBAM_GZIP_WINDOW_BITS
VD [int] Gzip window bits (-15 - no zlib header
VX
VN AJSEQBAM_Z_DEFAULT_MEM_LEVEL
VD [int] Z default memory level
VX
ID SeqPCdDiv
TY static
MO ajseqdb
LB ajaxdb
XX
DE EMBLCD division file record structure
XX
TN SeqSCdDiv
TD
TX
TN SeqOCdDiv
TD
TX
AN FileName
AT AjPStr
AD Filename(s)
AX
AN DivCode
AT ajuint
AD Division code
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SeqSCdDiv
{
AjPStr FileName;
ajuint DivCode;
char Padding[4];
} SeqOCdDiv;
#define SeqPCdDiv SeqOCdDiv*
ID SeqPCdEntry
TY static
MO ajseqdb
LB ajaxdb
XX
DE EMBLCD entrynam.idx file record structure
XX
TN SeqSCdEntry
TD
TX
TN SeqOCdEntry
TD
TX
AN div
AT ajuint
AD division file record
AX
AN annoff
AT ajuint
AD data file offset
AX
AN seqoff
AT ajuint
AD sequence file offset (if any)
AX
//
typedef struct SeqSCdEntry
{
ajuint div;
ajuint annoff;
ajuint seqoff;
} SeqOCdEntry;
#define SeqPCdEntry SeqOCdEntry*
ID SeqPCdFHeader
TY static
MO ajseqdb
LB ajaxdb
XX
DE EMBLCD index file header structure, same for all index files.
XX
TN SeqSCdFHeader
TD
TX
TN SeqOCdFHeader
TD
TX
AN FileSize
AT ajuint
AD Index file size
AX
AN NRecords
AT ajuint
AD Index record count
AX
AN IdSize
AT ajuint
AD Index string length
AX
AN RelDay
AT ajuint
AD Release date - day
AX
AN RelMonth
AT ajuint
AD Release date - month
AX
AN RelYear
AT ajuint
AD Release date - year
AX
AN RecSize
AT short
AD Record size
AX
AN SPadding
AT short
AD Padding to alignment boundary
AX
AN DbName
AT char[24]
AD Database name
AX
AN Release
AT char[12]
AD Release name/number
AX
AN Date
AT char[4]
AD Date as three integers.
AX
//
typedef struct SeqSCdFHeader
{
ajuint FileSize;
ajuint NRecords;
ajuint IdSize;
ajuint RelDay;
ajuint RelMonth;
ajuint RelYear;
short RecSize;
short SPadding;
char DbName[24];
char Release[12];
char Date[4];
} SeqOCdFHeader;
#define SeqPCdFHeader SeqOCdFHeader*
ID SeqPCdFile
TY static
MO ajseqdb
LB ajaxdb
XX
DE EMBLCD file data structure
XX
TN SeqSCdFile
TD
TX
TN SeqOCdFile
TD
TX
AN Header
AT SeqPCdFHeader
AD Header data
AX
AN File
AT AjPFile
AD File
AX
AN NRecords
AT ajuint
AD Number of records
AX
AN RecSize
AT ajuint
AD Record length (for calculating record offsets)
AX
//
typedef struct SeqSCdFile
{
SeqPCdFHeader Header;
AjPFile File;
ajuint NRecords;
ajuint RecSize;
} SeqOCdFile;
#define SeqPCdFile SeqOCdFile*
ID SeqPCdHit
TY static
MO ajseqdb
LB ajaxdb
XX
DE EMBLCD hit file record structure
XX
TN SeqSCdHit
TD
TX
TN SeqOCdHit
TD
TX
AN HitList
AT ajuint*
AD Array of hits, as record numbers in the
AD entrynam.idx file
AX
AN NHits
AT ajuint
AD Number of hits in HitList array
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SeqSCdHit
{
ajuint* HitList;
ajuint NHits;
char Padding[4];
} SeqOCdHit;
#define SeqPCdHit SeqOCdHit*
ID SeqPCdIdx
TY static
MO ajseqdb
LB ajaxdb
XX
DE EMBLCD entryname index file record structure
XX
TN SeqSCdIdx
TD
TX
TN SeqOCdIdx
TD
TX
AN AnnOffset
AT ajuint
AD Data file offset (see DivCode)
AX
AN SeqOffset
AT ajuint
AD Sequence file offset (if any) (see DivCode)
AX
AN EntryName
AT AjPStr
AD Entry ID - the file is sorted by these
AX
AN DivCode
AT ajushort
AD Division file record
AX
AN Padding
AT char[6]
AD Padding to alignment boundary
AX
//
typedef struct SeqSCdIdx
{
ajuint AnnOffset;
ajuint SeqOffset;
AjPStr EntryName;
ajushort DivCode;
char Padding[6];
} SeqOCdIdx;
#define SeqPCdIdx SeqOCdIdx*
ID SeqPCdTrg
TY static
MO ajseqdb
LB ajaxdb
XX
DE EMBLCD target (.trg) file record structure
XX
TN SeqSCdTrg
TD
TX
TN SeqOCdTrg
TD
TX
AN FirstHit
AT ajuint
AD First hit record in .hit file
AX
AN NHits
AT ajuint
AD Number of hit records in .hit file
AX
AN Target
AT AjPStr
AD Indexed target string (the file is sorted by these)
AX
//
typedef struct SeqSCdTrg
{
ajuint FirstHit;
ajuint NHits;
AjPStr Target;
} SeqOCdTrg;
#define SeqPCdTrg SeqOCdTrg*
ID SeqPCdQry
TY static
MO ajseqdb
LB ajaxdb
XX
DE EMBLCD query structure
XX
TN SeqSCdQry
TD
TX
TN SeqOCdQry
TD
TX
AN divfile
AT AjPStr
AD division.lkp
AX
AN idxfile
AT AjPStr
AD entryname.idx
AX
AN datfile
AT AjPStr
AD main data reference
AX
AN seqfile
AT AjPStr
AD sequence
AX
AN tblfile
AT AjPStr
AD BLAST table
AX
AN srcfile
AT AjPStr
AD BLAST FASTA source data
AX
AN dfp
AT SeqPCdFile
AD division.lkp
AX
AN ifp
AT SeqPCdFile
AD entryname.idx
AX
AN trgfp
AT SeqPCdFile
AD acnum.trg
AX
AN hitfp
AT SeqPCdFile
AD acnum.hit
AX
AN trgLine
AT SeqPCdTrg
AD acnum input line
AX
AN name
AT char*
AD filename from division.lkp
AX
AN nameSize
AT ajuint
AD division.lkp filename length
AX
AN div
AT ajuint
AD current division number
AX
AN maxdiv
AT ajuint
AD max division number
AX
AN type
AT ajuint
AD BLAST type
AX
AN libr
AT AjPFile
AD main data reference or BLAST header
AX
AN libs
AT AjPFile
AD sequence or BLAST compressed sequence
AX
AN libt
AT AjPFile
AD blast table
AX
AN libf
AT AjPFile
AD blast FASTA source data
AX
AN idnum
AT ajuint
AD current BLAST entry offset
AX
AN TopHdr
AT ajuint
AD BLAST table headers offset
AX
AN TopCmp
AT ajuint
AD BLAST table sequence offset
AX
AN TopAmb
AT ajuint
AD BLAST table ambiguities offset
AX
AN TopSrc
AT ajuint
AD BLAST table FASTA source offset
AX
AN Size
AT ajuint
AD BLAST database size
AX
AN Skip
AT AjBool*
AD skip file(s) in division.lkp
AX
AN idxLine
AT SeqPCdIdx
AD entryname.idx input line
AX
AN Samefile
AT AjBool
AD true if the same file is passed to
AD ajFilebuffReopenFile
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SeqSCdQry
{
AjPStr divfile;
AjPStr idxfile;
AjPStr datfile;
AjPStr seqfile;
AjPStr tblfile;
AjPStr srcfile;
SeqPCdFile dfp;
SeqPCdFile ifp;
SeqPCdFile trgfp;
SeqPCdFile hitfp;
SeqPCdTrg trgLine;
char* name;
ajuint nameSize;
ajuint div;
ajuint maxdiv;
ajuint type;
AjPFile libr;
AjPFile libs;
AjPFile libt;
AjPFile libf;
ajuint idnum;
ajuint TopHdr;
ajuint TopCmp;
ajuint TopAmb;
ajuint TopSrc;
ajuint Size;
AjBool* Skip;
SeqPCdIdx idxLine;
AjBool Samefile;
char Padding[4];
} SeqOCdQry;
#define SeqPCdQry SeqOCdQry*
ID SeqPEmbossQry
TY static
MO ajseqdb
LB ajaxdb
XX
DE Btree 'emboss' query structure
XX
TN SeqSEmbossQry
TD
TX
TN SeqOEmbossQry
TD
TX
AN idcache
AT AjPBtcache
AD ID cache
AX
AN Caches
AT AjPList
AD Caches for each query field
AX
AN files
AT AjPStr*
AD database filenames
AX
AN reffiles
AT AjPStr**
AD database reference filenames
AX
AN Skip
AT AjBool*
AD files numbers to exclude
AX
AN List
AT AjPList
AD List of files
AX
AN libs
AT AjPFile
AD Primary (database source) file
AX
AN libr
AT AjPFile
AD Secondary (database bibliographic source) file
AX
AN div
AT ajuint
AD division number of currently open database file
AX
AN refcount
AT ajuint
AD number of reference file(s) per entry
AX
AN nentries
AT ajint
AD number of entries in the filename array(s)
AD -1 when done
AX
AN Samefile
AT AjBool
AD true if the same file is passed to
AD ajFilebuffReopenFile
AX
//
typedef struct SeqSEmbossQry
{
AjPBtcache idcache;
AjPList Caches;
AjPStr *files;
AjPStr **reffiles;
AjBool *Skip;
AjPList List;
AjPFile libs;
AjPFile libr;
ajuint div;
ajuint refcount;
ajint nentries;
AjBool Samefile;
} SeqOEmbossQry;
#define SeqPEmbossQry SeqOEmbossQry*
ID SeqEEnsemblType
TY public
MO ajseqdb
LB ajaxdb
XX
DE Ensembl Object Type enumeration
XX
VN seqEEnsemblTypeNULL
VD Null
VX
VN seqEEnsemblTypeExon
VD Exon
VX
VN seqEEnsemblTypeGene
VD Gene
VX
VN seqEEnsemblTypeTranscript
VD Transcript
VX
VN seqEEnsemblTypeTranslation
VD Translation
VX
//
typedef enum SeqOEnsemblType
{
seqEEnsemblTypeNULL,
seqEEnsemblTypeExon,
seqEEnsemblTypeGene,
seqEEnsemblTypeTranscript,
seqEEnsemblTypeTranslation
} SeqEEnsemblType;
ID SeqPEnsembl
TY static
MO ajseqdb
LB ajaxdb
XX
DE Ensembl query structure
XX
TN SeqSEnsembl
TD
TX
TN SeqOEnsembl
TD
TX
AN Stableidentifiers
AT AjPList
AD AJAX List of AJAX String
AD (Ensembl stable identifier) objects
AX
AN Alias
AT AjPStr
AD Species alias parsed from the USA
AX
AN Database
AT AjPStr
AD The database name parsed from the USA
AX
AN Wildquery
AT AjPStr
AD AJAX Query Field Wild Query representing
AX
AN Species
AT AjPStr
AD Species resolved from an alias
AD Ensembl stable identifier
AX
AN Databaseadaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
AN EnsemblType
AT SeqEEnsemblType
AD Ensembl Object Type enumeration
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct SeqSEnsembl
{
AjPList Stableidentifiers;
AjPStr Alias;
AjPStr Database;
AjPStr Wildquery;
AjPStr Species;
EnsPDatabaseadaptor Databaseadaptor;
SeqEEnsemblType EnsemblType;
ajuint Padding;
} SeqOEnsembl;
#define SeqPEnsembl SeqOEnsembl*
ID SeqPInFormat
TY static
MO ajseqread
LB core
XX
DE Sequence input formats data structure
XX
TN SeqSInFormat
TD
TX
TN SeqOInFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Obo
AT const char*
AD Ontology term id from EDAM
AX
AN Desc
AT const char*
AD Format description
AX
AN Alias
AT AjBool
AD Name is an alias for an identical definition
AX
AN Try
AT AjBool
AD If true, try for an unknown input. Duplicate names
AD and read-anything formats are set false
AX
AN Nucleotide
AT AjBool
AD True if suitable for nucleotide
AX
AN Protein
AT AjBool
AD True if suitable for protein
AX
AN Feature
AT AjBool
AD True if includes parsable feature data
AX
AN Gap
AT AjBool
AD True if allows gap characters
AX
AN Read
AT AjBool function
AD Input function, returns ajTrue on success
AX
AN Multiset
AT AjBool
AD If true, supports multiple sequence sets
AD If false, multiple sets must be in separate files
AX
AN Binary
AT AjBool
AD Binary file format
AX
//
typedef struct SeqSInFormat
{
const char *Name;
const char *Obo;
const char *Desc;
AjBool Alias;
AjBool Try;
AjBool Nucleotide;
AjBool Protein;
AjBool Feature;
AjBool Gap;
AjBool (*Read) (AjPSeq thys, AjPSeqin seqin);
AjBool Multiset;
AjBool Binary;
} SeqOInFormat;
#define SeqPInFormat SeqOInFormat*
ID SeqPMsfData
TY static
MO ajseqread
LB core
XX
DE Sequence alignment data, stored until written when output file is closed
XX
TN SeqSMsfData
TD
TX
TN SeqOMsfData
TD
TX
AN Table
AT AjPTable
AD Ajax table of AjPMsfItem objects
AX
AN Names
AT AjPStr*
AD Sequence names
AX
AN Count
AT ajuint
AD Undocumented
AX
AN Nseq
AT ajuint
AD Number of sequences
AX
AN Nexus
AT AjPNexus
AD Nexus alignment data
AX
AN Gene
AT AjPStr
AD Gene name
AX
AN Domain
AT AjPStr
AD Domain name
AX
AN NextGene
AT AjPStr
AD Next block gene name
AX
AN NextDomain
AT AjPStr
AD Next block domain name
AX
AN Bufflines
AT ajuint
AD Number of buffered lines read
AX
AN CommentDepth
AT ajint
AD Comment depth
AX
AN Resume
AT AjBool
AD Resume processing
AX
AN Identchar
AT char
AD Identity character
AX
AN Indelchar
AT char
AD Gap character
AX
AN Misschar
AT char
AD Gap character
AX
AN Seqtype
AT char
AD Sequence type N:nucleotide P:protein
AX
//
typedef struct SeqSMsfData
{
AjPTable Table;
AjPStr* Names;
ajuint Count;
ajuint Nseq;
AjPNexus Nexus;
AjPStr Gene;
AjPStr Domain;
AjPStr NextGene;
AjPStr NextDomain;
ajuint Bufflines;
ajint CommentDepth;
AjBool Resume;
char Identchar;
char Indelchar;
char Misschar;
char Seqtype;
} SeqOMsfData;
#define SeqPMsfData SeqOMsfData*
ID SeqPMsfItem
TY static
MO ajseqread
LB core
XX
DE MSF alignment output individual sequence data
XX
TN SeqSMsfItem
TD
TX
TN SeqOMsfItem
TD
TX
AN Name
AT AjPStr
AD Sequence name
AX
AN Desc
AT AjPStr
AD Sequence description
AX
AN Len
AT ajuint
AD Sequence length
AX
AN Check
AT ajuint
AD Sequence GCG checksum
AX
AN Seq
AT AjPStr
AD Sequence
AX
AN Weight
AT float
AD Weight (default 1.0)
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SeqSMsfItem
{
AjPStr Name;
AjPStr Desc;
ajuint Len;
ajuint Check;
AjPStr Seq;
float Weight;
char Padding[4];
} SeqOMsfItem;
#define SeqPMsfItem SeqOMsfItem*
ID SeqPStockholm
TY static
MO ajseqread
LB core
XX
DE Ajax Stockholm object.
XX
NN stockholmNew
ND Default constructor
NX
DN stockholmDel
DD Default destructor
DX
AN id
AT AjPStr
AD identifier
AX
AN ac
AT AjPStr
AD accession
AX
AN de
AT AjPStr
AD description
AX
AN au
AT AjPStr
AD author
AX
AN al
AT AjPStr
AD Undocumented
AX
AN tp
AT AjPStr
AD Undocumented
AX
AN se
AT AjPStr
AD Undocumented
AX
AN ga
AT ajuint[2]
AD Undocumented
AX
AN tc
AT float[2]
AD Undocumented
AX
AN nc
AT float[2]
AD Undocumented
AX
AN bm
AT AjPStr
AD Undocumented
AX
AN ref
AT AjPStr
AD Undocumented
AX
AN dc
AT AjPStr
AD Undocumented
AX
AN dr
AT AjPStr
AD Undocumented
AX
AN cc
AT AjPStr
AD Undocumented
AX
AN sacons
AT AjPStr
AD Undocumented
AX
AN sqcons
AT AjPStr
AD Undocumented
AX
AN sscons
AT AjPStr
AD Undocumented
AX
AN gs
AT AjPStr
AD Undocumented
AX
AN name
AT AjPStr*
AD Undocumented
AX
AN str
AT AjPStr*
AD Undocumented
AX
AN n
AT ajuint
AD Undocumented
AX
AN Count
AT ajuint
AD Count
AX
//
typedef struct SeqSStockholm
{
AjPStr id;
AjPStr ac;
AjPStr de;
AjPStr au;
AjPStr al;
AjPStr tp;
AjPStr se;
ajuint ga[2];
float tc[2];
float nc[2];
AjPStr bm;
AjPStr ref;
AjPStr dc;
AjPStr dr;
AjPStr cc;
AjPStr sacons;
AjPStr sqcons;
AjPStr sscons;
AjPStr gs;
AjPStr *name;
AjPStr *str;
ajuint n;
ajuint Count;
} SeqOStockholm;
#define SeqPStockholm SeqOStockholm*
ID SeqPStockholmdata
TY static
MO ajseqread
LB core
XX
DE Ajax Stockholm data object (individual sequences)
XX
NN stockholmdataNew
ND Default constructor
NX
DN stockholmdataDel
DD Default destructor
DX
AN id
AT AjPStr
AD identifier
AX
AN ac
AT AjPStr
AD accession
AX
AN de
AT AjPStr
AD description
AX
AN au
AT AjPStr
AD author
AX
AN al
AT AjPStr
AD Undocumented
AX
AN tp
AT AjPStr
AD Undocumented
AX
AN se
AT AjPStr
AD Undocumented
AX
AN bm
AT AjPStr
AD Undocumented
AX
AN sacons
AT AjPStr
AD Undocumented
AX
AN sqcons
AT AjPStr
AD Undocumented
AX
AN sscons
AT AjPStr
AD Undocumented
AX
AN ref
AT AjPStr
AD Undocumented
AX
AN dc
AT AjPStr
AD Undocumented
AX
AN dr
AT AjPStr
AD Undocumented
AX
AN cc
AT AjPStr
AD Undocumented
AX
AN gs
AT AjPStr
AD Undocumented
AX
AN ga
AT float[2]
AD Undocumented
AX
AN tc
AT float[2]
AD Undocumented
AX
AN nc
AT float[2]
AD Undocumented
AX
//
typedef struct SeqSStockholmdata
{
AjPStr id;
AjPStr ac;
AjPStr de;
AjPStr au;
AjPStr al;
AjPStr tp;
AjPStr se;
AjPStr bm;
AjPStr sacons;
AjPStr sqcons;
AjPStr sscons;
AjPStr ref;
AjPStr dc;
AjPStr dr;
AjPStr cc;
AjPStr gs;
float ga[2];
float tc[2];
float nc[2];
} SeqOStockholmdata;
#define SeqPStockholmdata SeqOStockholmdata*
ID SeqPSelexseq
TY static
MO ajseqread
LB core
XX
DE Ajax Selex object for #=SQ information.
XX
NN selexSQNew
ND Default constructor
NX
DN selexSQDel
DD Default destructor
DX
AN name
AT AjPStr
AD Object name
AX
AN source
AT AjPStr
AD Source file
AX
AN ac
AT AjPStr
AD accession
AX
AN de
AT AjPStr
AD description
AX
AN wt
AT float
AD weight (default 1.0)
AX
AN start
AT ajuint
AD start position
AX
AN stop
AT ajuint
AD end position
AX
AN len
AT ajuint
AD length
AX
//
typedef struct SeqSSelexseq
{
AjPStr name;
AjPStr source;
AjPStr ac;
AjPStr de;
float wt;
ajuint start;
ajuint stop;
ajuint len;
} SeqOSelexseq;
#define SeqPSelexseq SeqOSelexseq*
ID SeqPSelex
TY static
MO ajseqread
LB core
XX
DE Ajax Selex object.
XX
NN selexNew
ND Default constructor
NX
DN selexDel
DD Default destructor
DX
AN id
AT AjPStr
AD identifier
AX
AN ac
AT AjPStr
AD accession
AX
AN de
AT AjPStr
AD description
AX
AN au
AT AjPStr
AD author
AX
AN cs
AT AjPStr
AD Undocumented
AX
AN rf
AT AjPStr
AD Undocumented
AX
AN name
AT AjPStr*
AD Undocumented
AX
AN str
AT AjPStr*
AD Undocumented
AX
AN ss
AT AjPStr*
AD Undocumented
AX
AN ga
AT float[2]
AD Undocumented
AX
AN tc
AT float[2]
AD Undocumented
AX
AN nc
AT float[2]
AD Undocumented
AX
AN sq
AT SeqPSelexseq*
AD Selex sequence objects
AX
AN n
AT ajuint
AD Number of SeqPSelexseq sequence objects
AX
AN Count
AT ajuint
AD Count
AX
//
typedef struct SeqSSelex
{
AjPStr id;
AjPStr ac;
AjPStr de;
AjPStr au;
AjPStr cs;
AjPStr rf;
AjPStr *name;
AjPStr *str;
AjPStr *ss;
float ga[2];
float tc[2];
float nc[2];
SeqPSelexseq *sq;
ajuint n;
ajuint Count;
} SeqOSelex;
#define SeqPSelex SeqOSelex*
ID SeqPSelexdata
TY static
MO ajseqread
LB core
XX
DE Ajax Selex data object (individual sequences)
XX
NN selexdataNew
ND Default constructor
NX
DN selexdataDel
DD Default destructor
DX
AN id
AT AjPStr
AD identifier
AX
AN ac
AT AjPStr
AD accession
AX
AN de
AT AjPStr
AD description
AX
AN au
AT AjPStr
AD author
AX
AN cs
AT AjPStr
AD Undocumented
AX
AN rf
AT AjPStr
AD Undocumented
AX
AN name
AT AjPStr
AD Undocumented
AX
AN str
AT AjPStr
AD Undocumented
AX
AN ss
AT AjPStr
AD Undocumented
AX
AN ga
AT float[2]
AD Undocumented
AX
AN tc
AT float[2]
AD Undocumented
AX
AN nc
AT float[2]
AD Undocumented
AX
AN sq
AT SeqPSelexseq
AD Selex sequence object
AX
//
typedef struct SeqSSelexdata
{
AjPStr id;
AjPStr ac;
AjPStr de;
AjPStr au;
AjPStr cs;
AjPStr rf;
AjPStr name;
AjPStr str;
AjPStr ss;
float ga[2];
float tc[2];
float nc[2];
SeqPSelexseq sq;
} SeqOSelexdata;
#define SeqPSelexdata SeqOSelexdata*
ID SeqPListUsa
TY static
MO ajseqread
LB core
XX
DE Usa processing list of USAs from a list file.
DE
DE Includes data from the original USA (XX
TN SeqSListUsa
TD
TX
TN SeqOListUsa
TD
TX
AN Begin
AT ajint
AD Begin if defined in original USA
AX
AN End
AT ajint
AD End if defined in original USA
AX
AN Rev
AT AjBool
AD Reverse if defined in original USA
AX
AN Format
AT ajuint
AD Format number from original USA
AX
AN Formatstr
AT AjPStr
AD Format name from original USA
AX
AN Usa
AT AjPStr
AD Current USA
AX
AN Fpos
AT ajulong
AD Start position offset
AX
AN Features
AT AjBool
AD if true, process features
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SeqSListUsa
{
ajint Begin;
ajint End;
AjBool Rev;
ajuint Format;
AjPStr Formatstr;
AjPStr Usa;
ajulong Fpos;
AjBool Features;
char Padding[4];
} SeqOListUsa;
#define SeqPListUsa SeqOListUsa*
ID SeqPType
TY static
MO ajseqtype
LB core
XX
DE Sequence types data structure, used to test input sequence against
DE a defined sequence type
XX
TN SeqSType
TD
TX
TN SeqOType
TD
TX
AN Name
AT const char*
AD sequence type name
AX
AN Gaps
AT AjBool
AD allow gap characters
AX
AN Ambig
AT AjBool
AD True if ambiguity codes are allowed
AX
AN Type
AT ajuint
AD enumerated ISANY=0 ISNUC=1 ISPROT=2
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
AN ConvertFrom
AT const char*
AD Convert each of these characters to the
AD ConvertTo equivalent
AX
AN ConvertTo
AT const char*
AD Equivalent for each sequence character in
AD ConvertFrom
AX
AN Badchars
AT AjPRegexp function
AD Test function
AX
AN Goodchars
AT AjPStr function
AD Test function
AX
AN Desc
AT const char*
AD Description for documentation purposes
AX
//
typedef struct SeqSType
{
const char *Name;
AjBool Gaps;
AjBool Ambig;
ajuint Type;
ajint Padding;
const char *ConvertFrom;
const char *ConvertTo;
AjPRegexp (*Badchars) (void);
AjPStr (*Goodchars) (void);
const char *Desc;
} SeqOType;
#define SeqPType SeqOType*
ID SeqPOutFormat
TY static
MO ajseqwrite
LB core
XX
DE Sequence output formats
XX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Alias
AT AjBool
AD Name is an alias for an identical definition
AX
AN Single
AT AjBool
AD Write each sequence to a new file if true (e.g. GCG)
AX
AN Save
AT AjBool
AD Save in memory and write at end (e.g. MSF alignments)
AX
AN Nucleotide
AT AjBool
AD True if nucleotide data is supported
AX
AN Protein
AT AjBool
AD True if protein data is supported
AX
AN Feature
AT AjBool
AD True if feature data can be written
AX
AN Gap
AT AjBool
AD True if gap characters are supported
AX
AN Multiset
AT AjBool
AD True if sets of sets (seqsetall) are supported
AX
AN Write
AT void function
AD Function to write the format
AX
//
typedef struct SeqSOutFormat
{
const char *Name;
const char *Desc;
AjBool Alias;
AjBool Single;
AjBool Save;
AjBool Nucleotide;
AjBool Protein;
AjBool Feature;
AjBool Gap;
AjBool Multiset;
void (*Write) (AjPSeqout outseq);
} SeqOOutFormat;
#define SeqPOutFormat SeqOOutFormat*
ID SeqPSeqFormat
TY static
MO ajseqwrite
LB core
XX
DE Data structure to hold definitions when writing sequence data.
DE
DE Most output functions generate the sequence header, then build
DE this data structure for the actual output using function seqWriteSeq
XX
AN linepos
AT ajuint
AD Undocumented
AX
AN namewidth
AT ajuint
AD Name format width
AX
AN numline
AT ajuint
AD Undocumented
AX
AN numwidth
AT ajuint
AD Number format width
AX
AN spacer
AT ajint
AD Spacer - can be negative
AX
AN tab
AT ajuint
AD Undocumented
AX
AN width
AT ajuint
AD Number of bases per line
AX
AN baseonlynum
AT AjBool
AD Undocumented
AX
AN degap
AT AjBool
AD Remove gap characters
AX
AN domatch
AT AjBool
AD Show matching line
AX
AN isactive
AT AjBool
AD Undocumented
AX
AN nameright
AT AjBool
AD Sequence name in right margin
AX
AN nameleft
AT AjBool
AD Sequence name in left margin
AX
AN noleaves
AT AjBool
AD Undocumented
AX
AN numjust
AT AjBool
AD Justify numbers
AX
AN numleft
AT AjBool
AD Base number on left
AX
AN numright
AT AjBool
AD Base number on right
AX
AN pretty
AT AjBool
AD Undocumented
AX
AN skipafter
AT AjBool
AD Undocumented
AX
AN skipbefore
AT AjBool
AD Undocumented
AX
AN gapchar
AT char
AD gap character
AX
AN matchchar
AT char
AD matching character
AX
AN endstr
AT char[20]
AD Last line(s)
AX
AN leftstr
AT char[20]
AD string in left margin
AX
AN Padding
AT char[2]
AD Padding to alignment boundary
AX
//
typedef struct SeqSSeqFormat
{
ajuint linepos;
ajuint namewidth;
ajuint numline;
ajuint numwidth;
ajint spacer;
ajuint tab;
ajuint width;
AjBool baseonlynum;
AjBool degap;
AjBool domatch;
AjBool isactive;
AjBool nameright;
AjBool nameleft;
AjBool noleaves;
AjBool numjust;
AjBool numleft;
AjBool numright;
AjBool pretty;
AjBool skipafter;
AjBool skipbefore;
char gapchar;
char matchchar;
char endstr[20];
char leftstr[20];
char Padding[2];
} SeqOSeqFormat;
#define SeqPSeqFormat SeqOSeqFormat*
ID TaxPEmbossQry
TY static
MO ajtaxdb
LB ajaxdb
XX
DE Btree 'emboss' query structure
XX
TN TaxSEmbossQry
TD
TX
TN TaxOEmbossQry
TD
TX
AN idcache
AT AjPBtcache
AD ID cache
AX
AN Caches
AT AjPList
AD Caches for each query field
AX
AN files
AT AjPStr*
AD database filenames
AX
AN reffiles
AT AjPStr**
AD database reference filenames
AX
AN Skip
AT AjBool*
AD files numbers to exclude
AX
AN libs
AT AjPFile
AD Primary (database source) file
AX
AN libr
AT AjPFile
AD Secondary (database bibliographic source) file
AX
AN div
AT ajuint
AD division number of currently open database file
AX
AN refcount
AT ajuint
AD number of reference file(s) per entry
AX
AN nentries
AT ajint
AD number of entries in the filename array(s)
AD -1 when done
AX
AN Samefile
AT AjBool
AD true if the same file is passed to
AD ajFilebuffReopenFile
AX
//
typedef struct TaxSEmbossQry
{
AjPBtcache idcache;
AjPList Caches;
AjPStr *files;
AjPStr **reffiles;
AjBool *Skip;
AjPFile libs;
AjPFile libr;
ajuint div;
ajuint refcount;
ajint nentries;
AjBool Samefile;
} TaxOEmbossQry;
#define TaxPEmbossQry TaxOEmbossQry*
ID TaxPInFormat
TY static
MO ajtaxread
LB core
XX
DE Taxonomy input formats data structure
XX
TN TaxSInFormat
TD
TX
TN TaxOInFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Alias
AT AjBool
AD Name is an alias for an identical definition
AX
AN Try
AT AjBool
AD If true, try for an unknown input. Duplicate names
AD and read-anything formats are set false
AX
AN Read
AT AjBool function
AD Input function, returns ajTrue on success
AX
//
typedef struct TaxSInFormat
{
const char *Name;
const char *Desc;
AjBool Alias;
AjBool Try;
AjBool (*Read) (AjPTaxin thys, AjPTax tax);
} TaxOInFormat;
#define TaxPInFormat TaxOInFormat*
ID TaxPOutFormat
TY static
MO ajtaxwrite
LB core
XX
DE Taxonomy output formats data structure
XX
TN TaxSoutFormat
TD
TX
TN TaxOOutFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Write
AT AjBool function
AD Output function, returns ajTrue on success
AX
//
typedef struct TaxSOutFormat
{
const char *Name;
const char *Desc;
AjBool (*Write) (AjPFile outf, const AjPTax tax);
} TaxOOutFormat;
#define TaxPOutFormat TaxOOutFormat*
ID TextPObdaFile
TY static
MO ajtextdb
LB ajaxdb
XX
DE OBDA division file record structure
XX
TN TextSObdaFile
TD
TX
TN TextOObdaFile
TD
TX
AN File
AT AjPFile
AD File
AX
AN NRecords
AT ajulong
AD Index record count
AX
AN RecSize
AT ajulong
AD Record length (for calculating record offsets)
AX
//
typedef struct TextSObdaFile
{
AjPFile File;
ajulong NRecords;
ajulong RecSize;
} TextOObdaFile;
#define TextPObdaFile TextOObdaFile*
ID TextPObdaEntry
TY static
MO ajtextdb
LB ajaxdb
XX
DE OBDA ID index file record structure
XX
TN TextSObdaEntry
TD
TX
TN TextOObdaEntry
TD
TX
AN div
AT ajuint
AD config file record
AX
AN annoff
AT ajulong
AD data file offset
AX
//
typedef struct TextSObdaEntry
{
ajuint div;
ajulong annoff;
} TextOObdaEntry;
#define TextPObdaEntry TextOObdaEntry*
ID TextPCdDiv
TY static
MO ajtextdb
LB ajaxdb
XX
DE EMBLCD division file record structure
XX
TN TextSCdDiv
TD
TX
TN TextOCdDiv
TD
TX
AN FileName
AT AjPStr
AD Filename(s)
AX
AN DivCode
AT ajuint
AD Division code
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct TextSCdDiv
{
AjPStr FileName;
ajuint DivCode;
char Padding[4];
} TextOCdDiv;
#define TextPCdDiv TextOCdDiv*
ID TextPCdEntry
TY static
MO ajtextdb
LB ajaxdb
XX
DE EMBLCD entrynam.idx file record structure
XX
TN TextSCdEntry
TD
TX
TN TextOCdEntry
TD
TX
AN div
AT ajuint
AD division file record
AX
AN annoff
AT ajuint
AD data file offset
AX
//
typedef struct TextSCdEntry
{
ajuint div;
ajuint annoff;
} TextOCdEntry;
#define TextPCdEntry TextOCdEntry*
ID TextPCdFHeader
TY static
MO ajtextdb
LB ajaxdb
XX
DE EMBLCD index file header structure, same for all index files.
XX
TN TextSCdFHeader
TD
TX
TN TextOCdFHeader
TD
TX
AN FileSize
AT ajuint
AD Index file size
AX
AN NRecords
AT ajuint
AD Index record count
AX
AN IdSize
AT ajuint
AD Index string length
AX
AN RelDay
AT ajuint
AD Release date - day
AX
AN RelMonth
AT ajuint
AD Release date - month
AX
AN RelYear
AT ajuint
AD Release date - year
AX
AN RecSize
AT short
AD Record size
AX
AN SPadding
AT short
AD Padding to alignment boundary
AX
AN DbName
AT char[24]
AD Database name
AX
AN Release
AT char[12]
AD Release name/number
AX
AN Date
AT char[4]
AD Date as three integers.
AX
//
typedef struct TextSCdFHeader
{
ajuint FileSize;
ajuint NRecords;
ajuint IdSize;
ajuint RelDay;
ajuint RelMonth;
ajuint RelYear;
short RecSize;
short SPadding;
char DbName[24];
char Release[12];
char Date[4];
} TextOCdFHeader;
#define TextPCdFHeader TextOCdFHeader*
ID TextPCdFile
TY static
MO ajtextdb
LB ajaxdb
XX
DE EMBLCD file data structure
XX
TN TextSCdFile
TD
TX
TN TextOCdFile
TD
TX
AN Header
AT TextPCdFHeader
AD Header data
AX
AN File
AT AjPFile
AD File
AX
AN NRecords
AT ajuint
AD Number of records
AX
AN RecSize
AT ajuint
AD Record length (for calculating record offsets)
AX
//
typedef struct TextSCdFile
{
TextPCdFHeader Header;
AjPFile File;
ajuint NRecords;
ajuint RecSize;
} TextOCdFile;
#define TextPCdFile TextOCdFile*
ID TextPCdHit
TY static
MO ajtextdb
LB ajaxdb
XX
DE EMBLCD hit file record structure
XX
TN TextSCdHit
TD
TX
TN TextOCdHit
TD
TX
AN HitList
AT ajuint*
AD Array of hits, as record numbers in the
AD entrynam.idx file
AX
AN NHits
AT ajuint
AD Number of hits in HitList array
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct TextSCdHit
{
ajuint* HitList;
ajuint NHits;
char Padding[4];
} TextOCdHit;
#define TextPCdHit TextOCdHit*
ID TextPObdaIdx
TY static
MO ajtextdb
LB ajaxdb
XX
DE EMBLCD entryname index file record structure
XX
TN TextSObdaIdx
TD
TX
TN TextOObdaIdx
TD
TX
AN AnnOffset
AT ajulong
AD Data file offset (see DivCode)
AX
AN EntryName
AT AjPStr
AD Entry ID - the file is sorted by these
AX
AN DivCode
AT ajuint
AD Division file record
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct TextObdaIdx
{
ajulong AnnOffset;
AjPStr EntryName;
ajuint DivCode;
char Padding[4];
} TextOObdaIdx;
#define TextPObdaIdx TextOObdaIdx*
ID TextPObdaSecidx
TY static
MO ajtextdb
LB ajaxdb
XX
DE OBDA secondary index file record structure
XX
TN TextSObdaSecidx
TD
TX
TN TextOObdaSecidx
TD
TX
AN Target
AT AjPStr
AD Indexed target string (the file is sorted by these)
AX
//
typedef struct TextSObdaSecidx
{
AjPStr Target;
} TextOObdaSecidx;
#define TextPObdaSecidx TextOObdaSecidx*
ID TextPCdIdx
TY static
MO ajtextdb
LB ajaxdb
XX
DE EMBLCD entryname index file record structure
XX
TN TextSCdIdx
TD
TX
TN TextOCdIdx
TD
TX
AN AnnOffset
AT ajuint
AD Data file offset (see DivCode)
AX
AN EntryName
AT AjPStr
AD Entry ID - the file is sorted by these
AX
AN DivCode
AT short
AD Division file record
AX
AN Padding
AT char[6]
AD Padding to alignment boundary
AX
//
typedef struct TextCdIdx
{
ajuint AnnOffset;
AjPStr EntryName;
short DivCode;
char Padding[6];
} TextOCdIdx;
#define TextPCdIdx TextOCdIdx*
ID TextPCdTrg
TY static
MO ajtextdb
LB ajaxdb
XX
DE EMBLCD target (.trg) file record structure
XX
TN TextSCdTrg
TD
TX
TN TextOCdTrg
TD
TX
AN FirstHit
AT ajuint
AD First hit record in .hit file
AX
AN NHits
AT ajuint
AD Number of hit records in .hit file
AX
AN Target
AT AjPStr
AD Indexed target string (the file is sorted by these)
AX
//
typedef struct TextSCdTrg
{
ajuint FirstHit;
ajuint NHits;
AjPStr Target;
} TextOCdTrg;
#define TextPCdTrg TextOCdTrg*
ID TextPCdQry
TY static
MO ajtextdb
LB ajaxdb
XX
DE EMBLCD query structure
XX
TN TextSCdQry
TD
TX
TN TextOCdQry
TD
TX
AN divfile
AT AjPStr
AD division.lkp
AX
AN idxfile
AT AjPStr
AD entryname.idx
AX
AN datfile
AT AjPStr
AD main data reference
AX
AN dfp
AT TextPCdFile
AD division.lkp
AX
AN ifp
AT TextPCdFile
AD entryname.idx
AX
AN trgfp
AT TextPCdFile
AD acnum.trg
AX
AN hitfp
AT TextPCdFile
AD acnum.hit
AX
AN trgLine
AT TextPCdTrg
AD acnum input line
AX
AN name
AT char*
AD filename from division.lkp
AX
AN nameSize
AT ajuint
AD division.lkp filename length
AX
AN div
AT ajuint
AD current division number
AX
AN maxdiv
AT ajuint
AD max division number
AX
AN Samefile
AT AjBool
AD true if the same file is used
AX
AN libt
AT AjPFile
AD main data file
AX
AN Skip
AT AjBool*
AD skip file(s) in division.lkp
AX
AN idxLine
AT TextPCdIdx
AD entryname.idx input line
AX
//
typedef struct TextSCdQry
{
AjPStr divfile;
AjPStr idxfile;
AjPStr datfile;
TextPCdFile dfp;
TextPCdFile ifp;
TextPCdFile trgfp;
TextPCdFile hitfp;
TextPCdTrg trgLine;
char* name;
ajuint nameSize;
ajuint div;
ajuint maxdiv;
AjBool Samefile;
AjPFile libt;
AjBool* Skip;
TextPCdIdx idxLine;
} TextOCdQry;
#define TextPCdQry TextOCdQry*
ID TextPObdaQry
TY static
MO ajtextdb
LB ajaxdb
XX
DE OBDA query structure
XX
TN TextSEmbossQry
TD
TX
TN TextOEmbossQry
TD
TX
AN divfile
AT AjPStr
AD division.lkp
AX
AN idxname
AT AjPStr
AD primary index file name
AX
AN files
AT AjPStr*
AD Database filenames
AX
AN idxfiles
AT AjPStr*
AD Index filenames
AX
AN Skip
AT AjBool*
AD Files numbers to exclude
AX
AN dfp
AT TextPObdaFile
AD config.dat
AX
AN ifp
AT TextPObdaFile
AD key_ID.key
AX
AN trgfp
AT TextPObdaFile
AD id_ACC.index
AX
AN idxLine
AT TextPObdaIdx
AD key_ID.key input line
AX
AN trgLine
AT TextPObdaSecidx
AD secondary index input line
AX
AN libt
AT AjPFile
AD Primary (database source) file
AX
AN nfiles
AT ajuint
AD Number of data files
AX
AN nindex
AT ajuint
AD Number of index files
AX
AN ifile
AT ajuint
AD Division number of currently open database file
AX
AN nentries
AT ajint
AD Number of entries in the filename array(s)
AD -1 when done
AX
AN Samefile
AT AjBool
AD True if the same file is passed to
AD ajFilebuffReopenFile
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct TextSObdaQry
{
AjPStr divfile;
AjPStr idxname;
AjPStr *files;
AjPStr *idxfiles;
AjBool *Skip;
TextPObdaFile dfp;
TextPObdaFile ifp;
TextPObdaFile trgfp;
TextPObdaIdx idxLine;
TextPObdaSecidx trgLine;
AjPFile libt;
ajuint nfiles;
ajuint nindex;
ajuint ifile;
ajint nentries;
AjBool Samefile;
char Padding[4];
} TextOObdaQry;
#define TextPObdaQry TextOObdaQry*
ID TextPEmbossQry
TY static
MO ajtextdb
LB ajaxdb
XX
DE B+tree 'emboss' query structure
XX
TN TextSEmbossQry
TD
TX
TN TextOEmbossQry
TD
TX
AN idcache
AT AjPBtcache
AD ID cache
AX
AN Caches
AT AjPList
AD Caches for each query field
AX
AN files
AT AjPStr*
AD Database filenames
AX
AN Skip
AT AjBool*
AD Files numbers to exclude
AX
AN libt
AT AjPFile
AD Primary (database source) file
AX
AN div
AT ajuint
AD Division number of currently open database file
AX
AN nentries
AT ajint
AD Number of entries in the filename array(s)
AD -1 when done
AX
AN Samefile
AT AjBool
AD True if the same file is passed to
AD ajFilebuffReopenFile
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct TextSEmbossQry
{
AjPBtcache idcache;
AjPList Caches;
AjPStr *files;
AjBool *Skip;
AjPFile libt;
ajuint div;
ajint nentries;
AjBool Samefile;
char Padding[4];
} TextOEmbossQry;
#define TextPEmbossQry TextOEmbossQry*
ID TextPInFormat
TY static
MO ajtextread
LB core
XX
DE Text input formats data structure
XX
TN TextSInFormat
TD
TX
TN TextOInFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Obo
AT const char*
AD Ontology term id from EDAM
AX
AN Desc
AT const char*
AD Format description
AX
AN Alias
AT AjBool
AD Name is an alias for an identical definition
AX
AN Try
AT AjBool
AD If true, try for an unknown input. Duplicate names
AD and read-anything formats are set false
AX
AN Read
AT AjBool function
AD Input function, returns ajTrue on success
AX
//
typedef struct TextSInFormat
{
const char *Name;
const char *Obo;
const char *Desc;
AjBool Alias;
AjBool Try;
AjBool (*Read) (AjPTextin thys, AjPText text);
} TextOInFormat;
#define TextPInFormat TextOInFormat*
ID TextPOutFormat
TY static
MO ajtextwrite
LB core
XX
DE Text output formats data structure
XX
TN TextSoutFormat
TD
TX
TN TextOOutFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Write
AT AjBool function
AD Output function, returns ajTrue on success
AX
//
typedef struct TextSOutFormat
{
const char *Name;
const char *Desc;
AjBool (*Write) (AjPFile outf, const AjPText text);
} TextOOutFormat;
#define TextPOutFormat TextOOutFormat*
ID TimePFormat
TY static
MO ajtime
LB core
XX
DE Internal structure for known Ajax time formats
XX
TN TimeSFormat
TD
TX
TN TimeOFormat
TD
TX
AN Name
AT const char*
AD format name
AX
AN Format
AT const char*
AD C run time library time format string
AX
AN Uppercase
AT AjBool
AD Convert to upper case on output
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
//
typedef struct TimeSFormat
{
const char* Name;
const char* Format;
AjBool Uppercase;
ajint Padding;
} TimeOFormat;
#define TimePFormat TimeOFormat*
ID UrlPInFormat
TY static
MO ajurlread
LB core
XX
DE Url input formats data structure
XX
TN UrlSInFormat
TD
TX
TN UrlOInFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Obo
AT const char*
AD Ontology term id from EDAM
AX
AN Desc
AT const char*
AD Format description
AX
AN Alias
AT AjBool
AD Name is an alias for an identical definition
AX
AN Try
AT AjBool
AD If true, try for an unknown input. Duplicate names
AD and read-anything formats are set false
AX
AN Read
AT AjBool function
AD Input function, returns ajTrue on success
AX
//
typedef struct UrlSInFormat
{
const char *Name;
const char *Obo;
const char *Desc;
AjBool Alias;
AjBool Try;
AjBool (*Read) (AjPUrlin thys, AjPUrl url);
} UrlOInFormat;
#define UrlPInFormat UrlOInFormat*
ID UrlPOutFormat
TY static
MO ajurlwrite
LB core
XX
DE Url output formats data structure
XX
TN UrlSoutFormat
TD
TX
TN UrlOOutFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Write
AT AjBool function
AD Output function, returns ajTrue on success
AX
//
typedef struct UrlSOutFormat
{
const char *Name;
const char *Desc;
AjBool (*Write) (AjPFile outf, const AjPUrl url);
} UrlOOutFormat;
#define UrlPOutFormat UrlOOutFormat*
ID VarPBcfdata
TY static
MO ajvarread
LB core
XX
DE Variation BCF format internals
XX
TN VarSBcfdata
TD
TX
TN VarOBcfdata
TD
TX
AN gzfile
AT AjPVarBcfFile
AD BGZF file
AX
AN Header
AT AjPVarBcfHeader
AD BCF Header object
AX
//
typedef struct VarSBcfdata
{
AjPVarBcfFile gzfile;
AjPVarBcfHeader Header;
} VarOBcfdata;
#define VarPBcfdata VarOBcfdata*
ID VarPId
TY static
MO ajvarread
LB core
XX
DE Variation known identifiers
XX
TN VarSId
TD
TX
TN VarOId
TD
TX
AN Id
AT const char*
AD Identifier
AX
AN Num
AT ajint
AD Number of values
AX
AN Type
AT AjEVarType
AD Format description
AX
AN Desc
AT const char*
AD Description
AX
//
typedef struct VarSId
{
const char *Id;
ajint Num;
AjEVarType Type;
const char *Desc;
} VarOId;
#define VarPId VarOId*
ID VarPInFormat
TY static
MO ajvarread
LB core
XX
DE Variation input formats data structure
XX
TN VarSInFormat
TD
TX
TN VarOInFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Obo
AT const char*
AD Ontology term id from EDAM
AX
AN Desc
AT const char*
AD Format description
AX
AN Alias
AT AjBool
AD Name is an alias for an identical definition
AX
AN Try
AT AjBool
AD If true, try for an unknown input. Duplicate names
AD and read-anything formats are set false
AX
AN Load
AT AjBool function
AD Loading function, returns ajTrue on success
AX
//
typedef struct VarSInFormat
{
const char *Name;
const char *Obo;
const char *Desc;
AjBool Alias;
AjBool Try;
AjBool (*Load) (AjPVarin thys, AjPVar var);
} VarOInFormat;
#define VarPInFormat VarOInFormat*
ID VarPOutFormat
TY static
MO ajvarwrite
LB core
XX
DE Variation output formats data structure
XX
TN VarSoutFormat
TD
TX
TN VarOOutFormat
TD
TX
AN Name
AT const char*
AD Format name
AX
AN Desc
AT const char*
AD Format description
AX
AN Write
AT AjBool function
AD Output function, returns ajTrue on success
AX
AN WriteNext
AT AjBool function
AD Partial output function
AX
//
typedef struct VarSOutFormat
{
const char *Name;
const char *Desc;
AjBool (*Write) (AjPFile outf, const AjPVar var);
AjBool (*WriteNext) (AjPFile outf, const AjPVar var);
} VarOOutFormat;
#define VarPOutFormat VarOOutFormat*
ID CachePNode
TY static
MO enscache
LB ensembl
XX
DE Ensembl Cache Node.
XX
TN CacheSNode
TD
TX
TN CacheONode
TD
TX
AN Key
AT void*
AD Key data address
AX
AN Value
AT void*
AD Value data address
AX
AN Bytes
AT size_t
AD Byte size of this node including key and value data
AX
AN Dirty
AT AjBool
AD Flag to mark that value data has not been written back
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct CacheSNode
{
void *Key;
void *Value;
size_t Bytes;
AjBool Dirty;
ajuint Padding;
} CacheONode;
#define CachePNode CacheONode*
ID DensityPTypeRatio
TY static
MO ensdensity
LB ensembl
XX
DE Ensembl Density Type Ratio.
DE
DE Holds Ensembl Density Types and corresponding ratios.
XX
TN DensitySTypeRatio
TD
TX
TN DensityOTypeRatio
TD
TX
AN Densitytype
AT EnsPDensitytype
AD Ensembl Density Type
AX
AN Ratio
AT float
AD Ratio
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct DensitySTypeRatio
{
EnsPDensitytype Densitytype;
float Ratio;
ajuint Padding;
} DensityOTypeRatio;
#define DensityPTypeRatio DensityOTypeRatio*
ID DensityPLengthValue
TY static
MO ensdensity
LB ensembl
XX
DE Ensembl Density Length Value.
DE
DE Holds density values and corresponding lengths.
XX
TN DensitySLengthValue
TD
TX
TN DensityOLengthValue
TD
TX
AN Length
AT ajuint
AD Length
AX
AN Value
AT float
AD Value
AX
//
typedef struct DensitySLengthValue
{
ajuint Length;
float Value;
} DensityOLengthValue;
#define DensityPLengthValue DensityOLengthValue*
ID ExonPCoordinates
TY static
MO ensexon
LB ensembl
XX
DE Ensembl Exon Coordinates.
DE
DE Holds Ensembl Exon coordinates relative to a particular associated
DE Transcript, as well as coding region coordinates relative to a Slice and a
DE particular associated Transcript.
XX
TN ExonSCoordinates
TD
TX
TN ExonOCoordinates
TD
TX
AN TranscriptStart
AT ajuint
AD Exon start on Transcript
AX
AN TranscriptEnd
AT ajuint
AD Exon end on Transcript
AX
AN TranscriptCodingStart
AT ajuint
AD Coding region start on Transcript
AX
AN TranscriptCodingEnd
AT ajuint
AD Coding region end on Transcript
AX
AN SliceCodingStart
AT ajint
AD Coding region start on Slice
AX
AN SliceCodingEnd
AT ajint
AD Coding region end on Slice
AX
//
typedef struct ExonSCoordinates
{
ajuint TranscriptStart;
ajuint TranscriptEnd;
ajuint TranscriptCodingStart;
ajuint TranscriptCodingEnd;
ajint SliceCodingStart;
ajint SliceCodingEnd;
} ExonOCoordinates;
#define ExonPCoordinates ExonOCoordinates*
ID GvPHaplotype
TY static
MO ensgvgenotype
LB ensembl
XX
DE Genetic Variation Haplotype.
DE
DE Associates haplotype identifiers with alleles.
XX
TN GvSHaplotype
TD
TX
TN GvOHaplotype
TD
TX
AN Haplotypeidentifier
AT ajuint
AD Haplotype identifier
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN Allele
AT AjPStr
AD Allele
AX
//
typedef struct GvSHaplotype
{
ajuint Haplotypeidentifier;
ajuint Padding;
AjPStr Allele;
} GvOHaplotype;
#define GvPHaplotype GvOHaplotype*
ID RegistryPComparativeGenomics
TY static
MO ensregistry
LB ensembl
XX
DE Registry Comparative Genomics structure.
DE
DE Holds an Ensembl Database Adaptor and associated Ensembl Object Adaptors
DE specific for Ensembl Comparative Genomics databases.
XX
TN RegistrySComparativeGenomics
TD
TX
TN RegistryOComparativeGenomics
TD
TX
AN Databaseadaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
//
typedef struct RegistrySComparativeGenomics
{
EnsPDatabaseadaptor Databaseadaptor;
} RegistryOComparativeGenomics;
#define RegistryPComparativeGenomics RegistryOComparativeGenomics*
ID RegistryPCoreStyle
TY static
MO ensregistry
LB ensembl
XX
DE Registry Core-Style structure.
DE
DE Holds an Ensembl Database Adaptor and associated Ensembl Object Adaptors
DE specific for Ensembl Core-Style databases.
XX
TN RegistrySCoreStyle
TD
TX
TN RegistryOCoreStyle
TD
TX
AN Stableidentifierprefix
AT AjPStr
AD Ensembl Stable Identifier Prefix
AX
AN Databaseadaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
AN Referenceadaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
AN Analysisadaptor
AT EnsPAnalysisadaptor
AD Ensembl Analysis Adaptor
AX
AN Assemblyexceptionadaptor
AT EnsPAssemblyexceptionadaptor
AD Ensembl Assembly Exception Adaptor
AX
AN Assemblyexceptionfeatureadaptor
AT EnsPAssemblyexceptionfeatureadaptor
AD Ensembl Assembly Exception Feature Adaptor
AX
AN Assemblymapperadaptor
AT EnsPAssemblymapperadaptor
AD Ensembl Assembly Mapper Adaptor
AX
AN Attributetypeadaptor
AT EnsPAttributetypeadaptor
AD Ensembl Attribute Type Adaptor
AX
AN Coordsystemadaptor
AT EnsPCoordsystemadaptor
AD Ensembl Coordinate System Adaptor
AX
AN Databaseentryadaptor
AT EnsPDatabaseentryadaptor
AD Ensembl Database Entry Adaptor
AX
AN Densityfeatureadaptor
AT EnsPDensityfeatureadaptor
AD Ensembl Density Feature Adaptor
AX
AN Densitytypeadaptor
AT EnsPDensitytypeadaptor
AD Ensembl Density Type Adaptor
AX
AN Ditagadaptor
AT EnsPDitagadaptor
AD Ensembl Ditag Adaptor
AX
AN Ditagfeatureadaptor
AT EnsPDitagfeatureadaptor
AD Ensembl Ditag Feature Adaptor
AX
AN Dnaalignfeatureadaptor
AT EnsPDnaalignfeatureadaptor
AD Ensembl DNA Alignment Feature Adaptor
AX
AN Exonadaptor
AT EnsPExonadaptor
AD Ensembl Exon Adaptor
AX
AN Externaldatabaseadaptor
AT EnsPExternaldatabaseadaptor
AD Ensembl External Database Adaptor
AX
AN Geneadaptor
AT EnsPGeneadaptor
AD Ensembl Gene Adaptor
AX
AN Karyotypebandadaptor
AT EnsPKaryotypebandadaptor
AD Ensembl Karyotype Band Adaptor
AX
AN Markeradaptor
AT EnsPMarkeradaptor
AD Ensembl Marker Adaptor
AX
AN Markerfeatureadaptor
AT EnsPMarkerfeatureadaptor
AD Ensembl Marker Feature Adaptor
AX
AN Metacoordinateadaptor
AT EnsPMetacoordinateadaptor
AD Ensembl Meta-Coordinate Adaptor
AX
AN Metainformationadaptor
AT EnsPMetainformationadaptor
AD Ensembl Meta-Information Adaptor
AX
AN Miscellaneousfeatureadaptor
AT EnsPMiscellaneousfeatureadaptor
AD Ensembl Miscellaneous Feature Adaptor
AX
AN Miscellaneoussetadaptor
AT EnsPMiscellaneoussetadaptor
AD Ensembl Miscellaneous Set Adaptor
AX
AN Predictionexonadaptor
AT EnsPPredictionexonadaptor
AD Ensembl Prediction Exon Adaptor
AX
AN Predictiontranscriptadaptor
AT EnsPPredictiontranscriptadaptor
AD Ensembl Prediction Transcript Adaptor
AX
AN Proteinalignfeatureadaptor
AT EnsPProteinalignfeatureadaptor
AD Ensembl Protein Alignment Feature Adaptor
AX
AN Proteinfeatureadaptor
AT EnsPProteinfeatureadaptor
AD Ensembl Protein Feature Adaptor
AX
AN Repeatconsensusadaptor
AT EnsPRepeatconsensusadaptor
AD Ensembl Repeat Consensus Adaptor
AX
AN Repeatfeatureadaptor
AT EnsPRepeatfeatureadaptor
AD Ensembl Repeat Feature Adaptor
AX
AN Seqregionadaptor
AT EnsPSeqregionadaptor
AD Ensembl Sequence Region Adaptor
AX
AN Seqregionsynonymadaptor
AT EnsPSeqregionsynonymadaptor
AD Ensembl Sequence Region Synonym Adaptor
AX
AN Sequenceadaptor
AT EnsPSequenceadaptor
AD Ensembl Sequence Adaptor
AX
AN Simplefeatureadaptor
AT EnsPSimplefeatureadaptor
AD Ensembl Simple Feature Adaptor
AX
AN Sliceadaptor
AT EnsPSliceadaptor
AD Ensembl Slice Adaptor
AX
AN Transcriptadaptor
AT EnsPTranscriptadaptor
AD Ensembl Transcript Adaptor
AX
AN Translationadaptor
AT EnsPTranslationadaptor
AD Ensembl Translation Adaptor
AX
//
typedef struct RegistrySCoreStyle
{
AjPStr Stableidentifierprefix;
EnsPDatabaseadaptor Databaseadaptor;
EnsPDatabaseadaptor Referenceadaptor;
EnsPAnalysisadaptor Analysisadaptor;
EnsPAssemblyexceptionadaptor Assemblyexceptionadaptor;
EnsPAssemblyexceptionfeatureadaptor Assemblyexceptionfeatureadaptor;
EnsPAssemblymapperadaptor Assemblymapperadaptor;
EnsPAttributetypeadaptor Attributetypeadaptor;
EnsPCoordsystemadaptor Coordsystemadaptor;
EnsPDatabaseentryadaptor Databaseentryadaptor;
EnsPDensityfeatureadaptor Densityfeatureadaptor;
EnsPDensitytypeadaptor Densitytypeadaptor;
EnsPDitagadaptor Ditagadaptor;
EnsPDitagfeatureadaptor Ditagfeatureadaptor;
EnsPDnaalignfeatureadaptor Dnaalignfeatureadaptor;
EnsPExonadaptor Exonadaptor;
EnsPExternaldatabaseadaptor Externaldatabaseadaptor;
EnsPGeneadaptor Geneadaptor;
EnsPKaryotypebandadaptor Karyotypebandadaptor;
EnsPMarkeradaptor Markeradaptor;
EnsPMarkerfeatureadaptor Markerfeatureadaptor;
EnsPMetacoordinateadaptor Metacoordinateadaptor;
EnsPMetainformationadaptor Metainformationadaptor;
EnsPMiscellaneousfeatureadaptor Miscellaneousfeatureadaptor;
EnsPMiscellaneoussetadaptor Miscellaneoussetadaptor;
EnsPPredictionexonadaptor Predictionexonadaptor;
EnsPPredictiontranscriptadaptor Predictiontranscriptadaptor;
EnsPProteinalignfeatureadaptor Proteinalignfeatureadaptor;
EnsPProteinfeatureadaptor Proteinfeatureadaptor;
EnsPRepeatconsensusadaptor Repeatconsensusadaptor;
EnsPRepeatfeatureadaptor Repeatfeatureadaptor;
EnsPSeqregionadaptor Seqregionadaptor;
EnsPSeqregionsynonymadaptor Seqregionsynonymadaptor;
EnsPSequenceadaptor Sequenceadaptor;
EnsPSimplefeatureadaptor Simplefeatureadaptor;
EnsPSliceadaptor Sliceadaptor;
EnsPTranscriptadaptor Transcriptadaptor;
EnsPTranslationadaptor Translationadaptor;
} RegistryOCoreStyle;
#define RegistryPCoreStyle RegistryOCoreStyle*
ID RegistryPEntry
TY static
MO ensregistry
LB ensembl
XX
DE Registry Entry structure.
DE
DE Holds Ensembl Database Adaptor Group-specific Registry objects.
XX
TN RegistrySEntry
TD
TX
TN RegistryOEntry
TD
TX
AN Registry
AT void*[EnsMDatabaseadaptorGroups]
AD Array of database-specific Registry Entry objects, indexed by the
AD Ensembl Database Adaptor Group enumeration.
AX
//
typedef struct RegistrySEntry
{
void *Registry[EnsMDatabaseadaptorGroups];
} RegistryOEntry;
#define RegistryPEntry RegistryOEntry*
ID RegistryPFunctionalGenomics
TY static
MO ensregistry
LB ensembl
XX
DE Registry Functional Genomics structure.
DE
DE Holds an Ensembl Database Adaptors and associated Ensembl Object Adaptors
DE specific for Ensembl Functional Genomics databases.
XX
TN RegistrySFunctionalGenomics
TD
TX
TN RegistryOFunctionalGenomics
TD
TX
AN Databaseadaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
//
typedef struct RegistrySFunctionalGenomics
{
EnsPDatabaseadaptor Databaseadaptor;
} RegistryOFunctionalGenomics;
#define RegistryPFunctionalGenomics RegistryOFunctionalGenomics*
ID RegistryPGeneticVariation
TY static
MO ensregistry
LB ensembl
XX
DE Registry Genetic Variation structure.
DE
DE Holds an Ensembl Database Adaptor and associated Ensembl Object Adaptors
DE specific for Ensembl Genetic Variation databases.
XX
TN RegistrySGeneticVariation
TD
TX
TN RegistryOGeneticVariation
TD
TX
AN Databaseadaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
AN Gvalleleadaptor
AT EnsPGvalleleadaptor
AD Ensembl Genetic Variation Allele Adaptor
AX
AN Gvattributeadaptor
AT EnsPGvattributeadaptor
AD Ensembl Genetic Variation Attribute Adaptor
AX
AN Gvdatabaseadaptor
AT EnsPGvdatabaseadaptor
AD Ensembl Genetic Variation Database Adaptor
AX
AN Gvgenotypecodeadaptor
AT EnsPGvgenotypecodeadaptor
AD ENsembl Genetic Variation Genotype Code Adaptor
AX
AN Gvindividualadaptor
AT EnsPGvindividualadaptor
AD Ensembl Genetic Variation Individual Adaptor
AX
AN Gvpopulationadaptor
AT EnsPGvpopulationadaptor
AD Ensembl Genetic Variation Population Adaptor
AX
AN Gvpopulationgenotypeadaptor
AT EnsPGvpopulationgenotypeadaptor
AD Ensembl Genetic Variation Population Genotype Adaptor
AX
AN Gvsampleadaptor
AT EnsPGvsampleadaptor
AD Ensembl Genetic Variation Sample Adaptor
AX
AN Gvsourceadaptor
AT EnsPGvsourceadaptor
AD Ensembl Genetic Variation Source Adaptor
AX
AN Gvtranscriptvariationadaptor
AT EnsPGvtranscriptvariationadaptor
AD Ensembl Genetic Variation Transcript Variation Adaptor
AX
AN Gvvariationadaptor
AT EnsPGvvariationadaptor
AD Ensembl Genetic Variation Variation Adaptor
AX
AN Gvvariationfeatureadaptor
AT EnsPGvvariationfeatureadaptor
AD Ensembl Genetic Variation Variation Feature Adaptor
AX
AN Gvvariationsetadaptor
AT EnsPGvvariationsetadaptor
AD Ensembl Genetic Variation Variation Set Adaptor
AX
//
typedef struct RegistrySGeneticVariation
{
EnsPDatabaseadaptor Databaseadaptor;
EnsPGvalleleadaptor Gvalleleadaptor;
EnsPGvattributeadaptor Gvattributeadaptor;
EnsPGvdatabaseadaptor Gvdatabaseadaptor;
EnsPGvgenotypecodeadaptor Gvgenotypecodeadaptor;
EnsPGvindividualadaptor Gvindividualadaptor;
EnsPGvpopulationadaptor Gvpopulationadaptor;
EnsPGvpopulationgenotypeadaptor Gvpopulationgenotypeadaptor;
EnsPGvsampleadaptor Gvsampleadaptor;
EnsPGvsourceadaptor Gvsourceadaptor;
EnsPGvtranscriptvariationadaptor Gvtranscriptvariationadaptor;
EnsPGvvariationadaptor Gvvariationadaptor;
EnsPGvvariationfeatureadaptor Gvvariationfeatureadaptor;
EnsPGvvariationsetadaptor Gvvariationsetadaptor;
} RegistryOGeneticVariation;
#define RegistryPGeneticVariation RegistryOGeneticVariation*
ID RegistryPIdentifier
TY static
MO ensregistry
LB ensembl
XX
DE Registry Identifier structure.
DE
DE Holds regular expressions for matching Ensembl Gene, Transcript,
DE Translation and Exon stable identifiers, as well as
DE Ensembl Database Adaptor species and group information.
XX
TN RegistrySIdentifier
TD
TX
TN RegistryOIdentifier
TD
TX
AN RegularExpression
AT AjPStr
AD Regular expression
AX
AN SpeciesName
AT AjPStr
AD Ensembl Database Adaptor species name
AX
AN Group
AT EnsEDatabaseadaptorGroup
AD Ensembl Database Adaptor Group enumeration
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct RegistrySIdentifier
{
AjPStr RegularExpression;
AjPStr SpeciesName;
EnsEDatabaseadaptorGroup Group;
ajuint Padding;
} RegistryOIdentifier;
#define RegistryPIdentifier RegistryOIdentifier*
ID RegistryPOntology
TY static
MO ensregistry
LB ensembl
XX
DE Registry Ontology structure.
DE
DE Holds an Ensembl Database Adaptor and associated Ensembl Object Adaptors
DE specific for Ensembl Ontology databases.
XX
TN RegistrySOntology
TD
TX
TN RegistryOOntology
TD
TX
AN Databaseadaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
AN Ontologyadaptor
AT EnsPOntologyadaptor
AD Ensembl Ontology Adaptor
AX
AN Ontologytermadaptor
AT EnsPOntologytermadaptor
AD Ensembl Ontology Term Adaptor
AX
//
typedef struct RegistrySOntology
{
EnsPDatabaseadaptor Databaseadaptor;
EnsPOntologyadaptor Ontologyadaptor;
EnsPOntologytermadaptor Ontologytermadaptor;
} RegistryOOntology;
#define RegistryPOntology RegistryOOntology*
ID RegistryPQualityCheck
TY static
MO ensregistry
LB ensembl
XX
DE Registry Quality Check structure.
DE
DE Holds an Ensembl Database Adaptor and associated Ensembl Object Adaptors
DE specific for Ensembl Quality Check databases.
XX
TN RegistrySQualityCheck
TD
TX
TN RegistryOQualityCheck
TD
TX
AN Databaseadaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
AN Qcalignmentadaptor
AT EnsPQcalignmentadaptor
AD Ensembl Quality Check Alignment Adaptor
AX
AN Qcdasfeatureadaptor
AT EnsPQcdasfeatureadaptor
AD Ensembl Quality Check DAS Feature Adaptor
AX
AN Qcdatabaseadaptor
AT EnsPQcdatabaseadaptor
AD Ensembl Quality Check Database Adaptor
AX
AN Qcsequenceadaptor
AT EnsPQcsequenceadaptor
AD Ensembl Quality Check Sequence Adaptor
AX
AN Qcsubmissionadaptor
AT EnsPQcsubmissionadaptor
AD Ensembl Quality Check Submission Adaptor
AX
AN Qcvariationadaptor
AT EnsPQcvariationadaptor
AD Ensembl Quality Check Variation Adaptor
AX
//
typedef struct RegistrySQualityCheck
{
EnsPDatabaseadaptor Databaseadaptor;
EnsPQcalignmentadaptor Qcalignmentadaptor;
EnsPQcdasfeatureadaptor Qcdasfeatureadaptor;
EnsPQcdatabaseadaptor Qcdatabaseadaptor;
EnsPQcsequenceadaptor Qcsequenceadaptor;
EnsPQcsubmissionadaptor Qcsubmissionadaptor;
EnsPQcvariationadaptor Qcvariationadaptor;
} RegistryOQualityCheck;
#define RegistryPQualityCheck RegistryOQualityCheck*
ID TranscriptPExonRank
TY static
MO enstranscript
LB ensembl
XX
DE Ensembl Transcript, Exon and rank associations.
DE
DE Holds associations between Ensembl Transcript objects, Ensembl Exon objects
DE and their rank in the Ensembl Transcript.
XX
TN TranscriptSExonRank
TD
TX
TN TranscriptOExonRank
TD
TX
AN Transcriptidentifier
AT ajuint
AD Ensembl Transcript identifier
AX
AN Rank
AT ajint
AD Ensembl Exon rank
AX
//
typedef struct TranscriptSExonRank
{
ajuint Transcriptidentifier;
ajint Rank;
} TranscriptOExonRank;
#define TranscriptPExonRank TranscriptOExonRank*
ID DbiOField
TY static
MO embdbi
LB nucleus
XX
DE Database index field names and index filenames
XX
AN name
AT const char*
AD Field name as used in USAs
AX
AN index
AT const char*
AD Index filename for EMBLCD indices
AX
AN desc
AT const char*
AD Field description
AX
//
typedef struct DbiSField
{
const char* name;
const char* index;
const char* desc;
} DbiOField;
ID EstPKeyValue
TY static
MO embest
LB nucleus
XX
DE Key value data structure
XX
TN EstSKeyValue
TD
TX
TN EstOKeyValue
TD
TX
AN key
AT float
AD key score
AX
AN value
AT ajint
AD value
AX
//
typedef struct EstSKeyValue
{
float key;
ajint value;
} EstOKeyValue;
#define EstPKeyValue EstOKeyValue*
ID EstPCoord
TY static
MO embest
LB nucleus
XX
DE Coordinates data structure
XX
TN EstSCoord
TD
TX
TN EstOCoord
TD
TX
AN left
AT ajint
AD left end
AX
AN right
AT ajint
AD right end
AX
//
typedef struct EstSCoord
{
ajint left;
ajint right;
} EstOCoord;
#define EstPCoord EstOCoord*
ID EstPSavePair
TY static
MO embest
LB nucleus
XX
DE Save pairwise matches
XX
TN EstSSavePair
TD
TX
TN EstOSavePair
TD
TX
AN col
AT ajint
AD Column number
AX
AN row
AT ajint
AD Row number
AX
//
typedef struct EstSSavePair
{
ajint col;
ajint row;
} EstOSavePair;
#define EstPSavePair EstOSavePair*
ID PatPTypes
TY static
MO embpat
LB nucleus
XX
DE Prosite pattern types
XX
TN PatSTypes
TD
TX
TN PatOTypes
TD
TX
AN Name
AT const char*
AD Type name
AX
AN Desc
AT const char*
AD Type description
AX
//
typedef struct PatSTypes
{
const char *Name;
const char *Desc;
} PatOTypes;
#define PatPTypes PatOTypes*
ID MethPData
TY static
MO embpat
LB nucleus
XX
DE Methylation data
XX
TN MethSData
TD
TX
TN MethOData
TD
TX
AN Name
AT AjPStr
AD Name of methylation type
AX
AN Site
AT AjPStr
AD Methylase recognition site
AX
AN Replace
AT AjPStr
AD Methylase recognition site replacement sequence
AX
//
typedef struct MethSData
{
AjPStr Name;
AjPStr Site;
AjPStr Replace;
} MethOData;
#define MethPData MethOData*
ID EmbPHitidx
TY static
MO embsig
LB nucleus
XX
DE Nucleus Hitidx object.
DE
DE Holds data for an indexing Hit and Hitlist objects
DE
DE EmbPHitidx is implemented as a pointer to a C data structure.
XX
TN EmbSHitidx
TD
TX
TN EmbOHitidx
TD
TX
AN Id
AT AjPStr
AD Identifier
AX
AN hptr
AT EmbPHit
AD Pointer to EmbPHit structure
AX
AN lptr
AT EmbPHitlist
AD Pointer to EmbPHitlist structure
AX
//
typedef struct EmbSHitidx
{
AjPStr Id;
EmbPHit hptr;
EmbPHitlist lptr;
}EmbOHitidx;
#define EmbPHitidx EmbOHitidx*
ID EmbPSigcell
TY static
MO embsig
LB nucleus
XX
DE Nucleus Sigcell object.
DE
DE Holds data for a cell of a path matrix for a signature:sequence alignment.
DE
DE EmbPSigcell is implemented as a pointer to a C data structure.
XX
TN EmbSSigcell
TD
TX
TN EmbOSigcell
TD
TX
AN val
AT float
AD Value for this cell
AX
AN prev
AT ajint
AD Index in path matrix of prev. highest value
AX
AN visited
AT AjBool
AD ajTrue if this cell has been visited
AX
//
typedef struct EmbSSigcell
{
float val;
ID PEdamdat
TY static
MO acdrelations
LB emboss
XX
DE edamdat object
DE Holds a single line from the data file edamtoacd.dat
XX
TN SEdamdat
TD
TX
TN OEdamdat
TD
TX
AN acdtype
AT AjPStr
AD ACD datatype, e.g. "align"
AX
AN acdattr
AT AjPStr*
AD Array of ACD attribute:value strings e.g. minseqs:"3"
AD Strings must contain no whitespace!
AX
AN edam
AT AjPStr
AD Text to be given after relations: attribute,
AD e.g. "EDAM: Multiple sequence alignment data"
AD if all relations in acdattr are defined for acdtype.
AX
AN n
AT ajint
AD Size of acdattr array
AX
AN Padding
AT ajint
AD Padding to alignment boundaty
AX
//
typedef struct SEdamdat
{
AjPStr acdtype;
ID PEdam
TY static
MO acdrelations
LB emboss
XX
DE edam object
DE Holds all lines from the data file edamtoacd.dat
XX
TN SEdam
TD
TX
TN OEdam
TD
TX
AN dat
AT PEdamdat*
AD Array of PEdamdat objects
AX
AN n
AT ajint
AD Size of dat array
AX
AN Padding
AT ajint
AD Padding to alignment boundaty
AX
//
typedef struct SEdam
{
PEdamdat *dat;
ID PKtypedat
TY static
MO acdrelations
LB emboss
XX
DE ktypedat object
DE Holds a single line from the data file knowntypes.standard
XX
TN SKtypedat
TD
TX
TN OKtypedat
TD
TX
AN acdtype
AT AjPStr
AD ACD datatype, e.g. "align"
AX
AN ktype
AT AjPStr
AD Value of knowntype: attribute: no whitespace!
AX
AN edam
AT AjPStr
AD Text to be given after relations: attribute,
AD e.g. "EDAM: Multiple sequence alignment data"
AD if ktype is defined for acdtype.
AX
//
typedef struct SKtypedat
{
AjPStr acdtype;
ID PKtype
TY static
MO acdrelations
LB emboss
XX
DE ktype object
DE Holds all lines from the data file knowntypes.standard
XX
TN SKtype
TD
TX
TN OKtype
TD
TX
AN dat
AT PKtypedat*
AD Array of PKtypedat objects
AX
AN n
AT ajint
AD Size of dat array
AX
AN Padding
AT ajint
AD Padding to alignment boundaty
AX
//
typedef struct SKtype
{
PKtypedat *dat;
ID dbinfo
TY static
MO cachedbfetch
LB emboss
XX
DE Database information for cachedbfetch
XX
AN name
AT AjPStr
AD Name on server
AX
AN displayname
AT AjPStr
AD Displayed name
AX
AN format
AT AjPStr
AD Format
AX
AN fmtterms
AT AjPStr
AD Format terms
AX
AN dataterms
AT AjPStr
AD Data terms
AX
AN tpcterms
AT AjPStr
AD EDAM topic terms
AX
AN dbtype
AT AjPStr
AD Database type
AX
AN description
AT AjPStr
AD Description
AX
AN example
AT AjPStr
AD Example
AX
//
typedef struct dbinfo
{
AjPStr name;
AjPStr displayname;
AjPStr format;
AjPStr fmtterms;
AjPStr dataterms;
AjPStr tpcterms;
AjPStr dbtype;
AjPStr description;
AjPStr example;
} dbOinfo;
#define dbPinfo dbOinfo*
ID ebeyePdbinfo
TY static
MO cacheebeyesearch
LB emboss
XX
DE Database information for cacheebeyesearch
XX
AN name
AT AjPStr
AD Name on server
AX
AN searchableFields
AT AjPStr
AD Searchable fields
AX
AN retrievableFields
AT AjPStr
AD Retrievable fields
AX
AN description
AT AjPStr
AD Description
AX
AN dbalias
AT AjPStr
AD Database alias
AX
//
typedef struct dbinfo
{
AjPStr name;
AjPStr searchableFields;
AjPStr retrievableFields;
AjPStr description;
AjPStr dbalias;
} ebeyeOdbinfo;
#define ebeyePdbinfo ebeyeOdbinfo*
ID CutgPValues
TY static
MO cutgextract
LB emboss
XX
DE Codon usage table data values
XX
TN CutgSValues
TD
TX
TN CutgOValues
TD
TX
AN Count
AT ajint[CODONS]
AD Number of occurrences for each codon
AD in standard order
AX
AN Division
AT AjPStr
AD EMBL/GenBank division
AX
AN Doc
AT AjPStr
AD Documentation string
AX
AN Species
AT AjPStr
AD Species
AX
AN Warn
AT ajint
AD Number of warnings issued
AX
AN Skip
AT ajint
AD Number of CDSs skipped
AX
AN CdsCount
AT ajint
AD Number of CDSs counted
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct CutgSValues
{
ajint Count[CODONS];
AjPStr Division;
AjPStr Doc;
AjPStr Species;
ajint Warn;
ajint Skip;
ajint CdsCount;
char Padding[4];
} CutgOValues;
#define CutgPValues CutgOValues*
ID dbinfo
TY static
MO dbfetchtest
LB emboss
XX
DE Database information for cachedbfetch
XX
AN name
AT AjPStr
AD Name on server
AX
AN displayname
AT AjPStr
AD Displayed name
AX
AN format
AT AjPStr
AD Format
AX
AN dbtype
AT AjPStr
AD Database type
AX
AN description
AT AjPStr
AD Description
AX
AN example
AT AjPStr
AD Example
AX
//
typedef struct dbinfo
{
AjPStr name;
AjPStr displayname;
AjPStr format;
AjPStr dbtype;
AjPStr description;
AjPStr example;
} dbOinfo;
#define dbPinfo dbOinfo*
ID PMemFile
TY static
MO dbiblast
LB emboss
XX
DE DbiBlast in-memory file
XX
AN File
AT AjPFile
AD Ajax file
AX
AN IsMem
AT AjBool
AD True if in memory mapped
AX
AN Fd
AT ajint
AD Unix file descriptor (integer)
AX
AN Pos
AT ajlong
AD Position in file/memory
AX
AN Size
AT ajlong
AD Size of file/memory
AX
AN Name
AT AjPStr
AD Name of file
AX
AN Mem
AT caddr_t
AD Memory map
AX
//
typedef struct SMemFile
{
AjPFile File;
AjBool IsMem;
ajint Fd;
ajlong Pos;
ajlong Size;
AjPStr Name;
caddr_t Mem;
} OMemFile;
#define PMemFile OMemFile*
ID PBlastDb
TY static
MO dbiblast
LB emboss
XX
DE DbiBlast database
XX
AN DbType
AT ajint
AD database type indicator
AX
AN DbFormat
AT ajint
AD database format (version) indicator
AX
AN IsProtein
AT ajint
AD 1 for protein
AX
AN IsBlast2
AT ajint
AD 1 for blast2, 0 for blast1
AX
AN TitleLen
AT ajint
AD length of database title
AX
AN DateLen
AT ajint
AD length of database date string
AX
AN LineLen
AT ajint
AD length of database lines
AX
AN HeaderLen
AT ajint
AD bytes before tables start
AX
AN CompLen
AT ajint
AD length of compressed seq file
AX
AN MaxSeqLen
AT ajint
AD max. entry length
AX
AN TotLen
AT ajint
AD number of bases or residues in database
AX
AN CleanCount
AT ajint
AD count of cleaned 8mers
AX
AN TopCmp
AT ajint
AD bytes before compressed table starts
AX
AN TopSrc
AT ajint
AD bytes before source table starts
AX
AN TopHdr
AT ajint
AD bytes before headers table starts
AX
AN TopAmb
AT ajint
AD bytes before ambiguity table starts
AX
AN IdType
AT ajint
AD ID type
AX
AN IdPrefix
AT ajint
AD ID prefix type
AX
AN TFile
AT PMemFile
AD table of offsets, also DB info
AX
AN HFile
AT PMemFile
AD description lines
AX
AN SFile
AT PMemFile
AD binary sequence data
AX
AN FFile
AT PMemFile
AD source sequence data
AX
AN Title
AT AjPStr
AD database title
AX
AN Date
AT AjPStr
AD database date
AX
AN Name
AT AjPStr
AD database base file name
AX
AN Size
AT ajint
AD number of database entries
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SBlastDb
{
ajint DbType;
ajint DbFormat;
ajint IsProtein;
ajint IsBlast2;
ajint TitleLen;
ajint DateLen;
ajint LineLen;
ajint HeaderLen;
ajint CompLen;
ajint MaxSeqLen;
ajint TotLen;
ajint CleanCount;
ajint TopCmp;
ajint TopSrc;
ajint TopHdr;
ajint TopAmb;
ajint IdType;
ajint IdPrefix;
PMemFile TFile;
PMemFile HFile;
PMemFile SFile;
PMemFile FFile;
AjPStr Title;
AjPStr Date;
AjPStr Name;
ajint Size;
char Padding[4];
} OBlastDb;
#define PBlastDb OBlastDb*
ID PBlastType
TY static
MO dbiblast
LB emboss
XX
DE DbiBlast types
XX
AN ExtT
AT const char*
AD Table filename extension
AX
AN ExtH
AT const char*
AD Header filename extension
AX
AN ExtS
AT const char*
AD Sequence filename extension
AX
AN IsProtein
AT AjBool
AD true for protein
AX
AN IsBlast2
AT AjBool
AD blast2.x or blast 1.x
AX
AN Type
AT ajint
AD enumerated type
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SBlastType
{
const char* ExtT;
const char* ExtH;
const char* ExtS;
AjBool IsProtein;
AjBool IsBlast2;
ajint Type;
char Padding[4];
} OBlastType;
#define PBlastType OBlastType*
ID OParser
TY static
MO dbiblast
LB emboss
XX
DE Parser definition structure
XX
TN SParser
TD
TX
TN OParser
TD
TX
AN Name
AT const char*
AD Parser name
AX
AN Parser
AT AjBool function
AD Parser function
AX
//
typedef struct SParser
{
const char* Name;
AjBool (*Parser) (const AjPStr line, AjPFile * alistfile,
AjBool systemsort, AjPStr const * fields,
ajint* maxFieldLen, ajuint* countfield,
AjPStr* myid, AjPList* myfdl);
} OParser;
ID DbiflatPParser
TY static
MO dbiflat
LB emboss
XX
DE Parser definition structure
XX
TN DbiflatSParser
TD
TX
TN DbiflatOParser
TD
TX
AN Name
AT const char*
AD Parser name
AX
AN Parser
AT AjBool function
AD Parser function
AX
//
typedef struct DbiflatSParser
{
const char* Name;
AjBool (*Parser) (AjPFile libr, AjPFile* alistfile,
AjBool systemsort, AjPStr* fields,
ajint* maxFieldLen, ajuint* countfield,
ajint *dpos, AjPStr* myid, AjPList* acl);
} DbiflatOParser;
#define DbiflatPParser DbiflatOParser*
ID OParser
TY static
MO dbigcg
LB emboss
XX
DE Parser definition structure
XX
TN SParser
TD
TX
AN Name
AT const char*
AD Parser name
AX
AN GcgFormat
AT AjBool
AD If true, use GCG format, if false, use NBRF
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
AN Parser
AT AjBool function
AD Parser function
AX
//
typedef struct SParser
{
const char* Name;
AjBool GcgFormat;
ajint Padding;
AjBool (*Parser) (AjPFile libr,
AjPFile* alistfile,
AjBool systemsort, AjPStr const * fields,
ajint* maxFieldLen, ajuint* countfield,
AjPStr *id);
} OParser;
ID DbxflatPParser
TY static
MO dbxflat
LB emboss
XX
DE Parser definition structure
XX
TN DbxflatSParser
TD
TX
TN DbxflatOParser
TD
TX
AN Name
AT const char*
AD Parser name
AX
AN Parser
AT AjBool function
AD Parser function
AX
//
typedef struct DbxflatSParser
{
const char* Name;
AjBool (*Parser) (EmbPBtreeEntry entry, AjPFile inf);
} DbxflatOParser;
#define DbxflatPParser DbxflatOParser*
ID DbxgcgPParser
TY static
MO dbxgcg
LB emboss
XX
DE Parser definition structure
XX
TN DbxgcgSParser
TD
TX
TN DbxgcgOParser
TD
TX
AN Name
AT const char*
AD Parser name
AX
AN GcgType
AT AjBool
AD Gcg type parser if true, PIR type if false
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
AN Parser
AT AjBool function
AD Parser function
AX
//
typedef struct DbxgcgSParser
{
const char* Name;
AjBool GcgType;
char Padding[4];
AjBool (*Parser) (AjPFile infr, AjPStr *reflibstr);
} DbxgcgOParser;
#define DbxgcgPParser DbxgcgOParser*
ID DbxreportPData
TY static
MO dbxreport
LB emboss
XX
DE Index file names
XX
TN DbxreportSData
TD
TX
TN DbxreportOData
TD
TX
AN cache
AT AjPBtcache
AD Index cache
AX
AN refs
AT ajulong*
AD Page reference count
AX
AN nroot
AT ajuint
AD Number of root pages
AX
AN nnroot
AT ajuint
AD Number of numeric root pages
AX
AN ninternal
AT ajuint
AD Number of internal node pages
AX
AN nleaf
AT ajuint
AD Number of leaf node pages
AX
AN nbucket
AT ajuint
AD Number of bucket pages
AX
AN noverflow
AT ajuint
AD Number of overflow pages
AX
AN npribucket
AT ajuint
AD Number of primary key bucket pages
AX
AN nsecbucket
AT ajuint
AD Number of secondary key bucket pages
AX
AN nnumbucket
AT ajuint
AD Number of numbucket pages
AX
AN nunknown
AT ajuint
AD Number of unknown type pages
AX
AN nkeys
AT ajuint
AD Number of keys
AX
AN nover
AT ajuint
AD Number of node overflow pages
AX
AN nbkeys
AT ajuint
AD Number of bucket key pages
AX
AN nbdups
AT ajuint
AD Number of bucket duplicate pages
AX
AN nbxtra
AT ajuint
AD Number of bucket extra pages
AX
AN nbover
AT ajuint
AD Number of bucket overflow pages
AX
AN npkeys
AT ajuint
AD Number of primary keys
AX
AN npover
AT ajuint
AD Number of primary key overflow pages
AX
AN nskeys
AT ajuint
AD Number of secondary keys
AX
AN nsover
AT ajuint
AD Number of secondary key overflow pages
AX
AN nnkeys
AT ajuint
AD Number of numeric keys
AX
AN nndups
AT ajuint
AD Number of numeric key duplicates
AX
AN nnover
AT ajuint
AD Number of numeric key overflow pages
AX
AN nlkeys
AT ajuint
AD Number of leaf keys
AX
AN nlover
AT ajuint
AD Number of leaf overflow pages
AX
AN nunused
AT ajuint
AD Number of unused pages
AX
AN freespace
AT ajulong
AD Free space total for all pages
AX
AN pagecount
AT ajulong
AD Page count
AX
AN totsize
AT ajulong
AD Total index size
AX
//
typedef struct DbxreportSData
{
AjPBtcache cache;
ajulong* refs;
ajuint nroot;
ajuint nnroot;
ajuint ninternal;
ajuint nleaf;
ajuint nbucket;
ajuint noverflow;
ajuint npribucket;
ajuint nsecbucket;
ajuint nnumbucket;
ajuint nunknown;
ajuint nkeys;
ajuint nover;
ajuint nbkeys;
ajuint nbdups;
ajuint nbxtra;
ajuint nbover;
ajuint npkeys;
ajuint npover;
ajuint nskeys;
ajuint nsover;
ajuint nnkeys;
ajuint nndups;
ajuint nnover;
ajuint nlkeys;
ajuint nlover;
ajuint nunused;
ajulong freespace;
ajulong pagecount;
ajulong totsize;
} DbxreportOData;
#define DbxreportPData DbxreportOData*
ID DbxreportPNames
TY static
MO dbxreport
LB emboss
XX
DE Index file names
XX
TN DbxreportSNames
TD
TX
TN DbxreportONames
TD
TX
AN name
AT const char*
AD Field name
AX
AN iname
AT const char*
AD Field index name
AX
AN isid
AT AjBool
AD Field is an identifier (false for keywords)
AX
//
typedef struct DbxreportSNames
{
const char* name;
const char* iname;
AjBool isid;
} DbxreportONames;
#define DbxreportPNames DbxreportONames*
ID PNucDensity
TY static
MO density
LB emboss
XX
DE Nucleic acid composition
XX
AN pos
AT float*
AD window position
AX
AN a
AT float*
AD A
AX
AN c
AT float*
AD C
AX
AN g
AT float*
AD G
AX
AN t
AT float*
AD T
AX
AN at
AT float*
AD AT
AX
AN gc
AT float*
AD GC
AX
//
typedef struct SNucDensity
{
float *pos;
float *a;
float *c;
float *g;
float *t;
float *at;
float *gc;
} ONucDensity;
#define PNucDensity ONucDensity*
ID CdsPval
TY static
MO diffseq
LB emboss
XX
DE CDS information object
XX
TN CdsSval
TD
TX
TN CdsOval
TD
TX
AN Start
AT ajint
AD Start of CDS (always less than End)
AX
AN End
AT ajint
AD End of CDS (always greater than Start)
AX
AN Phase
AT ajint
AD Phase of translation (0,1 or 2)
AX
AN Parent
AT AjBool
AD ajTrue is this CDS is a parent of a forward sense join
AD or the last CDS of a reverse sense join
AX
AN Single
AT AjBool
AD ajTrue is this CDS is a not member of a join()
AX
AN ReverseParent
AT AjBool
AD ajTrue is this CDS is a parent of rev sense join
AD or the last CDS in a forward sense join
AX
AN Local
AT AjBool
AD ajTrue is this CDS is local
AX
AN Sense
AT char
AD Sense '+' or '-'
AX
AN Padding
AT char[3]
AD Padding to alignment boundary
AX
//
typedef struct CdsSval
{
ajint Start;
ajint End;
ajint Phase;
AjBool Parent;
AjBool Single;
AjBool ReverseParent;
AjBool Local;
char Sense;
char Padding[3];
} CdsOval;
#define CdsPval CdsOval*
ID PosPDiff
TY static
MO diffseq
LB emboss
XX
DE Position of a difference between two matching regions
DE If there is something inserted in one sequence that does not
DE occur in the other, then the other has Start after the gap and
DE End before the gap and Len=0.
XX
TN PosSDiff
TD
TX
TN PosODiff
TD
TX
AN Start1
AT ajint
AD Start of difference in sequence 1 (End1+1 if gap)
AX
AN Start2
AT ajint
AD Start of difference in sequence 2 (End1+1 if gap)
AX
AN End1
AT ajint
AD End of difference in seq 1
AX
AN End2
AT ajint
AD End of difference in seq 2
AX
AN Len1
AT ajint
AD Length of difference in sequence 1 (0 = a gap)
AX
AN Len2
AT ajint
AD Length of difference in sequence 2 (0 = a gap)
AX
AN Rev1
AT AjBool
AD Reverse sequence 1
AX
AN Rev2
AT AjBool
AD Reverse sequence 2
AX
//
typedef struct PosSDiff
{
ajint Start1;
ajint Start2;
ajint End1;
ajint End2;
ajint Len1;
ajint Len2;
AjBool Rev1;
AjBool Rev2;
} PosODiff;
#define PosPDiff PosODiff*
ID PPoint
TY static
MO dotmatcher
LB emboss
XX
DE Dotmatcher point data
XX
TN SPoint
TD
TX
TN OPoint
TD
TX
AN x1
AT float
AD x1 coordinate
AX
AN y1
AT float
AD y1 coordinate
AX
AN x2
AT float
AD x2 coordinate
AX
AN y2
AT float
AD y2 coordinate
AX
//
typedef struct SPoint
{
float x1;
float y1;
float x2;
float y2;
} OPoint;
#define PPoint OPoint*
ID PTerm
TY static
MO edamclean
LB emboss
XX
DE Term object
DE Holds name and identifier of a single EDAM term
XX
TN STerm
TD
TX
TN OTerm
TD
TX
AN name
AT AjPStr
AD Name of term
AX
AN id
AT AjPStr
AD Id of term
AX
AN line
AT ajint
AD Line number of name: field for the term
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
//
typedef struct STerm
{
AjPStr name;
AjPStr id;
ajint line;
ajint Padding;
} OTerm;
#define PTerm OTerm*
ID PNamespace
TY static
MO edamclean
LB emboss
XX
DE Namespace object
DE Holds name and array of terms for an EDAM namespace.
DE Only one copy of the terms is kept in memory (list holds pointers only)
XX
TN SNamespace
TD
TX
TN ONamespace
TD
TX
AN name
AT AjPStr
AD Name of namespace
AX
AN terms
AT PTerm*
AD Array of terms
AX
AN list
AT AjPList
AD List of terms
AX
AN n
AT ajint
AD Size of array / list
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
//
typedef struct SNamespace
{
AjPStr name;
PTerm *terms;
AjPList list;
ajint n;
ajint Padding;
} ONamespace;
#define PNamespace ONamespace*
ID edialignPositionSet
TY static
MO edialign
LB emboss
XX
DE Dialign positionset structure
XX
AN pos
AT ajint*
AD Positions array
AX
AN nbr
AT ajint
AD Size of position array
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct
{
ajint *pos;
ajint nbr;
char Padding[4];
} edialignPositionSet;
ID edialignSequence
TY static
MO edialign
LB emboss
XX
DE Dialign sequence structure
XX
AN longueur
AT ajint
AD Length
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
AN aligSetNbr
AT ajint*
AD Numbers of sets
AX
AN predAligSetPos
AT ajint*
AD Predicted alignment set positions
AX
AN succAligSetPos
AT ajint*
AD Successful alignment set positions
AX
//
typedef struct {
ajint longueur;
ID edialignCLOSURE
TY static
MO edialign
LB emboss
XX
DE Dialign closure structure
XX
AN seq
AT edialignSequence*
AD Sequences
AX
AN seqNbr
AT ajint
AD Numbers of sequences
AX
AN maxLong
AT ajint
AD Maximum long
AX
AN aligSet
AT edialignPositionSet*
AD Alignment sets
AX
AN nbrAligSets
AT ajint
AD Number of alignment sets
AX
AN oldNbrAligSets
AT ajint
AD Old number of alignment sets
AX
AN predFrontier
AT ajint**
AD Predicted boundaries
AX
AN succFrontier
AT ajint**
AD Successful boundaries
AX
AN topolog
AT ajint*
AD Topologies
AX
AN gauche1
AT ajint*
AD Left end in 1
AX
AN gauche2
AT ajint*
AD Left end in 2
AX
AN droite1
AT ajint*
AD Right end in 1
AX
AN droite2
AT ajint*
AD Right end in 2
AX
AN pos_
AT ajint**
AD Positions
AX
//
typedef struct {
edialignSequence *seq;
ID EmbPMdata
TY static
MO emowse
LB emboss
XX
DE EMowse data
XX
TN EmbSMdata
TD
TX
TN EmbOMdata
TD
TX
AN mwt
AT double
AD Molecular weight
AX
AN sdata
AT AjPStr
AD string data
AX
//
typedef struct EmbSMdata
{
double mwt;
AjPStr sdata;
} EmbOMdata;
#define EmbPMdata EmbOMdata*
ID PHits
TY static
MO emowse
LB emboss
XX
DE EMowse hits
XX
TN SHits
TD
TX
TN OHits
TD
TX
AN seq
AT AjPStr
AD Sequence
AX
AN name
AT AjPStr
AD Name
AX
AN desc
AT AjPStr
AD Description
AX
AN found
AT AjPInt
AD Found data
AX
AN score
AT double
AD Score
AX
AN mwt
AT double
AD Molecular weight
AX
AN frags
AT EmbPMolFrag*
AD Fragment data
AX
AN nf
AT ajint
AD Number of fragments
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SHits
{
AjPStr seq;
AjPStr name;
AjPStr desc;
AjPInt found;
double score;
double mwt;
EmbPMolFrag* frags;
ajint nf;
char Padding[4];
} OHits;
#define PHits OHits*
ID EnsembltestPProjections
TY static
MO ensembltest
LB emboss
XX
DE Ensembl Test Slice Projection data structure.
XX
TN EnsembltestSProjection
TD
TX
TN EnsembltestOProjection
TD
TX
AN SliceName
AT const char*
AD Ensembl Slice name
AX
AN CoordsystemName
AT const char*
AD Ensembl Coordinate System name
AX
AN CoordsystemVersion
AT const char*
AD Ensembl Coordinate System version
AX
//
typedef struct EnsembltestSProjection
{
const char* SliceName;
const char* CoordsystemName;
const char* CoordsystemVersion;
} EnsembltestOProjection;
#define EnsembltestPProjection EnsembltestOProjection*
ID PestfindPData
TY static
MO epestfind
LB emboss
XX
DE Pestfind data object.
DE Holds results for application pestfind.
DE PestfindPData is implemented as a pointer to a C data structure.
XX
TN PestfindSData
TD
TX
TN PestfindOData
TD
TX
AN Type
AT ajint
AD 1 for potential, 2 for poor and 3 for invalid motifs
AX
AN Begin
AT ajint
AD Start position of PEST motif
AX
AN End
AT ajint
AD End position of PEST motif
AX
AN Length
AT ajint
AD Length of PEST motif
AX
AN Pscore
AT double
AD PEST score
AX
AN Hydind
AT double
AD Hydrophobicity index
AX
AN Pstpct
AT double
AD Mass percent (w/w) of DEPST
AX
//
typedef struct PestfindSData
{
ajint Type;
ajint Begin;
ajint End;
ajint Length;
double Pscore;
double Hydind;
double Pstpct;
} PestfindOData;
#define PestfindPData PestfindOData*
ID EtandemPCons
TY static
MO etandem
LB emboss
XX
DE Consensus pattern structure
XX
TN EtandemSCons
TD
TX
TN EtandemOCons
TD
TX
AN tab
AT ajint*
AD Undocumented
AX
AN max
AT ajint*
AD Undocumented
AX
AN start
AT ajint
AD Undocumented
AX
AN score
AT ajint
AD Undocumented
AX
AN bestScore
AT ajint
AD Undocumented
AX
AN ibest
AT ajint
AD Undocumented
AX
AN bestMax
AT ajint*
AD Undocumented
AX
AN phase
AT ajint
AD Undocumented
AX
AN repeat
AT ajint
AD Undocumented
AX
AN next
AT struct EtandemSCons*
AD Next node in linked list
AX
//
typedef struct EtandemSCons
{
ajint* tab ;
ajint* max ;
ajint start ;
ajint score ;
ajint bestScore ;
ajint ibest ;
ajint* bestMax ;
ajint phase ;
ajint repeat ;
struct EtandemSCons* next ;
} EtandemOCons, *EtandemPCons ;
ID ContigStatsP
TY static
MO infoassembly
LB emboss
XX
DE summary information for a contig
XX
TN ContigStatsS
TD
TX
TN ContigStatsO
TD
TX
AN rdepth
AT unsigned char*
AD read depth for each contig sequence
AD position (1-based)
AX
AN avdepth
AT double
AD average coverage for the contig sequence
AX
AN nReads
AT int
AD Number of reads
AX
AN mxdepth
AT int
AD maximum read depth
AX
AN sumqualvals
AT int
AD Total quality values
AX
AN sumreadbases
AT int
AD Total bases read
AX
AN astart
AT int
AD beginning of the contig region covered by the reads
AX
AN aend
AT int
AD end of the contig region covered by the reads
AX
//
typedef struct ContigStatsS
{
unsigned char* rdepth;
double avdepth;
int nReads;
int mxdepth;
int sumqualvals;
int sumreadbases;
int astart;
int aend;
} ContigStatsO;
#define ContigStatsP ContigStatsO*
ID AjPAssemStats
TY static
MO infoassembly
LB emboss
XX
DE Store statistical information about assemblies
XX
AN contigstats
AT ContigStatsP*
AD Contig statistics object
AX
AN qCounts
AT ajlong[128]
AD quality scores
AX
AN oqCounts
AT ajlong[128]
AD original quality scores,
AD stored using OG tag in sam format
AX
AN nContigs
AT ajuint
AD Number of contigs
AX
AN nReads
AT ajuint
AD Number of reads
AX
AN nFirstofPair
AT ajuint
AD Number of forward paired reads
AX
AN nSecondofPair
AT ajuint
AD Number of reverse paired reads
AX
AN nPair
AT ajuint
AD Number of paired reads
AX
AN nUnpaired
AT ajuint
AD Number of unpaired reads
AX
//
typedef struct AjSAssemStats
{
ContigStatsP* contigstats;
ajlong qCounts[128];
ajlong oqCounts[128];
ajuint nContigs;
ajuint nReads;
ajuint nFirstofPair;
ajuint nSecondofPair;
ajuint nPair;
ajuint nUnpaired;
} AjOAssemStats;
#define AjPAssemStats AjOAssemStats*
ID PIntarr
TY static
MO isochore
LB emboss
XX
DE Integer array
XX
TN SIntarr
TD
TX
TN PIntarr
TD
TX
AN Array
AT ajint*
AD Integer array
AX
AN Size
AT ajint
AD Size
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SIntarr
{
ajint* Array;
ajint Size;
char Padding[4];
} OIntarr;
#define PIntarr OIntarr*
ID IsochorePFltarr
TY static
MO isochore
LB emboss
XX
DE Integer array
XX
TN IsochoreSFltarr
TD
TX
TN IsochorePFltarr
TD
TX
AN Array
AT float*
AD Float array
AX
AN Size
AT ajint
AD Size
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct IsochoreSFltarr
{
float* Array;
ajint Size;
char Padding[4];
} IsochoreOFltarr;
#define IsochorePFltarr IsochoreOFltarr*
ID PJaspPrefix
TY static
MO jaspextract
LB emboss
XX
DE JASPAR data directory structure
XX
TN SJaspPrefix
TD
TX
TN OJaspPrefix
TD
TX
AN Prefix
AT const char*
AD Filename prefix of pfm files
AX
AN Directory
AT const char*
AD Directory name for files of a given prefix
AX
//
typedef struct SJaspPrefix
{
const char* Prefix;
const char* Directory;
} OJaspPrefix;
#define PJaspPrefix OJaspPrefix*
ID PJsphits
TY static
MO jaspscan
LB emboss
XX
DE Jaspar hits object
DE
DE Holds hits from scanning a sequence with a Jaspar matrix
DE Also holds matrix information and type.
DE
DE PJsphits is implemented as a pointer to a C data structure.
XX
TN AjPPStr
TD
TX
TN SJsphits
TD
TX
TN OJsphits
TD
TX
AN matname
AT AjPStr
AD matrix name
AX
AN start
AT ajuint
AD start position
AX
AN end
AT ajuint
AD end position
AX
AN score
AT float
AD score
AX
AN scorepc
AT float
AD percentage score
AX
AN threshold
AT float
AD threshold score
AX
AN maxscore
AT float
AD maximum score for a matrix
AX
AN type
AT char
AD type of Jaspar database (C,F or P)
AX
AN Padding
AT char[7]
AD padding to alignment boundary
AX
//
typedef struct SJsphits {
AjPStr matname;
ajuint start;
ajuint end;
float score;
float scorepc;
float threshold;
float maxscore;
char type;
char Padding[7];
} OJsphits;
#define PJsphits OJsphits*
ID PJspmat
TY static
MO jaspscan
LB emboss
XX
DE Jaspar matrix object
DE
DE Also holds matrix information and type from the matrix_list.txt file
DE
DE PJspmat is implemented as a pointer to a C data structure.
XX
TN SJspmat
TD
TX
TN OJspmat
TD
TX
AN id
AT AjPStr
AD Identifier
AX
AN num
AT AjPStr
AD Information content (very close to optional content value)
AX
AN name
AT AjPStr
AD Name or transcription factor
AX
AN klass
AT AjPStr
AD Class of transcription factor
AX
AN species
AT AjPStr
AD Species
AX
AN sgroup
AT AjPStr
AD Taxonomy supergroup
AX
AN protseq
AT AjPStr
AD Source database accession
AX
AN exp
AT AjPStr
AD Experiment type (e.g. SELEX)
AX
AN pmid
AT AjPStr
AD Source medline reference record and PMID number
AX
AN content
AT AjPStr
AD Shannon information content (floating point number)
AX
AN models
AT AjPStr
AD Included models
AX
AN mcs
AT AjPStr
AD MCS reference
AX
AN jaspar
AT AjPStr
AD Jaspar reference
AX
AN transfac
AT AjPStr
AD Transfac reference
AX
AN desc
AT AjPStr
AD Description
AX
AN comment
AT AjPStr
AD comment
AX
AN erttss
AT AjPStr
AD End relative to TSS
AX
AN srttss
AT AjPStr
AD Start relative to TSS
AX
AN consens
AT AjPStr
AD Consensus
AX
AN type
AT char
AD Type of Jaspar database (C,F or P)
AX
AN Padding
AT char[7]
AD padding to alignment boundary
AX
//
typedef struct SJspmat {
AjPStr id;
AjPStr num;
AjPStr name;
AjPStr klass;
AjPStr species;
AjPStr sgroup;
AjPStr protseq;
AjPStr exp;
AjPStr pmid;
AjPStr content;
AjPStr models;
AjPStr mcs;
AjPStr jaspar;
AjPStr transfac;
AjPStr desc;
AjPStr comment;
AjPStr erttss;
AjPStr srttss;
AjPStr consens;
char type;
char Padding[7];
} OJspmat;
#define PJspmat OJspmat*
ID vertex
TY static
MO matcher
LB emboss
XX
DE Matcher internals
XX
TN NODE
TD
TX
TN vertexptr
TD
TX
AN SCORE
AT ajint
AD Undocumented
AX
AN STARI
AT ajint
AD Undocumented
AX
AN STARJ
AT ajint
AD Undocumented
AX
AN ENDI
AT ajint
AD Undocumented
AX
AN ENDJ
AT ajint
AD Undocumented
AX
AN TOP
AT ajint
AD Undocumented
AX
AN BOT
AT ajint
AD Undocumented
AX
AN LEFT
AT ajint
AD Undocumented
AX
AN RIGHT
AT ajint
AD Undocumented
AX
//
typedef struct NODE
{
ajint SCORE;
ajint STARI;
ajint STARJ;
ajint ENDI;
ajint ENDJ;
ajint TOP;
ajint BOT;
ajint LEFT;
ajint RIGHT;
} vertex;
#define vertexptr vertex*
ID pair
TY static
MO matcher
LB emboss
XX
DE Matcher internals
XX
TN ONE
TD
TX
TN pairptr
TD
TX
AN NEXT
AT struct ONE*
AD Undocumented
AX
AN COL
AT ajint
AD Undocumented
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct ONE
{
struct ONE *NEXT;
ajint COL;
char Padding[4];
} pair;
#define pairptr pair*
ID AjPMwh
TY static
MO mwfilter
LB emboss
XX
DE mwfilter internals
XX
TN AjSMwh
TD
TX
TN AjOMwh
TD
TX
AN exp
AT double
AD Undocumented
AX
AN data
AT double
AD Undocumented
AX
//
typedef struct AjSMwh
{
double exp;
double data;
} AjOMwh,*AjPMwh;
ID Palindrome
TY static
MO palindrome
LB emboss
XX
DE Palindrome internals
XX
AN forwardStart
AT ajint
AD Start forward
AX
AN forwardEnd
AT ajint
AD End forward
AX
AN revStart
AT ajint
AD Start reverse
AX
AN revEnd
AT ajint
AD End reverse
AX
AN next
AT struct palindrome*
AD Pointer to next in list
AX
//
typedef struct palindrome
{
ajint forwardStart;
ajint forwardEnd;
ajint revStart;
ajint revEnd;
struct palindrome *next;
} *Palindrome;
ID PPoint
TY static
MO plotcon
LB emboss
XX
DE Plotcon internals
XX
TN SPoint
TD
TX
TN OPoint
TD
TX
AN x1
AT float
AD x1 coordinate
AX
AN y1
AT float
AD y1 coordinate
AX
AN x2
AT float
AD x2 coordinate
AX
AN y2
AT float
AD y2 coordinate
AX
//
typedef struct SPoint
{
float x1;
ID PPrimer
TY static
MO prima
LB emboss
XX
DE Definition of the primer object
XX
TN SPrimer
TD
TX
TN OPrimer
TD
TX
AN substr
AT AjPStr
AD Undocumented
AX
AN start
AT ajint
AD Undocumented
AX
AN primerlen
AT ajint
AD Undocumented
AX
AN primerTm
AT float
AD Undocumented
AX
AN primGCcont
AT float
AD Undocumented
AX
AN prodTm
AT float
AD Undocumented
AX
AN prodGC
AT float
AD Undocumented
AX
AN score
AT ajint
AD Undocumented
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
//
typedef struct SPrimer
{
AjPStr substr;
ajint start;
ajint primerlen;
float primerTm;
float primGCcont;
float prodTm;
float prodGC;
ajint score;
ajint Padding;
} OPrimer;
#define PPrimer OPrimer*
ID PPair
TY static
MO prima
LB emboss
XX
DE Object to hold awesome primer pairs
XX
TN SPair
TD
TX
TN OPair
TD
TX
AN f
AT PPrimer
AD Forward primer
AX
AN r
AT PPrimer
AD Reverse primer
AX
//
typedef struct SPair
{
PPrimer f;
PPrimer r;
} OPair;
#define PPair OPair*
ID PGuts
TY static
MO primersearch
LB emboss
XX
DE the internals of a primer; each Primer has two of these,
DE one forward and one reverse
XX
TN primerguts
TD
TX
AN patstr
AT AjPStr
AD Undocumented
AX
AN origpat
AT AjPStr
AD Undocumented
AX
AN type
AT ajuint
AD Undocumented
AX
AN len
AT ajuint
AD Undocumented
AX
AN real_len
AT ajuint
AD Undocumented
AX
AN amino
AT AjBool
AD Undocumented
AX
AN carboxyl
AT AjBool
AD Undocumented
AX
AN mm
AT ajuint
AD Undocumented
AX
AN buf
AT ajint*
AD Undocumented
AX
AN sotable
AT ajuint*
AD Undocumented
AX
AN off
AT EmbOPatBYPNode[AJALPHA]
AD Undocumented
AX
AN re
AT AjPStr
AD Undocumented
AX
AN skipm
AT ajuint**
AD Undocumented
AX
AN tidy
AT const void*
AD Undocumented
AX
AN solimit
AT ajuint
AD Undocumented
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct primerguts
{
AjPStr patstr;
AjPStr origpat;
ajuint type;
ajuint len;
ajuint real_len;
AjBool amino;
AjBool carboxyl;
ajuint mm;
ajint* buf;
ajuint* sotable;
EmbOPatBYPNode off[AJALPHA];
AjPStr re;
ajuint** skipm;
const void* tidy;
ajuint solimit;
char Padding[4];
} *PGuts;
ID PHit
TY static
MO primersearch
LB emboss
XX
DE holds details of a hit against a sequence ie this primer will amplify
XX
TN primerhit
TD
TX
AN seqname
AT AjPStr
AD Undocumented
AX
AN desc
AT AjPStr
AD Undocumented
AX
AN acc
AT AjPStr
AD Undocumented
AX
AN forward
AT AjPStr
AD pattern that hits forward strand
AX
AN reverse
AT AjPStr
AD pattern that hits reverse strand
AX
AN forward_pos
AT ajuint
AD Undocumented
AX
AN reverse_pos
AT ajuint
AD Undocumented
AX
AN amplen
AT ajuint
AD Undocumented
AX
AN forward_mismatch
AT ajuint
AD Undocumented
AX
AN reverse_mismatch
AT ajuint
AD Undocumented
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct primerhit
{
AjPStr seqname;
AjPStr desc;
AjPStr acc;
AjPStr forward;
AjPStr reverse;
ajuint forward_pos;
ajuint reverse_pos;
ajuint amplen;
ajuint forward_mismatch;
ajuint reverse_mismatch;
char Padding[4];
} *PHit;
ID Primer
TY static
MO primersearch
LB emboss
XX
DE primer pairs will be read into a list of these structs
XX
TN primers
TD
TX
AN Name
AT AjPStr
AD Undocumented
AX
AN forward
AT PGuts
AD Undocumented
AX
AN reverse
AT PGuts
AD Undocumented
AX
AN hitlist
AT AjPList
AD Undocumented
AX
//
typedef struct primers
{
AjPStr Name;
PGuts forward;
PGuts reverse;
AjPList hitlist;
} *Primer;
VN windowsize
VD constant window size
VX
ID psiphiEAtomWindowPoint
TY public
MO psiphi
LB emboss
XX
DE enumerated indexes to atoms in window
XX
VN ENPrev
VD Previous N
VX
VN ECAlphaPrev
VD Previous C-alpha
VX
VN ECPrimePrev
VD Previous C'
VX
VN ENCurr
VD Current N
VX
VN ECAlphaCurr
VD Current C-alpha
VX
VN ECPrimeCurr
VD Current C'
VX
VN ENNext
VD Next N
VX
VN ECAlphaNext
VD Next C-alpha
VX
VN ECPrimeNext
VD Next C'
VX
//
typedef enum
{
ENPrev,
ECAlphaPrev,
ECPrimePrev,
ENCurr,
ECAlphaCurr,
ECPrimeCurr,
ENNext,
ECAlphaNext,
ECPrimeNext
} psiphiEAtomWindowPoint;
VN FUnavailableAngle
VD for unavailable angles (360 deg is an
TD impossible torsion angle)
VX
ID PRinfo
TY static
MO recoder
LB emboss
XX
DE recoder internals for RE information
XX
TN SRinfo
TD
TX
TN ORinfo
TD
TX
AN code
AT AjPStr
AD Undocumented
AX
AN site
AT AjPStr
AD Undocumented
AX
AN revsite
AT AjPStr
AD Undocumented
AX
AN ncuts
AT ajint
AD Undocumented
AX
AN cut1
AT ajint
AD Undocumented
AX
AN cut2
AT ajint
AD Undocumented
AX
AN cut3
AT ajint
AD Undocumented
AX
AN cut4
AT ajint
AD Undocumented
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SRinfo
{
AjPStr code;
AjPStr site;
AjPStr revsite;
ajint ncuts;
ajint cut1;
ajint cut2;
ajint cut3;
ajint cut4;
char Padding[4];
} ORinfo;
#define PRinfo ORinfo*
ID PMutant
TY static
MO recoder
LB emboss
XX
DE recoder internals for mutation sites
XX
TN SMutant
TD
TX
TN OMutant
TD
TX
AN code
AT AjPStr
AD Undocumented
AX
AN site
AT AjPStr
AD Undocumented
AX
AN match
AT ajint
AD Undocumented
AX
AN base
AT ajint
AD Undocumented
AX
AN seqaa
AT AjPStr
AD Undocumented
AX
AN reaa
AT AjPStr
AD Undocumented
AX
AN obase
AT char
AD Undocumented
AX
AN nbase
AT char
AD Undocumented
AX
AN Padding
AT char[6]
AD Padding to alignment boudnary
AX
//
typedef struct SMutant
{
AjPStr code;
AjPStr site;
ajint match;
ajint base;
AjPStr seqaa;
AjPStr reaa;
char obase;
char nbase;
char Padding[6];
} OMutant;
#define PMutant OMutant*
ID PValue
TY static
MO remap
LB emboss
XX
DE structure for counts and isoschizomers of a restriction enzyme hit
XX
TN SValue
TD
TX
TN OValue
TD
TX
AN iso
AT AjPStr
AD Undocumented
AX
AN count
AT ajint
AD Undocumented
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SValue
{
AjPStr iso;
ajint count;
char Padding[4];
} OValue;
#define PValue OValue*
ID POrder
TY static
MO showalign
LB emboss
XX
DE showalign internals
XX
TN SOrder
TD
TX
TN OOrder
TD
TX
AN seq
AT AjPSeq
AD Sequence
AX
AN similarity
AT ajint
AD total of similarity scores to consensus
AD for sort order
AX
AN idcount
AT ajint
AD count of identical residues for stats
AX
AN simcount
AT ajint
AD count of similar residues for stats
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SOrder
{
AjPSeq seq;
ajint similarity;
ajint idcount;
ajint simcount;
char Padding[4];
} OOrder;
#define POrder OOrder*
ID PRinfo
TY static
MO silent
LB emboss
XX
DE recoder internals for RE information
XX
TN SRinfo
TD
TX
TN ORinfo
TD
TX
AN code
AT AjPStr
AD structure for silent mutation info
AX
AN site
AT AjPStr
AD Undocumented
AX
AN revsite
AT AjPStr
AD Undocumented
AX
AN ncuts
AT ajint
AD Undocumented
AX
AN cut1
AT ajint
AD Undocumented
AX
AN cut2
AT ajint
AD Undocumented
AX
AN cut3
AT ajint
AD Undocumented
AX
AN cut4
AT ajint
AD Undocumented
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SRinfo
{
AjPStr code;
AjPStr site;
AjPStr revsite;
ajint ncuts;
ajint cut1;
ajint cut2;
ajint cut3;
ajint cut4;
char Padding[4];
} ORinfo;
#define PRinfo ORinfo*
ID PSilent
TY static
MO silent
LB emboss
XX
DE recoder internals for silent sites
XX
TN SSilent
TD
TX
TN OSilent
TD
TX
AN code
AT AjPStr
AD Undocumented
AX
AN site
AT AjPStr
AD Undocumented
AX
AN match
AT ajint
AD Undocumented
AX
AN base
AT ajint
AD Undocumented
AX
AN seqaa
AT AjPStr
AD Undocumented
AX
AN reaa
AT AjPStr
AD Undocumented
AX
AN issilent
AT AjBool
AD Undocumented
AX
AN obase
AT char
AD Undocumented
AX
AN nbase
AT char
AD Undocumented
AX
AN Padding
AT char[2]
AD Padding to alignment boundary
AX
//
typedef struct SSilent
{
AjPStr code;
AjPStr site;
ajint match;
ajint base;
AjPStr seqaa;
AjPStr reaa;
AjBool issilent;
char obase;
char nbase;
char Padding[2];
} OSilent;
#define PSilent OSilent*
ID PValue
TY static
MO sirna
LB emboss
XX
DE structure for position, score and GC count at the start of a window
XX
TN SValue
TD
TX
TN OValue
TD
TX
AN pos
AT ajint
AD Position
AX
AN GCcount
AT ajint
AD GC count
AX
AN score
AT ajint
AD Score
AX
//
typedef struct SValue
{
ajint pos;
ajint GCcount;
ajint score;
} OValue;
#define PValue OValue*
ID Primer
TY static
MO stssearch
LB emboss
XX
DE stssearch internals
XX
TN primers
TD
TX
AN Name
AT AjPStr
AD Undocumented
AX
AN Prima
AT AjPRegexp
AD Undocumented
AX
AN Primb
AT AjPRegexp
AD Undocumented
AX
AN Oligoa
AT AjPStr
AD Undocumented
AX
AN Oligob
AT AjPStr
AD Undocumented
AX
//
typedef struct primers
{
AjPStr Name;
AjPRegexp Prima;
AjPRegexp Primb;
AjPStr Oligoa;
AjPStr Oligob;
} *Primer;
ID PTestcode
TY static
MO tcode
LB emboss
XX
DE tcode internals
XX
TN Stestcode
TD
TX
TN OTestcode
TD
TX
AN positions
AT AjPFloat
AD Undocumented
AX
AN content
AT AjPFloat
AD Undocumented
AX
AN npositions
AT ajint
AD Undocumented
AX
AN ncontent
AT ajint
AD Undocumented
AX
AN pprobA
AT AjPFloat
AD Undocumented
AX
AN pprobC
AT AjPFloat
AD Undocumented
AX
AN pprobG
AT AjPFloat
AD Undocumented
AX
AN pprobT
AT AjPFloat
AD Undocumented
AX
AN cprobA
AT AjPFloat
AD Undocumented
AX
AN cprobC
AT AjPFloat
AD Undocumented
AX
AN cprobG
AT AjPFloat
AD Undocumented
AX
AN cprobT
AT AjPFloat
AD Undocumented
AX
AN pweights
AT AjPFloat
AD Undocumented
AX
AN cweights
AT AjPFloat
AD Undocumented
AX
//
typedef struct AjSTestcode
{
AjPFloat positions;
AjPFloat content;
ajint npositions;
ajint ncontent;
AjPFloat pprobA;
AjPFloat pprobC;
AjPFloat pprobG;
AjPFloat pprobT;
AjPFloat cprobA;
AjPFloat cprobC;
AjPFloat cprobG;
AjPFloat cprobT;
AjPFloat pweights;
AjPFloat cweights;
} OTestcode;
#define PTestcode OTestcode*
ID PHit
TY static
MO twofeat
LB emboss
XX
DE twofeat internals
XX
TN SHit
TD
TX
TN OHit
TD
TX
AN gfA
AT AjPFeature
AD Undocumented
AX
AN gfB
AT AjPFeature
AD Undocumented
AX
AN Start
AT ajint
AD Undocumented
AX
AN End
AT ajint
AD Undocumented
AX
AN distance
AT ajint
AD Undocumented
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct SHit
{
AjPFeature gfA;
AjPFeature gfB;
ajint Start;
ajint End;
ajint distance;
char Padding[4];
} OHit;
#define PHit OHit*
ID CPattern
TY static
MO vectorstrip
LB emboss
XX
DE vectorstrip internals
XX
TN clip_pattern
TD
TX
AN patstr
AT AjPStr
AD Undocumented
AX
AN origpat
AT AjPStr
AD Undocumented
AX
AN len
AT ajuint
AD Undocumented
AX
AN real_len
AT ajuint
AD Undocumented
AX
AN amino
AT AjBool
AD Undocumented
AX
AN carboxyl
AT AjBool
AD Undocumented
AX
AN buf
AT ajint*
AD Undocumented
AX
AN sotable
AT ajuint*
AD Undocumented
AX
AN solimit
AT ajuint
AD Undocumented
AX
AN type
AT ajuint
AD Undocumented
AX
AN off
AT EmbOPatBYPNode[AJALPHA]
AD Undocumented
AX
AN re
AT AjPStr
AD Undocumented
AX
AN skipm
AT ajuint**
AD Undocumented
AX
AN tidy
AT const void*
AD Undocumented
AX
//
typedef struct clip_pattern
{
AjPStr patstr;
AjPStr origpat;
ajuint len;
ajuint real_len;
AjBool amino;
AjBool carboxyl;
ajint* buf;
ajuint* sotable;
ajuint solimit;
ajuint type;
EmbOPatBYPNode off[AJALPHA];
AjPStr re;
ajuint** skipm;
const void* tidy;
}*CPattern;
ID Vector
TY static
MO vectorstrip
LB emboss
XX
DE vectorstrip internals
XX
TN vector
TD
TX
AN name
AT AjPStr
AD Undocumented
AX
AN fiveprime
AT AjPStr
AD Undocumented
AX
AN threeprime
AT AjPStr
AD Undocumented
AX
//
typedef struct vector
{
AjPStr name;
AjPStr fiveprime;
AjPStr threeprime;
}*Vector;
ID concat
TY static
MO wordfinder
LB emboss
XX
DE wordfinder internals
XX
TN concatS
TD
TX
AN offset
AT ajint
AD Undocumented
AX
AN count
AT ajint
AD Undocumented
AX
AN list
AT AjPList
AD Undocumented
AX
AN total
AT ajint
AD Undocumented
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct concatS
{
ajint offset;
ajint count;
AjPList list;
ajint total;
char Padding[4];
} concat;
ID AjPAlign
TY public
MO ajalign
LB core
XX
DE Ajax Align Output object.
DE
DE Holds definition of feature align output.
XX
TN AjSAlign
TD
TX
TN AjOAlign
TD
TX
NN ajAlignNew
ND Default constructor
NX
DN ajAlignDel
DD Default destructor
DX
MN ajAlignReset
MD Resets ready for reuse.
MX
PN ajAlignWrite
PD Master alignment output routine
PX
PN ajAlignWriteHeader
PD Master header output routine
PX
PN ajAlignWriteTail
PD Master footer output routine
PX
CN ajAlignGetFormat
CD Returns the format of an alignment
CX
RN AjPSeqout
RD Sequence output
RX
RN AjPFeatout
RD Feature output
RX
RN AjPReport
RD Report output
RX
RN AjPFile
RD Input and output files
RX
AN Type
AT AjPStr
AD "P" Protein or "N" Nucleotide
AX
AN Formatstr
AT AjPStr
AD Report format (-aformat qualifier)
AX
AN File
AT AjPFile
AD Output file object
AX
AN Header
AT AjPStr
AD Text to add to header with newlines
AX
AN SubHeader
AT AjPStr
AD Text to add to align subheader with newlines
AX
AN Tail
AT AjPStr
AD Text to add to tail with newlines
AX
AN SubTail
AT AjPStr
AD Text to add to subtail with newlines
AX
AN Showacc
AT AjBool
AD Report accession number if ajTrue
AX
AN Showdes
AT AjBool
AD Report sequence description if ajTrue
AX
AN Showusa
AT AjBool
AD Report full USA (-ausa qualifier) if ajTrue
AD or only seqname if ajFalse
AX
AN Multi
AT AjBool
AD if true, assume >1 alignment
AX
AN Global
AT AjBool
AD if true, show full sequence beyond match
AX
AN Format
AT AjEnum
AD Report format (index number)
AX
AN Data
AT AjPList
AD Alignment specific data - see ajalign.c
AX
AN Nseqs
AT ajint
AD Number of sequences in all alignments
AX
AN Nmin
AT ajint
AD Minimum number of sequences e.g. 2
AX
AN Nmax
AT ajint
AD Maximum number of sequences e.g. 2
AX
AN Width
AT ajint
AD Output width (minimum 10)
AX
AN IMatrix
AT AjPMatrix
AD Integer matrix (see also FMatrix)
AX
AN FMatrix
AT AjPMatrixf
AD Floating point matrix (see also IMatrix)
AX
AN Matrix
AT AjPStr
AD Matrix name
AX
AN GapPen
AT AjPStr
AD Gap penalty (converted to string)
AX
AN ExtPen
AT AjPStr
AD Gap extend penalty (converted to string)
AX
AN SeqOnly
AT AjBool
AD Sequence output only, no head or tail
AX
AN SeqExternal
AT AjBool
AD Sequence is non-local, do not delete
AX
AN Count
AT ajint
AD Use count
AX
AN RefSeq
AT ajint
AD Index of the reference sequences in AlignOData objects
AD of the Data list
AX
//
typedef struct AjSAlign
{
AjPStr Type;
AjPStr Formatstr;
AjPFile File;
AjPStr Header;
AjPStr SubHeader;
AjPStr Tail;
AjPStr SubTail;
AjBool Showacc;
AjBool Showdes;
AjBool Showusa;
AjBool Multi;
AjBool Global;
AjEnum Format;
AjPList Data;
ajint Nseqs;
ajint Nmin;
ajint Nmax;
ajint Width;
AjPMatrix IMatrix;
AjPMatrixf FMatrix;
AjPStr Matrix;
AjPStr GapPen;
AjPStr ExtPen;
AjBool SeqOnly;
AjBool SeqExternal;
ajint Count;
ajint RefSeq;
} AjOAlign;
#define AjPAlign AjOAlign*
ID ajint
TY typedef
MO ajarch
LB core
XX
DE AJAX Signed Integer
XX
AN typedef
AT int
AD Value
AX
//
typedef int ajint;
ID ajlong
TY typedef
MO ajarch
LB core
XX
DE AJAX Long Signed Integer
XX
AN typedef
AT long
AD Value
AX
//
typedef long ajlong;
ID ajuint
TY typedef
MO ajarch
LB core
XX
DE AJAX Unsigned Integer
XX
AN typedef
AT unsigned int
AD Value
AX
//
typedef unsigned int ajuint;
ID ajshort
TY typedef
MO ajarch
LB core
XX
DE AJAX Short Signed Integer
XX
AN typedef
AT short
AD Value
AX
//
typedef short ajshort;
ID ajushort
TY typedef
MO ajarch
LB core
XX
DE AJAX Short Unsigned Integer
XX
AN typedef
AT unsigned short
AD Value
AX
//
typedef unsigned short ajushort;
ID ajulong
TY typedef
MO ajarch
LB core
XX
DE AJAX Long Unsigned Integer
XX
AN typedef
AT unsigned long
AD Value
AX
//
typedef unsigned long ajulong;
ID AjBool
TY typedef
MO ajarch
LB core
XX
DE Boolean data type
DE
DE Used to store true (ajTrue) and false (ajFalse) values.
DE
DE ajFalse is defined as zero, and the data type is equivalent to "ajint".
DE
DE For definitions, macros AJTRUE and AJFALSE are also defined.
DE
DE On output, conversion code "%b" writes "Y" or "N"
DE while conversion code "%B" writes "Yes" or "No".
XX
AN typedef
AT ajint
AD Value
AX
//
typedef ajint AjBool;
/* @datatype AjStatus *********************************************************
**
** Status code returned with bit fields.
**
** Intended as a general return code for functions, but currently unused
** because AjBool is enough. Indicates OK, info,
** warning, error and fatal returns
**
** @attr typedef [ajint] Value
** @@
******************************************************************************/
typedef ajint AjStatus;
ID AjStatus
TY typedef
MO ajarch
LB core
XX
DE Status code returned with bit fields.
DE
DE Intended as a general return code for functions, but currently unused
DE because AjBool is enough. Indicates OK, info,
DE warning, error and fatal returns
XX
AN typedef
AT ajint
AD Value
AX
//
typedef ajint AjStatus;
/* @datatype AjEnum ***********************************************************
**
** Undocumented
**
** @attr typedef [ajint] Value
** @@
******************************************************************************/
typedef ajint AjEnum;
ID AjEnum
TY typedef
MO ajarch
LB core
XX
DE Undocumented
XX
AN typedef
AT ajint
AD Value
AX
//
typedef ajint AjEnum;
/* @datatype AjMask ***********************************************************
**
** Undocumented
**
** @attr typedef [ajint] Value
** @@
******************************************************************************/
typedef ajint AjMask;
ID AjMask
TY typedef
MO ajarch
LB core
XX
DE Undocumented
XX
AN typedef
AT ajint
AD Value
AX
//
typedef ajint AjMask;
/* @datatype AjInt4 ***********************************************************
**
** 4 bytes integer
**
** @attr typedef [ajint] Value
** @@
******************************************************************************/
typedef ajint AjInt4;
ID AjInt4
TY typedef
MO ajarch
LB core
XX
DE 4 bytes integer
XX
AN typedef
AT ajint
AD Value
AX
//
typedef ajint AjInt4;
/* @datatype AjIntArray *******************************************************
**
** Array of integers
**
** @attr typedef [ajint*] Value
** @@
******************************************************************************/
typedef ajint* AjIntArray;
ID AjIntArray
TY typedef
MO ajarch
LB core
XX
DE Array of integers
XX
AN typedef
AT ajint*
AD Value
AX
//
typedef ajint* AjIntArray;
/* @datatype AjFloatArray *****************************************************
**
** Array of floats
**
** @attr typedef [float*] Value
** @@
******************************************************************************/
typedef float* AjFloatArray;
ID AjFloatArray
TY typedef
MO ajarch
LB core
XX
DE Array of floats
XX
AN typedef
AT float*
AD Value
AX
//
typedef float* AjFloatArray;
ID AjPChar
TY public
MO ajarr
LB core
XX
DE Ajax character object.
DE
DE Holds a character array with additional data.
DE The length is known and held internally.
DE
DE Saves on length calculation, and allows growth in reserved memory without
DE changing the pointer in the calling routine.
DE
DE AjPChar is implemented as a pointer to a C data structure.
XX
TN AjSChar
TD
TX
TN AjOChar
TD
TX
NN ajChararrNew
ND Default constructor
NX
NN ajChararrNewL
ND Constructor with reserved size
NX
DN ajChararrDel
DD Default destructor
DX
CN ajChararrGet
CD Retrieve a character from an array
CX
MN ajChararrPut
MD Load a character array element
MX
CN ajChararrChararr
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT char*
AD Array of characters
AX
//
typedef struct AjSChar
{
ajuint Res;
ajuint Len;
char *Ptr;
} AjOChar;
#define AjPChar AjOChar*
ID AjPInt
TY public
MO ajarr
LB core
XX
DE Ajax integer object.
DE
DE Holds an integer array with additional data.
DE The length is known and held internally.
DE
DE AjPInt is implemented as a pointer to a C data structure.
XX
TN AjSInt
TD
TX
TN AjOInt
TD
TX
NN ajIntNew
ND Default constructor
NX
NN ajIntNewL
ND Constructor with reserved size
NX
DN ajIntDel
DD Default destructor
DX
CN ajIntGet
CD Retrieve an integer from an array
CX
MN ajIntPut
MD Load an integer array element
MX
CN ajIntInt
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT ajint*
AD Array of integers
AX
//
typedef struct AjSInt
{
ajuint Res;
ajuint Len;
ajint *Ptr;
} AjOInt;
#define AjPInt AjOInt*
ID AjPInt2d
TY public
MO ajarr
LB core
XX
DE Ajax 2d integer object.
DE
DE Holds an integer array with additional data.
DE The length is known and held internally.
DE
DE AjPInt2d is implemented as a pointer to a C data structure.
XX
TN AjSInt2d
TD
TX
TN AjOInt2d
TD
TX
NN ajInt2dNew
ND Default constructor
NX
NN ajInt2dNewL
ND Constructor with reserved size
NX
DN ajInt2dDel
DD Default destructor
DX
CN ajInt2dGet
CD Retrieve an integer from an array
CX
MN ajInt2dPut
MD Load an integer array element
MX
CN ajInt2dInt
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT AjPInt*
AD Array of integer arrays
AX
//
typedef struct AjSInt2d
{
ajuint Res;
ajuint Len;
AjPInt *Ptr;
} AjOInt2d;
#define AjPInt2d AjOInt2d*
ID AjPInt3d
TY public
MO ajarr
LB core
XX
DE Ajax 3d integer object.
DE
DE Holds an integer array with additional data.
DE The length is known and held internally.
DE
DE AjPInt3d is implemented as a pointer to a C data structure.
XX
TN AjSInt3d
TD
TX
TN AjOInt3d
TD
TX
NN ajInt3dNew
ND Default constructor
NX
NN ajInt3dNewL
ND Constructor with reserved size
NX
DN ajInt3dDel
DD Default destructor
DX
CN ajInt3dGet
CD Retrieve an integer from an array
CX
MN ajInt3dPut
MD Load an integer array element
MX
CN ajInt3dInt
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT AjPInt2d*
AD Array of 2d integer arrays
AX
//
typedef struct AjSInt3d
{
ajuint Res;
ajuint Len;
AjPInt2d *Ptr;
} AjOInt3d;
#define AjPInt3d AjOInt3d*
ID AjPFloat
TY public
MO ajarr
LB core
XX
DE Ajax float object.
DE
DE Holds a float array with additional data.
DE The length is known and held internally.
DE
DE AjPFloat is implemented as a pointer to a C data structure.
XX
TN AjSFloat
TD
TX
TN AjOFloat
TD
TX
NN ajFloatNew
ND Default constructor
NX
NN ajFloatNewL
ND Constructor with reserved size
NX
DN ajFloatDel
DD Default destructor
DX
CN ajFloatGet
CD Retrieve a float from an array
CX
MN ajFloatPut
MD Load a float array element
MX
CN ajFloatFloat
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT float*
AD Array of floats
AX
//
typedef struct AjSFloat
{
ajuint Res;
ajuint Len;
float *Ptr;
} AjOFloat;
#define AjPFloat AjOFloat*
ID AjPFloat2d
TY public
MO ajarr
LB core
XX
DE Ajax 2d float object.
DE
DE Holds a 2d float array with additional data.
DE The length is known and held internally.
DE
DE AjPFloat2d is implemented as a pointer to a C data structure.
XX
TN AjSFloat2d
TD
TX
TN AjOFloat2d
TD
TX
NN ajFloat2dNew
ND Default constructor
NX
NN ajFloat2dNewL
ND Constructor with reserved size
NX
DN ajFloat2dDel
DD Default destructor
DX
CN ajFloat2dGet
CD Retrieve a float from an array
CX
MN ajFloat2dPut
MD Load a float array element
MX
CN ajFloat2dFloat
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT AjPFloat*
AD Array of float arrays
AX
//
typedef struct AjSFloat2d
{
ajuint Res;
ajuint Len;
AjPFloat *Ptr;
} AjOFloat2d;
#define AjPFloat2d AjOFloat2d*
ID AjPFloat3d
TY public
MO ajarr
LB core
XX
DE Ajax 3d float object.
DE
DE Holds a 3d float array with additional data.
DE The length is known and held internally.
DE
DE AjPFloat3d is implemented as a pointer to a C data structure.
XX
TN AjSFloat3d
TD
TX
TN AjOFloat3d
TD
TX
NN ajFloat3dNew
ND Default constructor
NX
NN ajFloat3dNewL
ND Constructor with reserved size
NX
DN ajFloat3dDel
DD Default destructor
DX
CN ajFloat3dGet
CD Retrieve a float from an array
CX
MN ajFloat3dPut
MD Load a float array element
MX
CN ajFloat3dFloat
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT AjPFloat2d*
AD Array of 2d float arrays
AX
//
typedef struct AjSFloat3d
{
ajuint Res;
ajuint Len;
AjPFloat2d *Ptr;
} AjOFloat3d;
#define AjPFloat3d AjOFloat3d*
ID AjPDouble
TY public
MO ajarr
LB core
XX
DE Ajax double object.
DE
DE Holds a double array with additional data.
DE The length is known and held internally.
DE
DE AjPDouble is implemented as a pointer to a C data structure.
XX
TN AjSDouble
TD
TX
TN AjODouble
TD
TX
NN ajDoubleNew
ND Default constructor
NX
NN ajDoubleNewL
ND Constructor with reserved size
NX
DN ajDoubleDel
DD Default destructor
DX
CN ajDoubleGet
CD Retrieve a double from an array
CX
MN ajDoublePut
MD Load a double array element
MX
CN ajDoubleDouble
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT double*
AD Array of doubles
AX
//
typedef struct AjSDouble
{
ajuint Res;
ajuint Len;
double *Ptr;
} AjODouble;
#define AjPDouble AjODouble*
ID AjPDouble2d
TY public
MO ajarr
LB core
XX
DE Ajax 2d double object.
DE
DE Holds a 2d double array with additional data.
DE The length is known and held internally.
DE
DE AjPDouble2d is implemented as a pointer to a C data structure.
XX
TN AjSDouble2d
TD
TX
TN AjODouble2d
TD
TX
NN ajDouble2dNew
ND Default constructor
NX
NN ajDouble2dNewL
ND Constructor with reserved size
NX
DN ajDouble2dDel
DD Default destructor
DX
CN ajDouble2dGet
CD Retrieve a double from an array
CX
MN ajDouble2dPut
MD Load a double array element
MX
CN ajDouble2dDouble
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT AjPDouble*
AD Array of double arrays
AX
//
typedef struct AjSDouble2d
{
ajuint Res;
ajuint Len;
AjPDouble *Ptr;
} AjODouble2d;
#define AjPDouble2d AjODouble2d*
ID AjPDouble3d
TY public
MO ajarr
LB core
XX
DE Ajax 3d double object.
DE
DE Holds a 3d double array with additional data.
DE The length is known and held internally.
DE
DE AjPDouble3d is implemented as a pointer to a C data structure.
XX
TN AjSDouble3d
TD
TX
TN AjODouble3d
TD
TX
NN ajDouble3dNew
ND Default constructor
NX
NN ajDouble3dNewL
ND Constructor with reserved size
NX
DN ajDouble3dDel
DD Default destructor
DX
CN ajDouble3dGet
CD Retrieve a double from an array
CX
MN ajDouble3dPut
MD Load a double array element
MX
CN ajDouble3dDouble
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT AjPDouble2d*
AD Array of 2d double arrays
AX
//
typedef struct AjSDouble3d
{
ajuint Res;
ajuint Len;
AjPDouble2d *Ptr;
} AjODouble3d;
#define AjPDouble3d AjODouble3d*
ID AjPShort
TY public
MO ajarr
LB core
XX
DE Ajax short object.
DE
DE Holds a short array with additional data.
DE The length is known and held internally.
DE
DE AjPShort is implemented as a pointer to a C data structure.
XX
TN AjSShort
TD
TX
TN AjOShort
TD
TX
NN ajShortNew
ND Default constructor
NX
NN ajShortNewL
ND Constructor with reserved size
NX
DN ajShortDel
DD Default destructor
DX
CN ajShortGet
CD Retrieve a short from an array
CX
MN ajShortPut
MD Load a short array element
MX
CN ajShortShort
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT short*
AD Array of shorts
AX
//
typedef struct AjSShort
{
ajuint Res;
ajuint Len;
short *Ptr;
} AjOShort;
#define AjPShort AjOShort*
ID AjPShort2d
TY public
MO ajarr
LB core
XX
DE Ajax 2d short object.
DE
DE Holds a 2d short array with additional data.
DE The length is known and held internally.
DE
DE AjPShort2d is implemented as a pointer to a C data structure.
XX
TN AjSShort2d
TD
TX
TN AjOShort2d
TD
TX
NN ajShort2dNew
ND Default constructor
NX
NN ajShort2dNewL
ND Constructor with reserved size
NX
DN ajShort2dDel
DD Default destructor
DX
CN ajShort2dGet
CD Retrieve a short from an array
CX
MN ajShort2dPut
MD Load a short array element
MX
CN ajShort2dShort
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT AjPShort*
AD Array of short arrays
AX
//
typedef struct AjSShort2d
{
ajuint Res;
ajuint Len;
AjPShort *Ptr;
} AjOShort2d;
#define AjPShort2d AjOShort2d*
ID AjPShort3d
TY public
MO ajarr
LB core
XX
DE Ajax 3d short object.
DE
DE Holds a 3d short array with additional data.
DE The length is known and held internally.
DE
DE AjPShort3d is implemented as a pointer to a C data structure.
XX
TN AjSShort3d
TD
TX
TN AjOShort3d
TD
TX
NN ajShort3dNew
ND Default constructor
NX
NN ajShort3dNewL
ND Constructor with reserved size
NX
DN ajShort3dDel
DD Default destructor
DX
CN ajShort3dGet
CD Retrieve a short from an array
CX
MN ajShort3dPut
MD Load a short array element
MX
CN ajShort3dShort
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT AjPShort2d*
AD Array of 2d short arrays
AX
//
typedef struct AjSShort3d
{
ajuint Res;
ajuint Len;
AjPShort2d *Ptr;
} AjOShort3d;
#define AjPShort3d AjOShort3d*
ID AjPLong
TY public
MO ajarr
LB core
XX
DE Ajax ajlong object.
DE
DE Holds a ajlong array with additional data.
DE The length is known and held internally.
DE
DE AjPLong is implemented as a pointer to a C data structure.
XX
TN AjSLong
TD
TX
TN AjOLong
TD
TX
NN ajLongNew
ND Default constructor
NX
NN ajLongNewL
ND Constructor with reserved size
NX
DN ajLongDel
DD Default destructor
DX
CN ajLongGet
CD Retrieve a ajlong from an array
CX
MN ajLongPut
MD Load a ajlong array element
MX
CN ajLongLong
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT ajlong*
AD Array of longs
AX
//
typedef struct AjSLong
{
ajuint Res;
ajuint Len;
ajlong *Ptr;
} AjOLong;
#define AjPLong AjOLong*
ID AjPLong2d
TY public
MO ajarr
LB core
XX
DE Ajax 2d ajlong object.
DE
DE Holds a 2d ajlong array with additional data.
DE The length is known and held internally.
DE
DE AjPLong2d is implemented as a pointer to a C data structure.
XX
TN AjSLong2d
TD
TX
TN AjOLong2d
TD
TX
NN ajLong2dNew
ND Default constructor
NX
NN ajLong2dNewL
ND Constructor with reserved size
NX
DN ajLong2dDel
DD Default destructor
DX
CN ajLong2dGet
CD Retrieve a ajlong from an array
CX
MN ajLong2dPut
MD Load a ajlong array element
MX
CN ajLong2dLong
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT AjPLong*
AD Array of long arrays
AX
//
typedef struct AjSLong2d
{
ajuint Res;
ajuint Len;
AjPLong *Ptr;
} AjOLong2d;
#define AjPLong2d AjOLong2d*
ID AjPLong3d
TY public
MO ajarr
LB core
XX
DE Ajax 3d ajlong object.
DE
DE Holds a 3d ajlong array with additional data.
DE The length is known and held internally.
DE
DE AjPLong3d is implemented as a pointer to a C data structure.
XX
TN AjSLong3d
TD
TX
TN AjOLong3d
TD
TX
NN ajLong3dNew
ND Default constructor
NX
NN ajLong3dNewL
ND Constructor with reserved size
NX
DN ajLong3dDel
DD Default destructor
DX
CN ajLong3dGet
CD Retrieve a ajlong from an array
CX
MN ajLong3dPut
MD Load a ajlong array element
MX
CN ajLong3dLong
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT AjPLong2d*
AD Array of 2d long arrays
AX
//
typedef struct AjSLong3d
{
ajuint Res;
ajuint Len;
AjPLong2d *Ptr;
} AjOLong3d;
#define AjPLong3d AjOLong3d*
ID AjPUint
TY public
MO ajarr
LB core
XX
DE Ajax unsigned integer object.
DE
DE Holds an unsigned integer array with additional data.
DE The length is known and held internally.
DE
DE AjPUint is implemented as a pointer to a C data structure.
XX
TN AjSUint
TD
TX
TN AjOUint
TD
TX
NN ajUintNew
ND Default constructor
NX
NN ajUintNewL
ND Constructor with reserved size
NX
DN ajUintDel
DD Default destructor
DX
CN ajUintGet
CD Retrieve an integer from an array
CX
MN ajUintPut
MD Load an integer array element
MX
CN ajUintUint
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT ajuint*
AD Array of integers
AX
//
typedef struct AjSUint
{
ajuint Res;
ajuint Len;
ajuint *Ptr;
} AjOUint;
#define AjPUint AjOUint*
ID AjPUint2d
TY public
MO ajarr
LB core
XX
DE Ajax 2d unsigned integer object.
DE
DE Holds an unsigned integer array with additional data.
DE The length is known and held internally.
DE
DE AjPUint2d is implemented as a pointer to a C data structure.
XX
TN AjSUint2d
TD
TX
TN AjOUint2d
TD
TX
NN ajUint2dNew
ND Default constructor
NX
NN ajUint2dNewL
ND Constructor with reserved size
NX
DN ajUint2dDel
DD Default destructor
DX
CN ajUint2dGet
CD Retrieve an integer from an array
CX
MN ajUint2dPut
MD Load an integer array element
MX
CN ajIUint2dUint
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT AjPUint*
AD Array of integer arrays
AX
//
typedef struct AjSUint2d
{
ajuint Res;
ajuint Len;
AjPUint *Ptr;
} AjOUint2d;
#define AjPUint2d AjOUint2d*
ID AjPUint3d
TY public
MO ajarr
LB core
XX
DE Ajax 3d unsigned integer object.
DE
DE Holds an unsigned integer array with additional data.
DE The length is known and held internally.
DE
DE AjPUint3d is implemented as a pointer to a C data structure.
XX
TN AjSUint3d
TD
TX
TN AjOUint3d
TD
TX
NN ajUint3dNew
ND Default constructor
NX
NN ajUint3dNewL
ND Constructor with reserved size
NX
DN ajUint3dDel
DD Default destructor
DX
CN ajUint3dGet
CD Retrieve an integer from an array
CX
MN ajUint3dPut
MD Load an integer array element
MX
CN ajUint3dUint
CD Retrieve internal pointer
CX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT AjPUint2d*
AD Array of 2d integer arrays
AX
//
typedef struct AjSUint3d
{
ajuint Res;
ajuint Len;
AjPUint2d *Ptr;
} AjOUint3d;
#define AjPUint3d AjOUint3d*
ID AjEAssemSortOrder
TY public
MO ajassemdata
LB core
XX
DE Assembly reads sort order Type enumeration.
XX
VN ajEAssemSortOrderUnknown
VD Unknown - default in SAM/BAM formats
VX
VN ajEAssemSortOrderUnsorted
VD Unsorted - unsorted
VX
VN ajEAssemSortOrderQueryname
VD Queryname - sorted by query/read names
VX
VN ajEAssemSortOrderCoordinate
VD Coordinate - major sort key is the
TD the reference/contig name, order defined by the order of VX
//
typedef enum AjOAssemSortOrder
{
ajEAssemSortOrderUnknown,
ajEAssemSortOrderUnsorted,
ajEAssemSortOrderQueryname,
ajEAssemSortOrderCoordinate
} AjEAssemSortOrder;
ID AjEAssemPlatform
TY public
MO ajassemdata
LB core
XX
DE Platforms/technologies to produce reads, as enumerated in SAM specv1.4.
XX
VN ajEAssemPlatformUnknown
VD Unknown
VX
VN ajEAssemPlatformCapillary
VD Capillary
VX
VN ajEAssemPlatformLS454
VD LS 454
VX
VN ajEAssemPlatformIllumina
VD Illumina
VX
VN ajEAssemPlatformSolid
VD Solid
VX
VN ajEAssemPlatformHelicos
VD Helicos
VX
VN ajEAssemPlatformIontorrent
VD IonTorrent
VX
VN ajEAssemPlatformPacbio
VD Pacific Biosciences
VX
//
typedef enum AjOAssemPlatform
{
ajEAssemPlatformUnknown,
ajEAssemPlatformCapillary,
ajEAssemPlatformLS454,
ajEAssemPlatformIllumina,
ajEAssemPlatformSolid,
ajEAssemPlatformHelicos,
ajEAssemPlatformIontorrent,
ajEAssemPlatformPacbio
} AjEAssemPlatform;
ID AjPAssemRead
TY public
MO ajassemdata
LB core
XX
DE Store individual alignments of reads in assemblies.
DE
DE In some assemblies some reads can align to more than one contig
DE or reference sequence, so current name of the data type is not perfect.
DE
DE For storing read information as part of an assembly object.
DE Current version of this data type is MIRA/SAM oriented,
DE it needs to be improved to be a proper common data type,
DE some of the current fields are used by MIRA MAF format only
DE while few others are used by the SAM format only.
XX
TN AjSAssemRead
TD
TX
TN AjOAssemRead
TD In it's simplest form, a DNA template is sequenced only once.
TD In paired-end sequencing, a DNA template is sequenced once in forward
TD and once in reverse direction (Sanger, 454, Solexa).
TD In Sanger sequencing, several forward and/or reverse reads
TD can be sequenced from a DNA template.
TD In PacBio sequencing, a DNA template can be sequenced
TD in several "strobes", leading to multiple reads on a DNA template.
TD (ref:MAF format specification on mira web site)
TX
AN Name
AT AjPStr
AD Name
AX
AN Seq
AT AjPStr
AD Sequence
AX
AN SeqQ
AT AjPStr
AD Sequence quality string
AX
AN Template
AT AjPStr
AD Name of the DNA template a sequence comes from
AX
AN File
AT AjPStr
AD Name of the sequencing file
AD which contains raw data for this read
AX
AN Technology
AT AjPStr
AD Sequencing technology
AX
AN Cigar
AT AjPStr
AD CIGAR string
AX
AN Tags
AT AjPList
AD List of AjPAssemTag objects
AX
AN AlignmentBlocks
AT AjPList
AD Alignment blocks
AX
AN Rnext
AT ajlong
AD Reference number of the mate/next fragment
AX
AN Reference
AT ajlong
AD Reference sequence
AX
AN Pnext
AT ajlong
AD Position of the mate/next fragment
AX
AN Tlen
AT ajint
AD Observed template length
AX
AN Flag
AT ajint
AD Flag
AX
AN MapQ
AT ajint
AD Map quality
AX
AN TemplateSizeMin
AT ajint
AD Minimum template size
AX
AN TemplateSizeMax
AT ajint
AD Maximum template size
AX
AN ClipLeft
AT ajint
AD Clip left
AX
AN ClipRight
AT ajint
AD Clip right
AX
AN VectorLeft
AT ajint
AD Clip left due to sequencing vector
AX
AN VectorRight
AT ajint
AD Clip right due to sequencing vector
AX
AN QualLeft
AT ajint
AD Clip left due to quality
AX
AN QualRight
AT ajint
AD Clip right due to quality
AX
AN x1
AT ajint
AD interval of the contig (1-based as in SAM and MAF)
AX
AN y1
AT ajint
AD end of contig interval
AX
AN x2
AT ajint
AD interval of the read
AX
AN y2
AT ajint
AD end of read interval
AX
AN Reversed
AT AjBool
AD true: has been reverse-complemented
AX
AN Direction
AT char
AD Direction of the read with respect to the template
AX
AN Padding
AT char[7]
AD Padding to alignment boundary
AX
//
typedef struct AjSAssemRead
{
AjPStr Name;
AjPStr Seq;
AjPStr SeqQ;
AjPStr Template;
AjPStr File;
AjPStr Technology;
AjPStr Cigar;
AjPList Tags;
AjPList AlignmentBlocks;
ajlong Rnext;
ajlong Reference;
ajlong Pnext;
ajint Tlen;
ajint Flag;
ajint MapQ;
ajint TemplateSizeMin;
ajint TemplateSizeMax;
ajint ClipLeft;
ajint ClipRight;
ajint VectorLeft;
ajint VectorRight;
ajint QualLeft;
ajint QualRight;
ajint x1;
ajint y1;
ajint x2;
ajint y2;
AjBool Reversed;
char Direction;
char Padding[7];
} AjOAssemRead;
#define AjPAssemRead AjOAssemRead*
ID AjPAssemContig
TY public
MO ajassemdata
LB core
XX
DE Ajax AssemContig object to store contigs in assemblies.
DE
DE In mapping assemblies consensus sequence refers to the reference sequence.
XX
AN Name
AT AjPStr
AD Name
AX
AN Consensus
AT AjPStr
AD Consensus/reference sequence
AX
AN ConsensusQ
AT AjPStr
AD Quality string for the consensus sequence
AX
AN Tags
AT AjPList
AD Tags for the consensus sequence
AX
AN Length
AT ajint
AD Length of the consensus sequence
AX
AN Nreads
AT ajint
AD Number of reads
AX
AN AssemblyID
AT AjPStr
AD Assembly ID
AX
AN MD5
AT AjPStr
AD MD5 checksum of the consensus sequence
AD in the uppercase, with gaps and spaces removed
AX
AN Species
AT AjPStr
AD Species
AX
AN URI
AT AjPStr
AD URI of the consensus sequences
AX
//
typedef struct AjSContig
{
AjPStr Name;
AjPStr Consensus;
AjPStr ConsensusQ;
AjPList Tags;
ajint Length;
ajint Nreads;
AjPStr AssemblyID;
AjPStr MD5;
AjPStr Species;
AjPStr URI;
} AjOContig;
#define AjPAssemContig AjOContig*
ID AjPAssemin
TY public
MO ajassemdata
LB core
XX
DE Ajax Assembly Input object.
DE
DE Holds the input specification and information needed to read
DE the assembly and possible further entries
XX
TN AjSAssemin
TD
TX
TN AjOAssemin
TD
TX
AN Input
AT AjPTextin
AD General text input object
AX
AN BamIdx
AT AjPBamIndex
AD BAM index
AX
AN BamInput
AT AjBool
AD BAM file input
AX
AN cbegin
AT ajint
AD Contig start position
AX
AN cend
AT ajint
AD Contig end position
AX
AN Loading
AT AjBool
AD True if data is now loading
AX
//
typedef struct AjSAssemin
{
AjPTextin Input;
AjPBamIndex BamIdx;
AjBool BamInput;
ajint cbegin;
ajint cend;
AjBool Loading;
} AjOAssemin;
#define AjPAssemin AjOAssemin*
ID AjPAssem
TY public
MO ajassemdata
LB core
XX
DE Ajax Assembly object.
DE
DE Holds the assembly itself, plus associated information.
XX
TN AjSAssem
TD
TX
TN AjOAssem
TD
TX
AN Id
AT AjPStr
AD Id of term
AX
AN Db
AT AjPStr
AD Database name from input
AX
AN Setdb
AT AjPStr
AD Database name from command line
AX
AN Full
AT AjPStr
AD Full name
AX
AN Qry
AT AjPStr
AD Query for re-reading
AX
AN Formatstr
AT AjPStr
AD Input format name
AX
AN Filename
AT AjPStr
AD Original filename
AX
AN Textptr
AT AjPStr
AD Full text
AX
AN BamHeader
AT AjPSeqBamHeader
AD BAM header
AX
AN Contigs
AT AjPTable
AD Contigs table, storing contigs by name
AX
AN ContigsIgnored
AT AjPTable
AD Contigs named as '*' because of
AD missing header 'AX
AN ContigsOrder
AT AjPList
AD Order of contigs in the assembly
AX
AN ContigArray
AT AjPAssemContig*
AD Contigs array for fast access
AX
AN Reads
AT AjPList
AD List of reads in the assembly
AX
AN Readgroups
AT AjPTable
AD Table of read-groups in the assembly
AX
AN rec
AT AjPAssemRead
AD Current/last read/alignment record read
AX
AN Fpos
AT ajlong
AD File position
AX
AN Format
AT AjEnum
AD Input format enum
AX
AN Count
AT ajuint
AD Number of lines read (contigs in case of BAM)
AX
AN Hasdata
AT AjBool
AD True when data has been loaded
AX
AN SO
AT AjEAssemSortOrder
AD Reads sort order in the assembly
AX
//
typedef struct AjSAssem
{
AjPStr Id;
AjPStr Db;
AjPStr Setdb;
AjPStr Full;
AjPStr Qry;
AjPStr Formatstr;
AjPStr Filename;
AjPStr Textptr;
AjPSeqBamHeader BamHeader;
AjPTable Contigs;
AjPTable ContigsIgnored;
AjPList ContigsOrder;
AjPAssemContig* ContigArray;
AjPList Reads;
AjPTable Readgroups;
AjPAssemRead rec;
ajlong Fpos;
AjEnum Format;
ajuint Count;
AjBool Hasdata;
AjEAssemSortOrder SO;
} AjOAssem;
#define AjPAssem AjOAssem*
ID AjPAssemload
TY public
MO ajassemdata
LB core
XX
DE Ajax assembly loader object.
DE
DE Inherits an AjPAssem but allows more assembly data to be read from the
DE same input by also inheriting the AjPVarin input object.
XX
TN AjSAssemload
TD
TX
TN AjOAssemload
TD
TX
AN Assem
AT AjPAssem
AD Current variation
AX
AN Assemin
AT AjPAssemin
AD Assembly input for reading next
AX
AN Count
AT ajuint
AD Count of terms so far
AX
AN Loading
AT AjBool
AD True if data is now loading
AX
AN Returned
AT AjBool
AD if true: Assembly object has been returned to a new
AD owner and is not to be deleted by the destructor
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSAssemload
{
AjPAssem Assem;
AjPAssemin Assemin;
ajuint Count;
AjBool Loading;
AjBool Returned;
ajuint Padding;
} AjOAssemload;
#define AjPAssemload AjOAssemload*
ID AjPAssemAccess
TY public
MO ajassemdata
LB core
XX
DE Ajax assembly access database reading object.
DE
DE Holds information needed to read an assembly entry from a database.
DE Access methods are defined for each known database type.
DE
DE Assembly entries are read from the database using the defined
DE database access function, which is usually a static function
DE within ajassemdb.c
DE
DE This should be a static data object but is needed for the definition
DE of AjPAssemin.
XX
TN AjSAssemAccess
TD
TX
TN AjOAssemAccess
TD
TX
AN Name
AT const char*
AD Access method name used in emboss.default
AX
AN Access
AT AjBool function
AD Access function
AX
AN AccessFree
AT AjBool function
AD Access cleanup function
AX
AN Qlink
AT const char*
AD Supported query link operators
AX
AN Desc
AT const char*
AD Description
AX
AN Alias
AT AjBool
AD Alias for another name
AX
AN Entry
AT AjBool
AD Supports retrieval of single entries
AX
AN Query
AT AjBool
AD Supports retrieval of selected entries
AX
AN All
AT AjBool
AD Supports retrieval of all entries
AX
AN Chunked
AT AjBool
AD Supports retrieval of entries in chunks
AX
AN Padding
AT AjBool
AD Padding to alignment boundary
AX
//
typedef struct AjSAssemAccess
{
const char *Name;
AjBool (*Access) (AjPAssemin assemin);
AjBool (*AccessFree) (void* qry);
const char* Qlink;
const char* Desc;
AjBool Alias;
AjBool Entry;
AjBool Query;
AjBool All;
AjBool Chunked;
AjBool Padding;
} AjOAssemAccess;
#define AjPAssemAccess AjOAssemAccess*
ID AjPAssemTag
TY public
MO ajassemdata
LB core
XX
DE Ajax AssemTag object to store MIRA tags for the read sequences as well as
DE the contig consensus sequences.
DE
DE SAM format also allows a set of predefined tags
DE as well as it reserves lowercase tags for end users.
XX
AN Name
AT AjPStr
AD Name
AX
AN Comment
AT AjPStr
AD Tag comment in case of MAF,
AD or tag value in case of SAM
AX
AN x1
AT ajuint
AD X value
AX
AN y1
AT ajuint
AD Y value
AX
AN type
AT char
AD Value type: AcCsSiIfZHB
AX
AN Padding
AT char[7]
AD Padding to alignment boundary
AX
//
typedef struct AjSAssemTag
{
AjPStr Name;
AjPStr Comment;
ajuint x1;
ajuint y1;
char type;
char Padding[7];
} AjOAssemTag;
#define AjPAssemTag AjOAssemTag*
ID AjPAssemReadalignmentblock
TY public
MO ajassemdata
LB core
XX
DE read alignment block
XX
AN readStart
AT int
AD Read start
AX
AN referenceStart
AT int
AD Reference start
AX
AN length
AT int
AD alignment length
AX
//
typedef struct AjSAssemReadalignmentblock
{
int readStart;
int referenceStart;
int length;
} AjOAssemReadalignmentblock;
#define AjPAssemReadalignmentblock AjOAssemReadalignmentblock*
ID AjPAssemReadgroup
TY public
MO ajassemdata
LB core
XX
DE read-group object to store information about read groups as described
DE in SAM spec.
XX
AN ID
AT AjPStr
AD Read group identifier
AX
AN CN
AT AjPStr
AD Name of the sequencing center producing the read
AX
AN Desc
AT AjPStr
AD Description
AX
AN Date
AT AjPStr
AD Date the run was produced
AX
AN FlowOrder
AT AjPStr
AD The array of nucleotide bases that correspond to
AD the nucleotides used for each flow of each record
AX
AN KeySeq
AT AjPStr
AD The array of nucleotide bases that correspond to
AD the key sequence of each read
AX
AN Library
AT AjPStr
AD Library
AX
AN Programs
AT AjPStr
AD Programs used for processing the read group
AX
AN Unit
AT AjPStr
AD Platform unit (e.g. flowcell-barcode for Illumina)
AX
AN Sample
AT AjPStr
AD Sample name, or pool name when a pool was sequenced
AX
AN Isize
AT ajint
AD Predicted median insert size
AX
AN Platform
AT AjEAssemPlatform
AD Instrument platform
AX
//
typedef struct AjSAssemReadgroup
{
AjPStr ID;
AjPStr CN;
AjPStr Desc;
AjPStr Date;
AjPStr FlowOrder;
AjPStr KeySeq;
AjPStr Library;
AjPStr Programs;
AjPStr Unit;
AjPStr Sample;
ajint Isize;
AjEAssemPlatform Platform;
} AjOAssemReadgroup;
#define AjPAssemReadgroup AjOAssemReadgroup*
ID pair64_t
TY public
MO ajbamindex
LB core
XX
DE A [start,stop) file pointer pairing into the BAM file, stored
DE as a BAM file index. A chunk is represented as a single 64-bit
DE value where the high-order 48 bits point to the location of the
DE start of a compressed BGZF block within a BGZF file and the
DE low-order 16 bits point to a position within the decompressed
DE data in the BGZF block.
DE ref: Chunk.java in picard project
XX
AN u
AT ajulong
AD virtual file offset of the start of the chunk
AX
AN v
AT ajulong
AD virtual file offset of the end of the chunk
AX
//
typedef struct pair64_t
{
ajulong u;
ajulong v;
} pair64_t;
ID bam_binlist_t
TY public
MO ajbamindex
LB core
XX
DE bin object in a binning index for a reference sequence
XX
AN m
AT ajuint
AD allocated size of the chunk array
AD and is always >= n
AX
AN n
AT ajuint
AD number of chunks
AX
AN list
AT pair64_t*
AD array of BAM file chunk start/stop offsets
AX
//
typedef struct bam_binlist_t
{
ajuint m;
ajuint n;
pair64_t *list;
} bam_binlist_t;
ID bam_lidx_t
TY public
MO ajbamindex
LB core
XX
DE linear index for a reference sequence
XX
AN n
AT ajint
AD number of chunks
AX
AN m
AT ajint
AD allocated size of the list or offset array
AD and is always >= n
AX
AN offset
AT ajulong*
AD Array of offsets
AX
//
typedef struct bam_lidx_t
{
ajint n;
ajint m;
ajulong *offset;
} bam_lidx_t;
ID AjPBamIndex
TY public
MO ajbamindex
LB core
XX
DE Structure for BAM indexes. (samtools name: bam_index_t)
XX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN n
AT ajint
AD number of reference sequences
AX
AN n_no_coor
AT ajulong
AD unmapped reads without coordinate
AX
AN bindex
AT AjPTable*
AD list of binning indices
AX
AN index2
AT bam_lidx_t*
AD list of intervals for the linear index
AX
//
typedef struct AjSBamIndex
{
ajuint Padding;
ajint n;
ajulong n_no_coor;
AjPTable* bindex;
bam_lidx_t *index2;
} AjOBamIndex;
#define AjPBamIndex AjOBamIndex*
ID bam_fetch_f
TY typedef
MO ajbamindex
LB core
XX
DE Type of function to be called by ajBamFetch().
XX
AN typedef
AT int
AD Value returned
AX
//
typedef int (*bam_fetch_f)(AjPSeqBam b, void *data);
ID AjPCod
TY public
MO ajcod
LB core
XX
DE Ajax codon object.
DE
DE Holds arrays describing codon usage
DE The length is known and held internally.
DE
DE AjPCod is implemented as a pointer to a C data structure.
XX
TN AjSCod
TD
TX
TN AjOCod
TD
TX
AN Name
AT AjPStr
AD Name of codon file
AX
AN Species
AT AjPStr
AD Species
AX
AN Division
AT AjPStr
AD Division (gbbct etc.)
AX
AN Release
AT AjPStr
AD Database name and release
AX
AN Desc
AT AjPStr
AD Description
AX
AN CdsCount
AT ajint
AD Number of coding sequences used
AX
AN CodonCount
AT ajint
AD Number of individual codons used
AX
AN aa
AT ajint*
AD Amino acid represented by codon
AX
AN num
AT ajint*
AD Number of codons
AX
AN tcount
AT double*
AD Codons per thousand
AX
AN fraction
AT double*
AD Fraction of amino acids of this type
AX
AN back
AT ajint*
AD Index of favoured amino acid for back translation
AX
AN GeneticCode
AT ajint
AD Genetic code NCBI number to match
AD amino acids to codons.
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSCod
{
AjPStr Name;
AjPStr Species;
AjPStr Division;
AjPStr Release;
AjPStr Desc;
ajint CdsCount;
ajint CodonCount;
ajint *aa;
ajint *num;
double *tcount;
double *fraction;
ajint *back;
ajint GeneticCode;
char Padding[4];
} AjOCod;
#define AjPCod AjOCod*
ID AjPMelt
TY public
MO ajdan
LB core
XX
DE Melting values for di-nucleotides
XX
TN AjSMelt
TD
TX
TN AjOMelt
TD
TX
AN pair
AT AjPStr
AD Di-nucleotide
AX
AN enthalpy
AT float
AD Enthalpy
AX
AN entropy
AT float
AD Entropy
AX
AN energy
AT float
AD Free energy
AX
AN Padding
AT char[4]
AD Padding
AX
//
typedef struct AjSMelt
{
AjPStr pair;
float enthalpy;
float entropy;
float energy;
char Padding[4];
} AjOMelt;
#define AjPMelt AjOMelt*
ID AjPDasCoordinate
TY public
MO ajdas
LB ajaxdb
XX
DE Description of the namespace/coordinate of a DAS source
XX
AN uri
AT AjPStr
AD the unique URI for a DAS source. For a DAS registration
AD server it should allow to access more information
AD about the coordinate/namespace
AX
AN taxid
AT AjPStr
AD NCBI taxonomy id of the organism, as a number
AX
AN source
AT AjPStr
AD type of the sources for the coordinate system,
AD such as chromosome, scaffold, supercontig
AX
AN authority
AT AjPStr
AD name of the organization that determined
AD the coordinate system
AX
AN test_range
AT AjPStr
AD example id with start/stop positions
AX
AN version
AT AjPStr
AD version of the build upon which
AD the coordinate system is based
AX
//
typedef struct AjSDasCoordinate
{
AjPStr uri;
AjPStr taxid;
AjPStr source;
AjPStr authority;
AjPStr test_range;
AjPStr version;
} AjODasCoordinate;
#define AjPDasCoordinate AjODasCoordinate*
ID AjPDasSource
TY public
MO ajdas
LB ajaxdb
XX
DE DAS Source
XX
AN uri
AT AjPStr
AD a unique URI for the DAS source
AX
AN title
AT AjPStr
AD nickname
AX
AN description
AT AjPStr
AD description
AX
AN entry_points_uri
AT AjPStr
AD URI for the DAS 'entry_points' command
AX
AN sequence_query_uri
AT AjPStr
AD URI for the DAS 'sequence' command
AX
AN features_query_uri
AT AjPStr
AD URI for the DAS 'features' command
AX
AN coordinates
AT AjPList
AD list of supported coordinates
AX
AN sequence
AT AjBool
AD whether 'sequence' queries are supported
AX
AN stylesheet
AT AjBool
AD whether 'stylesheet' queries are supported
AX
AN features
AT AjBool
AD whether 'features' queries are supported
AX
AN entry_points
AT AjBool
AD whether 'entry_points' queries are supported
AX
//
typedef struct AjSDasSource
{
AjPStr uri;
AjPStr title;
AjPStr description;
AjPStr entry_points_uri;
AjPStr sequence_query_uri;
AjPStr features_query_uri;
AjPList coordinates;
AjBool sequence;
AjBool stylesheet;
AjBool features;
AjBool entry_points;
} AjODasSource;
#define AjPDasSource AjODasSource*
ID AjPDasSegment
TY public
MO ajdas
LB ajaxdb
XX
DE DAS Segment
DE
DE segment elements are returned by DAS 'entry_points' query
XX
AN id
AT AjPStr
AD unique identifier
AX
AN type
AT AjPStr
AD type of the segment, such as "chromosome" or "scaffold"
AX
AN start
AT ajuint
AD start position of the segment
AX
AN stop
AT ajuint
AD stop position of the segment
AX
AN orientation
AT AjPStr
AD orientation is one of "+" or "-"
AD and indicates the strandedness of the segment
AD ("+" if the segment is not intrinsically ordered)
AX
AN subparts
AT AjBool
AD "yes" indicates that the segment has subparts
AX
AN padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSDasSegment
{
AjPStr id;
AjPStr type;
ajuint start;
ajuint stop;
AjPStr orientation;
AjBool subparts;
char padding[4];
} AjODasSegment;
#define AjPDasSegment AjODasSegment*
ID AjPDasServer
TY public
MO ajdas
LB ajaxdb
XX
DE DAS server object
XX
AN host
AT AjPStr
AD host-name
AX
AN path
AT AjPStr
AD path to DAS service on host
AX
AN port
AT ajuint
AD URL port
AX
AN padding
AT char[4]
AD Padding to alignment boundary
AX
AN sources
AT AjPList
AD list of available DAS sources on the server
AX
//
typedef struct AjSDasServer
{
AjPStr host;
AjPStr path;
ajuint port;
char padding[4];
AjPList sources;
} AjODasServer;
#define AjPDasServer AjODasServer*
ID AjPScophit
TY public
MO ajdmx
LB core
XX
DE AJAX SCOP Hit object
DE
DE Holds data associated with a protein / domain sequence. Includes SCOP
DE classification records.
DE
DE AjPScophit is implemented as a pointer to a C data structure.
XX
TN AjSScophit
TD
TX
TN AjOScophit
TD
TX
AN Class
AT AjPStr
AD Class name
AX
AN Architecture
AT AjPStr
AD CATH classification.
AX
AN Topology
AT AjPStr
AD CATH classification.
AX
AN Fold
AT AjPStr
AD Fold name
AX
AN Superfamily
AT AjPStr
AD Superfamily name
AX
AN Family
AT AjPStr
AD Family name
AX
AN Type
AT AjEDomainType
AD AJAX Domain Type enumeration
AX
AN Sunid_Family
AT ajuint
AD Domain identifier of node (e.g. family or
AD superfamily) represented.
AX
AN Seq
AT AjPStr
AD Sequence as string
AX
AN Start
AT ajuint
AD Start of sequence or signature alignment
AD relative to full length swissprot sequence
AX
AN End
AT ajuint
AD End of sequence or signature alignment relative
AD to full length swissprot sequence
AX
AN Acc
AT AjPStr
AD Accession number of sequence entry
AX
AN Spr
AT AjPStr
AD Swissprot code of sequence entry
AX
AN Dom
AT AjPStr
AD SCOP or CATH database identifier code of entry.
AX
AN Typeobj
AT AjPStr
AD Bibliographic information ... objective
AX
AN Typesbj
AT AjPStr
AD Bibliographic information ... subjective
AX
AN Model
AT AjPStr
AD String for model type (HMM, Gribskov etc)
AX
AN Group
AT AjPStr
AD 'REDUNDANT' or 'NON_REDUNDANT'
AX
AN Rank
AT ajuint
AD Rank order of hit
AX
AN Score
AT float
AD Score of hit
AX
AN Eval
AT float
AD E-value of hit
AX
AN Pval
AT float
AD p-value of hit
AX
AN Alg
AT AjPStr
AD Alignment, e.g. of a signature to the sequence
AX
AN Target
AT AjBool
AD True if the Scophit is targeted for removal
AD from a list of Scophit objects
AX
AN Target2
AT AjBool
AD Also used for garbage collection
AX
AN Priority
AT AjBool
AD True if the Scop hit is high priority
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajDmxScophitNew
ND Default Scophit object constructor.
NX
DN ajDmxScophitDel
DD Default Scophit object destructor.
DX
DN ajDmxScophitDelWrap
DD Wrapper to destructor for Scophit object
DD for use with generic functions.
DX
EN ajDmxScophitListCopy
ED Reads a list of Scophit structures and
ED returns a pointer to a duplicate of the list.
EX
ON ajDmxScophitCheckTarget
OD Checks to see if the Target element of a
OD Scophit object == ajTrue.
OX
MN ajDmxScophitTarget
MD Sets the Target element of a Scophit object
MD to True.
MX
MN ajDmxScophitTarget2
MD Sets the Target2 element of a Scophit object
MD to True.
MX
MN ajDmxScophitTargetLowPriority
MD Sets the Target element of a
MD Scophit object to True if its Priority is low.
MX
ON ajDmxScophitCompSpr
OD Function to sort Scophit object by Spr element.
OX
ON ajDmxScophitCompStart
OD Function to sort Scophit object by Spr
OD element.
OX
ON ajDmxScophitCompEnd
OD Function to sort Scophit object by End element.
OX
ON ajDmxScophitCompClass
OD Function to sort Scophit object by Class
OD element.
OX
ON ajDmxScophitCompFold
OD Function to sort Scophit object by Fold
OD element.
OX
ON ajDmxScophitCompSfam
OD Function to sort Scophit object by Superfamily
OD element.
OX
ON ajDmxScophitCompFam
OD Function to sort Scophit object by Family
OD element.
OX
ON ajDmxScophitCompAcc
OD Function to sort Scophit objects by Acc element.
OX
ON ajDmxScophitCompSunid
OD Function to sort Scophit objects by Sunid
OD element.
OX
ON ajDmxScophitCompScore
OD Function to sort Scophit objects by Score
OD element.
OX
ON ajDmxScophitCompPval
OD Function to sort Scophit objects by Pval
OD element.
OX
ON ajDmxScopSeqFromSunid
OD Writes a sequence corresponding to a Scop
OD domain given a Sunid for the domain. The sequence is taken from one
OD of a list of Scop objects that is provided.
OX
PN ajDmxScophitsWrite
PD Write contents of a list of Scophits to an output
PD file.
PX
PN ajDmxScophitsWriteFasta
PD Write contents of a list of Scophits to an
PD output file in extended FASTA format.
PX
JN ajDmxScophitReadFasta
JD Read a Scophit object from a file in
JD extended FASTA format.
JX
EN ajDmxScophitCopy
ED Copies the contents from one Scophit object to
ED another.
EX
//
typedef struct AjSScophit
{
AjPStr Class;
AjPStr Architecture;
AjPStr Topology;
AjPStr Fold;
AjPStr Superfamily;
AjPStr Family;
AjEDomainType Type;
ajuint Sunid_Family;
AjPStr Seq;
ajuint Start;
ajuint End;
AjPStr Acc;
AjPStr Spr;
AjPStr Dom;
AjPStr Typeobj;
AjPStr Typesbj;
AjPStr Model;
AjPStr Group;
ajuint Rank;
float Score;
float Eval;
float Pval;
AjPStr Alg;
AjBool Target;
AjBool Target2;
AjBool Priority;
char Padding[4];
} AjOScophit, *AjXScophit;
#define AjPScophit AjOScophit*
ID AjPScopalg
TY public
MO ajdmx
LB core
XX
DE AJAX SCOP Alignment object
DE
DE Holds data associated with a structure alignment.
DE Now adapted to hold CATH domain data also by addition of Type,
DE Architecture and Topology elements.
DE
DE AjPScopalg is implemented as a pointer to a C data structure.
XX
TN AjSScopalg
TD
TX
TN AjOScopalg
TD
TX
AN Class
AT AjPStr
AD Class name
AX
AN Architecture
AT AjPStr
AD CATH classification.
AX
AN Topology
AT AjPStr
AD CATH classification.
AX
AN Fold
AT AjPStr
AD Fold name
AX
AN Superfamily
AT AjPStr
AD Superfamily name
AX
AN Family
AT AjPStr
AD Family name (SCOP only)
AX
AN Sunid_Family
AT ajuint
AD SCOP sunid for family
AX
AN Width
AT ajuint
AD Width (residues) of widest part of alignment
AX
AN Type
AT AjEDomainType
AD AJAX Domain Type enumeration
AX
AN Number
AT ajuint
AD No. of sequences in alignment
AX
AN Codes
AT AjPStr*
AD Array of domain id codes of sequences
AX
AN Seqs
AT AjPStr*
AD Array of sequences
AX
AN Post_similar
AT AjPStr
AD Post_similar line from alignment
AX
AN Positions
AT AjPStr
AD Array of integers from 'Position' line in
AD alignment, used for manual specification of
AD signature positions
AX
NN ajDmxScopalgRead
ND Read a Scopalg object from a file.
NX
PN ajDmxScopalgWrite
PD Write a Scopalg object to file in clustal format
PD annotated with SCOP classification info.
PX
PN ajDmxScopalgWriteClustal
PD Writes a Scopalg object to file in clustal
PD format (just the alignment without the SCOP classification
PD information).
PX
PN ajDmxScopalgWriteClustal2
PD Writes a Scopalg object to file in clustal
PD format (just the alignment without the SCOP classification
PD information).
PX
PN ajDmxScopalgWriteFasta
PD Writes a Scopalg object to file in clustal
PD format (just the alignment without the SCOP classification
PD information).
PX
NN ajDmxScopalgNew
ND Scopalg object constructor.
NX
DN ajDmxScopalgDel
DD Scopalg object destructor.
DX
JN ajDmxScopalgGetseqs
JD Read a Scopalg object and writes an array of
JD AjPStr containing the sequences without gaps.
JX
//
typedef struct AjSScopalg
{
AjPStr Class;
AjPStr Architecture;
AjPStr Topology;
AjPStr Fold;
AjPStr Superfamily;
AjPStr Family;
ajuint Sunid_Family;
ajuint Width;
AjEDomainType Type;
ajuint Number;
AjPStr *Codes;
AjPStr *Seqs;
AjPStr Post_similar;
AjPStr Positions;
} AjOScopalg;
#define AjPScopalg AjOScopalg*
ID AjEDomNodeType
TY public
MO ajdom
LB core
XX
DE AJAX DOM Node Type enumeration
XX
VN ajEDomNodeTypeNULL
VD NULL
VX
VN ajEDomNodeTypeElement
VD Element
VX
VN ajEDomNodeTypeAttribute
VD Attribute
VX
VN ajEDomNodeTypeText
VD Text
VX
VN ajEDomNodeTypeCdataSection
VD CDATA Section
VX
VN ajEDomNodeTypeEntityReference
VD Entity Reference
VX
VN ajEDomNodeTypeEntityNode
VD Entity
VX
VN ajEDomNodeTypeProcessingInstruction
VD Processing Instruction
VX
VN ajEDomNodeTypeComment
VD Comment
VX
VN ajEDomNodeTypeDocumentNode
VD Document
VX
VN ajEDomNodeTypeDocumentType
VD Document Type
VX
VN ajEDomNodeTypeDocumentFragment
VD Document Fragment
VX
VN ajEDomNodeTypeNotation
VD Notation
VX
//
typedef enum AjODomNodeType
{
ajEDomNodeTypeNULL,
ajEDomNodeTypeElement,
ajEDomNodeTypeAttribute,
ajEDomNodeTypeText,
ajEDomNodeTypeCdataSection,
ajEDomNodeTypeEntityReference,
ajEDomNodeTypeEntityNode,
ajEDomNodeTypeProcessingInstruction,
ajEDomNodeTypeComment,
ajEDomNodeTypeDocumentNode,
ajEDomNodeTypeDocumentType,
ajEDomNodeTypeDocumentFragment,
ajEDomNodeTypeNotation
} AjEDomNodeType;
ID AjSDomNode
TY public
MO ajdom
LB core
XX
DE DOM parsing node
XX
TN AjODomNode
TD
TX
TN AjPDomNode
TD
TX
TN AjPDomDocument
TD
TX
TN AjPDomDocumentType
TD
TX
TN AjPDomElement
TD
TX
TN AjPDomText
TD
TX
TN AjPDomCharacterData
TD
TX
TN AjPDomDocumentFragment
TD
TX
TN AjPDomCDATASection
TD
TX
TN AjPDomComment
TD
TX
TN AjPDomAttr
TD
TX
TN AjPDomEntityReference
TD
TX
TN AjPDomEntity
TD
TX
TN AjPDomPi
TD
TX
TN AjPDomNotation
TD
TX
AN name
AT AjPStr
AD name of node
AX
AN value
AT AjPStr
AD value associated with name
AX
AN parentnode
AT struct AjSDomNode*
AD ancestor
AX
AN childnodes
AT struct AjSDomNodeList*
AD children
AX
AN firstchild
AT struct AjSDomNode*
AD first child in list
AX
AN lastchild
AT struct AjSDomNode*
AD last child in list
AX
AN previoussibling
AT struct AjSDomNode*
AD last node at this level
AX
AN nextsibling
AT struct AjSDomNode*
AD next node at this level
AX
AN attributes
AT struct AjSDomNodeList*
AD attributes
AX
AN ownerdocument
AT struct AjSDomNode*
AD document owner
AX
AN sub
AT union
AD substructure depending on node type
AX
AN type
AT AjEDomNodeType
AD AJAX DOM Node enumeration
AX
AN subtreeModified
AT ajuint
AD internal flag
AX
//
typedef struct AjSDomNode
{
AjPStr name;
AjPStr value;
struct AjSDomNode *parentnode;
struct AjSDomNodeList *childnodes;
struct AjSDomNode *firstchild;
struct AjSDomNode *lastchild;
struct AjSDomNode *previoussibling;
struct AjSDomNode *nextsibling;
struct AjSDomNodeList *attributes;
struct AjSDomNode *ownerdocument;
union
{
struct
{
struct AjSDomNode *doctype;
struct AjSDomNode *documentelement;
struct AjSDomNode *document;
struct AjSDomNode *defaultview;
struct AjSDomNode *commonparent;
AjPStr version;
AjPStr encoding;
ajint standalone;
char Padding[4];
} Document;
struct
{
AjPStr name;
struct AjSDomNodeList *entities;
struct AjSDomNodeList *notations;
AjPStr publicid;
AjPStr systemid;
AjPStr internalsubset;
} DocumentType;
struct
{
AjPStr tagname;
} Element;
struct
{
AjPStr name;
AjPStr value;
struct AjSDomNode *ownerelement;
ajint specified;
char Padding[4];
} Attr;
struct
{
AjPStr data;
ajint length;
char Padding[4];
} CharacterData;
struct
{
AjPStr publicid;
AjPStr systemid;
} Notation;
struct
{
AjPStr publicid;
AjPStr systemid;
AjPStr notationname;
} Entity;
struct
{
AjPStr target;
AjPStr data;
} ProcessingInstruction;
} sub;
AjEDomNodeType type;
ajuint subtreeModified;
} AjODomNode;
#define AjPDomNode AjODomNode*
/* @data AjSDomNodeEntry ******************************************************
**
** DOM parsing node entry
**
** @alias AjODomNodeEntry
** @alias AjPDomNodeEntry
**
** @attr prev [struct AjSDomNodeEntry*] previous node
** @attr next [struct AjSDomNodeEntry*] next node
** @attr node [AjPDomNode] linked list node
**
******************************************************************************/
typedef struct AjSDomNodeEntry
{
struct AjSDomNodeEntry *prev;
ID AjSDomNodeEntry
TY public
MO ajdom
LB core
XX
DE DOM parsing node entry
XX
TN AjODomNodeEntry
TD
TX
TN AjPDomNodeEntry
TD
TX
AN prev
AT struct AjSDomNodeEntry*
AD previous node
AX
AN next
AT struct AjSDomNodeEntry*
AD next node
AX
AN node
AT AjPDomNode
AD linked list node
AX
//
typedef struct AjSDomNodeEntry
{
struct AjSDomNodeEntry *prev;
struct AjSDomNodeEntry *next;
AjPDomNode node;
} AjODomNodeEntry;
#define AjPDomNodeEntry AjODomNodeEntry*
ID AjSDomNodeList
TY public
MO ajdom
LB core
XX
DE DOM parsing node list
XX
TN AjODomNodeList
TD
TX
TN AjPDomNodeList
TD
TX
TN AjPDomNodeMap
TD
TX
AN ownerdocument
AT AjPDomNode
AD document owner
AX
AN ownerelement
AT AjPDomNode
AD element owner
AX
AN first
AT AjPDomNodeEntry
AD first in list
AX
AN last
AT AjPDomNodeEntry
AD last in list
AX
AN length
AT ajint
AD length
AX
AN filter
AT ajuint
AD filter
AX
AN list
AT struct AjSDomNodeList*
AD list
AX
AN table
AT AjPTable
AD fast lookup table
AX
//
typedef struct AjSDomNodeList
{
AjPDomNode ownerdocument;
AjPDomNode ownerelement;
AjPDomNodeEntry first;
AjPDomNodeEntry last;
ajint length;
ajuint filter;
struct AjSDomNodeList *list;
AjPTable table;
} AjODomNodeList;
#define AjPDomNodeList AjODomNodeList*
ID AjSDomUserdata
TY public
MO ajdom
LB core
XX
DE DOM Userdata used when reading XML
XX
TN AjODomUserdata
TD
TX
TN AjPDomUserdata
TD
TX
AN Buffer
AT AjPStr
AD Utility string
AX
AN Stack
AT AjPList
AD Stack
AX
AN Cdata
AT AjBool
AD Cdata
AX
AN Padding
AT AjBool
AD Pad to alignment boundary
AX
//
typedef struct AjSDomUserdata
{
AjPStr Buffer;
AjPList Stack;
AjBool Cdata;
AjBool Padding;
} AjODomUserdata;
#define AjPDomUserdata AjODomUserdata*
ID AjEDomainType
TY public
MO ajdomain
LB core
XX
DE AJAX Domain Type enumeration
XX
VN ajEDomainTypeNULL
VD NULL
VX
VN ajEDomainTypeCATH
VD CATH
VX
VN ajEDomainTypeSCOP
VD SCOP
VX
//
typedef enum AjODomainType
{
ajEDomainTypeNULL,
ajEDomainTypeCATH,
ajEDomainTypeSCOP
} AjEDomainType;
ID AjPScop
TY public
MO ajdomain
LB core
XX
DE AJAX SCOP object
DE
DE Holds SCOP database data
XX
TN AjSScop
TD
TX
TN AjOScop
TD
TX
AN Entry
AT AjPStr
AD Domain identifier code
AX
AN Pdb
AT AjPStr
AD Corresponding pdb identifier code
AX
AN Class
AT AjPStr
AD SCOP class name as an AjPStr
AX
AN Fold
AT AjPStr
AD SCOP fold name as an AjPStr
AX
AN Superfamily
AT AjPStr
AD SCOP superfamily name as an AjPStr
AX
AN Family
AT AjPStr
AD SCOP family name as an AjPStr
AX
AN Domain
AT AjPStr
AD SCOP domain name as an AjPStr
AX
AN Source
AT AjPStr
AD SCOP source (species) as an AjPStr
AX
AN Chain
AT char*
AD Chain identifiers
AX
AN Start
AT AjPStr*
AD PDB residue number of first residue in domain
AX
AN End
AT AjPStr*
AD PDB residue number of last residue in domain
AX
AN Sse
AT AjPStr
AD Secondary structure element map
AX
AN Sss
AT AjPStr
AD Secondary structure element string
AX
AN Number
AT ajuint
AD Number of chains from which this domain is comprised
AX
AN Sunid_Class
AT ajint
AD SCOP sunid for class
AX
AN Sunid_Fold
AT ajint
AD SCOP sunid for fold
AX
AN Sunid_Superfamily
AT ajint
AD SCOP sunid for superfamily
AX
AN Sunid_Family
AT ajint
AD SCOP sunid for family
AX
AN Sunid_Domain
AT ajint
AD SCOP sunid for domain
AX
AN Sunid_Source
AT ajint
AD SCOP sunid for species
AX
AN Sunid_Domdat
AT ajint
AD SCOP sunid for domain data
AX
AN Acc
AT AjPStr
AD Accession number of sequence entry
AX
AN Spr
AT AjPStr
AD Swissprot code of sequence entry
AX
AN SeqPdb
AT AjPStr
AD Sequence (from PDB) as string
AX
AN SeqSpr
AT AjPStr
AD Sequence (from swissprot) as string
AX
AN Startd
AT ajint
AD Start of sequence relative to full
AD length swissprot sequence
AX
AN Endd
AT ajint
AD End of sequence relative to full length
AD swissprot sequence
AX
AN Score
AT float
AD Used by misc. algorithms for scoring the domain
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajScopNew
ND Scop default constructor
NX
NN ajScopReadNew
ND Scop constructor from reading DCF format file
NX
NN ajScopReadCNew
ND Scop constructor from reading DCF format file
NX
DN ajScopDel
DD Default Scop destructor
DX
EN ajScopCopy
ED Replicates a Scop object
EX
ON ajScopMatchSunid
OD Sort Scop objects by Sunid_Family element
OX
ON ajScopMatchScopid
OD Sort Scop objects by Entry element
OX
ON ajScopMatchPdbId
OD Sort Scop objects by Pdb element
OX
ON embScopToPdbid
OD Read a scop identifier code and writes the
OD equivalent PDB identifier code
OX
ON embScopToSp
OD Read a scop identifier code and writes the
OD equivalent swissprot identifier code
OX
ON embScopToAcc
OD Read a scop identifier code and writes the
OD equivalent accession number
OX
ON ajScopArrFindScopid
OD Binary search for Entry element over array
OD of Scop objects
OX
ON ajScopArrFindSunid
OD Binary search for Sunid_Family element over
OD array of Scop objects
OX
ON ajScopArrFindPdbid
OD Binary search for Pdb element over array of
OD Scop objects
OX
NN ajScopReadAllNew
ND Construct list of Scop objects from reading DCF
ND format file
NX
NN ajScopReadAllRawNew
ND Construct list of Scop objects from reading
ND raw SCOP parsable files
NX
PN ajScopWrite
PD Write Scop object to DCF format file
PX
PN ajPdbWriteDomain
PD Writes a CCF format file for a SCOP domain
PX
PN ajPdbWriteDomainRaw
PD Writes a PDB-format file for a SCOP domain
PX
PN ajPdbWriteDomainRecordRaw
PD Writes lines to a PDB format file for
PD a domain
PX
//
typedef struct AjSScop
{
AjPStr Entry;
AjPStr Pdb;
AjPStr Class;
AjPStr Fold;
AjPStr Superfamily;
AjPStr Family;
AjPStr Domain;
AjPStr Source;
char *Chain;
AjPStr *Start;
AjPStr *End;
AjPStr Sse;
AjPStr Sss;
ajuint Number;
ajint Sunid_Class;
ajint Sunid_Fold;
ajint Sunid_Superfamily;
ajint Sunid_Family;
ajint Sunid_Domain;
ajint Sunid_Source;
ajint Sunid_Domdat;
AjPStr Acc;
AjPStr Spr;
AjPStr SeqPdb;
AjPStr SeqSpr;
ajint Startd;
ajint Endd;
float Score;
char Padding[4];
} AjOScop;
#define AjPScop AjOScop*
ID AjPCath
TY public
MO ajdomain
LB core
XX
DE Ajax cath object
DE
DE Holds cath database data
DE
DE AjPScop is implemented as a pointer to a C data structure.
XX
TN AjSCath
TD
TX
TN AjOCath
TD
TX
AN DomainID
AT AjPStr
AD Domain identifier code
AX
AN Pdb
AT AjPStr
AD Corresponding PDB identifier code
AX
AN Class
AT AjPStr
AD CATH class name as an AjPStr
AX
AN Architecture
AT AjPStr
AD CATH architecture name as an AjPStr
AX
AN Topology
AT AjPStr
AD CATH topology name as an AjPStr
AX
AN Superfamily
AT AjPStr
AD CATH homologous superfamily name as an AjPStr
AX
AN Length
AT ajint
AD No. of residues in domain
AX
AN NSegment
AT ajuint
AD Number of chain segments domain is comprised of
AX
AN Start
AT AjPStr*
AD PDB residue number of 1st residue in segment
AX
AN End
AT AjPStr*
AD PDB residue number of last residue in segment
AX
AN Class_Id
AT ajint
AD CATH class no. as an ajint
AX
AN Arch_Id
AT ajint
AD CATH architecture no.as an ajint
AX
AN Topology_Id
AT ajint
AD CATH topology no. as an ajint
AX
AN Superfamily_Id
AT ajint
AD CATH superfamily no. as an ajint
AX
AN Family_Id
AT ajint
AD CATH family no. as an ajint
AX
AN NIFamily_Id
AT ajint
AD CATH near identical family no. as an ajint
AX
AN Acc
AT AjPStr
AD Accession number of sequence entry.
AX
AN Spr
AT AjPStr
AD Swissprot code of sequence entry.
AX
AN SeqPdb
AT AjPStr
AD Sequence (from PDB) as string.
AX
AN SeqSpr
AT AjPStr
AD Sequence (from swissprot) as string.
AX
AN IFamily_Id
AT ajint
AD CATH identical family no. as an ajint
AX
AN Startd
AT ajint
AD Start of sequence relative to full
AD length swissprot sequence.
AX
AN Endd
AT ajint
AD End of sequence relative to full length
AD swissprot sequence.
AX
AN Chain
AT char
AD Chain identifier
AX
AN Padding
AT char[3]
AD Padding to alignment boundary
AX
NN ajCathNew
ND Default Cath constructor
NX
NN ajCathReadCNew
ND Cath constructor from reading DCF format file.
NX
NN ajCathReadNew
ND Cath constructor from reading DCF format file.
NX
DN ajCathDel
DD Default Cath destructor
DX
EN ajCathCopy
ED Replicates a Scop object.
EX
ON ajCathArrFindPdbid
OD Binary search for Pdb element over array of
OD Cath objects.
OX
ON ajCathMatchPdbId
OD Sort Cath objects by Pdb element.
OX
NN ajCathReadAllNew
ND Construct list of Cath objects from reading DCF
ND format file.
NX
NN ajCathReadAllRawNew
ND Construct list of Cath objects from reading
ND raw CATH parsable files.
NX
RN ajCathWrite
RD Write Cath object to DCF format file.
RX
//
typedef struct AjSCath
{
AjPStr DomainID;
AjPStr Pdb;
AjPStr Class;
AjPStr Architecture;
AjPStr Topology;
AjPStr Superfamily;
ajint Length;
ajuint NSegment;
AjPStr *Start;
AjPStr *End;
ajint Class_Id;
ajint Arch_Id;
ajint Topology_Id;
ajint Superfamily_Id;
ajint Family_Id;
ajint NIFamily_Id;
AjPStr Acc;
AjPStr Spr;
AjPStr SeqPdb;
AjPStr SeqSpr;
ajint IFamily_Id;
ajint Startd;
ajint Endd;
char Chain;
char Padding[3];
} AjOCath;
#define AjPCath AjOCath*
ID AjPDomain
TY public
MO ajdomain
LB core
XX
DE Ajax Domain object.
DE
DE Holds an entry from a DCF file (domain classification file)
DE
DE AjPDomain is implemented as a pointer to a C data structure.
XX
TN AjSDomain
TD
TX
TN AjODomain
TD
TX
AN Scop
AT AjPScop
AD Scop object pointer.
AX
AN Cath
AT AjPCath
AD Cath object pointer.
AX
AN Type
AT AjEDomainType
AD AJAX Domain Type enumeration
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajDomainNew
ND Default Domain constructor.
NX
NN ajDomainReadNew
ND Domain constructor from reading DCF format file.
NX
NN ajDomainReadCNew
ND Domain constructor from reading DCF format file.
NX
NN ajDomainReadAllNew
ND Construct list of Domain objects from reading DCF
ND format file.
NX
DN ajDomainDel
DD Default Domain destructor.
DX
PN ajDomainWrite
PD Write Domain object to DCF format file.
PX
RN ajDomainDCFType
RD Ascertains type of domains (ajEDomainTypeSCOP
RD or ajEDomainTypeCATH) in a DCF file.
RX
EN ajDomainCopy
ED Replicates a Domain object.
EX
CN ajDomainGetId
CD Returns domain id, either DomainID element
CD (Cath object) or Entry (Scop object).
CX
CN ajDomainGetSeqPdb
CD Returns the PDB sequence from a Domain object.
CX
CN ajDomainGetSeqSpr
CD Returns the swissprot sequence from a
CD Domain object.
CX
CN ajDomainGetPdb
CD Returns the PDB identifier code corresponding to the
CD domain
CX
CN ajDomainGetAcc
CD Returns the accession number corresponding to the
CD domain.
CX
CN ajDomainGetSpr
CD Returns the swissprot code corresponding to the
CD domain.
CX
CN ajDomainGetN
CD Returns no. chains or chain segments in a domain,
CD either NSegment element (Cath domains) or N element (Scop domains).
CX
//
typedef struct AjSDomain
{
AjPScop Scop;
AjPCath Cath;
AjEDomainType Type;
char Padding[4];
} AjODomain;
#define AjPDomain AjODomain*
ID Except_T
TY public
MO ajexcept
LB core
XX
DE Exception data structure
XX
AN reason
AT const char*
AD Reason for the exception
AX
//
typedef struct Except_T
{
const char *reason;
} Except_T;
ID Except_Frame
TY public
MO ajexcept
LB core
XX
DE Exception frame data structure
XX
AN env
AT jmp_buf
AD Environment jump buffer
AX
AN prev
AT struct Except_Frame*
AD Previous exception if any
AX
AN file
AT const char*
AD source filename usually from __FILE__
AX
AN exception
AT const Except_T*
AD Exception data (reason)
AX
AN line
AT ajint
AD source line number usually from __LINE__
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct Except_Frame
{
jmp_buf env;
struct Except_Frame *prev;
const char *file;
const Except_T *exception;
ajint line;
char Padding[4];
} Except_Frame;
ID AjPFeattable
TY public
MO ajfeatdata
LB core
XX
DE Ajax data type for collecting AjPFeatures in a 'feature table'.
DE The features themselves may be accessed via iteration methods.
XX
TN AjSFeattable
TD
TX
TN AjOFeattable
TD
TX
NN ajFeattableNew
ND Constructor
NX
DN ajFeattableDel
DD Default destructor
DX
MN ajFeattableAdd
MD Adds an AjPFeature to a set
MX
NN ajFeatRead
ND Reads in a feature set in a specified format
NX
AN Seqid
AT AjPStr
AD Sequence name
AX
AN Type
AT AjPStr
AD Sequence type: P or N
AX
AN Features
AT AjPList
AD List of AjPFeatures...
AX
AN Start
AT ajuint
AD First position used (like sequence begin)
AX
AN End
AT ajuint
AD Last position used (like sequence end)
AX
AN Len
AT ajuint
AD Maximum length
AX
AN Offset
AT ajuint
AD Offset when trimmed
AX
AN Groups
AT ajuint
AD Number of current group being added
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN Db
AT AjPStr
AD Database name from input
AX
AN Setdb
AT AjPStr
AD Database name from command line
AX
AN Full
AT AjPStr
AD Full name
AX
AN Qry
AT AjPStr
AD UFO query for re-reading
AX
AN Formatstr
AT AjPStr
AD Input format name
AX
AN Filename
AT AjPStr
AD Original filename
AX
AN TextPtr
AT AjPStr
AD Full text
AX
AN Fpos
AT ajlong
AD File position (fseek) for Query
AX
AN Format
AT AjEnum
AD Input format enum
AX
AN Circular
AT AjBool
AD true: circular nucleotide molecule
AX
//
typedef struct AjSFeattable
{
AjPStr Seqid;
AjPStr Type;
AjPList Features;
ajuint Start;
ajuint End;
ajuint Len;
ajuint Offset;
ajuint Groups;
ajuint Padding;
AjPStr Db;
AjPStr Setdb;
AjPStr Full;
AjPStr Qry;
AjPStr Formatstr;
AjPStr Filename;
AjPStr TextPtr;
ajlong Fpos;
AjEnum Format;
AjBool Circular;
} AjOFeattable;
#define AjPFeattable AjOFeattable*
ID AjPFeattabin
TY public
MO ajfeatdata
LB core
XX
DE Ajax class for feature table input
XX
TN AjSFeattabin
TD
TX
TN AjOFeattabin
TD
TX
TN AjPFeattabIn
TD
TX
NN ajFeattabinNew
ND Constructor
NX
NN ajFeattabinNewSS
ND Constructor with format, name and type
NX
NN ajFeattabinNewSSF
ND Constructor with format, name, type and input file
NX
DN ajFeattabinDel
DD Destructor
DX
AN Input
AT AjPTextin
AD Text file input object
AX
AN Ufo
AT AjPStr
AD Original UFO
AX
AN Formatstr
AT AjPStr
AD Input format name
AX
AN Filename
AT AjPStr
AD Original filename
AX
AN Seqid
AT AjPStr
AD Sequence entryname
AX
AN Type
AT AjPStr
AD Type N or P
AX
AN Seqname
AT AjPStr
AD name of AjPSeq assoc. with feature table
AX
AN Local
AT AjBool
AD Opened as a local file if ajTrue
AX
AN Rev
AT AjBool
AD Reverse/complement if true
AX
AN Start
AT ajint
AD Start position
AX
AN End
AT ajint
AD End position
AX
AN Circular
AT AjBool
AD true: circular nucleotide molecule
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSFeattabin
{
AjPTextin Input;
AjPStr Ufo;
AjPStr Formatstr;
AjPStr Filename;
AjPStr Seqid;
AjPStr Type;
AjPStr Seqname;
AjBool Local;
AjBool Rev;
ajint Start;
ajint End;
AjBool Circular;
char Padding[4];
} AjOFeattabin;
#define AjPFeattabin AjOFeattabin*
ID AjPFeattaball
TY public
MO ajfeatdata
LB core
XX
DE Ajax feature all (stream) object.
DE
DE Inherits an AjPFeattable but allows more data resources to be read from the
DE same input by also inheriting the AjPFeattabin input object.
XX
TN AjSFeattaball
TD
TX
TN AjOFeattaball
TD
TX
AN Feattable
AT AjPFeattable
AD Current feature table
AX
AN Feattabin
AT AjPFeattabin
AD Feature input for reading next
AX
AN Totfeattables
AT ajulong
AD Count of feature tables so far
AX
AN Count
AT ajuint
AD Count of feature tables so far
AX
AN Multi
AT AjBool
AD True if multiple values are expected
AX
AN Returned
AT AjBool
AD if true: featuure table object has been returned
AD to a new owner
AD and is not to be deleted by the destructor
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSFeattaball
{
AjPFeattable Feattable;
AjPFeattabin Feattabin;
ajulong Totfeattables;
ajuint Count;
AjBool Multi;
AjBool Returned;
char Padding[4];
} AjOFeattaball;
#define AjPFeattaball AjOFeattaball*
ID AjPFeattabAccess
TY public
MO ajfeatdata
LB core
XX
DE Ajax feature table access database reading object.
DE
DE Holds information needed to read a feature table from a database.
DE Access methods are defined for each known database type.
DE
DE Feature tables are read from the database using the defined
DE database access function, which is usually a static function
DE within ajtextdb.c or ajfeatdb.c
DE
DE This should be a static data object but is needed for the definition
DE of AjPFeatin.
XX
TN AjSFeattabAccess
TD
TX
TN AjOFeattabAccess
TD
TX
AN Name
AT const char*
AD Access method name used in emboss.default
AX
AN Access
AT AjBool function
AD Access function
AX
AN AccessFree
AT AjBool function
AD Access cleanup function
AX
AN Qlink
AT const char*
AD Supported query link operators
AX
AN Desc
AT const char*
AD Description
AX
AN Alias
AT AjBool
AD Alias for another name
AX
AN Entry
AT AjBool
AD Supports retrieval of single entries
AX
AN Query
AT AjBool
AD Supports retrieval of selected entries
AX
AN All
AT AjBool
AD Supports retrieval of all entries
AX
AN Chunked
AT AjBool
AD Supports retrieval of entries in chunks
AX
AN Padding
AT AjBool
AD Padding to alignment boundary
AX
//
typedef struct AjSFeattabAccess
{
const char *Name;
AjBool (*Access) (AjPFeattabin ftabin);
AjBool (*AccessFree) (void* qry);
const char* Qlink;
const char* Desc;
AjBool Alias;
AjBool Entry;
AjBool Query;
AjBool All;
AjBool Chunked;
AjBool Padding;
} AjOFeattabAccess;
#define AjPFeattabAccess AjOFeattabAccess*
ID AjPFeattabOut
TY public
MO ajfeatdata
LB core
XX
DE Ajax class for feature table output
XX
TN AjSFeattabOut
TD
TX
TN AjOFeattabOut
TD
TX
NN ajFeattabOutNew
ND Constructor
NX
NN ajFeattabOutNewSSF
ND Constructor with format, name, type and
ND output file
NX
DN ajFeattabOutDel
DD Destructor
DX
AN Ufo
AT AjPStr
AD Original output UFO
AX
AN Formatstr
AT AjPStr
AD Output format name
AX
AN Filename
AT AjPStr
AD Output filename
AX
AN Directory
AT AjPStr
AD Output directory
AX
AN Seqid
AT AjPStr
AD Output entryname
AX
AN Type
AT AjPStr
AD Type N or P
AX
AN Handle
AT AjPFile
AD Output file
AX
AN Seqname
AT AjPStr
AD AjPSeq assoc. with feature table
AX
AN Basename
AT AjPStr
AD Basename for output file
AX
AN Format
AT ajint
AD Output format index
AX
AN Local
AT AjBool
AD Opened as a local file if ajTrue
AX
AN Count
AT ajuint
AD Number of feature tables written
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
AN Cleanup
AT void function
AD Function to write remaining lines on closing
AX
//
typedef struct AjSFeattabOut
{
AjPStr Ufo;
AjPStr Formatstr;
AjPStr Filename;
AjPStr Directory;
AjPStr Seqid;
AjPStr Type;
AjPFile Handle;
AjPStr Seqname;
AjPStr Basename;
ajint Format;
AjBool Local;
ajuint Count;
char Padding[4];
void (*Cleanup) (AjPFile filethys);
} AjOFeattabOut;
#define AjPFeattabOut AjOFeattabOut*
ID AjPFeature
TY public
MO ajfeatdata
LB core
XX
DE Ajax Biological Feature object superclass.
DE
DE Holds generic data describing a single genome feature.
DE
DE A feature is a description of a
DE sequence location which was determined by some 'source' analysis
DE (which may be of 'wet lab' experimental or 'in silico'
DE computational nature), has a 'primary' descriptor ('Type'),
DE may have some 'score' asserting the level of analysis confidence in
DE its identity (e.g. log likelihood relative to a null hypothesis or
DE other similar entity), has a 'Location' in the genome, and may have
DE any arbitrary number of descriptor Tags and TagValues associated with it.
XX
TN AjSFeature
TD
TX
TN AjOFeature
TD
TX
NN ajFeatNew
ND Constructor - must specify the associated
ND (non-null) AjPFeattable
NX
NN ajFeatNewII
ND Simple constructor with only start and end
ND positions
NX
NN ajFeatNewIIRev
ND Simple constructor with only start and end
ND positions, sets feature to be
ND on the reverse strand
NX
NN ajFeatNewProt
ND Protein-specific constructor -
ND must specify the associated
ND (non-null) AjPFeattable
NX
DN ajFeatDel
DD Default destructor
DX
NN ajFeatCopy
ND Copy constructor
NX
AN Source
AT AjPStr
AD Source program name (or EMBL)
AX
AN Type
AT AjPStr
AD Feature type (feature key) from internal list
AD for protein or nucleotide
AX
AN Subfeatures
AT AjPList
AD Subfeatures
AX
AN Tags
AT AjPList
AD Tag-value list (qualifier list)
AX
AN GffTags
AT AjPList
AD GFF3 Tag-value list (qualifier list)
AX
AN Protein
AT AjBool
AD true for a protein feature
AX
AN Start
AT ajuint
AD Start position
AX
AN End
AT ajuint
AD End position
AX
AN Start2
AT ajuint
AD Second start position - EMBL (a.b)
AX
AN End2
AT ajuint
AD Second end position - EMBL ..(a.b)
AX
AN Frame
AT ajint
AD Frame 1..3, -1..-3 or 0
AX
AN Flags
AT ajuint
AD Flag bit mask for EMBL location
AX
AN Group
AT ajuint
AD Group for join/order/one-of
AX
AN Remote
AT AjPStr
AD Remote ID - EMBL Remote:a.b
AX
AN Label
AT AjPStr
AD Label name for location - EMBL legacy
AX
AN Exon
AT ajuint
AD Exon number
AX
AN Score
AT float
AD Score or 0.0 if none
AX
AN Strand
AT char
AD Strand +/- or NULL
AX
AN Padding
AT char[7]
AD Padding to alignment boundary
AX
//
typedef struct AjSFeature
{
AjPStr Source;
AjPStr Type;
AjPList Subfeatures;
AjPList Tags;
AjPList GffTags;
AjBool Protein;
ajuint Start;
ajuint End;
ajuint Start2;
ajuint End2;
ajint Frame;
ajuint Flags;
ajuint Group;
AjPStr Remote;
AjPStr Label;
ajuint Exon;
float Score;
char Strand;
char Padding[7];
} AjOFeature;
#define AjPFeature AjOFeature*
ID AjPFeatGfftags
TY public
MO ajfeatdata
LB core
XX
DE Biological feature GFF3 special tags
XX
TN AjSFeatGfftags
TD
TX
TN AjOFeatGfftags
TD
TX
AN Id
AT AjPStr
AD Identifier attribute. Features with the same id are
AD one feature with multiple locations
AX
AN Name
AT AjPStr
AD Display name attribute, can be shared
AX
AN Alias
AT AjPStr
AD Alias attribute (list) e.g. locus name, can be shared
AX
AN Parent
AT AjPStr
AD Parent attribute (list) for part_of grouping
AX
AN Target
AT AjPStr
AD Target attribute "target_id start end [strand]"
AX
AN Gap
AT AjPStr
AD Gap attribute in exonerate CIGAR format
AX
AN DerivesFrom
AT AjPStr
AD Derives_from attribute for relations
AX
AN Note
AT AjPStr
AD Note attribute (list)
AX
AN Dbxref
AT AjPStr
AD Dbxref attribute (list) in format DBTAG:ID
AX
AN OntologyTerm
AT AjPStr
AD Ontology_term attribute (list) in format DBTAG:ID
AX
AN IsCircular
AT AjPStr
AD Is_circular attribute
AX
//
typedef struct AjSFeatGfftags
{
AjPStr Id;
AjPStr Name;
AjPStr Alias;
AjPStr Parent;
AjPStr Target;
AjPStr Gap;
AjPStr DerivesFrom;
AjPStr Note;
AjPStr Dbxref;
AjPStr OntologyTerm;
AjPStr IsCircular;
} AjOFeatGfftags;
#define AjPFeatGfftags AjOFeatGfftags*
ID AjEOutfileType
TY public
MO ajfile
LB core
XX
DE AJAX Outfile Type enumeration
XX
VN ajEOutfileTypeUnknown
VD Unknown - none of these
VX
VN ajEOutfileTypeAssembly
VD Assembly
VX
VN ajEOutfileTypeCodon
VD Codon usage
VX
VN ajEOutfileTypeCPDB
VD Clean PDB
VX
VN ajEOutfileTypeDiscrete
VD Discrete data
VX
VN ajEOutfileTypeDistance
VD Distance matrix data
VX
VN ajEOutfileTypeFrequency
VD Frequency data
VX
VN ajEOutfileTypeMatrix
VD Integer matrix data
VX
VN ajEOutfileTypeMatrixF
VD Floating point matrix data
VX
VN ajEOutfileTypeOBO
VD OBO ontology data
VX
VN ajEOutfileTypeProperties
VD Phylogenetic properties
VX
VN ajEOutfileTypeRefseq
VD Reference sequence data
VX
VN ajEOutfileTypeResource
VD Data resource catalogue data
VX
VN ajEOutfileTypeSCOP
VD SCOP data
VX
VN ajEOutfileTypeTaxon
VD NCBI taxonomy data
VX
VN ajEOutfileTypeText
VD Text data
VX
VN ajEOutfileTypeTree
VD Phylogenetic tree data
VX
VN ajEOutfileTypeURL
VD URL data
VX
VN ajEOutfileTypeVariation
VD Variation data
VX
//
typedef enum AjOOutfileType
{
ajEOutfileTypeUnknown,
ajEOutfileTypeAssembly,
ajEOutfileTypeCodon,
ajEOutfileTypeCPDB,
ajEOutfileTypeDiscrete,
ajEOutfileTypeDistance,
ajEOutfileTypeFrequency,
ajEOutfileTypeMatrix,
ajEOutfileTypeMatrixF,
ajEOutfileTypeOBO,
ajEOutfileTypeProperties,
ajEOutfileTypeRefseq,
ajEOutfileTypeResource,
ajEOutfileTypeSCOP,
ajEOutfileTypeTaxon,
ajEOutfileTypeText,
ajEOutfileTypeTree,
ajEOutfileTypeURL,
ajEOutfileTypeVariation
} AjEOutfileType;
ID AjPFile
TY public
MO ajfile
LB core
XX
DE Ajax file object. Holds information for an open (unbuffered)
DE input or output file.
DE
DE On output, conversion code "%F" writes the filename.
XX
TN AjSFile
TD
TX
TN AjOFile
TD
TX
AN fp
AT FILE*
AD C file pointer
AX
AN Name
AT AjPStr
AD File name as used when opening
AX
AN Printname
AT AjPStr
AD File name in a clean form for reporting
AX
AN List
AT AjPList
AD List of file names (first is open)
AX
AN End
AT AjBool
AD True if EOF has been reached
AX
AN App
AT AjBool
AD True if file was opened for append.
AX
AN Buff
AT AjPStr
AD Buffer for latest line read
AX
AN Workbuffer
AT char*
AD Block as a buffer for fgets etc
AX
AN Readblock
AT char*
AD Block as a buffer for fread
AX
AN Filepos
AT ajlong
AD File offset for start of latest read
AX
AN Blocksize
AT ajuint
AD Read block maximum size
AX
AN Blockpos
AT ajuint
AD Read block position
AX
AN Blocklen
AT ajuint
AD Read block length used
AX
AN Buffsize
AT ajuint
AD Buffer size (zero for default size)
AX
AN Handle
AT ajint
AD AJAX file number 0 if unused
AX
AN Pid
AT pid_t
AD Process PID if any (non-WIN32 only)
AX
AN Process
AT HANDLE
AD Process handle (WIN32 only)
AX
AN Thread
AT HANDLE
AD Thread handle (WIN32 only)
AX
//
typedef struct AjSFile
{
FILE *fp;
AjPStr Name;
AjPStr Printname;
AjPList List;
AjBool End;
AjBool App;
AjPStr Buff;
char *Workbuffer;
char *Readblock;
ajlong Filepos;
ajuint Blocksize;
ajuint Blockpos;
ajuint Blocklen;
ajuint Buffsize;
ajint Handle;
pid_t Pid;
HANDLE Process;
HANDLE Thread;
} AjOFile;
#define AjPFile AjOFile*
ID AjPFilebufflist
TY public
MO ajfile
LB core
XX
DE Ajax file buffer, holding a simple linked list of buffered lines.
DE This does not use the AjPList objects.
DE
DE This is a substructure of the AjPFilebuff object.
XX
TN AjSFilebufflist
TD
TX
TN AjSOilebufflist
TD
TX
AN Line
AT AjPStr
AD String : this line
AX
AN Next
AT struct AjSFilebufflist*
AD Next line in the list, NULL for last
AX
AN Fpos
AT ajlong
AD File offset for start of this line
AX
//
typedef struct AjSFilebufflist
{
AjPStr Line;
struct AjSFilebufflist* Next;
ajlong Fpos;
} AjOFilebufflist;
#define AjPFilebufflist AjOFilebufflist*
ID AjPFilebuff
TY public
MO ajfile
LB core
XX
DE Ajax buffered file object. Holds information for a buffered input file.
XX
TN AjSFilebuff
TD
TX
TN AjOFilebuff
TD
TX
AN File
AT AjPFile
AD The input file - data to be buffered
AX
AN Lines
AT AjPFilebufflist
AD All lines ... where the data really is
AX
AN Freelines
AT AjPFilebufflist
AD Free list of lines for reuse
AX
AN Curr
AT AjPFilebufflist
AD Current line in Lines list
AX
AN Prev
AT AjPFilebufflist
AD Previous line (points to Curr for delete)
AX
AN Last
AT AjPFilebufflist
AD Last line for quick appending
AX
AN Freelast
AT AjPFilebufflist
AD Last free line for quick append
AX
AN Nobuff
AT AjBool
AD if true, do not buffer the file
AX
AN Pos
AT ajint
AD Position in list
AX
AN Size
AT ajint
AD Size of list
AX
AN FreeSize
AT ajint
AD Size of free list
AX
AN Fpos
AT ajlong
AD File position in File
AX
//
typedef struct AjSFilebuff
{
AjPFile File;
AjPFilebufflist Lines;
AjPFilebufflist Freelines;
AjPFilebufflist Curr;
AjPFilebufflist Prev;
AjPFilebufflist Last;
AjPFilebufflist Freelast;
AjBool Nobuff;
ajint Pos;
ajint Size;
ajint FreeSize;
ajlong Fpos;
} AjOFilebuff;
#define AjPFilebuff AjOFilebuff*
ID AjPDir
TY public
MO ajfile
LB core
XX
DE Ajax directory object. Holds information for an open
DE input directory.
XX
TN AjSDir
TD
TX
TN AjODir
TD
TX
AN Name
AT AjPStr
AD Path
AX
AN Printname
AT AjPStr
AD Directory path in a clean form for reporting
AX
AN Prefix
AT AjPStr
AD Default filename prefix
AX
AN Extension
AT AjPStr
AD Default file extension
AX
//
typedef struct AjSDir
{
AjPStr Name;
AjPStr Printname;
AjPStr Prefix;
AjPStr Extension;
} AjODir;
#define AjPDir AjODir*
ID AjPDirout
TY public
MO ajfile
LB core
XX
DE Ajax output directory object. Holds information for an open
DE output directory.
XX
TN AjSDirout
TD
TX
TN AjODirout
TD
TX
AN Name
AT AjPStr
AD Path
AX
AN Printname
AT AjPStr
AD Directory path in a clean form for reporting
AX
AN Extension
AT AjPStr
AD Default file extension
AX
AN Created
AT AjBool
AD New directory created
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSDirout
{
AjPStr Name;
AjPStr Printname;
AjPStr Extension;
AjBool Created;
char Padding[4];
} AjODirout;
#define AjPDirout AjODirout*
ID AjPOutfile
TY public
MO ajfile
LB core
XX
DE Ajax file object. Holds information for an open (unbuffered)
DE input or output file.
DE
DE On output, conversion code "%F" writes the filename.
XX
TN AjSOutfile
TD
TX
TN AjOOutfile
TD
TX
AN File
AT AjPFile
AD File object
AX
AN Type
AT AjPStr
AD Named data file type
AX
AN Formatstr
AT AjPStr
AD Format specific for this data type
AX
AN Cleanup
AT void function
AD Function to write remaining lines on closing
AX
AN OutData
AT void*
AD Format data for reuse, e.g. multiple entry output
AX
AN Itype
AT ajuint
AD Index number for Type
AX
AN Format
AT ajint
AD Index for Formatstr for this data type
AX
AN Records
AT ajuint
AD Number of records written
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSOutfile
{
AjPFile File;
AjPStr Type;
AjPStr Formatstr;
void (*Cleanup) (struct AjSOutfile *outf);
void *OutData;
ajuint Itype;
ajint Format;
ajuint Records;
char Padding[4];
} AjOOutfile;
#define AjPOutfile AjOOutfile*
ID AjPGraphobj
TY public
MO ajgraphstruct
LB graphics
XX
DE AJAX data structure for graph objects, contained as a substructure
DE in AjPGraphdata
XX
AN type
AT ajuint
AD Object type in AjEGraphObjectTypes
AX
AN colour
AT ajuint
AD See AjEGraphColour for plplot colours
AX
AN text
AT AjPStr
AD Text to plot
AX
AN xx1
AT float
AD x start
AX
AN xx2
AT float
AD x end
AX
AN yy1
AT float
AD y start
AX
AN yy2
AT float
AD y end
AX
AN next
AT struct AjSGraphobj*
AD link to next object in the list
AX
AN scale
AT float
AD scale for text (0.0 to use the default)
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSGraphobj {
ajuint type;
ajuint colour;
AjPStr text;
float xx1;
float xx2;
float yy1;
float yy2;
struct AjSGraphobj *next;
float scale;
char Padding[4];
} AjOGraphobj;
#define AjPGraphobj AjOGraphobj*
ID AjPGraphdata
TY public
MO ajgraphstruct
LB graphics
XX
DE Graph data object. Substructure of AjPGraph.
XX
AN x
AT float*
AD x coordinates
AX
AN y
AT float*
AD y coordinates
AX
AN Dataobj
AT AjPGraphobj
AD First graph object - links to rest
AX
AN title
AT AjPStr
AD Plot title
AX
AN subtitle
AT AjPStr
AD Plot subtitle
AX
AN xaxis
AT AjPStr
AD Plot x axis title
AX
AN yaxis
AT AjPStr
AD Plot y axis title
AX
AN gtype
AT AjPStr
AD Graph type: 2D, Tick etc
AX
AN dataname
AT AjPStr
AD Source data name
AX
AN xcalc
AT AjBool
AD if x calculated then delete after
AX
AN ycalc
AT AjBool
AD as with x. So we do not delete data if it was
AD passed as a ptr
AX
AN truescale
AT AjBool
AD if true xy scale has been set
AX
AN numofpoints
AT ajuint
AD Number of points in x and y
AX
AN numofobjects
AT ajuint
AD Number of graph objects starting at Obj
AX
AN minX
AT float
AD Lowest x value
AX
AN maxX
AT float
AD Highest x value
AX
AN minY
AT float
AD Lowest y value
AX
AN maxY
AT float
AD Highest y value
AX
AN tminX
AT float
AD First x value to plot
AX
AN tmaxX
AT float
AD Last x value to plot
AX
AN tminY
AT float
AD First y value to plot
AX
AN tmaxY
AT float
AD Last y value to plot
AX
AN colour
AT ajint
AD See AjEGraphColour for plplot colours
AX
AN lineType
AT ajint
AD Line type for plplot
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSGraphdata {
float *x;
float *y;
AjPGraphobj Dataobj;
AjPStr title;
AjPStr subtitle;
AjPStr xaxis;
AjPStr yaxis;
AjPStr gtype;
AjPStr dataname;
AjBool xcalc;
AjBool ycalc;
AjBool truescale;
ajuint numofpoints;
ajuint numofobjects;
float minX;
float maxX;
float minY;
float maxY;
float tminX;
float tmaxX;
float tminY;
float tmaxY;
ajint colour;
ajint lineType;
char Padding[4];
} AjOGraphdata;
#define AjPGraphdata AjOGraphdata*
ID AjPGraph
TY public
MO ajgraphstruct
LB graphics
XX
DE Graph object.
XX
AN displaytype
AT ajuint
AD Displaytype index to graphType
AX
AN numsets
AT ajuint
AD Number of sets in a multiple graph
AX
AN numofgraphs
AT ajuint
AD Number of graphs in graphs
AX
AN numofobjects
AT ajuint
AD Number of objects in Mainobj
AX
AN numofgraphsmax
AT ajuint
AD Maximum number of graphs expected
AX
AN flags
AT ajuint
AD over rides the EmbGraphData flags
AX
AN minX
AT float
AD Lowest x value for all graphs
AX
AN maxX
AT float
AD Highest x value for all graphs
AX
AN minY
AT float
AD Lowest y value for all graphs
AX
AN maxY
AT float
AD Highest y value for all graphs
AX
AN xstart
AT float
AD First x value to plot
AX
AN xend
AT float
AD Last x value to plot
AX
AN ystart
AT float
AD First y value to plot
AX
AN yend
AT float
AD Last y value to plot
AX
AN ready
AT AjBool
AD Set by plplot device init
AX
AN minmaxcalc
AT AjBool
AD Set true when (xy)start/end are set
AX
AN windowset
AT AjBool
AD Set true when (xy) window coordinates are set
AX
AN isdata
AT AjBool
AD True for a data type graph
AX
AN desc
AT AjPStr
AD Plot description, used to set default title
AX
AN title
AT AjPStr
AD Plot title
AX
AN subtitle
AT AjPStr
AD Plot subtitle
AX
AN xaxis
AT AjPStr
AD Plot x axis title
AX
AN yaxis
AT AjPStr
AD Plot y axis title
AX
AN outputfile
AT AjPStr
AD Output filename
AX
AN dataname
AT AjPStr
AD Data source name for datafile outputs
AX
AN graphs
AT AjPGraphdata*
AD XY Data to plot for Graph(s)
AX
AN Mainobj
AT AjPGraphobj
AD Objects to plot for single graph
AX
//
typedef struct AjSGraph {
ajuint displaytype;
ajuint numsets;
ajuint numofgraphs;
ajuint numofobjects;
ajuint numofgraphsmax;
ajuint flags;
float minX;
float maxX;
float minY;
float maxY;
float xstart;
float xend;
float ystart;
float yend;
AjBool ready;
AjBool minmaxcalc;
AjBool windowset;
AjBool isdata;
AjPStr desc;
AjPStr title;
AjPStr subtitle;
AjPStr xaxis;
AjPStr yaxis;
AjPStr outputfile;
AjPStr dataname;
AjPGraphdata *graphs;
AjPGraphobj Mainobj;
} AjOGraph;
#define AjPGraph AjOGraph*
ID AjPHistdata
TY public
MO ajhist
LB graphics
XX
DE AJAX data structure for histogram graph data
XX
AN data
AT float*
AD y coordinates
AX
AN deletedata
AT AjBool
AD if true, delete data
AX
AN colour
AT ajint
AD colour code
AX
AN title
AT AjPStr
AD graph title
AX
AN subtitle
AT AjPStr
AD graph subtitle
AX
AN xaxis
AT AjPStr
AD x axis title
AX
AN yaxis
AT AjPStr
AD y axis title
AX
AN pattern
AT ajint
AD pattern code
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSHistdata {
float *data;
AjBool deletedata;
ajint colour;
AjPStr title;
AjPStr subtitle;
AjPStr xaxis;
AjPStr yaxis;
ajint pattern;
char Padding[4];
} AjOHistdata;
#define AjPHistdata AjOHistdata*
ID AjPHist
TY public
MO ajhist
LB graphics
XX
DE AJAX data structure for histogram graph objects
XX
AN numofsets
AT ajuint
AD number of current sets
AX
AN numofsetsmax
AT ajuint
AD maximum number of sets
AX
AN numofdatapoints
AT ajuint
AD number of data points
AX
AN xmin
AT float
AD Lowest x value
AX
AN xmax
AT float
AD Highest x value
AX
AN displaytype
AT ajuint
AD Display type index
AX
AN bins
AT ajuint
AD Number of histogram bins
AX
AN BaW
AT AjBool
AD Black and white rendering if ajTrue
AX
AN title
AT AjPStr
AD Plot title
AX
AN subtitle
AT AjPStr
AD Plot subtitle
AX
AN xaxis
AT AjPStr
AD x axis title
AX
AN yaxisleft
AT AjPStr
AD y axis title
AX
AN yaxisright
AT AjPStr
AD second y axis title for right side
AX
AN graph
AT AjPGraph
AD Graph
AX
AN hists
AT AjPHistdata*
AD Histogram bin data
AX
//
typedef struct AjSHist {
ajuint numofsets;
ajuint numofsetsmax;
ajuint numofdatapoints;
float xmin;
float xmax;
ajuint displaytype;
ajuint bins;
AjBool BaW;
AjPStr title;
AjPStr subtitle;
AjPStr xaxis;
AjPStr yaxisleft;
AjPStr yaxisright;
AjPGraph graph;
AjPHistdata *hists;
} AjOHist;
#define AjPHist AjOHist*
ID AjPUrlref
TY public
MO ajhttp
LB core
XX
DE Structure to hold parts of a URL
XX
TN AjSUrlref
TD
TX
TN AjOUrlref
TD
TX
AN Method
AT AjPStr
AD Method of access (e.g. http)
AX
AN Host
AT AjPStr
AD host
AX
AN Port
AT AjPStr
AD Port
AX
AN Absolute
AT AjPStr
AD Absolute path
AX
AN Relative
AT AjPStr
AD Relative path
AX
AN Fragment
AT AjPStr
AD Fragment/section
AX
AN Username
AT AjPStr
AD Username
AX
AN Password
AT AjPStr
AD Password
AX
//
typedef struct AjSUrlref
{
AjPStr Method;
AjPStr Host;
AjPStr Port;
AjPStr Absolute;
AjPStr Relative;
AjPStr Fragment;
AjPStr Username;
AjPStr Password;
} AjOUrlref;
#define AjPUrlref AjOUrlref*
ID AjPBtNode
TY public
MO ajindex
LB core
XX
DE Btree node
XX
AN BlockOffset
AT ajulong
AD Offset within main index
AX
AN Nkeys
AT ajuint
AD Number of keys filled
AX
AN TotLen
AT ajuint
AD Total length of keys
AX
AN Left
AT ajulong
AD Left Sibling
AX
AN Right
AT ajulong
AD Right Sibling
AX
AN Overflow
AT ajulong
AD Offset to overflow block
AX
AN PrevNode
AT ajulong
AD Previous node
AX
AN NodeType
AT ajuint
AD Root, Internal or Leaf
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSBtNode
{
ajulong BlockOffset;
ajuint Nkeys;
ajuint TotLen;
ajulong Left;
ajulong Right;
ajulong Overflow;
ajulong PrevNode;
ajuint NodeType;
char Padding[4];
} AjOBtNode;
#define AjPBtNode AjOBtNode*
ID AjPBtMem
TY public
MO ajindex
LB core
XX
DE Dynamic list for btree memory arrays
XX
AN next
AT struct AjSBtMem*
AD next node
AX
AN prev
AT struct AjSBtMem*
AD previous node
AX
AN karray
AT AjPStr*
AD key array (primary trees)
AX
AN parray
AT ajulong*
AD pointer arrays (primary and secondary trees)
AX
AN overflows
AT ajulong*
AD overflows (primary) and keys (secondary)
AX
AN used
AT AjBool
AD node in use
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSBtMem
{
struct AjSBtMem *next;
struct AjSBtMem *prev;
AjPStr *karray;
ajulong *parray;
ajulong *overflows;
AjBool used;
char Padding[4];
} AjOBtMem;
#define AjPBtMem AjOBtMem*
ID AjPBtId
TY public
MO ajindex
LB core
XX
DE Btree ID
XX
AN id
AT AjPStr
AD Unique ID
AX
AN offset
AT ajulong
AD Offset within database file (ftello)
AX
AN refoffsets
AT ajulong*
AD Offset within reference database file(s) (ftello)
AX
AN dbno
AT ajuint
AD Database file number
AX
AN dups
AT ajuint
AD Duplicates
AX
AN refcount
AT ajuint
AD Number of reference files
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSBtId
{
AjPStr id;
ajulong offset;
ajulong *refoffsets;
ajuint dbno;
ajuint dups;
ajuint refcount;
char Padding[4];
} AjOBtId;
#define AjPBtId AjOBtId*
ID AjPBHit
TY public
MO ajindex
LB core
XX
DE Btree index hit minimal information for refcount zero
XX
AN dbno
AT ajuint
AD Database file number
AX
AN refcount
AT ajuint
AD Number of reference files (zero, for padding)
AX
AN offset
AT ajulong
AD Offset within database file (ftello)
AX
//
typedef struct AjSBtHit
{
ajuint dbno;
ajuint refcount;
ajulong offset;
} AjOBtHit;
#define AjPBtHit AjOBtHit*
ID AjPBHitref
TY public
MO ajindex
LB core
XX
DE Btree index hit minimal information for refcount non-zero
XX
AN dbno
AT ajuint
AD Database file number
AX
AN refcount
AT ajuint
AD Number of reference files (one, for padding)
AX
AN offset
AT ajulong
AD Offset within database file (ftello)
AX
AN refoffset
AT ajulong
AD Offset within reference file (ftello)
AX
//
typedef struct AjSBtHitref
{
ajuint dbno;
ajuint refcount;
ajulong offset;
ajulong refoffset;
} AjOBtHitref;
#define AjPBtHitref AjOBtHitref*
ID AjPBtIdwild
TY public
MO ajindex
LB core
XX
DE Btree identifier search wildcard
XX
AN id
AT AjPStr
AD Wildcard ID
AX
AN pagepos
AT ajulong
AD Page number of leaf
AX
AN list
AT AjPList
AD list of AjPBtIds
AX
AN first
AT AjBool
AD true for first search
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSBIdild
{
AjPStr id;
ajulong pagepos;
AjPList list;
AjBool first;
char Padding[4];
} AjOBtIdwild;
#define AjPBtIdwild AjOBtIdwild*
ID AjPIdbucket
TY public
MO ajindex
LB core
XX
DE Id bucket structure on disc
DE
DE Key, file number, ftell ID, subkey page (char*, ajuint, ajulong, ajulong)
XX
AN NodeType
AT ajuint
AD Node type
AX
AN Maxentries
AT ajuint
AD Number of entries available
AX
AN Nentries
AT ajuint
AD Number of entries
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN Overflow
AT ajulong
AD Offset to overflow block
AX
AN keylen
AT ajuint*
AD Key lengths
AX
AN Ids
AT AjPBtId*
AD Ids
AX
//
typedef struct AjSIdbucket
{
ajuint NodeType;
ajuint Maxentries;
ajuint Nentries;
ajuint Padding;
ajulong Overflow;
ajuint *keylen;
AjPBtId *Ids;
} AjOIdbucket;
#define AjPIdbucket AjOIdbucket*
ID AjPBtNumId
TY public
MO ajindex
LB core
XX
DE Btree ID
XX
AN offset
AT ajulong
AD Offset within database file (ftello)
AX
AN refoffsets
AT ajulong*
AD Offset within reference database file(s) (ftello)
AX
AN dbno
AT ajuint
AD Database file number
AX
AN refcount
AT ajuint
AD Number of reference files
AX
//
typedef struct AjSBtNumId
{
ajulong offset;
ajulong *refoffsets;
ajuint dbno;
ajuint refcount;
} AjOBtNumId;
#define AjPBtNumId AjOBtNumId*
ID AjPNumbucket
TY public
MO ajindex
LB core
XX
DE Offset bucket structure on disc
DE
DE Key, file number, ftell ID, subkey page (char*, ajuint, ajulong, ajulong)
XX
AN NodeType
AT ajuint
AD Node type
AX
AN Maxentries
AT ajuint
AD Number of entries available
AX
AN Nentries
AT ajuint
AD Number of entries
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN Overflow
AT ajulong
AD Offset to overflow block
AX
AN NumId
AT AjPBtNumId*
AD secondary tree IDs
AX
//
typedef struct AjSNumbucket
{
ajuint NodeType;
ajuint Maxentries;
ajuint Nentries;
ajuint Padding;
ajulong Overflow;
AjPBtNumId *NumId;
} AjONumbucket;
#define AjPNumbucket AjONumbucket*
ID AjPBtpage
TY public
MO ajindex
LB core
XX
DE Btree page
XX
AN pagepos
AT ajulong
AD Page number
AX
AN next
AT struct AjSBtpage*
AD Next page
AX
AN prev
AT struct AjSBtpage*
AD Previous page
AX
AN buf
AT unsigned char*
AD Buffer
AX
AN dirty
AT ajuint
AD BT_DIRTY if page needs to be written to disc
AX
AN lockfor
AT ajuint
AD Reason for last setting of dirty as BT_LOCK
AX
//
typedef struct AjSBtpage
{
ajulong pagepos;
struct AjSBtpage *next;
struct AjSBtpage *prev;
unsigned char *buf;
ajuint dirty;
ajuint lockfor;
} AjOBtpage;
#define AjPBtpage AjOBtpage*
ID AjPBtcache
TY public
MO ajindex
LB core
XX
DE B+ tree cache
XX
AN fp
AT FILE*
AD Tree index file pointer
AX
AN filename
AT AjPStr
AD Filename
AX
AN plru
AT AjPBtpage
AD Least recently used primary cache page
AX
AN pmru
AT AjPBtpage
AD Most recently used primary cache page
AX
AN slru
AT AjPBtpage
AD Least recently used secondary cache page
AX
AN smru
AT AjPBtpage
AD Most recently used secondary cache page
AX
AN bmem
AT AjPBtMem
AD Primary array allocation MRU bottom
AX
AN tmem
AT AjPBtMem
AD Primary array allocation MRU top
AX
AN bsmem
AT AjPBtMem
AD Secondary array allocation MRU bottom
AX
AN tsmem
AT AjPBtMem
AD Secondary array allocation MRU top
AX
AN replace
AT AjPStr
AD Replacement ID
AX
AN pripagetable
AT AjPTable
AD Table of cached primary pages
AX
AN secpagetable
AT AjPTable
AD Table of cached secondary pages
AX
AN totsize
AT ajulong
AD Tree index total length
AX
AN filesize
AT ajulong
AD Tree index length after any compression
AX
AN pripagecount
AT ajulong
AD Tree index number of primary pages
AX
AN secpagecount
AT ajulong
AD Tree index number of secondary pages
AX
AN secrootblock
AT ajulong
AD Secondary tree root block
AX
AN numreplace
AT ajulong
AD Replacement numeric ID
AX
AN countunique
AT ajulong
AD Number of unique tokens indexed
AX
AN countall
AT ajulong
AD Number of total tokens indexed
AX
AN pricachehits
AT ajulong
AD Number of primnary cached page reads
AX
AN seccachehits
AT ajulong
AD Number of secondary cached page reads
AX
AN prireads
AT ajulong
AD Number of physical primary page reads from disk
AX
AN secreads
AT ajulong
AD Number of physical secondary page reads from disk
AX
AN priwrites
AT ajulong
AD Number of physical primary page writes to disk
AX
AN secwrites
AT ajulong
AD Number of physical secondary page writes to disk
AX
AN pripagesize
AT ajuint
AD Size of primary cache pages
AX
AN secpagesize
AT ajuint
AD Size of secondary cache pages
AX
AN prilistLength
AT ajuint
AD Number of pages in primary cache
AX
AN seclistLength
AT ajuint
AD Number of pages in secondary cache
AX
AN porder
AT ajuint
AD Order of primary tree
AX
AN plevel
AT ajuint
AD Depth of primary tree
AX
AN pnperbucket
AT ajuint
AD Number of entries in a primary bucket
AX
AN pricachesize
AT ajuint
AD Maximum number of pages to cache
AX
AN sorder
AT ajuint
AD Order of secondary tree
AX
AN slevel
AT ajuint
AD Depth of secondary tree
AX
AN snperbucket
AT ajuint
AD Number of entries in a secondary bucket
AX
AN seccachesize
AT ajuint
AD Maximum number of pages to cache
AX
AN keylimit
AT ajuint
AD Max length of primary key
AX
AN idlimit
AT ajuint
AD Max length of secondary key
AX
AN refcount
AT ajuint
AD Number of extra files for each entry
AX
AN secondary
AT AjBool
AD Secondary index
AX
AN readonly
AT AjBool
AD Read only flag
AX
AN dodelete
AT AjBool
AD Deletion flag
AX
AN compressed
AT AjBool
AD Index is compressed
AX
//
typedef struct AjSBtCache
{
FILE *fp;
AjPStr filename;
AjPBtpage plru;
AjPBtpage pmru;
AjPBtpage slru;
AjPBtpage smru;
AjPBtMem bmem;
AjPBtMem tmem;
AjPBtMem bsmem;
AjPBtMem tsmem;
AjPStr replace;
AjPTable pripagetable;
AjPTable secpagetable;
ajulong totsize;
ajulong filesize;
ajulong pripagecount;
ajulong secpagecount;
ajulong secrootblock;
ajulong numreplace;
ajulong countunique;
ajulong countall;
ajulong pricachehits;
ajulong seccachehits;
ajulong prireads;
ajulong secreads;
ajulong priwrites;
ajulong secwrites;
ajuint pripagesize;
ajuint secpagesize;
ajuint prilistLength;
ajuint seclistLength;
ajuint porder;
ajuint plevel;
ajuint pnperbucket;
ajuint pricachesize;
ajuint sorder;
ajuint slevel;
ajuint snperbucket;
ajuint seccachesize;
ajuint keylimit;
ajuint idlimit;
ajuint refcount;
AjBool secondary;
AjBool readonly;
AjBool dodelete;
AjBool compressed;
} AjOBtcache;
#define AjPBtcache AjOBtcache*
ID AjPBtPri
TY public
MO ajindex
LB core
XX
DE Btree primary link from a primary bucket for secondary identifier tree
XX
AN keyword
AT AjPStr
AD keyword
AX
AN treeblock
AT ajulong
AD root block of secondary tree
AX
AN id
AT AjPStr
AD Id string
AX
//
typedef struct AjSBtPri
{
AjPStr keyword;
ajulong treeblock;
AjPStr id;
} AjOBtPri;
#define AjPBtPri AjOBtPri*
ID AjPPribucket
TY public
MO ajindex
LB core
XX
DE Keyword primary bucket structure on disc
XX
AN NodeType
AT ajuint
AD Node type
AX
AN Maxentries
AT ajuint
AD Number of entries available
AX
AN Nentries
AT ajuint
AD Number of entries
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN Overflow
AT ajulong
AD Offset to overflow block
AX
AN keylen
AT ajuint*
AD key lengths
AX
AN codes
AT AjPBtPri*
AD Primary keywords
AX
//
typedef struct AjSPribucket
{
ajuint NodeType;
ajuint Maxentries;
ajuint Nentries;
ajuint Padding;
ajulong Overflow;
ajuint *keylen;
AjPBtPri *codes;
} AjOPribucket;
#define AjPPribucket AjOPribucket*
ID AjPSecbucket
TY public
MO ajindex
LB core
XX
DE Keyword secondary bucket structure on disc
XX
AN NodeType
AT ajuint
AD Node type
AX
AN Maxentries
AT ajuint
AD Number of entries available
AX
AN Nentries
AT ajuint
AD Number of entries
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN Overflow
AT ajulong
AD Offset to overflow block
AX
AN keylen
AT ajuint*
AD key lengths
AX
AN SecIds
AT AjPStr*
AD Ids
AX
//
typedef struct AjSSecbucket
{
ajuint NodeType;
ajuint Maxentries;
ajuint Nentries;
ajuint Padding;
ajulong Overflow;
ajuint *keylen;
AjPStr *SecIds;
} AjOSecbucket;
#define AjPSecbucket AjOSecbucket*
ID AjPBtKeywild
TY public
MO ajindex
LB core
XX
DE Btree keyword wildcard object
XX
AN keyword
AT AjPStr
AD Wildcard keyword
AX
AN prefix
AT AjPStr
AD Wildcard keyword prefix
AX
AN pagepos
AT ajulong
AD Page number of primary tree leaf
AX
AN list
AT AjPList
AD list of AjPBtPris
AX
AN cache
AT AjPBtcache
AD cache for secondary tree
AX
AN idlist
AT AjPList
AD list of AjPStr IDs
AX
AN secpagepos
AT ajulong
AD Page number of secondary tree leaf
AX
AN first
AT AjBool
AD true for first search
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSBtKeywild
{
AjPStr keyword;
AjPStr prefix;
ajulong pagepos;
AjPList list;
AjPBtcache cache;
AjPList idlist;
ajulong secpagepos;
AjBool first;
char Padding[4];
} AjOBtKeywild;
#define AjPBtKeywild AjOBtKeywild*
ID AjEListType
TY public
MO ajlist
LB core
XX
DE AJAX List Type enumeration
XX
VN ajEListTypeAny
VD Any data
VX
VN ajEListTypeStr
VD String data
VX
//
typedef enum AjOListType
{
ajEListTypeAny,
ajEListTypeStr
} AjEListType;
ID AjPListNode
TY public
MO ajlist
LB core
XX
DE AJAX List Node
XX
TN AjSListNode
TD
TX
TN AjOListNode
TD
TX
AN Next
AT struct AjSListNode*
AD Next AJAX List Node object
AX
AN Prev
AT struct AjSListNode*
AD Previous AJAX List Node object
AX
AN Item
AT void*
AD Data value
AX
//
typedef struct AjSListNode
{
struct AjSListNode* Next;
struct AjSListNode* Prev;
void* Item;
} AjOListNode;
#define AjPListNode AjOListNode*
ID AjPList
TY public
MO ajlist
LB core
XX
DE List data object. Lists are simple linked lists with performance optimised
DE to allow rapid extension of the beginning or end of the list.
DE
DE Lists can hold any data type. Special functions are available for lists
DE of AjPStr values. In general, these functions are the same. Many are
DE provided for ease of use to save remembering which calls need special cases.
XX
TN AjSList
TD
TX
TN AjOList
TD
TX
AN First
AT AjPListNode
AD first node
AX
AN Last
AT AjPListNode
AD dummy last node
AX
AN Fitemdel
AT void function
AD Item destructor, or NULL if not an object
AX
AN Count
AT ajulong
AD Number of nodes
AX
AN Use
AT ajuint
AD Reference count
AX
AN Padding
AT AjBool
AD Padding to alignment boundary
AX
//
typedef struct AjSList
{
AjPListNode First;
AjPListNode Last;
void (*Fitemdel)(void** Pitem);
ajulong Count;
ajuint Use;
AjBool Padding;
} AjOList;
#define AjPList AjOList*
ID AjIList
TY public
MO ajlist
LB core
XX
DE AJAX list iterator data structure
XX
TN AjSIList
TD
TX
TN AjOIList
TD
TX
AN Head
AT AjPList
AD Head of modifiable list
AX
AN ReadHead
AT const AjPList
AD Head of read-only list
AX
AN Here
AT AjPListNode
AD Current list node
AX
AN Back
AT AjBool
AD Direction of last iterative move, true if reading back
AX
AN Modify
AT AjBool
AD Allows iterator to modify the sequence
AX
//
typedef struct AjSIList
{
AjPList Head;
const AjPList ReadHead;
AjPListNode Here;
AjBool Back;
AjBool Modify;
} AjOIList;
#define AjIList AjOIList*
ID AjPMartLoc
TY public
MO ajmart
LB ajaxdb
XX
DE Ajax BioMart locations structure.
DE
DE Holds lists of RegistryDBPointer, MartDBLocation & MartURLLocation
DE locations. Each list consists of string tables.
DE
DE AjPMartLoc is implemented as a pointer to a C data structure.
XX
TN AjPPMartLoc
TD
TX
TN AjSMartLoc
TD
TX
TN AjOMartLoc
TD
TX
AN Registries
AT AjPTable*
AD Tables of registry entries
AX
AN Databases
AT AjPTable*
AD Tables of database entries
AX
AN Urls
AT AjPTable*
AD Tables of URL entries
AX
AN Reg_read
AT AjPList
AD List of registry tables used only
AD during XML reading and subsequently
AD converted to the table array above.
AX
AN Data_read
AT AjPList
AD List of database tables (see Reg_read)
AX
AN Url_read
AT AjPList
AD List of URL tables (see Reg_read)
AX
AN Nregistries
AT ajuint
AD Number of registry entries
AX
AN Ndatabases
AT ajuint
AD Number of database entries
AX
AN Nurls
AT ajuint
AD Number of url entries
AX
AN Depth
AT ajuint
AD Depth of XML when reading
AX
//
typedef struct AjSMartLoc
{
AjPTable *Registries;
AjPTable *Databases;
AjPTable *Urls;
AjPList Reg_read;
AjPList Data_read;
AjPList Url_read;
ajuint Nregistries;
ajuint Ndatabases;
ajuint Nurls;
ajuint Depth;
} AjOMartLoc;
#define AjPMartLoc AjOMartLoc*
ID AjPMartDataset
TY public
MO ajmart
LB ajaxdb
XX
DE Ajax BioMart dataset information
DE
DE AjPMartDataset is implemented as a pointer to a C data structure.
XX
TN AjPPMartDataset
TD
TX
TN AjSMartDataset
TD
TX
TN AjOMartDataset
TD
TX
AN Sets
AT AjPTable*
AD Datasets
AX
AN Set_read
AT AjPList
AD List used for XML / tab-sep processing
AX
AN Nsets
AT ajuint
AD Number of datasets
AX
AN Depth
AT ajuint
AD Depth for XML processing
AX
//
typedef struct AjSMartDataset
{
AjPTable *Sets;
AjPList Set_read;
ajuint Nsets;
ajuint Depth;
} AjOMartDataset;
#define AjPMartDataset AjOMartDataset*
ID AjPMartAttribute
TY public
MO ajmart
LB ajaxdb
XX
DE Ajax BioMart attribute information
DE
DE AjPMartAttribute is implemented as a pointer to a C data structure.
XX
TN AjPPMartAttribute
TD
TX
TN AjSMartAttribute
TD
TX
TN AjOMartAttribute
TD
TX
AN Attributes
AT AjPTable*
AD Attributes
AX
AN Att_read
AT AjPList
AD List used for XML / tab-sep processing
AX
AN Natts
AT ajuint
AD Number of attributes
AX
AN Depth
AT ajuint
AD Depth for XML processing
AX
//
typedef struct AjSMartAttribute
{
AjPTable *Attributes;
AjPList Att_read;
ajuint Natts;
ajuint Depth;
} AjOMartAttribute;
#define AjPMartAttribute AjOMartAttribute*
ID AjPMartFilter
TY public
MO ajmart
LB ajaxdb
XX
DE Ajax BioMart filter information
DE
DE AjPMartFilter is implemented as a pointer to a C data structure.
XX
TN AjPPMartFilter
TD
TX
TN AjSMartFilter
TD
TX
TN AjOMartFilter
TD
TX
AN Filters
AT AjPTable*
AD Filterss
AX
AN Filter_read
AT AjPList
AD List used for XML / tab-sep processing
AX
AN Nfilters
AT ajuint
AD Number of filters
AX
AN Depth
AT ajuint
AD Depth for XML processing
AX
//
typedef struct AjSMartFilter
{
AjPTable *Filters;
AjPList Filter_read;
ajuint Nfilters;
ajuint Depth;
} AjOMartFilter;
#define AjPMartFilter AjOMartFilter*
ID AjPMartdsinfo
TY public
MO ajmart
LB ajaxdb
XX
DE Biomart martservice object for holding query dataset info pre conversion
DE to an XML query string
XX
TN AjSMartdsinfo
TD
TX
TN AjOMartdsinfo
TD
TX
AN Name
AT AjPStr
AD Name of dataset
AX
AN Interface
AT AjPStr
AD Interface of dataset
AX
AN Attributes
AT AjPList
AD Attributes
AX
AN Filters
AT AjPList
AD Filters
AX
//
typedef struct AjSMartdsinfo
{
AjPStr Name;
AjPStr Interface;
AjPList Attributes;
AjPList Filters;
} AjOMartdsinfo;
#define AjPMartdsinfo AjOMartdsinfo*
ID AjPMartqinfo
TY public
MO ajmart
LB ajaxdb
XX
DE Biomart martservice object for holding query info pre conversion
DE to an XML query string
XX
TN AjSMartqinfo
TD
TX
TN AjOMartqinfo
TD
TX
AN Hvirtualschema
AT AjPStr
AD Header virtualSchemaName
AX
AN Hversion
AT AjPStr
AD Header datasetConfigVersion
AX
AN Hformatter
AT AjPStr
AD Header output formatter type
AX
AN Hcount
AT AjBool
AD Header count
AX
AN Hheader
AT AjBool
AD Header flag for printing column names
AX
AN Hstamp
AT AjBool
AD Header flag for completionStamp
AX
AN Hunique
AT AjBool
AD Header flag for unique rows
AX
AN Dsets
AT AjPMartdsinfo*
AD Mart attributes
AX
AN Dnsets
AT ajuint
AD Number of datasets
AX
AN Verify
AT AjBool
AD Check attnames and filtnames
AX
//
typedef struct AjSMartqinfo
{
AjPStr Hvirtualschema;
AjPStr Hversion;
AjPStr Hformatter;
AjBool Hcount;
AjBool Hheader;
AjBool Hstamp;
AjBool Hunique;
AjPMartdsinfo *Dsets;
ajuint Dnsets;
AjBool Verify;
} AjOMartqinfo;
#define AjPMartqinfo AjOMartqinfo*
ID AjPMartquery
TY public
MO ajmart
LB ajaxdb
XX
DE Biomart martservice query object
XX
TN AjSMartquery
TD
TX
TN AjOMartquery
TD
TX
AN Reghost
AT AjPStr
AD Registry host
AX
AN Regpath
AT AjPStr
AD Registry path to mart service on Reghost
AX
AN Marthost
AT AjPStr
AD Host containing desired mart (selected from registry)
AX
AN Martpath
AT AjPStr
AD Path to mart service on Marthost
AX
AN Cachedir
AT AjPStr
AD Cache directory
AX
AN Query
AT AjPStr
AD Mart query
AX
AN Loc
AT AjPMartLoc
AD Mart registry information
AX
AN Mart
AT AjPStr
AD Mart name
AX
AN Dsname
AT AjPStr
AD Dataset name
AX
AN Dataset
AT AjPMartDataset
AD Mart datasets
AX
AN Atts
AT AjPMartAttribute
AD Mart attributes
AX
AN Filters
AT AjPMartFilter
AD Mart filters
AX
AN Config
AT AjPDomDocument
AD Configuration Information
AX
AN Regport
AT ajuint
AD Registry host URL port
AX
AN Martport
AT ajuint
AD Mart host URL port
AX
AN Cacheflag
AT ajuint
AD Control operation of cache
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSMartquery
{
AjPStr Reghost;
AjPStr Regpath;
AjPStr Marthost;
AjPStr Martpath;
AjPStr Cachedir;
AjPStr Query;
AjPMartLoc Loc;
AjPStr Mart;
AjPStr Dsname;
AjPMartDataset Dataset;
AjPMartAttribute Atts;
AjPMartFilter Filters;
AjPDomDocument Config;
ajuint Regport;
ajuint Martport;
ajuint Cacheflag;
ajuint Padding;
} AjOMartquery;
#define AjPMartquery AjOMartquery*
ID AjPMatrix
TY public
MO ajmatrices
LB core
XX
DE AJAX data structure for sequence comparison matrices with integer values
XX
TN AjSMatrix
TD
TX
TN AjOMatrix
TD
TX
AN Size
AT ajint
AD Matrix size (size of 2D array)
AX
AN SizeRow
AT ajint
AD Number of rows (if different to Size)
AX
AN Name
AT AjPStr
AD Matrix name
AX
AN Codes
AT AjPStr*
AD Row/column codes
AX
AN CodesRow
AT AjPStr*
AD Row codes (if different to Codes)
AX
AN Matrix
AT AjIntArray*
AD Matrix as 2D array
AX
AN Cvt
AT AjPSeqCvt
AD Conversion table
AX
//
typedef struct AjSMatrix
{
ajint Size;
ajint SizeRow;
AjPStr Name;
AjPStr* Codes;
AjPStr* CodesRow;
AjIntArray* Matrix;
AjPSeqCvt Cvt;
} AjOMatrix;
#define AjPMatrix AjOMatrix*
ID AjPMatrixf
TY public
MO ajmatrices
LB core
XX
DE AJAX data structure for sequence comparison matrices with floating
DE point values
XX
TN AjSMatrixf
TD
TX
TN AjOMatrixf
TD
TX
AN Size
AT ajint
AD Matrix size (size of 2D array)
AX
AN SizeRow
AT ajint
AD Number of rows (if different to Size)
AX
AN Name
AT AjPStr
AD Matrix name
AX
AN Codes
AT AjPStr*
AD Row/column codes
AX
AN CodesRow
AT AjPStr*
AD Row codes (if different to Codes)
AX
AN Matrixf
AT AjFloatArray*
AD Matrix as 2D array
AX
AN Cvt
AT AjPSeqCvt
AD Conversion table
AX
//
typedef struct AjSMatrixf
{
ajint Size;
ajint SizeRow;
AjPStr Name;
AjPStr* Codes;
AjPStr* CodesRow;
AjFloatArray* Matrixf;
AjPSeqCvt Cvt;
} AjOMatrixf;
#define AjPMatrixf AjOMatrixf*
ID AjPError
TY public
MO ajmess
LB core
XX
DE Ajax error message levels object
XX
TN AjSError
TD
TX
TN AjOError
TD
TX
AN warning
AT AjBool
AD Display ajWarn messages
AX
AN error
AT AjBool
AD Display ajErr messages
AX
AN fatal
AT AjBool
AD Display ajFatal messages
AX
AN die
AT AjBool
AD Display ajDie messages
AX
//
typedef struct AjSError
{
AjBool warning;
AjBool error;
AjBool fatal;
AjBool die;
} AjOError;
#define AjPError AjOError*
ID AjPNexusTaxa
TY public
MO ajnexus
LB core
XX
DE Ajax nexus data taxa block object.
XX
TN AjSNexusTaxa
TD
TX
TN AjONexusTaxa
TD
TX
NN nexusTaxaNew
ND Default constructor
NX
DN nexusTaxaDel
DD Default destructor
DX
AN TaxLabels
AT AjPStr*
AD Taxon names
AX
AN Ntax
AT ajuint
AD Number of taxons
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSNexusTaxa
{
AjPStr* TaxLabels;
ajuint Ntax;
char Padding[4];
} AjONexusTaxa;
#define AjPNexusTaxa AjONexusTaxa*
ID AjPNexusCharacters
TY public
MO ajnexus
LB core
XX
DE Ajax nexus data characters block object.
XX
TN AjSNexusCharacters
TD
TX
TN AjONexusCharacters
TD
TX
NN nexusCharactersNew
ND Default constructor
NX
DN nexusCharactersDel
DD Default destructor
DX
AN NewTaxa
AT AjBool
AD New taxa read from data block
AX
AN Ntax
AT ajuint
AD Number of taxons
AX
AN Nchar
AT ajuint
AD Number of characters
AX
AN RespectCase
AT AjBool
AD Respect case if true
AX
AN DataType
AT AjPStr
AD Data type
AX
AN Symbols
AT AjPStr
AD Character symbols
AX
AN Equate
AT AjPStr
AD Character equivalent names
AX
AN Labels
AT AjBool
AD Labels if true
AX
AN Transpose
AT AjBool
AD Transpose data if true
AX
AN Interleave
AT AjBool
AD Interleaved input if true
AX
AN Tokens
AT AjBool
AD If true, tokens set
AX
AN Items
AT AjPStr
AD Character items
AX
AN StatesFormat
AT AjPStr
AD States format string
AX
AN Eliminate
AT AjPStr
AD Eliminate string
AX
AN CharStateLabels
AT AjPStr*
AD Character and state labels
AX
AN CharLabels
AT AjPStr*
AD Character labels
AX
AN StateLabels
AT AjPStr*
AD State labels
AX
AN Matrix
AT AjPStr*
AD Matrix data
AX
AN Sequences
AT AjPStr*
AD Sequence data
AX
AN Missing
AT char
AD Missing character in input data
AX
AN Gap
AT char
AD Gap character in input data
AX
AN MatchChar
AT char
AD Matching character in input
AX
AN Padding
AT char[5]
AD Padding to alignment boundary
AX
//
typedef struct AjSNexusCharacters
{
AjBool NewTaxa;
ajuint Ntax;
ajuint Nchar;
AjBool RespectCase;
AjPStr DataType;
AjPStr Symbols;
AjPStr Equate;
AjBool Labels;
AjBool Transpose;
AjBool Interleave;
AjBool Tokens;
AjPStr Items;
AjPStr StatesFormat;
AjPStr Eliminate;
AjPStr* CharStateLabels;
AjPStr* CharLabels;
AjPStr* StateLabels;
AjPStr* Matrix;
AjPStr* Sequences;
char Missing;
char Gap;
char MatchChar;
char Padding[5];
} AjONexusCharacters;
#define AjPNexusCharacters AjONexusCharacters*
ID AjPNexusUnaligned
TY public
MO ajnexus
LB core
XX
DE Ajax nexus data unaligned block object.
DE
DE Very similar to a character block and will be merged with AjPNexusCharacter
DE in the near future
XX
TN AjSNexusUnaligned
TD
TX
TN AjONexusUnaligned
TD
TX
NN nexusUnalignedNew
ND Default constructor
NX
DN nexusUnalignedDel
DD Default destructor
DX
AN NewTaxa
AT AjBool
AD New taxa read from data block
AX
AN Ntax
AT ajuint
AD Number of taxons
AX
AN DataType
AT AjPStr
AD Data type
AX
AN RespectCase
AT AjBool
AD Respect case if true
AX
AN Labels
AT AjBool
AD Labels if true
AX
AN Symbols
AT AjPStr
AD Character symbols
AX
AN Equate
AT AjPStr
AD Character equivalent names
AX
AN Matrix
AT AjPStr*
AD Matrix data
AX
AN Missing
AT char
AD Missing character in input data
AX
AN Padding
AT char[7]
AD Padding to alignment boundary
AX
//
typedef struct AjSNexusUnaligned
{
AjBool NewTaxa;
ajuint Ntax;
AjPStr DataType;
AjBool RespectCase;
AjBool Labels;
AjPStr Symbols;
AjPStr Equate;
AjPStr* Matrix;
char Missing;
char Padding[7];
} AjONexusUnaligned;
#define AjPNexusUnaligned AjONexusUnaligned*
ID AjPNexusDistances
TY public
MO ajnexus
LB core
XX
DE Ajax nexus data distances block object.
XX
TN AjSNexusDistances
TD
TX
TN AjONexusDistances
TD
TX
NN nexusDistancesNew
ND Default constructor
NX
DN nexusDistancesDel
DD Default destructor
DX
AN NewTaxa
AT AjBool
AD New taxa read from data block
AX
AN Ntax
AT ajuint
AD Number of taxons
AX
AN Nchar
AT ajuint
AD Number of characters
AX
AN Diagonal
AT AjBool
AD If true, expect to read diagonal of matrix
AX
AN Labels
AT AjBool
AD Labels if true
AX
AN Interleave
AT AjBool
AD Interleaved input if true
AX
AN Triangle
AT AjPStr
AD Triangular distances block type
AX
AN Matrix
AT AjPStr*
AD Matrix data
AX
AN Missing
AT char
AD Missing character in input data
AX
AN Padding
AT char[7]
AD Padding to alignment boundary
AX
//
typedef struct AjSNexusDistances
{
AjBool NewTaxa;
ajuint Ntax;
ajuint Nchar;
AjBool Diagonal;
AjBool Labels;
AjBool Interleave;
AjPStr Triangle;
AjPStr* Matrix;
char Missing;
char Padding[7];
} AjONexusDistances;
#define AjPNexusDistances AjONexusDistances*
ID AjPNexusSets
TY public
MO ajnexus
LB core
XX
DE Ajax nexus data sets block object.
DE
DE The data is generally the NEXUS command strings as in the original file.
XX
TN AjSNexusSets
TD
TX
TN AjONexusSets
TD
TX
NN nexusSetsNew
ND Default constructor
NX
DN nexusSetsDel
DD Default destructor
DX
AN CharSet
AT AjPStr*
AD Character set commands
AX
AN StateSet
AT AjPStr*
AD State set commands
AX
AN ChangeSet
AT AjPStr*
AD Change set commands
AX
AN TaxSet
AT AjPStr*
AD Taxon set commands
AX
AN TreeSet
AT AjPStr*
AD Tree set commands
AX
AN CharPartition
AT AjPStr*
AD Character partition statements
AX
AN TaxPartition
AT AjPStr*
AD Taxa partition statements
AX
AN TreePartition
AT AjPStr*
AD Tree partition statements
AX
//
typedef struct AjSNexusSets
{
AjPStr* CharSet;
AjPStr* StateSet;
AjPStr* ChangeSet;
AjPStr* TaxSet;
AjPStr* TreeSet;
AjPStr* CharPartition;
AjPStr* TaxPartition;
AjPStr* TreePartition;
} AjONexusSets;
#define AjPNexusSets AjONexusSets*
ID AjPNexusAssumptions
TY public
MO ajnexus
LB core
XX
DE Ajax nexus data assumptions block object.
XX
TN AjSNexusAssumptions
TD
TX
TN AjONexusAssumptions
TD
TX
NN nexusAssumptionsNew
ND Default constructor
NX
DN nexusAssumptionsDel
DD Default destructor
DX
AN DefType
AT AjPStr
AD Options deftype subcommand
AX
AN PolyTCount
AT AjPStr
AD Options polytcount subcommand
AX
AN GapMode
AT AjPStr
AD Options gapmode subcommand
AX
AN UserType
AT AjPStr*
AD Usertype commands
AX
AN TypeSet
AT AjPStr*
AD Typeset commands
AX
AN WtSet
AT AjPStr*
AD Wtset commands
AX
AN ExSet
AT AjPStr*
AD Exset commands
AX
AN AncStates
AT AjPStr*
AD Ancstates commands
AX
//
typedef struct AjSNexusAssumptions
{
AjPStr DefType;
AjPStr PolyTCount;
AjPStr GapMode;
AjPStr* UserType;
AjPStr* TypeSet;
AjPStr* WtSet;
AjPStr* ExSet;
AjPStr* AncStates;
} AjONexusAssumptions;
#define AjPNexusAssumptions AjONexusAssumptions*
ID AjPNexusCodons
TY public
MO ajnexus
LB core
XX
DE Ajax nexus data codons block object.
XX
TN AjSNexusCodons
TD
TX
TN AjONexusCodons
TD
TX
NN nexusCodonsNew
ND Default constructor
NX
DN nexusCodonsDel
DD Default destructor
DX
AN CodonPosSet
AT AjPStr*
AD CodonPosSetcommands
AX
AN GeneticCode
AT AjPStr*
AD GeneticCodecommands
AX
AN CodeSet
AT AjPStr*
AD CodeSetcommands
AX
//
typedef struct AjSNexusCodons
{
AjPStr* CodonPosSet;
AjPStr* GeneticCode;
AjPStr* CodeSet;
} AjONexusCodons;
#define AjPNexusCodons AjONexusCodons*
ID AjPNexusTrees
TY public
MO ajnexus
LB core
XX
DE Ajax nexus data trees block object.
XX
TN AjSNexusTrees
TD
TX
TN AjONexusTrees
TD
TX
NN nexusTreesNew
ND Default constructor
NX
DN nexusTreesDel
DD Default destructor
DX
AN Translate
AT AjPStr*
AD Translate commands
AX
AN Tree
AT AjPStr*
AD Tree commands
AX
//
typedef struct AjSNexusTrees
{
AjPStr* Translate;
AjPStr* Tree;
} AjONexusTrees;
#define AjPNexusTrees AjONexusTrees*
ID AjPNexusNotes
TY public
MO ajnexus
LB core
XX
DE Ajax nexus data notes block object.
XX
TN AjSNexusNotes
TD
TX
TN AjONexusNotes
TD
TX
NN nexusNotesNew
ND Default constructor
NX
DN nexusNotesDel
DD Default destructor
DX
AN Text
AT AjPStr*
AD Text commands
AX
AN Picture
AT AjPStr*
AD Picture commands
AX
//
typedef struct AjSNexusNotes
{
AjPStr* Text;
AjPStr* Picture;
} AjONexusNotes;
#define AjPNexusNotes AjONexusNotes*
ID AjPNexus
TY public
MO ajnexus
LB core
XX
DE Ajax nexus data object.
XX
TN AjSNexus
TD
TX
TN AjONexus
TD
TX
NN ajNexusNew
ND Default constructor
NX
DN ajNexusDel
DD Default destructor
DX
AN Taxa
AT AjPNexusTaxa
AD Taxa
AX
AN Characters
AT AjPNexusCharacters
AD Characters (or data)
AX
AN Unaligned
AT AjPNexusUnaligned
AD Unaligned
AX
AN Distances
AT AjPNexusDistances
AD Distances
AX
AN Sets
AT AjPNexusSets
AD Sets
AX
AN Assumptions
AT AjPNexusAssumptions
AD Assumptions
AX
AN Codons
AT AjPNexusCodons
AD Codons
AX
AN Trees
AT AjPNexusTrees
AD Trees
AX
AN Notes
AT AjPNexusNotes
AD Notes
AX
AN Ntax
AT ajuint
AD Number of taxa (wherever they were defined)
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSNexus
{
AjPNexusTaxa Taxa;
AjPNexusCharacters Characters;
AjPNexusUnaligned Unaligned;
AjPNexusDistances Distances;
AjPNexusSets Sets;
AjPNexusAssumptions Assumptions;
AjPNexusCodons Codons;
AjPNexusTrees Trees;
AjPNexusNotes Notes;
ajuint Ntax;
char Padding[4];
} AjONexus;
#define AjPNexus AjONexus*
ID AjPOboin
TY public
MO ajobodata
LB core
XX
DE Ajax Obo Input object.
DE
DE Holds the obo term specification and information needed to read
DE the obo term and possible further terms.
XX
TN AjSOboin
TD
TX
TN AjOOboin
TD
TX
AN Input
AT AjPTextin
AD General text input object
AX
AN OboData
AT void*
AD Format data for reuse, e.g. multiple term input
AD (unused in current code)
AX
//
typedef struct AjSOboin
{
AjPTextin Input;
void *OboData;
} AjOOboin;
#define AjPOboin AjOOboin*
ID AjPOboAccess
TY public
MO ajobodata
LB core
XX
DE Ajax Obo Access database reading object.
DE
DE Holds information needed to read an obo term from a database.
DE Access methods are defined for each known database type.
DE
DE Obo terms are read from the database using the defined
DE database access function, which is usually a static function
DE within ajobodb.c
DE
DE This should be a static data object but is needed for the definition
DE of AjPOboin.
XX
TN AjSOboAccess
TD
TX
TN AjOOboAccess
TD
TX
NN ajOboMethod
ND returns a copy of a known access method definition.
NX
RN AjPOboin
RD Obo input
RX
AN Name
AT const char*
AD Access method name used in emboss.default
AX
AN Access
AT AjBool function
AD Access function
AX
AN AccessFree
AT AjBool function
AD Access cleanup function
AX
AN Qlink
AT const char*
AD Supported query link operators
AX
AN Desc
AT const char*
AD Description
AX
AN Alias
AT AjBool
AD Alias for another name
AX
AN Entry
AT AjBool
AD Supports retrieval of single entries
AX
AN Query
AT AjBool
AD Supports retrieval of selected entries
AX
AN All
AT AjBool
AD Supports retrieval of all entries
AX
AN Chunked
AT AjBool
AD Supports retrieval of entries in chunks
AX
AN Padding
AT AjBool
AD Padding to alignment boundary
AX
//
typedef struct AjSOboAccess
{
const char *Name;
AjBool (*Access)(AjPOboin oboin);
AjBool (*AccessFree)(void* qry);
const char* Qlink;
const char* Desc;
AjBool Alias;
AjBool Entry;
AjBool Query;
AjBool All;
AjBool Chunked;
AjBool Padding;
} AjOOboAccess;
#define AjPOboAccess AjOOboAccess*
ID AjPOboData
TY public
MO ajobodata
LB core
XX
DE OBO parsed data
XX
AN Termtable
AT AjPTable
AD Table of terms by id
AX
AN Termnametable
AT AjPTable
AD Table of terms by name
AX
AN Typedeftable
AT AjPTable
AD Table of typedefs
AX
AN Instancetable
AT AjPTable
AD Table of instances
AX
AN Annotable
AT AjPTable
AD Table of annotation stanzas
AX
AN Formulatable
AT AjPTable
AD Table of formula stanzas
AX
AN Misctable
AT AjPTable
AD Table of other stanzas
AX
//
typedef struct AjSOboData
{
AjPTable Termtable;
AjPTable Termnametable;
AjPTable Typedeftable;
AjPTable Instancetable;
AjPTable Annotable;
AjPTable Formulatable;
AjPTable Misctable;
} AjOOboData;
#define AjPOboData AjOOboData*
ID AjPObotag
TY public
MO ajobodata
LB core
XX
DE OBO tag name, value and comment.
XX
TN AjSObotag
TD
TX
TN AjOObotag
TD
TX
AN Name
AT AjPStr
AD Tag name
AX
AN Value
AT AjPStr
AD Tag value
AX
AN Modifier
AT AjPStr
AD Tag modifier
AX
AN Comment
AT AjPStr
AD Tag comment
AX
AN Linenumber
AT ajuint
AD OBO file line number
AX
AN Padding
AT ajuint
AD Padding to align structure
AX
//
typedef struct AjSObotag
{
AjPStr Name;
AjPStr Value;
AjPStr Modifier;
AjPStr Comment;
ajuint Linenumber;
ajuint Padding;
} AjOObotag;
#define AjPObotag AjOObotag*
ID AjPOboxref
TY public
MO ajobodata
LB core
XX
DE OBO dbxref name and description
XX
TN AjSOboxref
TD
TX
TN AjOOboxref
TD
TX
AN Name
AT AjPStr
AD Dbxref name
AX
AN Desc
AT AjPStr
AD Description (optional)
AX
//
typedef struct AjSOboxref
{
AjPStr Name;
AjPStr Desc;
} AjOOboxref;
#define AjPOboxref AjOOboxref*
ID AjPOboalias
TY public
MO ajobodata
LB core
XX
DE Alias name for an OBO identifier
XX
TN AjSOboalias
TD
TX
TN AjOOboalias
TD
TX
AN Alias
AT AjPStr
AD Alias name of term
AX
AN Id
AT AjPStr
AD Id of term
AX
//
typedef struct AjSOboalias
{
AjPStr Alias;
AjPStr Id;
} AjOOboalias;
#define AjPOboalias AjOOboalias*
ID AjPObo
TY public
MO ajobodata
LB core
XX
DE Ajax obo term object.
DE
DE Holds the term itself, plus associated information.
XX
TN AjOObo
TD
TX
TN AjSObo
TD
TX
AN Id
AT AjPStr
AD Id of term
AX
AN Trueid
AT AjPStr
AD True id of an alt_id
AX
AN Fullid
AT AjPStr
AD Id of term with prefix
AX
AN Name
AT AjPStr
AD Name of term
AX
AN Namespace
AT AjPStr
AD Namespace of term
AX
AN Def
AT AjPStr
AD Definition of term
AX
AN Dbxrefs
AT AjPList
AD List of AjPOboxref names descriptions and modifiers
AX
AN Comment
AT AjPStr
AD Comment tag in term stanza
AX
AN Replaced
AT AjPStr
AD Replacement term for an obsolete term
AX
AN Taglist
AT AjPList
AD List of other AjPObotag tag name-value pairs
AX
AN Obsolete
AT AjBool
AD True if term is obsolete
AX
AN Builtin
AT AjBool
AD True if term is an OBO Built-in term
AX
AN Db
AT AjPStr
AD Database name from input
AX
AN Setdb
AT AjPStr
AD Database name from command line
AX
AN Full
AT AjPStr
AD Full name
AX
AN Qry
AT AjPStr
AD Query for re-reading
AX
AN Formatstr
AT AjPStr
AD Input format name
AX
AN Filename
AT AjPStr
AD Original filename
AX
AN TextPtr
AT AjPStr
AD Full text
AX
AN Fpos
AT ajlong
AD File position (fseek) for Query
AX
AN Format
AT AjEnum
AD Input format enum
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSObo
{
AjPStr Id;
AjPStr Trueid;
AjPStr Fullid;
AjPStr Name;
AjPStr Namespace;
AjPStr Def;
AjPList Dbxrefs;
AjPStr Comment;
AjPStr Replaced;
AjPList Taglist;
AjBool Obsolete;
AjBool Builtin;
AjPStr Db;
AjPStr Setdb;
AjPStr Full;
AjPStr Qry;
AjPStr Formatstr;
AjPStr Filename;
AjPStr TextPtr;
ajlong Fpos;
AjEnum Format;
ajuint Padding;
} AjOObo;
#define AjPObo AjOObo*
ID AjPOboall
TY public
MO ajobodata
LB core
XX
DE Ajax obo term all (stream) object.
DE
DE Inherits an AjPObo but allows more obo terms to be read from the
DE same input by also inheriting the AjPOboin input object.
XX
TN AjSOboall
TD
TX
TN AjOOboall
TD
TX
AN Obo
AT AjPObo
AD Current term
AX
AN Oboin
AT AjPOboin
AD Obo input for reading next
AX
AN Totterms
AT ajulong
AD Count of terms so far
AX
AN Count
AT ajuint
AD Count of terms so far
AX
AN Multi
AT AjBool
AD True if multiple values are expected
AX
AN Returned
AT AjBool
AD if true: Obo object has been returned to a new owner
AD and is not to be deleted by the destructor
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSOboall
{
AjPObo Obo;
AjPOboin Oboin;
ajulong Totterms;
ajuint Count;
AjBool Multi;
AjBool Returned;
char Padding[4];
} AjOOboall;
#define AjPOboall AjOOboall*
ID AjPPatBYPNode
TY public
MO ajpat
LB core
XX
DE AJAX data structure for nodes in Baeza-Yates & Perleberg algorithm
XX
AN next
AT struct AjSPatBYPNode*
AD Pointer to next node
AX
AN offset
AT ajint
AD Offset
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSPatBYPNode
{
struct AjSPatBYPNode *next;
ajint offset;
char Padding[4];
} AjOPatBYPNode;
#define AjPPatBYPNode AjOPatBYPNode*
ID AjPPatComp
TY public
MO ajpat
LB core
XX
DE AJAX data structure that holds all needed data for compiling and
DE searching. Not including mismatch number.
XX
TN AjSPatComp
TD
TX
TN AjOPatComp
TD
TX
AN pattern
AT AjPStr
AD Prosite pattern string
AX
AN type
AT ajuint
AD Prosite pattern compile type
AX
AN plen
AT ajuint
AD Prosite pattern length
AX
AN buf
AT ajint*
AD Buffer for BMH search (can be -1)
AX
AN off
AT AjOPatBYPNode[AJALPHA]
AD Offset buffer for B-Y/P search
AX
AN sotable
AT ajuint*
AD Buffer for SHIFT-OR
AX
AN solimit
AT ajuint
AD Limit for BMH search
AX
AN m
AT ajuint
AD Real length of pattern (from embPatGetType)
AX
AN regex
AT AjPStr
AD PCRE regexp string
AX
AN skipm
AT ajuint**
AD Skip buffer for Tarhio-Ukkonen
AX
AN amino
AT AjBool
AD Must match left begin
AX
AN carboxyl
AT AjBool
AD Must match right
AX
//
typedef struct AjSPatComp
{
AjPStr pattern;
ajuint type;
ajuint plen;
ajint* buf;
AjOPatBYPNode off[AJALPHA];
ajuint* sotable;
ajuint solimit;
ajuint m;
AjPStr regex;
ajuint** skipm;
AjBool amino;
AjBool carboxyl;
} AjOPatComp;
#define AjPPatComp AjOPatComp*
ID AjPPatternSeq
TY public
MO ajpat
LB core
XX
DE Ajax sequence pattern object.
DE
DE Holds definition of feature pattern. Regular expression patterns ignore
DE mismatch value.
XX
TN AjSPatternSeq
TD
TX
TN AjOPatternSeq
TD
TX
AN Name
AT AjPStr
AD Name.
AX
AN Pattern
AT AjPStr
AD Pattern in string format.
AX
AN Compiled
AT void*
AD Compiled version of the pattern.
AX
AN Protein
AT AjBool
AD True if protein pattern
AX
AN Mismatch
AT ajuint
AD Mismatch value.
AX
NN ajPatternSeqNew
ND Default constructor
NX
DN ajPatternSeqDel
DD Default destructor
DX
ON ajPatternSeqGetName
OD Returns name.
OX
ON ajPatternSeqGetPattern
OD Returns pattern in string format.
OX
ON ajPatternSeqGetCompiled
OD Returns pointer to compiled pattern.
OX
ON ajPatternSeqGetType
OD Returns type as integer value.
OX
ON ajPatternSeqGetMismatch
OD Return mismatch value.
OX
//
typedef struct AjSPatternSeq
{
AjPStr Name;
AjPStr Pattern;
void* Compiled;
AjBool Protein;
ajuint Mismatch;
} AjOPatternSeq;
#define AjPPatternSeq AjOPatternSeq*
ID AjPPatternRegex
TY public
MO ajpat
LB core
XX
DE Ajax regular expression pattern object.
DE
DE Holds definition of feature pattern. Regular expression patterns ignore
DE mismatch value.
XX
TN AjSPatternRegex
TD
TX
TN AjOPatternRegex
TD
TX
AN Name
AT AjPStr
AD Name.
AX
AN Pattern
AT AjPStr
AD Pattern in string format.
AX
AN Compiled
AT AjPRegexp
AD Compiled version of the pattern.
AX
AN Type
AT ajuint
AD Type.
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajPatternRegexNew
ND Default constructor
NX
DN ajPatternRegexDel
DD Default destructor
DX
ON ajPatternRegexGetName
OD Returns name.
OX
ON ajPatternRegexGetPattern
OD Returns pattern in string format.
OX
ON ajPatternRegexGetCompiled
OD Returns pointer to compiled pattern.
OX
ON ajPatternRegexGetType
OD Returns type as integer value.
OX
//
typedef struct AjSPatternRegex
{
AjPStr Name;
AjPStr Pattern;
AjPRegexp Compiled;
ajuint Type;
char Padding[4];
} AjOPatternRegex;
#define AjPPatternRegex AjOPatternRegex*
ID AjPPatlistSeq
TY public
MO ajpat
LB core
XX
DE Ajax Pattern List object.
DE
DE Holds list of feature patterns and general information of them.
XX
TN AjSPatlistSeq
TD
TX
TN AjOPatlistSeq
TD
TX
AN Patlist
AT AjPList
AD List for patterns.
AX
AN Iter
AT AjIList
AD List iterator.
AX
AN Protein
AT AjBool
AD True if protein
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajPatlistNew
ND Default constructor.
NX
DN ajPatlistDel
DD Default destructor.
DX
MN ajPatlistRegexRead
MD Reads the pattern file and fills the list.
MX
MN ajPatlistSeqRead
MD Reads the pattern file and fills the list.
MX
MN ajPatlistRewind
MD Restarts the iteration loop.
MX
MN ajPatlistAdd
MD Adds new pattern into list.
MX
ON ajPatlistGetNext
OD Gets the next pattern from file and returns true if
OD available and false if not.
OX
//
typedef struct AjSPatlistSeq
{
AjPList Patlist;
AjIList Iter;
AjBool Protein;
char Padding[4];
} AjOPatlistSeq;
#define AjPPatlistSeq AjOPatlistSeq*
ID AjPPatlistRegex
TY public
MO ajpat
LB core
XX
DE Ajax Pattern List object.
DE
DE Holds list of feature patterns and general information of them.
XX
TN AjSPatlistRegex
TD
TX
TN AjOPatlistRegex
TD
TX
AN Patlist
AT AjPList
AD List for patterns.
AX
AN Iter
AT AjIList
AD List iterator.
AX
AN Type
AT ajuint
AD Type of expression
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajPatlistNew
ND Default constructor.
NX
DN ajPatlistDel
DD Default destructor.
DX
MN ajPatlistRegexRead
MD Reads the pattern file and fills the list.
MX
MN ajPatlistSeqRead
MD Reads the pattern file and fills the list.
MX
MN ajPatlistRewind
MD Restarts the iteration loop.
MX
MN ajPatlistAdd
MD Adds new pattern into list.
MX
ON ajPatlistGetNext
OD Gets the next pattern from file and returns true if
OD available and false if not.
OX
//
typedef struct AjSPatlistRegex
{
AjPList Patlist;
AjIList Iter;
ajuint Type;
char Padding[4];
} AjOPatlistRegex;
#define AjPPatlistRegex AjOPatlistRegex*
ID AjECmapType
TY public
MO ajpdb
LB core
XX
DE AJAX Cmap Type enumeration
XX
VN ajECmapTypeNULL
VD NULL
VX
VN ajECmapTypeIntra
VD Intra-molecular contact
VX
VN ajECmapTypeInter
VD Inter-molecular contact
VX
VN ajECmapTypeLigand
VD Ligand contact
VX
//
typedef enum AjOCmapType
{
ajECmapTypeNULL,
ajECmapTypeIntra,
ajECmapTypeInter,
ajECmapTypeLigand
} AjECmapType;
ID AjEPdbMethod
TY public
MO ajpdb
LB core
XX
DE AJAX PDB Method enumeration
XX
VN ajEPdbMethodNULL
VD NULL
VX
VN ajEPdbMethodXray
VD Structure was determined by X-ray crystallography
VX
VN ajEPdbMethodNmr
VD Structure was determined by NMR or is a model
VX
//
typedef enum AjOPdbMethod
{
ajEPdbMethodNULL,
ajEPdbMethodXray,
ajEPdbMethodNmr
} AjEPdbMethod;
ID AjEPdbMode
TY public
MO ajpdb
LB core
XX
DE AJAX PDB Mode enumeration
XX
VN ajEPdbModeNULL
VD NULL
VX
VN ajEPdbModePdb
VD Original PDB residue numbering
VX
VN ajEPdbModeIdx
VD Corrected residue numbering
TD (index into SEQRES sequence)
VX
//
typedef enum AjOPdbMode
{
ajEPdbModeNULL,
ajEPdbModePdb,
ajEPdbModeIdx
} AjEPdbMode;
ID AjPAtom
TY public
MO ajpdb
LB core
XX
DE Ajax atom object.
DE
DE Holds protein atom data
DE
DE AjPAtom is implemented as a pointer to a C data structure.
XX
TN AjSAtom
TD
TX
TN AjOAtom
TD
TX
AN Mod
AT ajuint
AD Model number
AX
AN Chn
AT ajuint
AD Chain number
AX
AN Gpn
AT ajint
AD Group number
AX
AN Idx
AT ajuint
AD Residue number - index into sequence.
AX
AN Pdb
AT AjPStr
AD Residue number string from the original PDB file.
AX
AN Id3
AT AjPStr
AD Residue or group identifier.
AX
AN Atm
AT AjPStr
AD Atom identifier.
AX
AN X
AT float
AD X coordinate.
AX
AN Y
AT float
AD Y coordinate.
AX
AN Z
AT float
AD Z coordinate.
AX
AN O
AT float
AD Occupancy.
AX
AN B
AT float
AD B value thermal factor.
AX
AN Id1
AT char
AD Standard residue identifier or 'X' for unknown
AD types or '.' for heterogens and water.
AX
AN Type
AT char
AD 'P' (protein atom), 'H' ("heterogens") or 'W'
AD (water).
AX
AN Padding
AT char[2]
AD Padding to alignment boundary
AX
NN ajAtomNew
ND Default Atom constructor.
NX
DN ajAtomDel
DD Default Atom destructor.
DX
EN ajAtomCopy
ED Replicates an Atom object.
EX
EN ajAtomListCopy
ED Replicates a list of Atom objects.
EX
ON embAtomInContact
OD Determines whether two atoms are in physical
OD contact.
OX
ON embAtomDistance
OD Returns the distance (Angstroms) between two
OD atoms.
OX
ON embVdwRad
OD Returns the van der Waals radius of an atom.
OX
RN embPdbListHeterogens
RD Construct a list of arrays of Atom objects
RD for ligands in the current Pdb object (a single array for each
RD ligand).
RX
//
typedef struct AjSAtom
{
ajuint Mod;
ajuint Chn;
ajint Gpn;
ajuint Idx;
AjPStr Pdb;
AjPStr Id3;
AjPStr Atm;
float X;
float Y;
float Z;
float O;
float B;
char Id1;
char Type;
char Padding[2];
} AjOAtom;
#define AjPAtom AjOAtom*
ID AjPResidue
TY public
MO ajpdb
LB core
XX
DE Ajax Residue object.
DE
DE Holds data for an amino acid residue.
DE
DE AjPResidue is implemented as a pointer to a C data structure.
XX
TN AjSResidue
TD
TX
TN AjOResidue
TD
TX
AN Mod
AT ajuint
AD Model number
AX
AN Chn
AT ajuint
AD Chain number
AX
AN Idx
AT ajuint
AD Residue number. Can be used to index into the
AD polypeptide sequence (the Seq element of an
AD AjSChain object). Idx numbers start at 1 and run
AD sequentially.
AX
AN eNum
AT ajint
AD Element serial number (for secondary structure
AD from the PDB file).
AX
AN Pdb
AT AjPStr
AD Residue number string from the original PDB file.
AX
AN Id3
AT AjPStr
AD 3-letter residue identifier code.
AX
AN eId
AT AjPStr
AD Element identifier (for secondary structure from
AD the PDB file).
AX
AN eClass
AT ajint
AD Class of helix, an int from 1-10, from
AD http://www.rcsb.org/pdb/docs/format/pdbguide2.2/guide2.2_frame.html
AD (for secondary structure from the PDB file).
AX
AN eStrideNum
AT ajint
AD Number of the element: sequential count from
AD N-term (for secondary structure from STRIDE).
AX
AN Phi
AT float
AD Phi angle.
AX
AN Psi
AT float
AD Psi angle.
AX
AN Area
AT float
AD Residue solvent accessible area.
AX
AN all_abs
AT float
AD Absolute accessibility, all atoms.
AX
AN all_rel
AT float
AD Relative accessibility, all atoms.
AX
AN side_abs
AT float
AD Absolute accessibility, atoms in side chain.
AX
AN side_rel
AT float
AD Relative accessibility, atoms in side chain.
AX
AN main_abs
AT float
AD Absolute accessibility, atoms in main chain.
AX
AN main_rel
AT float
AD Relative accessibility, atoms in main chain.
AX
AN npol_abs
AT float
AD Absolute accessibility, non-polar atoms.
AX
AN npol_rel
AT float
AD Relative accessibility, non-polar atoms.
AX
AN pol_abs
AT float
AD Absolute accessibility, polar atoms.
AX
AN pol_rel
AT float
AD Relative accessibility, polar atoms.
AX
AN Id1
AT char
AD Standard 1-letter residue identifier or 'X' for
AD unknown types.
AX
AN eType
AT char
AD Element type COIL ('C'), HELIX ('H'), SHEET ('E')
AD or TURN ('T'). Has a default value of COIL
AD (for secondary structure from the PDB file).
AX
AN eStrideType
AT char
AD Element type:
AD ALPHA HELIX ('H'),
AD 3-10 HELIX ('G'),
AD PI-HELIX ('I'),
AD EXTENDED CONFORMATION ('E'),
AD ISOLATED BRIDGE ('B' or 'b'),
AD TURN ('T') or
AD COIL (none of the above) ('C')
AD (for secondary structure from STRIDE).
AX
AN Padding
AT char[1]
AD Padding to alignment boundary
AX
NN ajResidueNew
ND Default Residue constructor.
NX
DN ajResidueDel
DD Default Residue destructor.
DX
EN ajResidueCopy
ED Replicates a Residue object.
EX
EN ajResidueListCopy
ED Replicates a list of Residue objects.
EX
ON ajResidueEnv1
OD Assigns environment based on side chain accessibility and
OD secondary structure.
OX
ON ajResidueEnv2
OD Assigns environment based on side chain accessibility and
OD secondary structure.
OX
ON ajResidueEnv3
OD Assigns environment based on side chain accessibility and
OD secondary structure.
OX
ON ajResidueEnv4
OD Assigns environment based on side chain accessibility and
OD secondary structure.
OX
ON ajResidueEnv5
OD Assigns environment based on side chain accessibility and
OD secondary structure.
OX
ON ajResidueEnv6
OD Assigns environment based on side chain accessibility and
OD secondary structure.
OX
ON ajResidueEnv7
OD Assigns environment based on side chain accessibility and
OD secondary structure.
OX
ON ajResidueEnv8
OD Assigns environment based on side chain accessibility and
OD secondary structure.
OX
ON ajResidueEnv9
OD Assigns environment based on side chain accessibility
OD and secondary structure.
OX
ON ajResidueEnv10
OD Assigns environment based on side chain accessibility
OD and secondary structure.
OX
ON ajResidueEnv11
OD Assigns environment based on side chain accessibility
OD and secondary structure.
OX
ON ajResidueEnv12
OD Assigns environment based on side chain accessibility
OD and secondary structure.
OX
ON ajResidueEnv13
OD Assigns environment based on side chain accessibility
OD and secondary structure.
OX
ON ajResidueEnv14
OD Assigns environment based on side chain accessibility
OD and secondary structure.
OX
ON ajResidueEnv15
OD Assigns environment based on side chain accessibility
OD and secondary structure.
OX
ON ajResidueEnv16
OD Assigns environment based on side chain accessibility
OD and secondary structure.
OX
ON ajResidueSSEnv
OD Assigns secondary structure environment of a residue.
OX
//
typedef struct AjSResidue
{
ajuint Mod;
ajuint Chn;
ajuint Idx;
ajint eNum;
AjPStr Pdb;
AjPStr Id3;
AjPStr eId;
ajint eClass;
ajint eStrideNum;
float Phi;
float Psi;
float Area;
float all_abs;
float all_rel;
float side_abs;
float side_rel;
float main_abs;
float main_rel;
float npol_abs;
float npol_rel;
float pol_abs;
float pol_rel;
char Id1;
char eType;
char eStrideType;
char Padding[1];
} AjOResidue;
#define AjPResidue AjOResidue*
ID AjPChain
TY public
MO ajpdb
LB core
XX
DE Ajax chain object.
DE
DE Holds protein chain data
DE
DE AjPChain is implemented as a pointer to a C data structure.
XX
TN AjSChain
TD
TX
TN AjOChain
TD
TX
AN Nres
AT ajuint
AD Number of amino acid residues.
AX
AN Nlig
AT ajuint
AD Number of groups which are non-covalently
AD associated with the chain, excluding water
AD ("heterogens").
AX
AN numHelices
AT ajint
AD No. of helices in the chain according to the
AD PDB file.
AX
AN numStrands
AT ajint
AD No. of strands in the chain according to the
AD PDB file.
AX
AN Seq
AT AjPStr
AD Protein sequence as string.
AX
AN Atoms
AT AjPList
AD List of Atom objects for (potentially multiple
AD models) of the polypeptide chain and any
AD groups (ligands) that could be uniquely
AD associated with a chain.
AX
AN Residues
AT AjPList
AD List of Residue objects for (potentially
AD multiple models) of the polypeptide chain.
AX
AN Id
AT char
AD Chain id, ('.' if one wasn't specified in
AD the PDB file).
AX
AN Padding
AT char[7]
AD Padding to alignment boundary
AX
NN ajChainNew
ND Default Chain constructor.
NX
DN ajChainDel
DD Default Chain destructor.
DX
//
typedef struct AjSChain
{
ajuint Nres;
ajuint Nlig;
ajint numHelices;
ajint numStrands;
AjPStr Seq;
AjPList Atoms;
AjPList Residues;
char Id;
char Padding[7];
} AjOChain;
#define AjPChain AjOChain*
ID AjPPdb
TY public
MO ajpdb
LB core
XX
DE Ajax pdb object.
DE
DE Holds arrays describing pdb data
DE
DE AjPPdb is implemented as a pointer to a C data structure.
XX
TN AjSPdb
TD
TX
TN AjOPdb
TD
TX
AN Pdb
AT AjPStr
AD PDB code
AX
AN Compnd
AT AjPStr
AD Text from COMPND records in PDB file
AX
AN Source
AT AjPStr
AD Text from SOURCE records in PDB file
AX
AN Method
AT AjEPdbMethod
AD AJAX PDB Method enumeration
AX
AN Reso
AT float
AD Resolution of an XRAY structure or 0
AX
AN Nmod
AT ajuint
AD Number of models (always 1 for XRAY structures)
AX
AN Nchn
AT ajuint
AD Number of polypeptide chains
AX
AN Chains
AT AjPChain*
AD Array of pointers to AjSChain structures
AX
AN gpid
AT AjPChar
AD Array of chain (group) id's for groups that
AD could not be uniquely associated with a chain.
AX
AN Groups
AT AjPList
AD List of Atom objects for groups that could not
AD be uniquely associated with a chain.
AX
AN Water
AT AjPList
AD List of Atom objects for water molecules.
AX
AN Ngp
AT ajuint
AD Number of groups that could not be uniquely
AD associated with a chain in the SEQRES records.
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajPdbNew
ND Default Pdb constructor.
NX
NN ajPdbReadRawNew
ND Pdb constructor from reading pdb format file.
NX
NN ajPdbReadNew
ND Pdb constructor from reading CCF format file.
NX
NN ajPdbReadFirstModelNew
ND Pdb constructor from reading CCF format
ND file (retrieve data for 1st model only).
NX
NN ajPdbReadoldNew
ND Pdb constructor from reading CCF format file
ND lacking residue-level description in RE records.
NX
NN ajPdbReadoldFirstModelNew
ND Pdb constructor from reading CCF format
ND file lacking residue-level description in RE records.
NX
DN ajPdbDel
DD Default Pdb destructor.
DX
EN ajPdbCopy
ED Replicates a Pdb object.
EX
ON ajPdbGetEStrideType
OD Reads a Pdb object and writes a string with
OD the secondary structure.
OX
ON ajPdbChnidToNum
OD Finds the chain number for a given chain
OD identifier.
OX
ON embPdbToIdx
OD Reads a Pdb object and writes an integer which gives
OD the index into the protein sequence for a residue with a
OD specified pdb residue number and a specified chain number.
OX
ON embPdbidToSp
OD Read a pdb identifier code and writes the equivalent
OD swissprot identifier code.
OX
ON embPdbidToAcc
OD Read a pdb identifier code and writes the equivalent
OD accession number.
OX
ON embPdbidToScop
OD Writes a list of scop identifier codes for the
OD domains that a Pdb object contains.
OX
CN embPdbAtomIndexI
CD Reads a Pdb object and writes an integer array
CD which gives the index into the protein sequence for structured
CD residues (residues for which electron density was determined) for
CD a given chain.
CX
CN embPdbAtomIndexICA
CD Reads a Pdb object and writes an integer array
CD which gives the index into the protein sequence for structured
CD residues (residues for which electron density was determined) for
CD a given chain, EXCLUDING those residues for which CA atoms are
CD missing.
CX
CN embPdbAtomIndexCCA
CD Reads a Pdb object and writes an integer array
CD which gives the index into the protein sequence for structured
CD residues (residues for which electron density was determined) for
CD a given chain, EXCLUDING those residues for which CA atoms are
CD missing.
CX
PN ajPdbWriteDomainRecordRaw
PD Writes lines to a pdb format file for
PD a domain.
PX
PN ajPdbWriteRecordRaw
PD Writes lines to a pdb format file for a
PD protein.
PX
PN ajPdbWriteAllRaw
PD Writes a pdb-format file for a protein.
PX
PN ajPdbWriteDomainRaw
PD Writes a pdb-format file for a SCOP domain.
PX
PN ajPdbWriteAll
PD Writes a CCF-format file for a protein.
PX
PN ajPdbWriteDomain
PD Writes a CCF-format file for a domain).
PX
PN ajPdbWriteSegment
PD Writes a CCF-format file for a segment of a
PD protein.
PX
CN embPdbListHeterogens
CD Construct a list of arrays of Atom objects
CD for ligands in the current Pdb object (a single array for each
CD ligand).
CX
//
typedef struct AjSPdb
{
AjPStr Pdb;
AjPStr Compnd;
AjPStr Source;
AjEPdbMethod Method;
float Reso;
ajuint Nmod;
ajuint Nchn;
AjPChain *Chains;
AjPChar gpid;
AjPList Groups;
AjPList Water;
ajuint Ngp;
char Padding[4];
} AjOPdb;
#define AjPPdb AjOPdb*
ID AjPHetent
TY public
MO ajpdb
LB core
XX
DE AJAX Hetent object.
DE
DE Holds a single entry from a dictionary of heterogen groups.
DE
DE AjPHetent is implemented as a pointer to a C data structure.
XX
TN AjSHetent
TD
TX
TN AjOHetent
TD
TX
AN abv
AT AjPStr
AD 3-letter abbreviation of heterogen.
AX
AN syn
AT AjPStr
AD Synonym.
AX
AN ful
AT AjPStr
AD Full name.
AX
AN cnt
AT ajint
AD No. of occurrences (files) of this heterogen in a
AD directory.
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajHetentNew
ND Default Hetent constructor.
NX
DN ajHetentDel
DD Default Hetent destructor.
DX
//
typedef struct AjSHetent
{
AjPStr abv;
AjPStr syn;
AjPStr ful;
ajint cnt;
char Padding[4];
} AjOHetent;
#define AjPHetent AjOHetent*
ID AjPHet
TY public
MO ajpdb
LB core
XX
DE AJAX Het object.
DE Holds a dictionary of heterogen groups.
DE
DE AjPHet is implemented as a pointer to a C data structure.
XX
TN AjSHet
TD
TX
TN AjOHet
TD
TX
AN Entries
AT AjPHetent*
AD Array of AJAX Heterogen Entries
AX
AN Number
AT ajuint
AD Number of entries
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajHetNew
ND Default Het constructor.
NX
NN ajHetReadRawNew
ND Het constructor from reading dictionary of
ND heterogen groups in raw format.
NX
NN ajHetReadNew
ND Het constructor from reading dictionary of
ND heterogen groups in embl-like format (see documentation for the
ND EMBASSY DOMAINATRIX package).
NX
DN ajHetDel
DD Default Het destructor.
DX
PN ajHetWrite
PD Write Het object to file in embl-like format (see
PD documentation for the EMBASSY DOMAINATRIX package).
PX
//
typedef struct AjSHet
{
AjPHetent *Entries;
ajuint Number;
char Padding[4];
} AjOHet;
#define AjPHet AjOHet*
ID AjPVdwres
TY public
MO ajpdb
LB core
XX
DE AJAX Vdwres object.
DE
DE Holds the Van der Waals radius for atoms in a residue
DE
DE AjPVdwres is implemented as a pointer to a C data structure.
XX
TN AjSVdwres
TD
TX
TN AjOVdwres
TD
TX
AN Id3
AT AjPStr
AD 3 character residue identifier.
AX
AN Atm
AT AjPStr*
AD Array of atom identifiers.
AX
AN Rad
AT float*
AD Array of van der Waals radii.
AX
AN N
AT ajuint
AD Number of atoms in residue.
AX
AN Id1
AT char
AD Standard residue identifier or 'X' for unknown.
AX
AN Padding
AT char[3]
AD Padding to alignment boundary
AX
NN ajVdwresNew
ND Default Vdwres constructor.
NX
DN ajVdwresDel
DD Default Vdwres destructor.
DX
//
typedef struct AjSVdwres
{
AjPStr Id3;
AjPStr *Atm;
float *Rad;
ajuint N;
char Id1;
char Padding[3];
} AjOVdwres;
#define AjPVdwres AjOVdwres*
ID AjPVdwall
TY public
MO ajpdb
LB core
XX
DE Ajax Vdwall object.
DE
DE Holds the Van der Waals radii for all types of protein atoms
DE
DE AjPVdwall is implemented as a pointer to a C data structure.
XX
TN AjSVdwall
TD
TX
TN AjOVdwall
TD
TX
AN Res
AT AjPVdwres*
AD Array of Vdwres structures.
AX
AN N
AT ajuint
AD Number of residues.
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajVdwallNew
ND Default Vdwall constructor.
NX
NN ajVdwallReadNew
ND Vdwall constructor from reading file in embl-like
ND format (see documentation for the EMBASSY DOMAINATRIX package).
NX
DN ajVdwallDel
DD Default Vdwall destructor.
DX
//
typedef struct AjSVdwall
{
AjPVdwres *Res;
ajuint N;
char Padding[4];
} AjOVdwall;
#define AjPVdwall AjOVdwall*
ID AjPCmap
TY public
MO ajpdb
LB core
XX
DE Ajax Cmap object.
DE
DE Holds a contact map and associated data for a protein domain / chain
DE (intra or inter-chain contacts) or between a protein / domain and a
DE ligand. For ligand contacts, the first row / column only of the contact
DE map is used.
DE
DE AjPCmap is implemented as a pointer to a C data structure.
XX
TN AjSCmap
TD
TX
TN AjOCmap
TD for intra-chain, inter-chain and chain-ligand contacts respectively.
TX
AN Id
AT AjPStr
AD Protein id code.
AX
AN Domid
AT AjPStr
AD Domain id code.
AX
AN Ligid
AT AjPStr
AD Ligand id code.
AX
AN Chn1
AT ajint
AD Chain number 1 (first chain)
AX
AN Chn2
AT ajint
AD Chain number 2 (second chain if available)
AX
AN Nres1
AT ajint
AD Number of residues in chain/domain 1
AX
AN Nres2
AT ajint
AD Number of residues in chain/domain 2
AX
AN Seq1
AT AjPStr
AD The sequence of the first domain or chain.
AX
AN Seq2
AT AjPStr
AD The sequence of the second domain or chain.
AX
AN Mat
AT AjPUint2d
AD Contact map.
AX
AN Dim
AT ajint
AD Dimension of contact map.
AX
AN Ncon
AT ajint
AD No. of contacts (1's in contact map).
AX
AN en
AT ajint
AD Entry number.
AX
AN ns
AT ajint
AD No. of sites (ajLIGAND only)
AX
AN sn
AT ajint
AD Site number (ajLIGAND only)
AX
AN Type
AT AjECmapType
AD AJAX Cmap Type enumeration
AX
AN Desc
AT AjPStr
AD Description of ligand (ajLIGAND only)
AX
AN Chid1
AT char
AD Chain identifier 1 (first chain)
AX
AN Chid2
AT char
AD Chain identifier 2 (second chain if available)
AX
AN Padding
AT char[6]
AD Padding to alignment boundary
AX
NN ajCmapNew
ND Default Cmap constructor.
NX
NN ajCmapReadINew
ND Cmap constructor from reading file in CON
ND (embl-like)format (see documentation for the EMBASSY DOMAINATRIX
ND package).
NX
NN ajCmapReadCNew
ND Cmap constructor from reading file in CON
ND format (see documentation for the EMBASSY DOMAINATRIX package).
NX
NN ajCmapReadNew
ND Cmap constructor from reading file in CON
ND format (see documentation for the EMBASSY DOMAINATRIX package).
NX
NN ajCmapReadAllNew
ND Constructs list of Cmap objects from reading file
ND in CON format (see documentation for the EMBASSY
ND DOMAINATRIX package).
NX
DN ajCmapDel
DD Default Cmap destructor.
DX
PN ajCmapWrite
PD Write Cmap object to file in CON format.
PX
//
typedef struct AjSCmap
{
AjPStr Id;
AjPStr Domid;
AjPStr Ligid;
ajint Chn1;
ajint Chn2;
ajint Nres1;
ajint Nres2;
AjPStr Seq1;
AjPStr Seq2;
AjPUint2d Mat;
ajint Dim;
ajint Ncon;
ajint en;
ajint ns;
ajint sn;
AjECmapType Type;
AjPStr Desc;
char Chid1;
char Chid2;
char Padding[6];
} AjOCmap;
#define AjPCmap AjOCmap*
ID AjPPdbtosp
TY public
MO ajpdb
LB core
XX
DE Ajax Pdbtosp object.
DE
DE Holds swissprot codes and accession numbers for a PDB code.
DE
DE AjPPdbtosp is implemented as a pointer to a C data structure.
XX
TN AjSPdbtosp
TD
TX
TN AjOPdbtosp
TD
TX
AN Pdb
AT AjPStr
AD PDB code
AX
AN Acc
AT AjPStr*
AD Accession numbers
AX
AN Spr
AT AjPStr*
AD Swissprot codes
AX
AN Number
AT ajuint
AD Number of entries for this pdb code
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajPdbtospNew
ND Default Pdbtosp constructor.
NX
NN ajPdbtospReadAllRawNew
ND Pdbtosp constructor from reading swissprot-
ND pdb equivalence table in raw format.
NX
NN ajPdbtospReadNew
ND Pdbtosp constructor from reading file in
ND embl-like format (see documentation for the EMBASSY DOMAINATRIX
ND package).
NX
NN ajPdbtospReadCNew
ND Pdbtosp constructor from reading file in
ND embl-like format (see documentation for the EMBASSY DOMAINATRIX
ND package).
NX
DN ajPdbtospDel
DD Default Pdbtosp destructor.
DX
NN ajPdbtospReadAllNew
ND Constructor for list of Pdbtosp objects from
ND reading file in embl-like format (see documentation for the
ND EMBASSY DOMAINATRIX package).
NX
PN ajPdbtospWrite
PD Write Pdbtosp object to file in embl-like format
PD (see documentation for the EMBASSY DOMAINATRIX package).
PX
ON ajPdbtospArrFindPdbid
OD Binary search for Pdb element over array
OD of Pdbtosp objects.
OX
//
typedef struct AjSPdbtosp
{
AjPStr Pdb;
AjPStr *Acc;
AjPStr *Spr;
ajuint Number;
char Padding[4];
} AjOPdbtosp;
#define AjPPdbtosp AjOPdbtosp*
ID AjEPdbioMode
TY public
MO ajpdbio
LB core
XX
DE AJAX PDB Input Output Mode enumeration for writing in PDB format
XX
VN ajEPdbioModeHeaderDomain
VD Header line for domain PDB file
VX
VN ajEPdbioModeSeqresDomain
VD SEQRES records for domain
VX
VN ajEPdbioModeAtomPdbDomain
VD ATOM records for domain using original residue numbers
VX
VN ajEPdbioModeAtomIdxDomain
VD ATOM records for domain using residues numbers that give correct index
TD into SEQRES sequence
VX
VN ajEPdbioModeSeqResChain
VD SEQRES records for a chain
VX
VN ajEPdbioModeAtomPdbChain
VD ATOM records for chain using original residue numbers
VX
VN ajEPdbioModeAtomIdxChain
VD ATOM records for domain using residues numbers that give correct index
TD into SEQRES sequence
VX
VN ajEPdbioModeHeterogen
VD ATOM line for a heterogen (small ligand)
VX
VN ajEPdbioModeHeader
VD Header line
VX
VN ajEPdbioModeTitle
VD Title line
VX
VN ajEPdbioModeCompnd
VD COMPND records (info. on compound)
VX
VN ajEPdbioModeSource
VD SOURCE records (info. on protein source)
VX
VN ajEPdbioModeEmptyRemark
VD An empty REMARK record
VX
VN ajEPdbioModeResolution
VD Record with resolution of the structure
VX
//
typedef enum AjOPdbioMode
{
ajEPdbioModeHeaderDomain,
ajEPdbioModeSeqresDomain,
ajEPdbioModeAtomPdbDomain,
ajEPdbioModeAtomIdxDomain,
ajEPdbioModeSeqResChain,
ajEPdbioModeAtomPdbChain,
ajEPdbioModeAtomIdxChain,
ajEPdbioModeHeterogen,
ajEPdbioModeHeader,
ajEPdbioModeTitle,
ajEPdbioModeCompnd,
ajEPdbioModeSource,
ajEPdbioModeEmptyRemark,
ajEPdbioModeResolution
} AjEPdbioMode;
ID AjPPhyloDist
TY public
MO ajphylo
LB core
XX
DE Ajax phylogeny distance matrix
DE
DE Input can be square (all values) or lower-triangular (diagonal and below)
DE or upper-triangular (diagonal and above). We can count values for the
DE first 2 species to identify the format.
DE
DE S-format allows degree of replication for each distance (integer)
DE we can check for this (twice as many numbers) otherwise we set the
DE replicates to 1.
XX
TN AjSPhyloDist
TD
TX
TN AjOPhyloDist
TD
TX
AN Size
AT ajint
AD Size - number of rows and number of columns
AX
AN HasReplicates
AT AjBool
AD Has (some) replicates data in file
AX
AN Names
AT AjPStr*
AD Row names, NULL at end
AX
AN Data
AT float*
AD Distance matrix Size*Size with diagonal 0.0
AX
AN Replicates
AT ajint*
AD Replicate count default=1 missing=0
AX
AN HasMissing
AT AjBool
AD Has missing data in file
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSPhyloDist
{
ajint Size;
AjBool HasReplicates;
AjPStr* Names;
float* Data;
ajint* Replicates;
AjBool HasMissing;
char Padding[4];
} AjOPhyloDist;
#define AjPPhyloDist AjOPhyloDist*
ID AjPPhyloFreq
TY public
MO ajphylo
LB core
XX
DE Ajax phylogeny frequencies.
DE
DE For continuous data there are always 2 alleles
DE For gene frequency data there can be more than 2 alleles
XX
TN AjSPhyloFreq
TD
TX
TN AjOPhyloFreq
TD
TX
AN Size
AT ajint
AD Number of rows
AX
AN Loci
AT ajint
AD Number of loci per name
AX
AN Len
AT ajint
AD Number of values per name
AD may be more than 1 per locus
AX
AN ContChar
AT AjBool
AD Continuous character data if true
AX
AN Names
AT AjPStr*
AD Row names array (size is Size)
AX
AN Species
AT ajint*
AD Species number 1, 2, 3 for each value
AD array size is Len
AX
AN Individuals
AT ajint*
AD Allele countNumber of individuals
AD 1 or more per species
AD array size is Loci
AX
AN Locus
AT ajint*
AD Locus number 1, 2, 3 for each value
AD array size is Len
AX
AN Allele
AT ajint*
AD Allele count 2 or more per locus
AD array size is Loci
AX
AN Data
AT float*
AD Frequency for each allele for each Name
AX
AN Within
AT AjBool
AD Individual data within species if true
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSPhyloFreq
{
ajint Size;
ajint Loci;
ajint Len;
AjBool ContChar;
AjPStr* Names;
ajint* Species;
ajint* Individuals;
ajint* Locus;
ajint* Allele;
float* Data;
AjBool Within;
char Padding[4];
} AjOPhyloFreq;
#define AjPPhyloFreq AjOPhyloFreq*
ID AjPPhyloProp
TY public
MO ajphylo
LB core
XX
DE Ajax phylogeny properties: weights, ancestral states, factors.
DE
DE Basically, all of these are one value per position
DE
DE Weights are converted to integers 0-9, A=10 Z=35 by phylip
DE There are programs that can use multiple weights
DE We can handle this by making all of these multiple,
DE and using ACD to limit them to 1 for non-weight data.
DE
DE Ancestral states are character data
DE
DE Factors are multi-state character data where the factor character changes
DE when moving to a new character. Without this, all factors are assumed to
DE be different. The default would be to make each character distinct by
DE alternating 12121212 or to use 12345678901234567890.
DE
DE We can, in fact, convert any input string into this format for factors
DE but probably we can leave them unchanged.
XX
TN AjSPhyloProp
TD
TX
TN AjOPhyloProp
TD
TX
AN Len
AT ajint
AD string length
AX
AN Size
AT ajint
AD number of strings
AX
AN IsWeight
AT AjBool
AD is phylip weight values if true
AX
AN IsFactor
AT AjBool
AD is phylip factor values if true
AX
AN Str
AT AjPStr*
AD The original string(s)
AX
//
typedef struct AjSPhyloProp
{
ajint Len;
ajint Size;
AjBool IsWeight;
AjBool IsFactor;
AjPStr* Str;
} AjOPhyloProp;
#define AjPPhyloProp AjOPhyloProp*
ID AjPPhyloState
TY public
MO ajphylo
LB core
XX
DE Ajax discrete state data.
DE
DE Basically, all of these are one value per position
DE
DE States have a limited character set, usually defined through ACD
XX
TN AjSPhyloState
TD
TX
TN AjOPhyloState
TD
TX
AN Len
AT ajint
AD string length
AX
AN Size
AT ajint
AD number of strings
AX
AN Characters
AT AjPStr
AD The allowed state characters
AX
AN Names
AT AjPStr*
AD The names
AX
AN Str
AT AjPStr*
AD The original string(s)
AX
AN Count
AT ajint
AD number of enzymes for restriction data
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSPhyloState
{
ajint Len;
ajint Size;
AjPStr Characters;
AjPStr* Names;
AjPStr* Str;
ajint Count;
char Padding[4];
} AjOPhyloState;
#define AjPPhyloState AjOPhyloState*
ID AjPPhyloTree
TY public
MO ajphylo
LB core
XX
DE Ajax phylogeny trees
DE
DE For programs that read multiple tree inputs we use an array,
DE and let ACD limit the others to 1 tree.
XX
TN AjSPhyloTree
TD
TX
TN AjOPhyloTree
TD
TX
AN Multifurcated
AT AjBool
AD Multifurcating (..(a,b,c)..)
AX
AN BaseTrifurcated
AT AjBool
AD 3-way base (a,b,c)
AX
AN BaseBifurcated
AT AjBool
AD Rooted 2-way base (a,b)
AX
AN BaseQuartet
AT AjBool
AD Unrooted quartet ((a,b),(c,d));
AX
AN HasLengths
AT AjBool
AD Tree has branch lengths
AX
AN Size
AT ajint
AD Number of nodes
AX
AN Tree
AT AjPStr
AD Newick tree string
AX
//
typedef struct AjSPhyloTree
{
AjBool Multifurcated;
AjBool BaseTrifurcated;
AjBool BaseBifurcated;
AjBool BaseQuartet;
AjBool HasLengths;
ajint Size;
AjPStr Tree;
} AjOPhyloTree;
#define AjPPhyloTree AjOPhyloTree*
ID AjEQryType
TY public
MO ajquerydata
LB core
XX
DE Query type or scope (one, some or all entries)
XX
VN AJQUERY_UNKNOWN
VD Unknown
VX
VN AJQUERY_ENTRY
VD Single entry
VX
VN AJQUERY_QUERY
VD Query for one or more entries
VX
VN AJQUERY_ALL
VD All entries
VX
//
typedef enum AjOQryType
{
AJQUERY_UNKNOWN, AJQUERY_ENTRY,
AJQUERY_QUERY, AJQUERY_ALL
} AjEQryType;
ID AjEQryLink
TY public
MO ajquerydata
LB core
XX
DE Query link operators
XX
VN AJQLINK_INIT
VD Initial query
VX
VN AJQLINK_OR
VD Current OR next
VX
VN AJQLINK_AND
VD Current AND next
VX
VN AJQLINK_EOR
VD Current EOR next
VX
VN AJQLINK_NOT
VD Current but NOT next
VX
VN AJQLINK_ELSE
VD Current if it exists, else next
VX
VN AJQLINK_MAX
VD Above last defined value
VX
//
typedef enum AjOQryLink
{
AJQLINK_INIT,
AJQLINK_OR,
AJQLINK_AND,
AJQLINK_EOR,
AJQLINK_NOT,
AJQLINK_ELSE,
AJQLINK_MAX
} AjEQryLink;
ID AjEDataType
TY public
MO ajquerydata
LB core
XX
DE AJAX data type
XX
VN AJDATATYPE_UNKNOWN
VD Undefined type
VX
VN AJDATATYPE_SEQUENCE
VD Sequence data
VX
VN AJDATATYPE_FEATURES
VD Feature data
VX
VN AJDATATYPE_ASSEMBLY
VD Assembly data
VX
VN AJDATATYPE_OBO
VD OBO ontology term data
VX
VN AJDATATYPE_REFSEQ
VD Reference sequence data
VX
VN AJDATATYPE_RESOURCE
VD Data resource data
VX
VN AJDATATYPE_TAXON
VD Taxonomy data
VX
VN AJDATATYPE_TEXT
VD Text data
VX
VN AJDATATYPE_URL
VD URL data
VX
VN AJDATATYPE_VARIATION
VD Variation data
VX
VN AJDATATYPE_MAX
VD Above last defined value
VX
//
typedef enum AjODataType
{
AJDATATYPE_UNKNOWN,
AJDATATYPE_SEQUENCE,
AJDATATYPE_FEATURES,
AJDATATYPE_ASSEMBLY,
AJDATATYPE_OBO,
AJDATATYPE_REFSEQ,
AJDATATYPE_RESOURCE,
AJDATATYPE_TAXON,
AJDATATYPE_TEXT,
AJDATATYPE_URL,
AJDATATYPE_VARIATION,
AJDATATYPE_MAX
} AjEDataType;
ID AjPQueryField
TY public
MO ajquerydata
LB core
XX
DE Ajax Query Field object.
DE
DE Holds data needed for a specific field query
DE This must refer to an field name (id, acc or any other queriable field)
DE and the query string including wildcards specified by the user
XX
TN AjSQueryField
TD
TX
TN AjOQueryField
TD
TX
AN Field
AT AjPStr
AD Field name
AX
AN Wildquery
AT AjPStr
AD Query Wildcard
AX
AN Link
AT AjEQryLink
AD Link to previous queries
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSQueryField
{
AjPStr Field;
AjPStr Wildquery;
AjEQryLink Link;
ajuint Padding;
} AjOQueryField;
#define AjPQueryField AjOQueryField*
ID AjPQuery
TY public
MO ajquerydata
LB core
XX
DE Ajax Query object.
DE
DE Holds data needed to interpret an entry specification
DE This can refer to an entry name (or "id"), and accession number or
DE other queriable items.
DE
DE AjPQuery is created with the entry specification part of a USA
DE (Uniform Sequence Address) or euivalent for other data types.
DE The syntax is currently related to that
DE used by SRS release 5.1.
XX
TN AjSQuery
TD
TX
TN AjOQuery
TD
TX
AN SvrName
AT AjPStr
AD Server name used by EMBOSS
AX
AN DbName
AT AjPStr
AD Database name used by EMBOSS
AX
AN DbAlias
AT AjPStr
AD Database name used by access method
AX
AN DbType
AT AjPStr
AD Database type
AX
AN QueryFields
AT AjPList
AD Query field list
AX
AN ResultsList
AT AjPList
AD Query results list
AX
AN ResultsTable
AT AjPTable
AD Query results table
AX
AN Method
AT AjPStr
AD Name of access method
AX
AN Qlinks
AT AjPStr
AD Supported query link operators
AX
AN Formatstr
AT AjPStr
AD Name of input format for parser
AX
AN IndexDir
AT AjPStr
AD Index directory
AX
AN Directory
AT AjPStr
AD Data directory
AX
AN Filename
AT AjPStr
AD Individual filename
AX
AN Exclude
AT AjPStr
AD File wildcards to exclude (spaced)
AX
AN Namespace
AT AjPStr
AD Ontology namespace query to include
AX
AN Organisms
AT AjPStr
AD Organism/taxonomy query to include
AX
AN DbFields
AT AjPStr
AD Query fields (plus id and acc)
AX
AN DbFilter
AT AjPStr
AD Database filter (query) fields
AX
AN DbReturn
AT AjPStr
AD Database attribute (returned data) fields
AX
AN DbIdentifier
AT AjPStr
AD Database primary identifier field
AX
AN DbAccession
AT AjPStr
AD Database secondary identifier field
AX
AN DbUrl
AT AjPStr
AD Query URL
AX
AN DbProxy
AT AjPStr
AD Proxy host
AX
AN DbHttpVer
AT AjPStr
AD HTTP version
AX
AN ServerVer
AT AjPStr
AD Server version
AX
AN SingleField
AT AjPStr
AD Query single field from end of query string
AX
AN QryString
AT AjPStr
AD Query term
AX
AN QryFields
AT AjPStr
AD Query fields or ID list
AX
AN Application
AT AjPStr
AD External application command
AX
AN Fpos
AT ajlong
AD File position from fseek
AX
AN TextAccess
AT void*
AD Text access function : see ajtextdb.h
AX
AN Access
AT void*
AD Datatype-specific access function : see ajseqdb.h
AD ajobodb.h and others
AX
AN QryData
AT void*
AD Private data for access function
AX
AN QueryType
AT AjEQryType
AD Enumerated query type
AX
AN DataType
AT AjEDataType
AD Enumerated datatype general scope
AX
AN QryDone
AT AjBool
AD Has the query been done yet
AX
AN SetServer
AT AjBool
AD True if server data has been set
AX
AN SetDatabase
AT AjBool
AD True if database data has been set
AX
AN SetQuery
AT AjBool
AD True if query data has been set
AX
AN InDrcat
AT AjBool
AD True if database is defined in DRCAT
AX
AN Wild
AT AjBool
AD True if query contains '*' or '?'
AX
AN CaseId
AT AjBool
AD True if ID match is case-sensitive
AX
AN HasAcc
AT AjBool
AD True if entries have acc field
AX
AN CountEntries
AT ajuint
AD Number of entries processed
AX
AN TotalEntries
AT ajuint
AD Number of entries found
AX
//
typedef struct AjSQuery
{
AjPStr SvrName;
AjPStr DbName;
AjPStr DbAlias;
AjPStr DbType;
AjPList QueryFields;
AjPList ResultsList;
AjPTable ResultsTable;
AjPStr Method;
AjPStr Qlinks;
AjPStr Formatstr;
AjPStr IndexDir;
AjPStr Directory;
AjPStr Filename;
AjPStr Exclude;
AjPStr Namespace;
AjPStr Organisms;
AjPStr DbFields;
AjPStr DbFilter;
AjPStr DbReturn;
AjPStr DbIdentifier;
AjPStr DbAccession;
AjPStr DbUrl;
AjPStr DbProxy;
AjPStr DbHttpVer;
AjPStr ServerVer;
AjPStr SingleField;
AjPStr QryString;
AjPStr QryFields;
AjPStr Application;
ajlong Fpos;
void* TextAccess;
void* Access;
void* QryData;
AjEQryType QueryType;
AjEDataType DataType;
AjBool QryDone;
AjBool SetServer;
AjBool SetDatabase;
AjBool SetQuery;
AjBool InDrcat;
AjBool Wild;
AjBool CaseId;
AjBool HasAcc;
ajuint CountEntries;
ajuint TotalEntries;
} AjOQuery;
#define AjPQuery AjOQuery*
ID AjPQueryList
TY public
MO ajquerydata
LB core
XX
DE Query processing list of queries from a list file.
DE
DE Includes data from the original query (XX
TN AjSQueryList
TD
TX
TN AjOQueryList
TD
TX
AN Qry
AT AjPStr
AD Current query
AX
AN Formatstr
AT AjPStr
AD Format name from original query
AX
AN QryFields
AT AjPStr
AD Query fields or ID list
AX
AN Fpos
AT ajlong
AD File position
AX
AN Format
AT ajuint
AD Format enumeration
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSQueryList
{
AjPStr Qry;
AjPStr Formatstr;
AjPStr QryFields;
ajlong Fpos;
ajuint Format;
char Padding[4];
} AjOQueryList;
#define AjPQueryList AjOQueryList*
ID AjEQueryFmtcode
TY public
MO ajquerydata
LB core
XX
DE Format code.
XX
VN FMT_OK
VD OK
VX
VN FMT_NOMATCH
VD No match
VX
VN FMT_BADTYPE
VD Bad datatype
VX
VN FMT_FAIL
VD Failed
VX
VN FMT_EOF
VD End of file reached
VX
VN FMT_EMPTY
VD Data object empty
VX
//
typedef enum AjOQueryFmtcode
{
FMT_OK,
FMT_NOMATCH,
FMT_BADTYPE,
FMT_FAIL,
FMT_EOF,
FMT_EMPTY
} AjEQueryFmtcode;
ID AjPRange
TY public
MO ajrange
LB core
XX
DE Data structure for AJAX sequence range specifications
XX
TN AjORange
TD
TX
TN AjSRange
TD
TX
AN start
AT ajuint*
AD From positions
AX
AN end
AT ajuint*
AD End positions
AX
AN text
AT AjPStr*
AD Associated text for each range
AX
AN n
AT ajuint
AD Number of ranges
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSRange
{
ajuint *start;
ajuint *end;
AjPStr *text;
ajuint n;
char Padding[4];
} AjORange;
#define AjPRange AjORange*
ID AjPRefseq
TY public
MO ajrefseqdata
LB core
XX
DE Ajax refseq object.
DE
DE Holds the refseq itself, plus associated information.
XX
TN AjSRefseq
TD
TX
TN AjORefseq
TD
TX
AN Id
AT AjPStr
AD Id of term
AX
AN Db
AT AjPStr
AD Database name from input
AX
AN Setdb
AT AjPStr
AD Database name from command line
AX
AN Full
AT AjPStr
AD Full name
AX
AN Qry
AT AjPStr
AD Query for re-reading
AX
AN Formatstr
AT AjPStr
AD Input format name
AX
AN Filename
AT AjPStr
AD Original filename
AX
AN TextPtr
AT AjPStr
AD Full text
AX
AN Desc
AT AjPStr
AD Description
AX
AN Seq
AT AjPStr
AD Sequence
AX
AN Seqlist
AT AjPList
AD Sequence list
AX
AN Fpos
AT ajlong
AD File position
AX
AN Format
AT AjEnum
AD Input format enum
AX
AN Count
AT ajuint
AD Number of lines read
AX
//
typedef struct AjSRefseq {
AjPStr Id;
AjPStr Db;
AjPStr Setdb;
AjPStr Full;
AjPStr Qry;
AjPStr Formatstr;
AjPStr Filename;
AjPStr TextPtr;
AjPStr Desc;
AjPStr Seq;
AjPList Seqlist;
ajlong Fpos;
AjEnum Format;
ajuint Count;
} AjORefseq;
#define AjPRefseq AjORefseq*
ID AjPRefseqin
TY public
MO ajrefseqdata
LB core
XX
DE Ajax refseq input object.
DE
DE Holds the input specification and information needed to read
DE the refseq and possible further entries
XX
TN AjSRefseqin
TD
TX
TN AjORefseqin
TD
TX
AN Input
AT AjPTextin
AD General text input object
AX
AN RefseqData
AT void*
AD Format data for reuse, e.g. multiple term input
AD (unused in current code)
AX
//
typedef struct AjSRefseqin {
AjPTextin Input;
void *RefseqData;
} AjORefseqin;
#define AjPRefseqin AjORefseqin*
ID AjPRefseqall
TY public
MO ajrefseqdata
LB core
XX
DE Ajax refseq all (stream) object.
DE
DE Inherits an AjPRefseq but allows more refseqs to be read from the
DE same input by also inheriting the AjPRefseqin input object.
XX
TN AjSRefseqall
TD
TX
TN AjORefseqall
TD
TX
AN Refseq
AT AjPRefseq
AD Current refseq
AX
AN Refseqin
AT AjPRefseqin
AD Refseq input for reading next
AX
AN Totterms
AT ajulong
AD Count of terms so far
AX
AN Count
AT ajuint
AD Count of terms so far
AX
AN Multi
AT AjBool
AD True if multiple values are expected
AX
AN Returned
AT AjBool
AD if true: Refseq object has been returned to a new
AD owner and is not to be deleted by the destructor
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSRefseqall
{
AjPRefseq Refseq;
AjPRefseqin Refseqin;
ajulong Totterms;
ajuint Count;
AjBool Multi;
AjBool Returned;
char Padding[4];
} AjORefseqall;
#define AjPRefseqall AjORefseqall*
ID AjPRefseqAccess
TY public
MO ajrefseqdata
LB core
XX
DE Ajax reference sequence access database reading object.
DE
DE Holds information needed to read a refseq entry from a database.
DE Access methods are defined for each known database type.
DE
DE Refseq entries are read from the database using the defined
DE database access function, which is usually a static function
DE within ajrefseqdb.c
DE
DE This should be a static data object but is needed for the definition
DE of AjPRefseqin.
XX
TN AjSRefseqAccess
TD
TX
TN AjORefseqAccess
TD
TX
AN Name
AT const char*
AD Access method name used in emboss.default
AX
AN Access
AT AjBool function
AD Access function
AX
AN AccessFree
AT AjBool function
AD Access cleanup function
AX
AN Qlink
AT const char*
AD Supported query link operators
AX
AN Desc
AT const char*
AD Description
AX
AN Alias
AT AjBool
AD Alias for another name
AX
AN Entry
AT AjBool
AD Supports retrieval of single entries
AX
AN Query
AT AjBool
AD Supports retrieval of selected entries
AX
AN All
AT AjBool
AD Supports retrieval of all entries
AX
AN Chunked
AT AjBool
AD Supports retrieval of entries in chunks
AX
AN Padding
AT AjBool
AD Padding to alignment boundary
AX
//
typedef struct AjSRefseqAccess
{
const char *Name;
AjBool (*Access)(AjPRefseqin refseqin);
AjBool (*AccessFree)(void* qry);
const char* Qlink;
const char* Desc;
AjBool Alias;
AjBool Entry;
AjBool Query;
AjBool All;
AjBool Chunked;
AjBool Padding;
} AjORefseqAccess;
#define AjPRefseqAccess AjORefseqAccess*
ID AjPRegexp
TY public
MO ajreg
LB core
XX
DE PCRE expression internals, wrapped for AJAX calls
XX
TN AjSRegexp
TD
TX
TN AjORegexp
TD
TX
AN pcre
AT real_pcre*
AD PCRE compiled expression
AX
AN extra
AT pcre_extra*
AD PCRE study data (if available, else NULL)
AX
AN ovector
AT int*
AD Output vector offsets
AX
AN orig
AT const char*
AD Original string
AX
AN ovecsize
AT int
AD Output vector size
AX
AN matches
AT int
AD Number of matches
AX
//
typedef struct AjSRegexp
{
real_pcre *pcre;
pcre_extra *extra;
int *ovector;
const char* orig;
int ovecsize;
int matches;
} AjORegexp;
#define AjPRegexp AjORegexp*
ID AjPReport
TY public
MO ajreport
LB core
XX
DE Ajax Report Output object.
DE
DE Holds definition of feature report output.
XX
TN AjSReport
TD
TX
TN AjOReport
TD
TX
RN AjPSeqout
RD Sequence output
RX
RN AjPFile
RD Input and output files
RX
AN Name
AT AjPStr
AD As "Source" for features, usually empty
AX
AN Type
AT AjPStr
AD "P" Protein or "N" Nucleotide
AX
AN Formatstr
AT AjPStr
AD Report format (-rformat)
AX
AN Fttable
AT AjPFeattable
AD Feature table to use (obsolete?)
AX
AN Ftquery
AT AjPFeattabOut
AD Output definition for features
AX
AN Extension
AT AjPStr
AD Output file extension
AX
AN File
AT AjPFile
AD Output file object
AX
AN Tagnames
AT AjPList
AD List of extra tag names (from ACD)
AX
AN Tagprints
AT AjPList
AD List of extra tag printnames (from ACD)
AX
AN Tagtypes
AT AjPList
AD List of extra tag datatypes (from ACD)
AX
AN Header
AT AjPStr
AD Text to add to header with newlines
AX
AN SubHeader
AT AjPStr
AD Text to add to subheader with newlines
AX
AN Tail
AT AjPStr
AD Text to add to tail with newlines
AX
AN SubTail
AT AjPStr
AD Text to add to subtail with newlines
AX
AN FileNames
AT AjPList
AD Names of extra files (see FileTypes)
AX
AN FileTypes
AT AjPList
AD Types of extra files (see FileNames)
AX
AN Totseqs
AT ajlong
AD Total number of sequences processed
AX
AN Totlength
AT ajlong
AD Total length of sequences processed
AX
AN Precision
AT ajint
AD Floating precision for score
AX
AN Showacc
AT AjBool
AD Report accession number
AX
AN Showdes
AT AjBool
AD Report sequence description
AX
AN Showusa
AT AjBool
AD Report USA (-rusa) or only seqname
AX
AN Showscore
AT AjBool
AD Report score (if optional for format)
AX
AN Showstrand
AT AjBool
AD Report nucleotide strand (if optional for format)
AX
AN Multi
AT AjBool
AD if true, assume >1 sequence
AX
AN Mintags
AT ajint
AD Minimum number of tags to report
AX
AN CountSeq
AT ajint
AD Number of sequences reported so far
AX
AN CountHit
AT ajint
AD Number of features reported so far
AX
AN TotHits
AT ajint
AD Number of features found so far
AX
AN MaxHitAll
AT ajint
AD Maximum number of hits to report overall
AX
AN MaxHitSeq
AT ajint
AD Maximum number of hits to report for each sequence
AX
AN MaxLimit
AT AjBool
AD if true, maximum hits reached
AX
AN Format
AT AjEnum
AD Report format (index number)
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajReportNew
ND Default constructor
NX
DN ajReportDel
DD Default destructor
DX
PN ajReportWrite
PD Master sequence output routine
PX
//
typedef struct AjSReport {
AjPStr Name;
AjPStr Type;
AjPStr Formatstr;
AjPFeattable Fttable;
AjPFeattabOut Ftquery;
AjPStr Extension;
AjPFile File;
AjPList Tagnames;
AjPList Tagprints;
AjPList Tagtypes;
AjPStr Header;
AjPStr SubHeader;
AjPStr Tail;
AjPStr SubTail;
AjPList FileNames;
AjPList FileTypes;
ajlong Totseqs;
ajlong Totlength;
ajint Precision;
AjBool Showacc;
AjBool Showdes;
AjBool Showusa;
AjBool Showscore;
AjBool Showstrand;
AjBool Multi;
ajint Mintags;
ajint CountSeq;
ajint CountHit;
ajint TotHits;
ajint MaxHitAll;
ajint MaxHitSeq;
AjBool MaxLimit;
AjEnum Format;
char Padding[4];
} AjOReport;
#define AjPReport AjOReport*
ID AjPResource
TY public
MO ajresourcedata
LB core
XX
DE Ajax resource object.
DE
DE Holds the resource itself, plus associated information.
XX
TN AjSResource
TD
TX
TN AjOResource
TD
TX
AN Id
AT AjPStr
AD Standard identifier of rerousce
AX
AN Idalt
AT AjPList
AD Alternative identifiers for this resource
AX
AN Acc
AT AjPStr
AD Accession number for this resource
AX
AN Name
AT AjPStr
AD Name, usually the ID in full
AX
AN Desc
AT AjPStr
AD Description
AX
AN Url
AT AjPStr
AD Resource web server
AX
AN Urllink
AT AjPStr
AD URL on linking instructions.
AX
AN Urlrest
AT AjPStr
AD URL of documentation on REST interface
AX
AN Urlsoap
AT AjPStr
AD URL of documentation on SOAP interface
AX
AN Cat
AT AjPList
AD Database category (from drcat.dat)
AX
AN Taxon
AT AjPList
AD NCBI Taxonomy
AX
AN Edamdat
AT AjPList
AD EDAM ontology references (retrievable data)
AX
AN Edamfmt
AT AjPList
AD EDAM ontology references (retrieved data format)
AX
AN Edamid
AT AjPList
AD EDAM ontology references (query fields)
AX
AN Edamtpc
AT AjPList
AD EDAM ontology references (data resource topic)
AX
AN Xref
AT AjPList
AD Database cross-reference link details
AX
AN Query
AT AjPList
AD Formatted query definitions
AX
AN Example
AT AjPList
AD Formatted query examples
AX
AN Db
AT AjPStr
AD Database name from input
AX
AN Setdb
AT AjPStr
AD Database name from command line
AX
AN Full
AT AjPStr
AD Full name
AX
AN Qry
AT AjPStr
AD Query for re-reading
AX
AN Formatstr
AT AjPStr
AD Input format name
AX
AN Filename
AT AjPStr
AD Original filename
AX
AN TextPtr
AT AjPStr
AD Full text
AX
AN Fpos
AT ajlong
AD File position
AX
AN Format
AT AjEnum
AD Input format enum
AX
AN Count
AT ajuint
AD Number of lines read
AX
//
typedef struct AjSResource
{
AjPStr Id;
AjPList Idalt;
AjPStr Acc;
AjPStr Name;
AjPStr Desc;
AjPStr Url;
AjPStr Urllink;
AjPStr Urlrest;
AjPStr Urlsoap;
AjPList Cat;
AjPList Taxon;
AjPList Edamdat;
AjPList Edamfmt;
AjPList Edamid;
AjPList Edamtpc;
AjPList Xref;
AjPList Query;
AjPList Example;
AjPStr Db;
AjPStr Setdb;
AjPStr Full;
AjPStr Qry;
AjPStr Formatstr;
AjPStr Filename;
AjPStr TextPtr;
ajlong Fpos;
AjEnum Format;
ajuint Count;
} AjOResource;
#define AjPResource AjOResource*
ID AjPResquery
TY public
MO ajresourcedata
LB core
XX
DE Ajax data resource query object
DE
DE Describes a standard public data resource query definition
DE
DE AjPResquery is implemented as a pointer to a C data structure.
XX
TN AjSResquery
TD
TX
TN AjOResquery
TD
TX
AN Datatype
AT AjPStr
AD Resource query datatype
AX
AN Format
AT AjPStr
AD Resource query format
AX
AN FormatTerm
AT AjPStr
AD Resource query format EDAM term
AX
AN Term
AT AjPStr
AD Resource query term
AX
AN Url
AT AjPStr
AD Resource query URL
AX
AN Nterms
AT ajuint
AD Number of terms
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSResquery
{
AjPStr Datatype;
AjPStr Format;
AjPStr FormatTerm;
AjPStr Term;
AjPStr Url;
ajuint Nterms;
ajuint Padding;
} AjOResquery;
#define AjPResquery AjOResquery*
ID AjPReslink
TY public
MO ajresourcedata
LB core
XX
DE Ajax data resource link object
DE
DE Describes a standard public data resource link definition
DE
DE AjPReslink is implemented as a pointer to a C data structure.
XX
TN AjSReslink
TD
TX
TN AjOReslink
TD
TX
AN Source
AT AjPStr
AD Resource link source
AX
AN Term
AT AjPStr
AD Resource query terms
AX
AN Nterms
AT ajuint
AD Resource query number of terms
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSReslink
{
AjPStr Source;
AjPStr Term;
ajuint Nterms;
ajuint Padding;
} AjOReslink;
#define AjPReslink AjOReslink*
ID AjPResterm
TY public
MO ajresourcedata
LB core
XX
DE Ajax data resource term object
DE
DE Describes a standard public data resource term definition
DE
DE AjPResterm is implemented as a pointer to a C data structure.
XX
TN AjSResterm
TD
TX
TN AjOResterm
TD
TX
AN Id
AT AjPStr
AD Term ID in EDAM
AX
AN Name
AT AjPStr
AD Term name in EDAM
AX
//
typedef struct AjSResterm
{
AjPStr Id;
AjPStr Name;
} AjOResterm;
#define AjPResterm AjOResterm*
ID AjPResourcein
TY public
MO ajresourcedata
LB core
XX
DE Ajax resource input object.
DE
DE Holds the input specification and information needed to read
DE the resource and possible further entries
XX
TN AjSResourcein
TD
TX
TN AjOResourcein
TD
TX
AN Input
AT AjPTextin
AD General text input object
AX
AN ResourceData
AT void*
AD Format data for reuse, e.g. multiple term input
AD (unused in current code)
AX
//
typedef struct AjSResourcein
{
AjPTextin Input;
void *ResourceData;
} AjOResourcein;
#define AjPResourcein AjOResourcein*
ID AjPResourceall
TY public
MO ajresourcedata
LB core
XX
DE Ajax data resource all (stream) object.
DE
DE Inherits an AjPResource but allows more data resources to be read from the
DE same input by also inheriting the AjPResourcein input object.
XX
TN AjSResourceall
TD
TX
TN AjOResourceall
TD
TX
AN Resource
AT AjPResource
AD Current term
AX
AN Resourcein
AT AjPResourcein
AD Data resource input for reading next
AX
AN Totresources
AT ajulong
AD Count of resources so far
AX
AN Count
AT ajuint
AD Count of resources so far
AX
AN Multi
AT AjBool
AD True if multiple values are expected
AX
AN Returned
AT AjBool
AD if true: data resource object has been returned
AD to a new owner
AD and is not to be deleted by the destructor
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSResourceall
{
AjPResource Resource;
AjPResourcein Resourcein;
ajulong Totresources;
ajuint Count;
AjBool Multi;
AjBool Returned;
char Padding[4];
} AjOResourceall;
#define AjPResourceall AjOResourceall*
ID AjPResourceAccess
TY public
MO ajresourcedata
LB core
XX
DE Ajax data access database reading object.
DE
DE Holds information needed to read a resource entry from a database.
DE Access methods are defined for each known database type.
DE
DE Resource entries are read from the database using the defined
DE database access function, which is usually a static function
DE within ajresourcedb.c
DE
DE This should be a static data object but is needed for the definition
DE of AjPResourcein.
XX
TN AjSResourceAccess
TD
TX
TN AjOResourceAccess
TD
TX
AN Name
AT const char*
AD Access method name used in emboss.default
AX
AN Access
AT AjBool function
AD Access function
AX
AN AccessFree
AT AjBool function
AD Access cleanup function
AX
AN Qlink
AT const char*
AD Supported query link operators
AX
AN Desc
AT const char*
AD Description
AX
AN Alias
AT AjBool
AD Alias for another name
AX
AN Entry
AT AjBool
AD Supports retrieval of single entries
AX
AN Query
AT AjBool
AD Supports retrieval of selected entries
AX
AN All
AT AjBool
AD Supports retrieval of all entries
AX
AN Chunked
AT AjBool
AD Supports retrieval of entries in chunks
AX
AN Padding
AT AjBool
AD Padding to alignment boundary
AX
//
typedef struct AjSResourceAccess
{
const char *Name;
AjBool (*Access)(AjPResourcein resourcein);
AjBool (*AccessFree)(void* qry);
const char* Qlink;
const char* Desc;
AjBool Alias;
AjBool Entry;
AjBool Query;
AjBool All;
AjBool Chunked;
AjBool Padding;
} AjOResourceAccess;
#define AjPResourceAccess AjOResourceAccess*
ID AjPSeqCvt
TY public
MO ajseq
LB core
XX
DE Sequence conversion data. Used to convert a sequence to binary.
XX
NN ajSeqCvtNew
ND Creates from a character string of valid bases.
NX
NN ajSeqCvtNewText
ND Creates from a character string of valid bases.
NX
NN ajSeqCvtNewZero
ND Creates from a character string of valid bases.
NX
NN ajSeqCvtNewZeroS
ND Creates from an array of strings of valid bases.
NX
NN ajSeqCvtNewZeroSS
ND Creates from an array of strings of valid bases.
NX
PN ajSeqCvtTrace
PD Reports on contents for debugging
PX
TN AjSSeqCvt
TD
TX
TN AjOSeqCvt
TD
TX
AN size
AT ajint
AD Number of characters in table, usually
AD all possible characters.
AX
AN len
AT ajint
AD Number of characters defined
AX
AN missing
AT ajint
AD Index of the missing character value
AX
AN nrlabels
AT ajint
AD Number of row labels
AX
AN bases
AT AjPStr
AD The bases which can be converted
AX
AN rlabels
AT AjPStr*
AD Row labels
AX
AN clabels
AT AjPStr*
AD Column labels
AX
AN table
AT char*
AD Binary character value for each character in bases
AX
AN nclabels
AT ajint
AD Number of column labels
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSSeqCvt
{
ajint size;
ajint len;
ajint missing;
ajint nrlabels;
AjPStr bases;
AjPStr* rlabels;
AjPStr* clabels;
char *table;
ajint nclabels;
char Padding[4];
} AjOSeqCvt;
#define AjPSeqCvt AjOSeqCvt*
ID AjPSeqBamBgzf
TY public
MO ajseqbam
LB core
XX
DE BGZF file handling object
XX
TN AjOSeqBamBgzf
TD
TX
TN AjSSeqBamBgzf
TD
TX
AN file
AT FILE*
AD File object
AX
AN cache
AT AjPTable
AD Block cache
AX
AN uncompressed_block
AT void*
AD Uncompressed block data
AX
AN compressed_block
AT void*
AD Compressed block data
AX
AN error
AT const char*
AD Error description
AX
AN block_address
AT ajlong
AD Block offset
AX
AN file_descriptor
AT int
AD File descriptor
AX
AN cache_size
AT int
AD Cache size
AX
AN uncompressed_block_size
AT int
AD Uncompressed block size
AX
AN compressed_block_size
AT int
AD Compressed block size
AX
AN block_length
AT int
AD Block length
AX
AN block_offset
AT int
AD Block offset
AX
AN open_mode
AT char
AD Open_mode 'r' or 'w'
AX
AN owned_file
AT char
AD Boolean
AX
AN is_uncompressed
AT char
AD Boolean
AX
AN Padding
AT char[5]
AD Padding
AX
//
typedef struct AjSSeqBamBgzf
{
FILE* file;
AjPTable cache;
void* uncompressed_block;
void* compressed_block;
const char* error;
ajlong block_address;
int file_descriptor;
int cache_size;
int uncompressed_block_size;
int compressed_block_size;
int block_length;
int block_offset;
char open_mode;
char owned_file;
char is_uncompressed;
char Padding[5];
} AjOSeqBamBgzf;
#define AjPSeqBamBgzf AjOSeqBamBgzf*
ID AjPSeqBamHeader
TY public
MO ajseqbam
LB core
XX
DE BAM alignment file header data
XX
AN target_name
AT char**
AD names of the reference sequences
AX
AN target_len
AT ajuint*
AD lengths of the reference sequences
AX
AN dict
AT AjPList
AD header dictionary
AX
AN hash
AT AjPTable
AD hash table for fast name lookup
AX
AN rg2lib
AT AjPTable
AD hash table for AX
AN text
AT char*
AD plain text
AX
AN n_targets
AT ajint
AD number of reference sequences
AX
AN l_text
AT ajint
AD length of the plain text in the header
AX
//
typedef struct AjSSeqBamheader
{
char **target_name;
ajuint *target_len;
AjPList dict;
AjPTable hash;
AjPTable rg2lib;
char *text;
ajint n_targets;
ajint l_text;
} AjOSeqBamHeader;
#define AjPSeqBamHeader AjOSeqBamHeader*
ID AjPSeqBamCore
TY public
MO ajseqbam
LB core
XX
DE Structure for core alignment information.
XX
AN tid
AT ajint
AD read ID, defined by AjPSeqBamheader
AX
AN pos
AT ajint
AD 0-based leftmost coordinate
AX
AN bin
AT ajushort
AD bin calculated by ajSeqBamReg2bin()
AX
AN qual
AT unsigned char
AD mapping quality
AX
AN l_qname
AT unsigned char
AD length of the query name
AX
AN flag
AT ajushort
AD bitwise flag
AX
AN n_cigar
AT ajushort
AD number of CIGAR operations
AX
AN l_qseq
AT ajint
AD length of the query sequence (read)
AX
AN mtid
AT ajint
AD paired read (mate) ID
AX
AN mpos
AT ajint
AD paired read (mate) position
AX
AN isize
AT ajint
AD insert size for paired reads
AX
//
typedef struct AjSBamSeqCore
{
ajint tid;
ajint pos;
ajushort bin;
unsigned char qual;
unsigned char l_qname;
ajushort flag;
ajushort n_cigar;
ajint l_qseq;
ajint mtid;
ajint mpos;
ajint isize;
} AjOSeqBamCore;
#define AjPSeqBamCore AjOSeqBamCore*
ID AjPSeqBam
TY public
MO ajseqbam
LB core
XX
DE Structure for one alignment.
XX
TN AjSSeqBam
TD
TX
TN AjOSeqBam
TD
TX
AN core
AT AjOSeqBamCore
AD core information about the alignment
AX
AN data
AT unsigned char*
AD all variable-length data, concatenated;
AD structure: cigar-qname-seq-qual-aux
AX
AN l_aux
AT int
AD length of auxiliary data
AX
AN data_len
AT int
AD current length of data
AX
AN m_data
AT int
AD maximum reserved size of data
AX
AN Padding
AT int
AD Padding to alignment boundary
AX
//
typedef struct AjSSeqBam
{
AjOSeqBamCore core;
unsigned char *data;
int l_aux;
int data_len;
int m_data;
int Padding;
} AjOSeqBam;
#define AjPSeqBam AjOSeqBam*
ID AjEXrefType
TY public
MO ajseqdata
LB core
XX
DE Enumerated cross-reference type
XX
VN XREF_UNKNOWN
VD type not defined
VX
VN XREF_DR
VD DR line in EMBL, SwissProt
VX
VN XREF_DBXREF
VD db_xref in EMBL/Genbank
VX
VN XREF_EC
VD EC= in SwissProt
VX
VN XREF_DESC
VD Allergen= and CD_Antigen= in SwissProt DE
VX
VN XREF_TAX
VD NCBI_TaxID
VX
VN XREF_RX
VD RX line in EMBL or SwissProt
VX
VN XREF_MAX
VD Beyond last defined value
VX
//
typedef enum AjOXrefType
{
XREF_UNKNOWN,
XREF_DR,
XREF_DBXREF,
XREF_EC,
XREF_DESC,
XREF_TAX,
XREF_RX,
XREF_MAX
} AjEXrefType;
ID AjPSeqDesc
TY public
MO ajseqdata
LB core
XX
DE Ajax sequence description object.
DE
DE Defines the gene fields needed to support various standard
DE sequence database entry formats, especially UniProt
XX
TN AjSSeqDesc
TD
TX
TN AjOSeqDesc
TD
TX
AN Name
AT AjPStr
AD Recommended name (only one per sequence)
AX
AN Short
AT AjPList
AD String list of short names
AX
AN EC
AT AjPList
AD String list of EC numbers
AX
AN AltNames
AT AjPList
AD List of alternate description objects
AX
AN SubNames
AT AjPList
AD List of submitted name objects
AX
AN Includes
AT AjPList
AD List of names for included functional domains
AX
AN Contains
AT AjPList
AD List of names for post-processing components
AX
AN Precursor
AT AjBool
AD True if this is a precursor
AX
AN Fragments
AT ajuint
AD 1 to mark as a fragment, more to mark as fragments
AX
//
typedef struct AjSSeqDesc
{
AjPStr Name;
AjPList Short;
AjPList EC;
AjPList AltNames;
AjPList SubNames;
AjPList Includes;
AjPList Contains;
AjBool Precursor;
ajuint Fragments;
} AjOSeqDesc;
#define AjPSeqDesc AjOSeqDesc*
ID AjPSeqSubdesc
TY public
MO ajseqdata
LB core
XX
DE Ajax sequence sub-description object.
DE
DE Defines the gene fields needed to support various standard
DE sequence database entry formats, especially UniProt
XX
TN AjSSeqSubdesc
TD
TX
TN AjOSeqSubdesc
TD
TX
AN Name
AT AjPStr
AD Recommended name (only one per sequence)
AX
AN Short
AT AjPList
AD String list of short names
AX
AN EC
AT AjPList
AD String list of EC numbers
AX
AN Allergen
AT AjPList
AD String list of Ig-E mediated atopic allergens
AX
AN Biotech
AT AjPList
AD String list of biotechnology context names
AX
AN Cdantigen
AT AjPList
AD String list of Cell Differentiation antigens
AX
AN Inn
AT AjPList
AD String list of International Non-proprietary Names
AX
//
typedef struct AjSSeqSubdesc
{
AjPStr Name;
AjPList Short;
AjPList EC;
AjPList Allergen;
AjPList Biotech;
AjPList Cdantigen;
AjPList Inn;
} AjOSeqSubdesc;
#define AjPSeqSubdesc AjOSeqSubdesc*
ID AjPSeqGene
TY public
MO ajseqdata
LB core
XX
DE Ajax genes object.
DE
DE Defines the gene fields needed to support various standard
DE sequence database entry formats, especially UniProt
XX
TN AjSSeqGene
TD
TX
TN AjOSeqGene
TD
TX
AN Name
AT AjPStr
AD Gene standard name
AX
AN Synonyms
AT AjPStr
AD Accepted synonyms
AX
AN Orf
AT AjPStr
AD Recognised open reading frame (ORF) names
AD usually for sequencing projects in progress
AX
AN Oln
AT AjPStr
AD Ordered locus name(s) representing order on chromosome
AX
//
typedef struct AjSSeqGene
{
AjPStr Name;
AjPStr Synonyms;
AjPStr Orf;
AjPStr Oln;
} AjOSeqGene;
#define AjPSeqGene AjOSeqGene*
ID AjPSeqDate
TY public
MO ajseqdata
LB core
XX
DE Ajax sequence dates object.
DE
DE Defines the date fields needed to support various standard
DE sequence database entry formats
XX
TN AjSSeqDate
TD
TX
TN AjOSeqDate
TD
TX
AN CreDate
AT AjPTime
AD Creation date
AX
AN ModDate
AT AjPTime
AD Entry modification date
AX
AN SeqDate
AT AjPTime
AD Sequence modification date
AX
AN CreRel
AT AjPStr
AD Database release when first released
AX
AN ModRel
AT AjPStr
AD Database release when entry last changed
AX
AN SeqRel
AT AjPStr
AD Database release when sequence last changed
AX
AN CreVer
AT AjPStr
AD Entry version when last changed
AX
AN ModVer
AT AjPStr
AD Entry version when last changed
AX
AN SeqVer
AT AjPStr
AD Entry version when sequence last changed
AX
//
typedef struct AjSSeqDate
{
AjPTime CreDate;
AjPTime ModDate;
AjPTime SeqDate;
AjPStr CreRel;
AjPStr ModRel;
AjPStr SeqRel;
AjPStr CreVer;
AjPStr ModVer;
AjPStr SeqVer;
} AjOSeqDate;
#define AjPSeqDate AjOSeqDate*
ID AjPSeqRange
TY public
MO ajseqdata
LB core
XX
DE Ajax sequence range
DE
DE Defines the queries that map to positions in a sequence (or physical map)
XX
TN AjSSeqRange
TD
TX
TN AjOSeqRange
TD
TX
AN Query
AT AjPStr
AD Query
AX
AN Start
AT ajulong
AD Start position
AX
AN Length
AT ajulong
AD Length
AX
//
typedef struct AjSSeqRange
{
AjPStr Query;
ajulong Start;
ajulong Length;
} AjOSeqRange;
#define AjPSeqRange AjOSeqRange*
ID AjPSeqRef
TY public
MO ajseqdata
LB core
XX
DE Ajax sequence citation object.
DE
DE Defines the fields needed to support various standard
DE entry citation formats
XX
TN AjSSeqRef
TD
TX
TN AjOSeqRef
TD
TX
AN Position
AT AjPStr
AD Sequence positions
AX
AN Groupname
AT AjPStr
AD Working group or consortium
AX
AN Authors
AT AjPStr
AD Author list, comma-delimited
AX
AN Title
AT AjPStr
AD Title
AX
AN Comment
AT AjPStr
AD Comment
AX
AN Xref
AT AjPStr
AD Cross reference
AX
AN Location
AT AjPStr
AD Location (journal, book, submission)
AX
AN Loctype
AT AjPStr
AD Location type
AX
AN Number
AT ajuint
AD Reference number. This may be used in the feature
AD table and references can disappear so the position
AD in the list is not enough
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSSeqRef
{
AjPStr Position;
AjPStr Groupname;
AjPStr Authors;
AjPStr Title;
AjPStr Comment;
AjPStr Xref;
AjPStr Location;
AjPStr Loctype;
ajuint Number;
char Padding[4];
} AjOSeqRef;
#define AjPSeqRef AjOSeqRef*
ID AjPSeqXref
TY public
MO ajseqdata
LB core
XX
DE Ajax sequence cross-reference object.
DE
DE Defines the fields needed to support various standard
DE entry cross-reference formats
XX
TN AjSSeqXref
TD
TX
TN AjOSeqXref
TD
TX
AN Db
AT AjPStr
AD Database name
AX
AN Id
AT AjPStr
AD Primary identifier
AX
AN Secid
AT AjPStr
AD Secondary identifier
AX
AN Terid
AT AjPStr
AD Tertiary identifier
AX
AN Quatid
AT AjPStr
AD Quaternary identifier
AX
AN Type
AT ajuint
AD Type of cross-reference
AX
AN Start
AT ajuint
AD Start position
AX
AN End
AT ajuint
AD End position
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSSeqXref
{
AjPStr Db;
AjPStr Id;
AjPStr Secid;
AjPStr Terid;
AjPStr Quatid;
ajuint Type;
ajuint Start;
ajuint End;
char Padding[4];
} AjOSeqXref;
#define AjPSeqXref AjOSeqXref*
ID AjPSeq
TY public
MO ajseqdata
LB core
XX
DE Ajax Sequence object.
DE
DE Holds the sequence itself, plus associated information such as a
DE sequence name, accession number, format, type.
DE
DE Also holds information on a selected sequence range and other
DE options.
DE
DE Sequence features can also be stored, but for efficiency reasons
DE features are turned off by default.
XX
TN AjOSeq
TD
TX
TN AjSSeq
TD
TX
AN Name
AT AjPStr
AD Name (ID)
AX
AN Acc
AT AjPStr
AD Accession number (primary only)
AX
AN Sv
AT AjPStr
AD SeqVersion number
AX
AN Gi
AT AjPStr
AD GI NCBI version number
AX
AN Tax
AT AjPStr
AD Main taxonomy (species)
AX
AN Taxid
AT AjPStr
AD Main taxonomy (species) id in NCBI taxonomy
AX
AN Organelle
AT AjPStr
AD Organelle taxonomy
AX
AN Type
AT AjPStr
AD Type N or P
AX
AN Molecule
AT AjPStr
AD Molecule type
AX
AN Class
AT AjPStr
AD Class of entry
AX
AN Division
AT AjPStr
AD Database division
AX
AN Evidence
AT AjPStr
AD Experimental evidence (e.g. from UniProt)
AX
AN Db
AT AjPStr
AD Database name from input
AX
AN Setdb
AT AjPStr
AD Database name from command line
AX
AN Full
AT AjPStr
AD Full name
AX
AN Date
AT AjPSeqDate
AD Creation, modification and sequence mod dates
AX
AN Desc
AT AjPStr
AD One-line description
AX
AN Fulldesc
AT AjPSeqDesc
AD Detailed description
AX
AN Doc
AT AjPStr
AD Obsolete - see TextPtr
AX
AN Usa
AT AjPStr
AD USA for re-reading
AX
AN Ufo
AT AjPStr
AD UFO for re-reading
AX
AN Formatstr
AT AjPStr
AD Input format name
AX
AN Filename
AT AjPStr
AD Original filename
AX
AN Entryname
AT AjPStr
AD Entryname (ID)
AX
AN TextPtr
AT AjPStr
AD Full text
AX
AN Acclist
AT AjPList
AD Secondary accessions
AX
AN Keylist
AT AjPList
AD Keyword list
AX
AN Taxlist
AT AjPList
AD Taxonomy list (organelle, species, taxa)
AX
AN Genelist
AT AjPList
AD Gene names list
AX
AN Reflist
AT AjPList
AD Reference citation list
AX
AN Cmtlist
AT AjPList
AD Comment block list
AX
AN Xreflist
AT AjPList
AD Cross reference list
AX
AN Seq
AT AjPStr
AD The sequence
AX
AN Fttable
AT AjPFeattable
AD Feature table
AX
AN Accuracy
AT float*
AD Accuracy values (one per base) from base calling
AX
AN Fpos
AT ajlong
AD File position (fseek) for USA
AX
AN Rev
AT AjBool
AD true: to be reverse-complemented
AX
AN Reversed
AT AjBool
AD true: has been reverse-complemented
AX
AN Trimmed
AT AjBool
AD true: has been trimmed
AX
AN Circular
AT AjBool
AD true: circular nucleotide molecule
AX
AN Begin
AT ajint
AD start position (processed on reading)
AX
AN End
AT ajint
AD end position (processed on reading)
AX
AN Offset
AT ajuint
AD offset from start
AX
AN Offend
AT ajuint
AD offset from end
AX
AN Qualsize
AT ajuint
AD Size of Accuracy array
AX
AN Weight
AT float
AD Weight from multiple alignment
AX
AN Format
AT AjEnum
AD Input format enum
AX
AN EType
AT AjEnum
AD unused, obsolete
AX
//
typedef struct AjSSeq
{
AjPStr Name;
AjPStr Acc;
AjPStr Sv;
AjPStr Gi;
AjPStr Tax;
AjPStr Taxid;
AjPStr Organelle;
AjPStr Type;
AjPStr Molecule;
AjPStr Class;
AjPStr Division;
AjPStr Evidence;
AjPStr Db;
AjPStr Setdb;
AjPStr Full;
AjPSeqDate Date;
AjPStr Desc;
AjPSeqDesc Fulldesc;
AjPStr Doc;
AjPStr Usa;
AjPStr Ufo;
AjPStr Formatstr;
AjPStr Filename;
AjPStr Entryname;
AjPStr TextPtr;
AjPList Acclist;
AjPList Keylist;
AjPList Taxlist;
AjPList Genelist;
AjPList Reflist;
AjPList Cmtlist;
AjPList Xreflist;
AjPStr Seq;
AjPFeattable Fttable;
float* Accuracy;
ajlong Fpos;
AjBool Rev;
AjBool Reversed;
AjBool Trimmed;
AjBool Circular;
ajint Begin;
ajint End;
ajuint Offset;
ajuint Offend;
ajuint Qualsize;
float Weight;
AjEnum Format;
AjEnum EType;
} AjOSeq;
#define AjPSeq AjOSeq*
ID AjPSeqset
TY public
MO ajseqdata
LB core
XX
DE Ajax Sequence set object. A sequence set contains one or more
DE sequences together in memory, for example as a sequence alignment.
DE
DE Holds the sequence set itself, plus associated information such as a
DE sequence names, accession number, format, type.
DE
DE Also holds information on a selected sequence range and other
DE options.
DE
DE Sequence set features can also be stored, but for efficiency reasons
DE features are turned off by default.
XX
TN AjSSeqset
TD
TX
TN AjOSeqset
TD
TX
RN AjPSeq
RD Sequences
RX
RN AjPSeqall
RD Sequence streams
RX
AN Size
AT ajuint
AD Number of sequences
AX
AN Len
AT ajuint
AD Maximum sequence length
AX
AN Begin
AT ajint
AD start position
AX
AN End
AT ajint
AD end position
AX
AN Offset
AT ajuint
AD offset from start
AX
AN Offend
AT ajuint
AD offset from end
AX
AN Rev
AT AjBool
AD true: reverse-complemented
AX
AN Trimmed
AT AjBool
AD true: has been trimmed
AX
AN Type
AT AjPStr
AD Type N or P
AX
AN Totweight
AT float
AD total weight (usually 1.0 * Size)
AX
AN EType
AT AjEnum
AD enum type obsolete
AX
AN Formatstr
AT AjPStr
AD Input format name
AX
AN Filename
AT AjPStr
AD Original filename
AX
AN Full
AT AjPStr
AD Full name
AX
AN Name
AT AjPStr
AD Name
AX
AN Usa
AT AjPStr
AD USA for re-reading
AX
AN Ufo
AT AjPStr
AD UFO for re-reading
AX
AN Seq
AT AjPSeq*
AD Sequence array (see Size)
AX
AN Seqweight
AT float*
AD Sequence weights (see also AjPSeq)
AX
AN Format
AT AjEnum
AD Input format enum
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajSeqsetNew
ND Default constructor
NX
DN ajSeqsetDel
DD Default destructor
DX
JN ajSeqsetRead
JD Master input routine for a sequence set
JX
MN ajSeqsetToLower
MD Converts a sequence set to lower case
MX
MN ajSeqsetToUpper
MD Converts a sequence set to upper case
MX
CN ajSeqsetLen
CD Returns the maximum length of a sequence set
CX
CN ajSeqsetSize
CD Returns the number of sequences in a sequence set
CX
CN ajSeqsetAcc
CD Returns the accession number of a sequence in a set
CX
CN ajSeqsetName
CD Returns the name of a sequence in a set
CX
CN ajSeqsetSeq
CD Returns the char* pointer to a sequence in a set
CX
CN ajSeqsetIsNuc
CD Tests whether the sequence set is nucleotide
CX
CN ajSeqsetIsProt
CD Tests whether the sequence set is protein
CX
CN ajSeqsetGetFilename
CD Returns the filename of a sequence set
CX
PN ajSeqsetWrite
PD Writes out all sequences in a set
PX
//
typedef struct AjSSeqset
{
ajuint Size;
ajuint Len;
ajint Begin;
ajint End;
ajuint Offset;
ajuint Offend;
AjBool Rev;
AjBool Trimmed;
AjPStr Type;
float Totweight;
AjEnum EType;
AjPStr Formatstr;
AjPStr Filename;
AjPStr Full;
AjPStr Name;
AjPStr Usa;
AjPStr Ufo;
AjPSeq* Seq;
float* Seqweight;
AjEnum Format;
char Padding[4];
} AjOSeqset;
#define AjPSeqset AjOSeqset*
ID AjPSeqin
TY public
MO ajseqdata
LB core
XX
DE Ajax Sequence Input object.
DE
DE Holds the sequence specification and information needed to read
DE the sequence and possible further sequences.
DE
DE Also holds information on a selected sequence range and other
DE options.
XX
TN AjSSeqin
TD
TX
TN AjOSeqin
TD
TX
RN AjPSeq
RD Sequences
RX
RN AjPSeqset
RD Sequence sets
RX
RN AjPSeqall
RD Sequence streams
RX
AN Input
AT AjPTextin
AD Text file input object
AX
AN Name
AT AjPStr
AD Sequence name (replace on reading)
AX
AN Acc
AT AjPStr
AD Sequence accession number (replace on reading)
AX
AN Inputtype
AT AjPStr
AD Sequence type from ACD
AX
AN Type
AT AjPStr
AD Sequence type N or P
AX
AN Full
AT AjPStr
AD Full name
AX
AN Date
AT AjPStr
AD Date
AX
AN Desc
AT AjPStr
AD One-line description
AX
AN Doc
AT AjPStr
AD Full text
AX
AN Inseq
AT AjPStr
AD Temporary input sequence holder
AX
AN DbSequence
AT AjPStr
AD Field name of sequence string
AX
AN Usalist
AT AjPList
AD List of USA processing nodes
AX
AN Begin
AT ajint
AD Start position
AX
AN End
AT ajint
AD End position
AX
AN Ufo
AT AjPStr
AD UFO for features (if any)
AX
AN Fttable
AT AjPFeattable
AD Input feature table (why in AjPSeqin?)
AX
AN Ftquery
AT AjPFeattabin
AD Feature table input spec
AX
AN Entryname
AT AjPStr
AD Entry name
AX
AN Features
AT AjBool
AD true: read features if any
AX
AN IsNuc
AT AjBool
AD true: known to be nucleic
AX
AN IsProt
AT AjBool
AD true: known to be protein
AX
AN Multiset
AT AjBool
AD true: seqsetall input
AX
AN Multidone
AT AjBool
AD seqsetall input: true when set completed
AX
AN Lower
AT AjBool
AD true: convert to lower case -slower
AX
AN Upper
AT AjBool
AD true: convert to upper case -supper
AX
AN Rev
AT AjBool
AD Reverse/complement if true
AX
AN Circular
AT AjBool
AD Set sequences to be circular
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
AN SeqData
AT void*
AD Format data for reuse,
AD e.g. multiple sequence input
AX
//
typedef struct AjSSeqin
{
AjPTextin Input;
AjPStr Name;
AjPStr Acc;
AjPStr Inputtype;
AjPStr Type;
AjPStr Full;
AjPStr Date;
AjPStr Desc;
AjPStr Doc;
AjPStr Inseq;
AjPStr DbSequence;
AjPList Usalist;
ajint Begin;
ajint End;
AjPStr Ufo;
AjPFeattable Fttable;
AjPFeattabin Ftquery;
AjPStr Entryname;
AjBool Features;
AjBool IsNuc;
AjBool IsProt;
AjBool Multiset;
AjBool Multidone;
AjBool Lower;
AjBool Upper;
AjBool Rev;
AjBool Circular;
char Padding[4];
void *SeqData;
} AjOSeqin;
#define AjPSeqin AjOSeqin*
ID AjPSeqall
TY public
MO ajseqdata
LB core
XX
DE Ajax Sequence all (stream) object.
DE
DE Inherits an AjPSeq but allows more sequences to be read from the
DE same input by also inheriting the AjPSeqin input object.
XX
TN AjSSeqall
TD
TX
TN AjOSeqall
TD
TX
NN ajSeqallNew
ND Default constructor
NX
DN ajSeqallDel
DD Default destructor
DX
MN ajSeqallNext
MD Master sequence stream input, reads next sequence
MD from an open input stream.
MX
CN ajSeqallGetFilename
CD Returns the filename of a seqall object.
CX
RN AjPSeq
RD Sequences
RX
RN AjPSeqin
RD Sequence input
RX
RN AjPSeqset
RD Sequence sets
RX
AN Seq
AT AjPSeq
AD Current sequence
AX
AN Seqin
AT AjPSeqin
AD Sequence input for reading next
AX
AN Totseqs
AT ajlong
AD Count of sequences so far
AX
AN Totlength
AT ajlong
AD Count of sequence lengths so far
AX
AN Count
AT ajint
AD Count of sequences so far
AX
AN Begin
AT ajint
AD start position
AX
AN End
AT ajint
AD end position
AX
AN Rev
AT AjBool
AD if true: reverse-complement
AX
AN Returned
AT AjBool
AD if true: Seq object has been returned to a new owner
AD and is not to be deleted by the destructor
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSSeqall
{
AjPSeq Seq;
AjPSeqin Seqin;
ajlong Totseqs;
ajlong Totlength;
ajint Count;
ajint Begin;
ajint End;
AjBool Rev;
AjBool Returned;
char Padding[4];
} AjOSeqall;
#define AjPSeqall AjOSeqall*
ID AjPSeqAccess
TY public
MO ajseqdata
LB core
XX
DE Ajax sequence access database reading object.
DE
DE Holds information needed to read a sequence from a database.
DE Access methods are defined for each known database type.
DE
DE Sequences are read from the database using the defined
DE database access function, which is usually a static function
DE within ajtextdb.c ajseqdb.c
DE
DE This should be a static data object but is needed for the definition
DE of AjPSeqin.
XX
TN AjSSeqAccess
TD
TX
TN AjOSeqAccess
TD
TX
AN Name
AT const char*
AD Access method name used in emboss.default
AX
AN Access
AT AjBool function
AD Access function
AX
AN AccessFree
AT AjBool function
AD Access cleanup function
AX
AN Qlink
AT const char*
AD Supported query link operators
AX
AN Desc
AT const char*
AD Description
AX
AN Alias
AT AjBool
AD Alias for another name
AX
AN Entry
AT AjBool
AD Supports retrieval of single entries
AX
AN Query
AT AjBool
AD Supports retrieval of selected entries
AX
AN All
AT AjBool
AD Supports retrieval of all entries
AX
AN Chunked
AT AjBool
AD Supports retrieval of entries in chunks
AX
AN Padding
AT AjBool
AD Padding to alignment boundary
AX
//
typedef struct AjSSeqAccess
{
const char *Name;
AjBool (*Access)(AjPSeqin seqin);
AjBool (*AccessFree)(void* qry);
const char* Qlink;
const char* Desc;
AjBool Alias;
AjBool Entry;
AjBool Query;
AjBool All;
AjBool Chunked;
AjBool Padding;
} AjOSeqAccess;
#define AjPSeqAccess AjOSeqAccess*
ID AjPSeqout
TY public
MO ajseqdata
LB core
XX
DE Ajax Sequence Output object.
DE
DE Holds definition of sequence output.
XX
TN AjSSeqout
TD
TX
TN AjOSeqout
TD
TX
AN Name
AT AjPStr
AD Name (ID)
AX
AN Acc
AT AjPStr
AD Accession number (primary only)
AX
AN Sv
AT AjPStr
AD SeqVersion number
AX
AN Gi
AT AjPStr
AD GI NCBI version number
AX
AN Desc
AT AjPStr
AD One-line description
AX
AN Tax
AT AjPStr
AD Main taxonomy (species)
AX
AN Taxid
AT AjPStr
AD Main taxonomy (species) id in NCBI taxonomy
AX
AN Organelle
AT AjPStr
AD Organelle taxonomy
AX
AN Type
AT AjPStr
AD Type N or P
AX
AN Outputtype
AT AjPStr
AD Output sequence known type
AX
AN Molecule
AT AjPStr
AD Molecule type
AX
AN Class
AT AjPStr
AD Class of entry
AX
AN Division
AT AjPStr
AD Database division
AX
AN Evidence
AT AjPStr
AD Experimental evidence (e.g. from UniProt)
AX
AN Db
AT AjPStr
AD Database name from input name
AX
AN Setdb
AT AjPStr
AD Database name from input command line
AX
AN Setoutdb
AT AjPStr
AD Database name from command line
AX
AN Full
AT AjPStr
AD Full name
AX
AN Date
AT AjPSeqDate
AD Dates
AX
AN Fulldesc
AT AjPSeqDesc
AD Dates
AX
AN Doc
AT AjPStr
AD Obsolete - see TextPtr
AX
AN Usa
AT AjPStr
AD USA for re-reading
AX
AN Ufo
AT AjPStr
AD UFO for re-reading
AX
AN Fttable
AT AjPFeattable
AD Feature table
AX
AN Ftquery
AT AjPFeattabOut
AD Feature table output
AX
AN FtFormat
AT AjPStr
AD Feature output format (if not in UFO)
AX
AN FtFilename
AT AjPStr
AD Feature output filename (if not in UFO)
AX
AN Informatstr
AT AjPStr
AD Input format
AX
AN Formatstr
AT AjPStr
AD Output format
AX
AN EType
AT AjEnum
AD unused, obsolete
AX
AN Format
AT AjEnum
AD Output format index
AX
AN Filename
AT AjPStr
AD Output filename (if not in USA)
AX
AN Directory
AT AjPStr
AD Output directory
AX
AN Entryname
AT AjPStr
AD Entry name
AX
AN Acclist
AT AjPList
AD Secondary accessions
AX
AN Keylist
AT AjPList
AD Keyword list
AX
AN Taxlist
AT AjPList
AD Taxonomy list
AX
AN Genelist
AT AjPList
AD Gene list
AX
AN Reflist
AT AjPList
AD References (citations)
AX
AN Cmtlist
AT AjPList
AD Comment block list
AX
AN Xreflist
AT AjPList
AD Database cross reference list
AX
AN Seq
AT AjPStr
AD The sequence
AX
AN File
AT AjPFile
AD Output file
AX
AN Knownfile
AT AjPFile
AD Already open output file (we don't close this one)
AX
AN Extension
AT AjPStr
AD File extension
AX
AN Savelist
AT AjPList
AD Previous sequences saved for later output
AD (e.g. MSF format)
AX
AN Accuracy
AT float*
AD Accuracy values (one per base) from base calling
AX
AN Data
AT void*
AD Format data for reuse, e.g. multiple sequence output
AX
AN Cleanup
AT void function
AD Function to write remaining lines on closing
AX
AN Rev
AT AjBool
AD true: to be reverse-complemented
AX
AN Circular
AT AjBool
AD true: circular nucleotide molecule
AX
AN Single
AT AjBool
AD If true, single sequence in each file (-ossingle)
AX
AN Features
AT AjBool
AD If true, save features with sequence or in file
AX
AN Qualsize
AT ajuint
AD Size of Accuracy array
AX
AN Count
AT ajint
AD Number of sequences
AX
AN Offset
AT ajint
AD offset from start
AX
NN ajSeqoutNew
ND Default constructor
NX
DN ajSeqoutDel
DD Default destructor
DX
MN ajSeqoutUsa
MD Resets using a new USA
MX
MN ajSeqoutClear
MD Resets ready for reuse.
MX
MN ajSeqoutOpen
MD If the file is not yet open, calls seqoutUsaProcess
MX
CN ajSeqoutCheckGcg
CD Calculates the GCG checksum for a sequence set.
CX
MN ajSeqWrite
MD Master sequence output routine
MX
MN ajSeqsetWrite
MD Master sequence set output routine
MX
MN ajSeqFileNewOut
MD Opens an output file for sequence writing.
MX
RN AjPSeq
RD Sequences
RX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSSeqout
{
AjPStr Name;
AjPStr Acc;
AjPStr Sv;
AjPStr Gi;
AjPStr Desc;
AjPStr Tax;
AjPStr Taxid;
AjPStr Organelle;
AjPStr Type;
AjPStr Outputtype;
AjPStr Molecule;
AjPStr Class;
AjPStr Division;
AjPStr Evidence;
AjPStr Db;
AjPStr Setdb;
AjPStr Setoutdb;
AjPStr Full;
AjPSeqDate Date;
AjPSeqDesc Fulldesc;
AjPStr Doc;
AjPStr Usa;
AjPStr Ufo;
AjPFeattable Fttable;
AjPFeattabOut Ftquery;
AjPStr FtFormat;
AjPStr FtFilename;
AjPStr Informatstr;
AjPStr Formatstr;
AjEnum EType;
AjEnum Format;
AjPStr Filename;
AjPStr Directory;
AjPStr Entryname;
AjPList Acclist;
AjPList Keylist;
AjPList Taxlist;
AjPList Genelist;
AjPList Reflist;
AjPList Cmtlist;
AjPList Xreflist;
AjPStr Seq;
AjPFile File;
AjPFile Knownfile;
AjPStr Extension;
AjPList Savelist;
float* Accuracy;
void *Data;
void (*Cleanup)(struct AjSSeqout * outseq);
AjBool Rev;
AjBool Circular;
AjBool Single;
AjBool Features;
ajuint Qualsize;
ajint Count;
ajint Offset;
char Padding[4];
} AjOSeqout;
#define AjPSeqout AjOSeqout*
ID AjPVoid
TY public
MO ajsql
LB core
XX
DE Ajax address object.
DE
DE Holds a void array with additional data.
DE The length is known and held internally.
DE
DE Saves on length calculation, and allows growth in reserved memory without
DE changing the pointer in the calling routine.
DE
DE AjPVoid is implemented as a pointer to a C data structure.
XX
TN AjSVoid
TD
TX
TN AjOVoid
TD
TX
NN ajVoidNew
ND Default constructor
NX
NN ajVoidNewRes
ND Constructor with reserved size
NX
DN ajVoidDel
DD Default destructor
DX
CN ajVoidGet
CD Retrieve a pointer from an array
CX
MN ajVoidPut
MD Load a pointer array element
MX
AN Res
AT ajuint
AD Reserved space in case of extension
AX
AN Len
AT ajuint
AD Actual length used
AX
AN Ptr
AT void**
AD Array of void pointers
AX
//
typedef struct AjSVoid
{
ajuint Res;
ajuint Len;
void **Ptr;
} AjOVoid;
#define AjPVoid AjOVoid*
ID AjESqlconnectionClient
TY public
MO ajsql
LB core
XX
DE AJAX SQL Connection client library enumeration.
XX
TN AjOSqlconnectionClient
TD
TX
VN ajESqlconnectionClientNULL
VD Null
VX
VN ajESqlconnectionClientMySQL
VD MySQL client
VX
VN ajESqlconnectionClientPostgreSQL
VD PostgreSQL client
VX
//
typedef enum AjOSqlconnectionClient
{
ajESqlconnectionClientNULL,
ajESqlconnectionClientMySQL,
ajESqlconnectionClientPostgreSQL
} AjESqlconnectionClient;
ID AjPSqlconnection
TY public
MO ajsql
LB core
XX
DE AJAX SQL Connection.
DE
DE Holds the client type and a pointer to a SQL client library-specific
DE connection object.
XX
TN AjSSqlconnection
TD
TX
TN AjOSqlconnection
TD
TX
AN Pconnection
AT void*
AD SQL client library-specific connection object
AD (MYSQL*) for the MySQL client library
AD (PGconn*) for the PostgreSQL client library
AX
AN Client
AT AjESqlconnectionClient
AD Client library
AX
AN Use
AT ajuint
AD Use counter
AX
//
typedef struct AjSSqlconnection
{
void *Pconnection;
AjESqlconnectionClient Client;
ajuint Use;
} AjOSqlconnection;
#define AjPSqlconnection AjOSqlconnection*
ID AjPSqlstatement
TY public
MO ajsql
LB core
XX
DE AJAX SQL Statement.
DE
DE Holds pointers to an AJAX SQL Connection and to a client library-specific
DE result object.
XX
TN AjSSqlstatement
TD
TX
TN AjOSqlstatement
TD
TX
AN Sqlconnection
AT AjPSqlconnection
AD AJAX SQL Connection.
AX
AN Presult
AT void*
AD SQL client library-specific result object
AD (MYSQL_RES*) for the MySQL client library
AD (PGresult*) for the PostgreSQL client library
AX
AN AffectedRows
AT ajulong
AD Number of rows affected by non-SELECT SQL
AD statements
AX
AN SelectedRows
AT ajulong
AD Number of rows selected by SELECT-like SQL
AD statements
AX
AN Columns
AT ajuint
AD Number of columns returned by SELECT-like statements
AX
AN Use
AT ajuint
AD Use counter
AX
//
typedef struct AjSSqlstatement
{
AjPSqlconnection Sqlconnection;
void *Presult;
ajulong AffectedRows;
ajulong SelectedRows;
ajuint Columns;
ajuint Use;
} AjOSqlstatement;
#define AjPSqlstatement AjOSqlstatement*
ID AjPSqlrow
TY public
MO ajsql
LB core
XX
DE AJAX SQL Result Row.
DE
DE Holds an AjPChar array of C-type character strings and an AjLong array of
DE data lengths for each column data values in SQL client library-specific
DE result objects.
XX
TN AjSSqlrow
TD
TX
TN AjOSqlrow
TD
TX
AN Values
AT AjPVoid
AD AJAX Character Array of SQL column values
AX
AN Lengths
AT AjPLong
AD AJAX Long Integer Array of SQL column value lengths
AX
AN Columns
AT ajuint
AD Number of columns per row
AX
AN Current
AT ajuint
AD Current column in column interactions
AX
//
typedef struct AjSSqlrow
{
AjPVoid Values;
AjPLong Lengths;
ajuint Columns;
ajuint Current;
} AjOSqlrow;
#define AjPSqlrow AjOSqlrow*
ID AjISqlrow
TY public
MO ajsql
LB core
XX
DE AJAX SQL Row Iterator.
DE
DE Allows iteration over AJAX SQL Rows of an AJAX SQL Statement.
XX
TN AjSSqlrowiter
TD
TX
TN AjOSqlrowiter
TD
TX
TN AjPSqlrowiter
TD
TX
AN Sqlstatement
AT AjPSqlstatement
AD AJAX SQL Statement
AX
AN Sqlrow
AT AjPSqlrow
AD AJAX SQL Result Row
AX
AN Current
AT ajulong
AD Current row number
AX
//
typedef struct AjSSqlrowiter
{
AjPSqlstatement Sqlstatement;
AjPSqlrow Sqlrow;
ajulong Current;
} AjOSqlrowiter;
#define AjISqlrow AjOSqlrowiter*
ID AjPStr
TY public
MO ajstr
LB core
XX
DE Ajax string object.
DE
DE Holds a null terminated character string with additional data.
DE The length is known and held internally.
DE The reserved memory size is known and held internally.
DE The reference count is known and held internally.
DE New pointers can refer to the same string without needing
DE to duplicate the character data.
DE
DE If a string has multiple references it cannot be changed. Any
DE instance to be changed is first copied to a new string. This
DE means that any function which can change the character data must
DE pass a pointer to the string so that the string can be moved.
DE
DE A default null string is provided. New strings are by default
DE implemented as pointers to this with increased reference counters.
DE
DE AjPStr is implemented as a pointer to a C data structure.
XX
TN AjPPStr
TD
TX
TN AjSStr
TD
TX
TN AjOStr
TD
TX
KN AjIStr
KD
KX
AN Res
AT size_t
AD Reserved bytes (usable for expanding in place)
AX
AN Len
AT size_t
AD Length of current string, excluding NULL at end
AX
AN Ptr
AT char*
AD The string, as a NULL-terminated C string.
AX
AN Use
AT ajuint
AD Use count: 1 for single reference, more if several
AD pointers share the same string.
AD Must drop to 0 before deleting. Modifying means making
AD a new string if not 1.
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
//
typedef struct AjSStr
{
size_t Res;
size_t Len;
char *Ptr;
ajuint Use;
ajint Padding;
} AjOStr;
#define AjPStr AjOStr*
ID AjIStr
TY public
MO ajstr
LB core
XX
DE String iterator, used to test iterator functionality.
XX
TN AjSStrIter
TD
TX
TN AjOStrIter
TD
TX
NN ajStrIter
ND Creates and initialises an iterator for a string
NX
DN ajStrIterFree
DD Destructor for a string iterator
DX
MN ajStrIterNext
MD Steps to the next iteration
MX
MN ajStrIterBegin
MD returns result of first iteration
MX
MN ajStrIterNext
MD Steps to the next iteration
MX
MN ajStrIterBackNext
MD Step to previous character in string iterator.
MX
MN ajStrIterEnd
MD returns result of last iteration
MX
CN ajStrIterDone
CD Tests whether iteration is complete
CX
CN ajStrIterGetC
CD returns the character* from the iterator
CX
CN ajStrIterGetK
CD returns the character from the iterator
CX
AN Start
AT char*
AD Starting string pointer
AX
AN End
AT char*
AD Final string pointer (NULL character position)
AX
AN Ptr
AT char*
AD Current string pointer
AX
//
typedef struct AjSStrIter
{
char *Start;
char *End;
char *Ptr;
} AjOStrIter;
#define AjIStr AjOStrIter*
ID AjPStrTok
TY public
MO ajstr
LB core
XX
DE String token parser object for the string parsing functions. These normally
DE require a set of characters to be skipped, but some functions use a string
DE delimiter instead.
XX
AN String
AT AjPStr
AD String
AX
AN Delim
AT AjPStr
AD Delimiter set for ajStrToken
AX
AN Pos
AT ajuint
AD Position in string
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN ajStrTokenInit
ND Generates a string token parser object
NX
DN ajStrTokenClear
DD Destroys a string token parser
DX
//
typedef struct AjSStrTok
{
AjPStr String;
AjPStr Delim;
ajuint Pos;
char Padding[4];
} AjOStrTok;
#define AjPStrTok AjOStrTok*
ID AjPSysSocket
TY public
MO ajsys
LB core
XX
DE Socket data for Unix or Windows systems
XX
AN sock
AT ajint
AD Socket number for Unix
AX
//
typedef struct AjSSysSocket
{
#ifndef WIN32
ajint sock;
ID AjPSysTimeout
TY public
MO ajsys
LB core
XX
DE Timeout object for Unix and Windows
XX
AN sa
AT struct sigaction
AD sigaction data for Unix
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
AN seconds
AT ajint
AD Time limit in seconds
AX
//
typedef struct AjSSysTimeout
{
#ifndef WIN32
struct sigaction sa;
ID AjETableType
TY public
MO ajtable
LB core
XX
DE AJAX Table Type enumeration
XX
VN ajETableTypeUnknown
VD no type set
VX
VN ajETableTypeChar
VD char* type
VX
VN ajETableTypeStr
VD AJAX String (AjPStr) type
VX
VN ajETableTypeInt
VD AJAX integer (ajint) type
VX
VN ajETableTypeUint
VD AJAX unsigned integer (ajuint) type
VX
VN ajETableTypeLong
VD AJAX long integer (ajlong) type
VX
VN ajETableTypeUlong
VD AJAX unsigned long integer (ajulong) type
VX
VN ajETableTypeUser
VD user-defined type
VX
VN ajETableTypeMax
VD beyond last defined value
VX
//
typedef enum AjOTableType
{
ajETableTypeUnknown,
ajETableTypeChar,
ajETableTypeStr,
ajETableTypeInt,
ajETableTypeUint,
ajETableTypeLong,
ajETableTypeUlong,
ajETableTypeUser,
ajETableTypeMax
} AjETableType;
ID AjPTableNode
TY public
MO ajtable
LB core
XX
DE AJAX Table Node object.
XX
AN Link
AT struct AjSTableNode*
AD Link top next AJAX Table Node
AX
AN Key
AT void*
AD Key data
AX
AN Value
AT void*
AD Value data
AX
//
typedef struct AjSTableNode {
struct AjSTableNode* Link;
void* Key;
void* Value;
} AjOTableNode;
#define AjPTableNode AjOTableNode*
ID AjPTable
TY public
MO ajtable
LB core
XX
DE Hash table object. Tables are key/value pairs with a simple hash function
DE to provide rapid searching for keys.
DE
DE Tables can hold any data type. Special functions are available for
DE tables of AjPStr values, but these are in the ajstr library,
DE and start with ajStrTable...
DE
DE In general, these functions are the same
DE but with different hash and comparison functions used. Alternative
DE function names are provided in all cases to save remembering which
DE calls need special cases.
XX
NN ajTableNew
ND Creates a table.
NX
DN ajTableFree
DD Deallocates and clears a table.
DX
MN ajTablePut
MD Adds or updates a value for a given key.
MX
MN ajTableMap
MD Calls a function for each key/value in a table.
MX
MN ajTableRemove
MD Removes a key/value pair from a table, and returns
MD the value.
MX
CN ajTableToarray
CD Creates an array to hold each key value pair
CD in pairs of array elements. The last element is null.
CX
CN ajTableGet
CD Returns the value for a given key.
CX
CN ajTableLength
CD Returns the number of keys in a table.
CX
PN ajTableTrace
PD Writes debug messages to trace the contents of a table.
PX
AN Fcmp
AT ajint function
AD Key compare function
AD (0 for match, -1 or +1 if not matched)
AX
AN Fhash
AT ajulong function
AD Hash function
AX
AN Fkeydel
AT void function
AD Key destructor, or NULL if not an object
AX
AN Fvaldel
AT void function
AD Value destructor, or NULL if not an object
AX
AN Buckets
AT AjPTableNode*
AD Buckets of AJAX Table Node objects
AX
AN Size
AT ajulong
AD Size - number of hash buckets
AX
AN Length
AT ajulong
AD Number of entries
AX
AN Timestamp
AT ajuint
AD Time stamp
AX
AN Use
AT ajuint
AD Reference count
AX
AN Type
AT AjETableType
AD AJAX Table Type enumeration
AX
//
typedef struct AjSTable
{
ajint (*Fcmp)(const void* key1, const void* key2);
ajulong (*Fhash)(const void* key, ajulong hashsize);
void (*Fkeydel)(void** Pkey);
void (*Fvaldel)(void** Pvalue);
AjPTableNode* Buckets;
ajulong Size;
ajulong Length;
ajuint Timestamp;
ajuint Use;
AjETableType Type;
} AjOTable;
#define AjPTable AjOTable*
ID AjPTagval
TY public
MO ajtagval
LB core
XX
DE General tag values data structure
XX
TN AjSTagval
TD
TX
TN AjOTagval
TD
TX
AN Tag
AT AjPStr
AD Tag name usually from a controlled internal vocabulary
AX
AN Value
AT AjPStr
AD Tag value
AX
//
typedef struct AjSTagval
{
AjPStr Tag;
AjPStr Value;
} AjOTagval;
#define AjPTagval AjOTagval*
ID AjPTax
TY public
MO ajtaxdata
LB core
XX
DE Ajax tax object.
DE
DE Holds the tax itself, plus associated information.
XX
TN AjSTax
TD
TX
TN AjOTax
TD
TX
AN Id
AT AjPStr
AD Taxonomy id
AX
AN Db
AT AjPStr
AD Database name from input
AX
AN Setdb
AT AjPStr
AD Database name from command line
AX
AN Full
AT AjPStr
AD Full name
AX
AN Qry
AT AjPStr
AD Query for re-reading
AX
AN Formatstr
AT AjPStr
AD Input format name
AX
AN Filename
AT AjPStr
AD Original filename
AX
AN Rank
AT AjPStr
AD Rank in taxomony hierarchy
AX
AN Emblcode
AT AjPStr
AD EMBL locus name prefix (not unique)
AX
AN Comment
AT AjPStr
AD Comment
AX
AN Name
AT AjPStr
AD Standard name
AX
AN Namelist
AT AjPList
AD Names list
AX
AN Citations
AT AjPList
AD Citations list
AX
AN Lines
AT AjPStr*
AD Lines of input data
AX
AN Fpos
AT ajlong
AD File position
AX
AN Format
AT AjEnum
AD Input format enum
AX
AN Count
AT ajuint
AD Number of lines read
AX
AN Taxid
AT ajuint
AD Taxon node id
AX
AN Parent
AT ajuint
AD Parent taxid
AX
AN Flags
AT ajuint
AD Flags:
AD if node inherits division from parent
AD if node inherits genetic code from parent
AD if node inherits mito gencode from parent
AD if name is suppressed in GB entry lineage
AD if this subtree has no sequence data yet
AX
AN Divid
AT unsigned char
AD Division id
AX
AN Gencode
AT unsigned char
AD Genetic code id
AX
AN Mitocode
AT unsigned char
AD Mitochondrial genetic code id
AX
AN Padchar
AT unsigned char
AD Padding to alignment boundary
AX
//
typedef struct AjSTax
{
AjPStr Id;
AjPStr Db;
AjPStr Setdb;
AjPStr Full;
AjPStr Qry;
AjPStr Formatstr;
AjPStr Filename;
AjPStr Rank;
AjPStr Emblcode;
AjPStr Comment;
AjPStr Name;
AjPList Namelist;
AjPList Citations;
AjPStr *Lines;
ajlong Fpos;
AjEnum Format;
ajuint Count;
ajuint Taxid;
ajuint Parent;
ajuint Flags;
unsigned char Divid;
unsigned char Gencode;
unsigned char Mitocode;
unsigned char Padchar;
} AjOTax;
#define AjPTax AjOTax*
ID AjPTaxin
TY public
MO ajtaxdata
LB core
XX
DE Ajax tax input object.
DE
DE Holds the input specification and information needed to read
DE the tax and possible further entries
XX
TN AjSTaxin
TD
TX
TN AjOTaxin
TD
TX
AN Input
AT AjPTextin
AD General text input object
AX
AN TaxData
AT void*
AD Format data for reuse, e.g. multiple term input
AD (unused in current code)
AX
//
typedef struct AjSTaxin
{
AjPTextin Input;
void *TaxData;
} AjOTaxin;
#define AjPTaxin AjOTaxin*
ID AjPTaxall
TY public
MO ajtaxdata
LB core
XX
DE Ajax taxon all (stream) object.
DE
DE Inherits an AjPTax but allows more taxons to be read from the
DE same input by also inheriting the AjPTaxin input object.
XX
TN AjSTaxall
TD
TX
TN AjOTaxall
TD
TX
AN Tax
AT AjPTax
AD Current taxon
AX
AN Taxin
AT AjPTaxin
AD Taxon input for reading next
AX
AN Totterms
AT ajulong
AD Count of terms so far
AX
AN Count
AT ajuint
AD Count of terms so far
AX
AN Multi
AT AjBool
AD True if multiple values are expected
AX
AN Returned
AT AjBool
AD if true: Taxon object has been returned to a new
AD owner and is not to be deleted by the destructor
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSTaxall
{
AjPTax Tax;
AjPTaxin Taxin;
ajulong Totterms;
ajuint Count;
AjBool Multi;
AjBool Returned;
char Padding[4];
} AjOTaxall;
#define AjPTaxall AjOTaxall*
ID AjPTaxname
TY public
MO ajtaxdata
LB core
XX
DE NCBI taxonomy node name, listed within AjPTax
XX
TN AjSTaxname
TD
TX
TN AjOTaxname
TD
TX
AN Name
AT AjPStr
AD Name of taxon node
AX
AN UniqueName
AT AjPStr
AD Unique name of taxon node
AX
AN NameClass
AT AjPStr
AD Synonym, common name, etc.
AX
//
typedef struct AjSTaxname
{
AjPStr Name;
AjPStr UniqueName;
AjPStr NameClass;
} AjOTaxname;
#define AjPTaxname AjOTaxname*
ID AjPTaxdiv
TY public
MO ajtaxdata
LB core
XX
DE NCBI taxonomy division
XX
TN AjSTaxdiv
TD
TX
TN AjOTaxdiv
TD
TX
AN GbCode
AT AjPStr
AD GenBank division code (three characters)
AX
AN GbName
AT AjPStr
AD GenBank division name
AX
AN Comments
AT AjPStr
AD Comments
AX
AN Divid
AT ajuint
AD Taxonomy division id
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSTaxdiv
{
AjPStr GbCode;
AjPStr GbName;
AjPStr Comments;
ajuint Divid;
ajuint Padding;
} AjOTaxdiv;
#define AjPTaxdiv AjOTaxdiv*
ID AjPTaxcode
TY public
MO ajtaxdata
LB core
XX
DE NCBI taxonomy genetic code
XX
TN AjSTaxcode
TD
TX
TN AjOTaxcode
TD
TX
AN Abbrev
AT AjPStr
AD Genetic code name abbreviation
AX
AN Name
AT AjPStr
AD Genetic code full name
AX
AN Trans
AT AjPStr
AD Amino acids for each codon
AX
AN Starts
AT AjPStr
AD Start codons
AX
AN Gencode
AT ajuint
AD NCBI genetic code id
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSTaxcode
{
AjPStr Abbrev;
AjPStr Name;
AjPStr Trans;
AjPStr Starts;
ajuint Gencode;
ajuint Padding;
} AjOTaxcode;
#define AjPTaxcode AjOTaxcode*
ID AjPTaxdel
TY public
MO ajtaxdata
LB core
XX
DE NCBI taxonomy deleted node
XX
TN AjSTaxdel
TD
TX
TN AjOTaxdel
TD
TX
AN Taxid
AT ajuint
AD Taxon node id
AX
//
typedef struct AjSTaxdel
{
ajuint Taxid;
} AjOTaxdel;
#define AjPTaxdel AjOTaxdel*
ID AjPTaxmerge
TY public
MO ajtaxdata
LB core
XX
DE NCBI taxonomy mergednode
XX
TN AjSTaxmerge
TD
TX
TN AjOTaxmerge
TD
TX
AN Taxid
AT ajuint
AD Oldaxon node id
AX
AN Mergeid
AT ajuint
AD Merged taxon node id
AX
//
typedef struct AjSTaxmerge
{
ajuint Taxid;
ajuint Mergeid;
} AjOTaxmerge;
#define AjPTaxmerge AjOTaxmerge*
ID AjPTaxcit
TY public
MO ajtaxdata
LB core
XX
DE NCBI taxonomy citation, listed within AjPTax
XX
TN AjSTaxcit
TD
TX
TN AjOTaxcit
TD
TX
AN Citid
AT ajuint
AD Taxonomy citation id
AX
AN Pubmed
AT ajuint
AD PubMed id (0 if not found)
AX
AN Medline
AT ajuint
AD Medline id (0 if not found)
AX
AN Refcount
AT ajuint
AD Reference count
AX
AN Key
AT AjPStr
AD Citation key
AX
AN Url
AT AjPStr
AD Url associated with citation
AX
AN Text
AT AjPStr
AD Text, usually article name and authors
AX
//
typedef struct AjSTaxcit
{
ajuint Citid;
ajuint Pubmed;
ajuint Medline;
ajuint Refcount;
AjPStr Key;
AjPStr Url;
AjPStr Text;
} AjOTaxcit;
#define AjPTaxcit AjOTaxcit*
ID AjPTaxAccess
TY public
MO ajtaxdata
LB core
XX
DE Ajax taxonomy access database reading object.
DE
DE Holds information needed to read a tax entry from a database.
DE Access methods are defined for each known database type.
DE
DE Tax entries are read from the database using the defined
DE database access function, which is usually a static function
DE within ajtaxdb.c
DE
DE This should be a static data object but is needed for the definition
DE of AjPTaxin.
XX
TN AjSTaxAccess
TD
TX
TN AjOTaxAccess
TD
TX
AN Name
AT const char*
AD Access method name used in emboss.default
AX
AN Access
AT AjBool function
AD Access function
AX
AN AccessFree
AT AjBool function
AD Access cleanup function
AX
AN Qlink
AT const char*
AD Supported query link operators
AX
AN Desc
AT const char*
AD Description
AX
AN Alias
AT AjBool
AD Alias for another name
AX
AN Entry
AT AjBool
AD Supports retrieval of single entries
AX
AN Query
AT AjBool
AD Supports retrieval of selected entries
AX
AN All
AT AjBool
AD Supports retrieval of all entries
AX
AN Chunked
AT AjBool
AD Supports retrieval of entries in chunks
AX
AN Padding
AT AjBool
AD Padding to alignment boundary
AX
//
typedef struct AjSTaxAccess
{
const char *Name;
AjBool (*Access) (AjPTaxin taxin);
AjBool (*AccessFree) (void* qry);
const char* Qlink;
const char* Desc;
AjBool Alias;
AjBool Entry;
AjBool Query;
AjBool All;
AjBool Chunked;
AjBool Padding;
} AjOTaxAccess;
#define AjPTaxAccess AjOTaxAccess*
ID AjETextqryType
TY public
MO ajtextdata
LB core
XX
DE Enumerated text query type
XX
VN TEXTQRY_UNKNOWN
VD Unknown
VX
VN TEXTQRY_ENTRY
VD Single entry
VX
VN TEXTQRY_QUERY
VD Query
VX
VN TEXTQRY_ALL
VD All entries
VX
//
typedef enum AjOTextqryType
{
TEXTQRY_UNKNOWN,
TEXTQRY_ENTRY,
TEXTQRY_QUERY,
TEXTQRY_ALL
} AjETextqryType;
ID AjETextqryLink
TY public
MO ajtextdata
LB core
XX
DE Text query link operators
XX
VN TEXTQRY_INIT
VD Undefined
VX
VN TEXTQRY_OR
VD Current OR next
VX
VN TEXTQRY_AND
VD Current AND next
VX
VN TEXTQRY_NOT
VD Current but NOT next
VX
VN TEXTQRY_EOR
VD Current EOR next
VX
VN TEXTQRY_MAX
VD Beyond last defined value
VX
//
typedef enum AjOTextqryLink
{
TEXTQRY_INIT,
TEXTQRY_OR,
TEXTQRY_AND,
TEXTQRY_NOT,
TEXTQRY_EOR,
TEXTQRY_MAX
} AjETextqryLink;
ID AjPText
TY public
MO ajtextdata
LB core
XX
DE Ajax Text data object.
DE
DE Holds the input specification and information needed to read
DE the entry text and possible further entries
XX
TN AjSText
TD
TX
TN AjOText
TD
TX
AN Id
AT AjPStr
AD Id of text item
AX
AN Db
AT AjPStr
AD Database name from input
AX
AN Setdb
AT AjPStr
AD Database name from command line
AX
AN Full
AT AjPStr
AD Full name
AX
AN Qry
AT AjPStr
AD Query for re-reading
AX
AN Formatstr
AT AjPStr
AD Input format name
AX
AN Filename
AT AjPStr
AD Original filename
AX
AN Lines
AT AjPList
AD Lines of input data
AX
AN Fpos
AT ajlong
AD File position
AX
AN Format
AT AjEnum
AD Input format enum
AX
AN Count
AT ajuint
AD Number of lines read
AX
//
typedef struct AjSText
{
AjPStr Id;
AjPStr Db;
AjPStr Setdb;
AjPStr Full;
AjPStr Qry;
AjPStr Formatstr;
AjPStr Filename;
AjPList Lines;
ajlong Fpos;
AjEnum Format;
ajuint Count;
} AjOText;
#define AjPText AjOText*
ID AjPTextin
TY public
MO ajtextdata
LB core
XX
DE Ajax Text Input object.
DE
DE Holds the input specification and information needed to read
DE the entry text and possible further entries
XX
TN AjSTextin
TD
TX
TN AjOTextin
TD
TX
AN Db
AT AjPStr
AD Database name (from commandline, replace on reading)
AX
AN Qry
AT AjPStr
AD Querystring for the entry
AX
AN Formatstr
AT AjPStr
AD Input format name
AX
AN QryFields
AT AjPStr
AD Query fields or ID list
AX
AN Filename
AT AjPStr
AD Original filename
AX
AN List
AT AjPList
AD List of USAs to be read
AX
AN Filebuff
AT AjPFilebuff
AD Input buffered file
AX
AN Fpos
AT ajlong
AD File position (fseek) for building USA
AX
AN Query
AT AjPQuery
AD Query data
AX
AN TextData
AT void*
AD Format data for reuse, e.g. multiple entry input
AX
AN Search
AT AjBool
AD Search for more entries (always true?)
AX
AN Single
AT AjBool
AD Read single entries
AX
AN Multi
AT AjBool
AD Multiple entry input
AX
AN CaseId
AT AjBool
AD Id case sensitive (default false)
AX
AN Text
AT AjBool
AD true: save full text of entry
AX
AN ChunkEntries
AT AjBool
AD true: access method returns entries in chunks
AD and should be called again when input is empty
AX
AN Dataread
AT AjBool
AD true: input through a loader has started to read
AX
AN Datadone
AT AjBool
AD true: input through a loader has read everything
AX
AN Count
AT ajuint
AD count of entries so far. Used when ACD reads first
AD entry and we need to reuse it in a Next loop
AX
AN Filecount
AT ajuint
AD Number of files read
AX
AN Entrycount
AT ajuint
AD Number of entries in file
AX
AN Datacount
AT ajuint
AD Number of data values read in current entry
AX
AN Records
AT ajuint
AD Records processed
AX
AN Format
AT AjEnum
AD Text input format enum
AX
AN TextFormat
AT AjEnum
AD Text input format enum
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSTextin
{
AjPStr Db;
AjPStr Qry;
AjPStr Formatstr;
AjPStr QryFields;
AjPStr Filename;
AjPList List;
AjPFilebuff Filebuff;
ajlong Fpos;
AjPQuery Query;
void *TextData;
AjBool Search;
AjBool Single;
AjBool Multi;
AjBool CaseId;
AjBool Text;
AjBool ChunkEntries;
AjBool Dataread;
AjBool Datadone;
ajuint Count;
ajuint Filecount;
ajuint Entrycount;
ajuint Datacount;
ajuint Records;
AjEnum Format;
AjEnum TextFormat;
ajuint Padding;
} AjOTextin;
#define AjPTextin AjOTextin*
ID AjPTextall
TY public
MO ajtextdata
LB core
XX
DE Ajax text data all (stream) object.
DE
DE Inherits an AjPText but allows more text blocks to be read from the
DE same input by also inheriting the AjPTextin input object.
XX
TN AjSTextall
TD
TX
TN AjOTextall
TD
TX
AN Text
AT AjPText
AD Current text block
AX
AN Textin
AT AjPTextin
AD Text input for reading next
AX
AN Totterms
AT ajulong
AD Count of terms so far
AX
AN Count
AT ajuint
AD Count of terms so far
AX
AN Multi
AT AjBool
AD True if multiple values are expected
AX
AN Returned
AT AjBool
AD if true: Text object has been returned to a new owner
AD and is not to be deleted by the destructor
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSTextall
{
AjPText Text;
AjPTextin Textin;
ajulong Totterms;
ajuint Count;
AjBool Multi;
AjBool Returned;
char Padding[4];
} AjOTextall;
#define AjPTextall AjOTextall*
ID AjPTextAccess
TY public
MO ajtextdata
LB core
XX
DE Ajax Text Access database reading object.
DE
DE Holds information needed to read a text entry from a database.
DE Access methods are defined for each known database type.
DE
DE Text entries are read from the database using the defined
DE database access function, which is usually a static function
DE within ajtextdb.c
DE
DE This should be a static data object but is needed for the definition
DE of AjPTextin.
XX
TN AjSTextAccess
TD
TX
TN AjOTextAccess
TD
TX
AN Name
AT const char*
AD Access method name used in emboss.default
AX
AN Access
AT AjBool function
AD Access function
AX
AN AccessFree
AT AjBool function
AD Access cleanup function
AX
AN Qlink
AT const char*
AD Supported query link operators
AX
AN Desc
AT const char*
AD Description
AX
AN Alias
AT AjBool
AD Alias for another name
AX
AN Entry
AT AjBool
AD Supports retrieval of single entries
AX
AN Query
AT AjBool
AD Supports retrieval of selected entries
AX
AN All
AT AjBool
AD Supports retrieval of all entries
AX
AN Chunked
AT AjBool
AD Supports retrieval of entries in chunks
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSTextAccess
{
const char *Name;
AjBool (*Access)(AjPTextin textin);
AjBool (*AccessFree)(void* qry);
const char* Qlink;
const char* Desc;
AjBool Alias;
AjBool Entry;
AjBool Query;
AjBool All;
AjBool Chunked;
ajuint Padding;
} AjOTextAccess;
#define AjPTextAccess AjOTextAccess*
ID AjPTime
TY public
MO ajtime
LB core
XX
DE AJAX time and data data structure. The same structure is used for both.
XX
TN AjSTime
TD
TX
TN AjOTime
TD
TX
TN AjPDate
TD
TX
AN time
AT struct tm
AD Time in C standard structure
AX
AN format
AT const char*
AD Format string if specified
AX
AN uppercase
AT AjBool
AD Convert to upper case on output
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSTime
{
struct tm time;
const char *format;
AjBool uppercase;
char Padding[4];
} AjOTime, AjODate;
#define AjPTime AjOTime*
ID AjPTrn
TY public
MO ajtranslate
LB core
XX
DE Ajax Sequence translation object.
DE
DE Holds the Genetic Code specification and information needed to translate
DE the sequence and find initiation sites.
XX
NN ajTrnNew
ND Default constructor
NX
NN ajTrnNewI
ND Default constructor
NX
NN ajTrnNewC
ND Default constructor
NX
DN ajTrnDel
DD Default destructor
DX
JN ajTrnReadFile
JD Reads a Genetic Code file
JX
ON ajTrnCodon
OD Translating a codon from an AjPStr
OX
ON ajTrnRevCodon
OD Reverse complement translating a codon from an AjPStr
OX
ON ajTrnCodonC
OD Translating a codon from a char* text
OX
ON ajTrnRevCodonC
OD Translating a codon from a char* text
OX
ON ajTrnCodonK
OD Translating a codon from a char* to a char
OX
ON ajTrnRevCodonK
OD Reverse complement translating a codon
OD from a char* to a char
OX
ON ajTrnC
OD Translating a sequence from a char* text
OX
ON ajTrnRevC
OD Reverse complement translating a sequence from a char* text
OX
ON ajTrnAltRevC
OD (Alt) Reverse complement translating a sequence
OD from a char* text
OX
ON ajTrnStr
OD Translating a sequence from a AjPStr
OX
ON ajTrnRevStr
OD Reverse complement translating a sequence from a AjPStr
OX
ON ajTrnAltRevStr
OD (Alt) Reverse complement translating a sequence
OD from a AjPStr
OX
ON ajTrnSeq
OD Translating a sequence from a AjPSeq
OX
ON ajTrnRevSeq
OD Reverse complement translating a sequence from a AjPSeq
OX
ON ajTrnAltRevSeq
OD Reverse complement translating a sequence from a AjPSeq
OX
ON ajTrnCFrame
OD Translating a sequence from a char* in a frame
OX
ON ajTrnStrFrame
OD Translating a sequence from a AjPStr in a frame
OX
ON ajTrnSeqFrame
OD Translating a sequence from a AjPSeq in a frame
OX
ON ajTrnSeqFramePep
OD Translating a sequence from a AjPSeq in a frame
OD and returns a new peptide
OX
ON ajTrnDangleC
OD Translates the last 1 or two bases of a sequence
OD in a char* text
OX
ON ajTrnDangleS
OD Translates the last 1 or two bases of a sequence
OD in a AjStr
OX
ON ajTrnSeqOrig
OD Translating a sequence
OX
CN ajTrnGetTitle
CD Returns description of the translation table
CX
CN ajTrnGetFilename
CD Returns file name the translation table was read from
CX
ON ajTrnCodonstrTypeS
OD Checks whether the input codon is a Start codon,
OD a Stop codon or something else
OX
ON ajTrnCodonstrTypeC
OD Checks whether a const char* codon is
OD a Start codon, a Stop codon or something else
OX
AN FileName
AT AjPStr
AD name of file that held the data
AX
AN Title
AT AjPStr
AD title of data read from file
AX
AN GC
AT char[16][16][16]
AD genetic codon table
AX
AN Starts
AT char[16][16][16]
AD initiation site table
AX
TN AjSTrn
TD
TX
TN AjOTrn
TD
TX
//
typedef struct AjSTrn
{
AjPStr FileName;
AjPStr Title;
char GC[16][16][16];
char Starts[16][16][16];
} AjOTrn;
#define AjPTrn AjOTrn*
ID AjETreeType
TY public
MO ajtree
LB core
XX
DE Tree type
XX
VN ajETreeAny
VD Any
VX
VN ajETreeStr
VD String data
VX
VN ajETreeSpecial
VD Other special data
VX
//
typedef enum AjOTreeType
{
ajETreeAny,
ajETreeStr,
ajETreeSpecial
} AjETreeType;
#define AjPTreeNode AjOTreeNode*
ID AjPTree
TY public
MO ajtree
LB core
XX
DE Tree data object. Trees are simple linked nodes with back pointers.
DE
DE Trees can hold any data type. Special functions are available for trees
DE of AjPStr values. In general, these functions are the same. Many are
DE provided for ease of use to save remembering which calls need special cases.
DE
DE At the top level, a tree has a list of named nodes and a pointer to the
DE top node in the tree.
XX
NN ajTreeNew
ND Creates a new general tree.
NX
NN ajTreestrNew
ND Creates a new AjPStr tree.
NX
AN Right
AT struct AjSTree*
AD Next tree node
AX
AN Left
AT struct AjSTree*
AD Previous tree node
AX
AN Up
AT struct AjSTree*
AD Parent tree node
AX
AN Down
AT struct AjSTree*
AD First child tree node
AX
AN Name
AT AjPStr
AD Name string
AX
AN Data
AT void*
AD Data value
AX
AN Freedata
AT AjBool function
AD Complex data free function
AX
AN Type
AT AjEnum
AD Tree type (any, string, etc.)
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSTree
{
struct AjSTree* Right;
struct AjSTree* Left;
struct AjSTree* Up;
struct AjSTree* Down;
AjPStr Name;
void* Data;
AjBool (*Freedata)(void** data);
AjEnum Type;
char Padding[4];
} AjOTree;
#define AjPTree AjOTree*
ID AjPUrl
TY public
MO ajurldata
LB core
XX
DE Ajax url object.
DE
DE Holds the url itself, plus associated information.
XX
TN AjSUrl
TD
TX
TN AjOUrl
TD
TX
AN Id
AT AjPStr
AD Id of term
AX
AN Db
AT AjPStr
AD Database name from input
AX
AN Setdb
AT AjPStr
AD Database name from command line
AX
AN Full
AT AjPStr
AD Full name
AX
AN Qry
AT AjPStr
AD Query for re-reading
AX
AN Formatstr
AT AjPStr
AD Input format name
AX
AN Filename
AT AjPStr
AD Original filename
AX
AN Lines
AT AjPStr*
AD Full text
AX
AN Resqry
AT AjPResquery
AD Resource query
AX
AN Fpos
AT ajlong
AD File position
AX
AN Format
AT AjEnum
AD Input format enum
AX
AN Count
AT ajuint
AD Number of lines read
AX
//
typedef struct AjSUrl
{
AjPStr Id;
AjPStr Db;
AjPStr Setdb;
AjPStr Full;
AjPStr Qry;
AjPStr Formatstr;
AjPStr Filename;
AjPStr *Lines;
AjPResquery Resqry;
ajlong Fpos;
AjEnum Format;
ajuint Count;
} AjOUrl;
#define AjPUrl AjOUrl*
ID AjPUrlin
TY public
MO ajurldata
LB core
XX
DE Ajax url input object.
DE
DE Holds the input specification and information needed to read
DE the url and possible further entries
XX
TN AjSUrlin
TD
TX
TN AjOUrlin
TD
TX
AN Input
AT AjPTextin
AD General text input object
AX
AN Resource
AT AjPResource
AD Resource object
AX
AN UrlList
AT AjPList
AD Result URLs list
AX
AN QryList
AT AjPList
AD Resource query objects for result URLs list
AX
AN UrlData
AT void*
AD Format data for reuse, e.g. multiple term input
AD (unused in current code)
AX
AN Identifiers
AT AjPStr
AD Identifiers of source entry
AX
AN Accession
AT AjPStr
AD Accession number of source entry
AX
AN IdTypes
AT AjPStr
AD Identifier types in DRCAT
AX
AN IsSwiss
AT AjBool
AD True if URL is from a SwissProt reference
AX
AN IsEmbl
AT AjBool
AD True if URL is from an Embl/GenBank/DDBJ reference
AX
//
typedef struct AjSUrlin
{
AjPTextin Input;
AjPResource Resource;
AjPList UrlList;
AjPList QryList;
void *UrlData;
AjPStr Identifiers;
AjPStr Accession;
AjPStr IdTypes;
AjBool IsSwiss;
AjBool IsEmbl;
} AjOUrlin;
#define AjPUrlin AjOUrlin*
ID AjPUrlall
TY public
MO ajurldata
LB core
XX
DE Ajax URL all (stream) object.
DE
DE Inherits an AjPUrl but allows more URLs to be read from the
DE same input by also inheriting the AjPUrlin input object.
XX
TN AjSUrlall
TD
TX
TN AjOUrlall
TD
TX
AN Url
AT AjPUrl
AD Current URL
AX
AN Urlin
AT AjPUrlin
AD URL input for reading next
AX
AN Totterms
AT ajulong
AD Count of terms so far
AX
AN Count
AT ajuint
AD Count of terms so far
AX
AN Multi
AT AjBool
AD True if multiple values are expected
AX
AN Returned
AT AjBool
AD if true: URL object has been returned to a new
AD owner and is not to be deleted by the destructor
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct AjSUrlall
{
AjPUrl Url;
AjPUrlin Urlin;
ajulong Totterms;
ajuint Count;
AjBool Multi;
AjBool Returned;
char Padding[4];
} AjOUrlall;
#define AjPUrlall AjOUrlall*
ID AjPUrlAccess
TY public
MO ajurldata
LB core
XX
DE Ajax url access database reading object.
DE
DE Holds information needed to read an url entry from a database.
DE Access methods are defined for each known database type.
DE
DE Url entries are read from the database using the defined
DE database access function, which is usually a static function
DE within ajurldb.c
DE
DE This should be a static data object but is needed for the definition
DE of AjPUrlin.
XX
TN AjSUrlAccess
TD
TX
TN AjOUrlAccess
TD
TX
AN Name
AT const char*
AD Access method name used in emboss.default
AX
AN Access
AT AjBool function
AD Access function
AX
AN AccessFree
AT AjBool function
AD Access cleanup function
AX
AN Qlink
AT const char*
AD Supported query link operators
AX
AN Desc
AT const char*
AD Description
AX
AN Alias
AT AjBool
AD Alias for another name
AX
AN Entry
AT AjBool
AD Supports retrieval of single entries
AX
AN Query
AT AjBool
AD Supports retrieval of selected entries
AX
AN All
AT AjBool
AD Supports retrieval of all entries
AX
AN Chunked
AT AjBool
AD Supports retrieval of entries in chunks
AX
AN Padding
AT AjBool
AD Padding to alignment boundary
AX
//
typedef struct AjSUrlAccess
{
const char *Name;
AjBool (*Access)(AjPUrlin urlin);
AjBool (*AccessFree)(void* qry);
const char* Qlink;
const char* Desc;
AjBool Alias;
AjBool Entry;
AjBool Query;
AjBool All;
AjBool Chunked;
AjBool Padding;
} AjOUrlAccess;
#define AjPUrlAccess AjOUrlAccess*
ID AjPVarBcfGinfo
TY public
MO ajvarbcf
LB core
XX
DE Individual BCF variation records
DE
DE derived info: fmt, len (<-AjOVarBcf::fmt)
XX
TN AjOVarBcfGinfo
TD
TX
TN AjSVarBcfGinfo
TD
TX
AN fmt
AT ajuint
AD format of the block, set by bcf_str2int()
AX
AN len
AT ajint
AD length of data for each individual
AX
AN data
AT void*
AD concatenated data
AX
//
typedef struct AjSVarBcfGinfo
{
ajuint fmt;
ajint len;
void *data;
} AjOVarBcfGinfo;
#define AjPVarBcfGinfo AjOVarBcfGinfo*
ID AjPVarBcf
TY public
MO ajvarbcf
LB core
XX
DE Individual BCF variation records
DE
DE derived info: ref, alt, flt, info, fmt (<-str),
DE n_gi (<-fmt),
DE n_alleles (<-alt),
DE n_smpl (<-bcf_hdr_t::n_smpl)
XX
TN AjOVarBcf
TD
TX
TN AjSVarBcf
TD
TX
AN tid
AT ajint
AD reference sequence id
AX
AN pos
AT ajint
AD 0-based position
AX
AN l_str
AT ajint
AD length of ->str
AX
AN m_str
AT ajint
AD allocated size of ->str
AX
AN qual
AT float
AD SNP quality
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN str
AT char*
AD concatenated string of variable length strings in VCF
AD (from col.2 to col.7)
AX
AN ref
AT char*
AD reference sequence name (pointer to ->str)
AX
AN alt
AT char*
AD alternate allele(s) (pointer to ->str)
AX
AN flt
AT char*
AD filters applied (pointer to ->str)
AX
AN info
AT char*
AD variant information (pointer to ->str)
AX
AN fmt
AT char*
AD format of the genotype fields (pointer to ->str)
AX
AN n_gi
AT ajint
AD number of genotype fields
AX
AN m_gi
AT ajint
AD allocated size genotype fields
AX
AN gi
AT AjOVarBcfGinfo*
AD array of genotype fields
AX
AN n_alleles
AT ajint
AD number of alleles
AX
AN n_smpl
AT ajint
AD number of samples
AX
//
typedef struct AjSVarBcf
{
ajint tid;
ajint pos;
ajint l_str;
ajint m_str;
float qual;
ajuint Padding;
char *str;
char *ref;
char *alt;
char *flt;
char *info;
char *fmt;
ajint n_gi;
ajint m_gi;
AjOVarBcfGinfo *gi;
ajint n_alleles;
ajint n_smpl;
} AjOVarBcf;
#define AjPVarBcf AjOVarBcf*
ID AjPVarBcfHeader
TY public
MO ajvarbcf
LB core
XX
DE BCF header
DE
DE derived info: n_ref (<-name),
DE n_smpl (<-sname),
DE ns (<-name),
DE sns (<-sname)
XX
TN AjOVarBcfHeader
TD
TX
TN AjSVarBcfHeader
TD
TX
AN n_ref
AT ajint
AD number of reference sequences
AX
AN n_smpl
AT ajint
AD number of samples
AX
AN l_nm
AT ajint
AD length of concatenated sequence names; 0 padded
AX
AN l_smpl
AT ajint
AD length of concatenated sample names; 0 padded
AX
AN l_txt
AT ajint
AD length of header text (lines started with ##)
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN name
AT char*
AD concatenated sequence names
AX
AN sname
AT char*
AD concatenated sample names
AX
AN txt
AT char*
AD header text
AX
AN ns
AT const char**
AD array of sequence names (pointer to ->name)
AX
AN sns
AT const char**
AD array of sample names (pointer to ->sname)
AX
//
typedef struct AjSVarBcfHeader
{
ajint n_ref;
ajint n_smpl;
ajint l_nm;
ajint l_smpl;
ajint l_txt;
ajuint Padding;
char *name;
char *sname;
char *txt;
const char **ns;
const char **sns;
} AjOVarBcfHeader;
#define AjPVarBcfHeader AjOVarBcfHeader*
ID AjEVarType
TY public
MO ajvardata
LB core
XX
DE Variation metadata value type for INFO and FORMAT definitions
XX
VN AJVAR_UNKNOWN
VD Unknown
VX
VN AJVAR_INT
VD Integer
VX
VN AJVAR_FLOAT
VD Float
VX
VN AJVAR_CHAR
VD Character
VX
VN AJVAR_STR
VD String
VX
VN AJVAR_FLAG
VD Flag (INFO, not FORMAT)
VX
VN AJVAR_MAX
VD Above last defined value
VX
//
typedef enum AjOVarType
{
AJVAR_UNKNOWN, AJVAR_INT, AJVAR_FLOAT, AJVAR_CHAR, AJVAR_STR,
AJVAR_FLAG, AJVAR_MAX
} AjEVarType;
ID AjPVarHeader
TY public
MO ajvardata
LB core
XX
DE Ajax variation header object.
DE
DE Holds the metadata definitions for variation data
DE
DE Based on the requirements for VCF format 4.1
XX
TN AjSVarHeader
TD
TX
TN AjOVarHeader
TD
TX
AN Header
AT AjPList
AD Tag-value list of general header records
AX
AN Fields
AT AjPList
AD List of VarField definitions (INFO and FORMAT)
AX
AN Samples
AT AjPList
AD List of VarSample definitions
AX
AN Filters
AT AjPList
AD List of Filter tag-value definitions
AX
AN Alts
AT AjPList
AD List of Alternate tag-value definitions
AX
AN Pedigrees
AT AjPList
AD List of Pedigree tag-value definitions
AX
AN SampleIds
AT AjPList
AD List of SampleID strings from column headings
AX
AN RefseqIds
AT AjPTable
AD Table of reference sequence name-id pairs
AX
//
typedef struct AjSVarHeader
{
AjPList Header;
AjPList Fields;
AjPList Samples;
AjPList Filters;
AjPList Alts;
AjPList Pedigrees;
AjPList SampleIds;
AjPTable RefseqIds;
} AjOVarHeader;
#define AjPVarHeader AjOVarHeader*
ID AjPVarField
TY public
MO ajvardata
LB core
XX
DE Ajax variation field description object.
DE
DE Holds the metadata definitions for variation data fields
DE
DE Based on the requirements for VCF format 4.1
XX
TN AjSVarField
TD
TX
TN AjOVarField
TD
TX
AN Field
AT AjPStr
AD Field name (INFO, FILTER, FORMAT)
AX
AN Id
AT AjPStr
AD Identifier
AX
AN Desc
AT AjPStr
AD Description
AX
AN Type
AT AjEVarType
AD Type of value
AX
AN Number
AT ajint
AD Count of values
AX
//
typedef struct AjSVarField
{
AjPStr Field;
AjPStr Id;
AjPStr Desc;
AjEVarType Type;
ajint Number;
} AjOVarField;
#define AjPVarField AjOVarField*
ID AjPVarSample
TY public
MO ajvardata
LB core
XX
DE Ajax variation sample description object.
DE
DE Holds the metadata definitions for variation data samples
DE
DE Based on the requirements for VCF format 4.1
XX
TN AjSVarSample
TD
TX
TN AjOVarSample
TD
TX
AN Id
AT AjPStr
AD Identifier
AX
AN Desc
AT AjPStr*
AD Descriptions for each genome identifier
AX
AN Genomes
AT AjPStr*
AD Genome identifiers
AX
AN Mixture
AT float*
AD Mixture proportions, summing to 1.0
AX
AN Number
AT ajuint
AD Count of genome identifiers
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSVarSample
{
AjPStr Id;
AjPStr *Desc;
AjPStr *Genomes;
float *Mixture;
ajuint Number;
ajuint Padding;
} AjOVarSample;
#define AjPVarSample AjOVarSample*
ID AjPVarData
TY public
MO ajvardata
LB core
XX
DE Ajax variation data object.
DE
DE Holds the metadata definitions for variation data records
DE
DE Based on the requirements for VCF format 4.1
XX
TN AjSVarAlt
TD
TX
TN AjOVarAlt
TD
TX
AN Chrom
AT AjPStr
AD Chromosome
AX
AN Id
AT AjPStr
AD Identifier
AX
AN Ref
AT AjPStr
AD Reference sequence(s)
AX
AN Alt
AT AjPStr
AD Alternate sequence(s)
AX
AN Qual
AT AjPStr
AD Quality
AX
AN Filter
AT AjPStr
AD Filter(s) failed
AX
AN Info
AT AjPStr
AD Info field metadata
AX
AN Format
AT AjPStr
AD Format field metadata
AX
AN Samples
AT AjPList
AD Sample string records
AX
AN Pos
AT ajuint
AD Position
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSVarData
{
AjPStr Chrom;
AjPStr Id;
AjPStr Ref;
AjPStr Alt;
AjPStr Qual;
AjPStr Filter;
AjPStr Info;
AjPStr Format;
AjPList Samples;
ajuint Pos;
ajuint Padding;
} AjOVarData;
#define AjPVarData AjOVarData*
ID AjPVar
TY public
MO ajvardata
LB core
XX
DE Ajax variation object.
DE
DE Holds the variation itself, plus associated information.
XX
TN AjSVar
TD
TX
TN AjOVar
TD
TX
AN Id
AT AjPStr
AD Id of term
AX
AN Db
AT AjPStr
AD Database name from input
AX
AN Setdb
AT AjPStr
AD Database name from command line
AX
AN Full
AT AjPStr
AD Full name
AX
AN Qry
AT AjPStr
AD Query for re-reading
AX
AN Formatstr
AT AjPStr
AD Input format name
AX
AN Filename
AT AjPStr
AD Original filename
AX
AN Textptr
AT AjPStr
AD Full text
AX
AN Data
AT AjPList
AD Data records as AjPVarData objects
AX
AN Header
AT AjPVarHeader
AD Header record metadata
AX
AN Fpos
AT ajlong
AD File position
AX
AN Format
AT AjEnum
AD Input format enum
AX
AN Hasdata
AT AjBool
AD True when data has been loaded
AX
//
typedef struct AjSVar
{
AjPStr Id;
AjPStr Db;
AjPStr Setdb;
AjPStr Full;
AjPStr Qry;
AjPStr Formatstr;
AjPStr Filename;
AjPStr Textptr;
AjPList Data;
AjPVarHeader Header;
ajlong Fpos;
AjEnum Format;
AjBool Hasdata;
} AjOVar;
#define AjPVar AjOVar*
ID AjPVarin
TY public
MO ajvardata
LB core
XX
DE Ajax variation input object.
DE
DE Holds the input specification and information needed to read
DE the variation and possible further entries
XX
TN AjSVarin
TD
TX
TN AjOVarin
TD
TX
AN Input
AT AjPTextin
AD General text input object
AX
AN Begin
AT ajint
AD Start position
AX
AN End
AT ajint
AD End position
AX
AN Loading
AT AjBool
AD True if data is now loading
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
AN VarData
AT void*
AD Format data for reuse, e.g. multiple term input
AD (unused in current code)
AX
//
typedef struct AjSVarin
{
AjPTextin Input;
ajint Begin;
ajint End;
AjBool Loading;
char Padding[4];
void *VarData;
} AjOVarin;
#define AjPVarin AjOVarin*
ID AjPVarload
TY public
MO ajvardata
LB core
XX
DE Ajax variation loader object.
DE
DE Inherits an AjPVar but allows more variations to be read from the
DE same input by also inheriting the AjPVarin input object.
XX
TN AjSVarload
TD
TX
TN AjOVarload
TD
TX
AN Var
AT AjPVar
AD Current variation
AX
AN Varin
AT AjPVarin
AD Variation input for reading next
AX
AN Count
AT ajuint
AD Count of terms so far
AX
AN Loading
AT AjBool
AD True if data is now loading
AX
AN Returned
AT AjBool
AD if true: Variation object has been returned to a new
AD owner and is not to be deleted by the destructor
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSVarload
{
AjPVar Var;
AjPVarin Varin;
ajuint Count;
AjBool Loading;
AjBool Returned;
ajuint Padding;
} AjOVarload;
#define AjPVarload AjOVarload*
ID AjPVarall
TY public
MO ajvardata
LB core
XX
DE Ajax variation all (stream) object.
DE
DE Inherits an AjPVar but allows more variations to be read from the
DE same input by also inheriting the AjPVarin input object.
XX
TN AjSVarall
TD
TX
TN AjOVarall
TD
TX
AN Loader
AT AjPVarload
AD Variation loader for reading next
AX
AN Totterms
AT ajulong
AD Count of terms so far
AX
AN Count
AT ajuint
AD Count of terms so far
AX
AN Multi
AT AjBool
AD True if multiple values are expected
AX
AN Returned
AT AjBool
AD if true: Variation object has been returned to a new
AD owner and is not to be deleted by the destructor
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct AjSVarall
{
AjPVarload Loader;
ajulong Totterms;
ajuint Count;
AjBool Multi;
AjBool Returned;
ajuint Padding;
} AjOVarall;
#define AjPVarall AjOVarall*
ID AjPVarAccess
TY public
MO ajvardata
LB core
XX
DE Ajax variation access database reading object.
DE
DE Holds information needed to read a variation entry from a database.
DE Access methods are defined for each known database type.
DE
DE Variation entries are read from the database using the defined
DE database access function, which is usually a static function
DE within ajvardb.c
DE
DE This should be a static data object but is needed for the definition
DE of AjPVarin.
XX
TN AjSVarAccess
TD
TX
TN AjOVarAccess
TD
TX
AN Name
AT const char*
AD Access method name used in emboss.default
AX
AN Access
AT AjBool function
AD Access function
AX
AN AccessFree
AT AjBool function
AD Access cleanup function
AX
AN Qlink
AT const char*
AD Supported query link operators
AX
AN Desc
AT const char*
AD Description
AX
AN Alias
AT AjBool
AD Alias for another name
AX
AN Entry
AT AjBool
AD Supports retrieval of single entries
AX
AN Query
AT AjBool
AD Supports retrieval of selected entries
AX
AN All
AT AjBool
AD Supports retrieval of all entries
AX
AN Chunked
AT AjBool
AD Supports retrieval of entries in chunks
AX
AN Padding
AT AjBool
AD Padding to alignment boundary
AX
//
typedef struct AjSVarAccess
{
const char *Name;
AjBool (*Access)(AjPVarin varin);
AjBool (*AccessFree)(void* qry);
const char* Qlink;
const char* Desc;
AjBool Alias;
AjBool Entry;
AjBool Query;
AjBool All;
AjBool Chunked;
AjBool Padding;
} AjOVarAccess;
#define AjPVarAccess AjOVarAccess*
ID AjP3dVector
TY public
MO ajvector
LB core
XX
DE Ajax 3-D vector object.
DE
DE Holds three floats
DE
DE AjP3dVector is implemented as a pointer to a C data structure.
XX
TN AjS3dVector
TD
TX
TN AjO3dVector
TD
TX
NN aj3dVectorNew
ND default constructor
NX
NN aj3dVectorCreate
ND constructor initialising values of vector components
NX
DN aj3dVectorDel
DD default destructor
DX
ON aj3dVectorSum
OD return sum of two vectors
OX
ON aj3dVectorDotProduct
OD return dot product of two vectors
OX
ON aj3dVectorCrossProduct
OD return cross product of two vectors
OX
ON aj3dVectorAngle
OD return angle between two vectors
OX
ON aj3dVectorDihedralAngle
OD return angle between two planes
OX
MN aj3dVectorBetweenPoints
MD return vector between two points
MX
CN aj3dVectorLength
CD return length of vector
CX
AN x
AT float
AD x coordinate
AX
AN y
AT float
AD y coordinate
AX
AN z
AT float
AD z coordinate
AX
//
typedef struct AjS3dVector
{
float x;
float y;
float z;
} AjO3dVector;
#define AjP3dVector AjO3dVector*
ID EnsEBasealignfeatureType
TY public
MO ensalign
LB ensembl
XX
DE Ensembl Base Align Feature Type enumeration
XX
VN ensEBasealignfeatureTypeNULL
VD Null
VX
VN ensEBasealignfeatureTypeDNA
VD DNA alignment
VX
VN ensEBasealignfeatureTypeProtein
VD Protein alignment
VX
//
typedef enum EnsOBasealignfeatureType
{
ensEBasealignfeatureTypeNULL,
ensEBasealignfeatureTypeDNA,
ensEBasealignfeatureTypeProtein
} EnsEBasealignfeatureType;
ID EnsPBasealignfeature
TY public
MO ensalign
LB ensembl
XX
DE Ensembl Base Align Feature.
XX
TN EnsSBasealignfeature
TD
TX
TN EnsOBasealignfeature
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Dnaalignfeatureadaptor
AT EnsPDnaalignfeatureadaptor
AD Ensembl DNA Align Feature Adaptor
AX
AN Proteinalignfeatureadaptor
AT EnsPProteinalignfeatureadaptor
AD Ensembl Protein Align Feature Adaptor
AX
AN Featurepair
AT EnsPFeaturepair
AD Ensembl Feature Pair
AX
AN FobjectGetFeaturepair
AT EnsPFeaturepair function
AD Ensembl Object Get Ensembl Feature Pair function
AX
AN Cigar
AT AjPStr
AD CIGAR line
AX
AN Type
AT EnsEBasealignfeatureType
AD Type
AX
AN Alignmentlength
AT ajuint
AD Target component alignment length
AX
AN Pairdnaalignfeatureidentifier
AT ajuint
AD Pair DNA Align Feature identifier
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSBasealignfeature
{
ajuint Use;
ajuint Identifier;
EnsPDnaalignfeatureadaptor Dnaalignfeatureadaptor;
EnsPProteinalignfeatureadaptor Proteinalignfeatureadaptor;
EnsPFeaturepair Featurepair;
EnsPFeaturepair (*FobjectGetFeaturepair) (const void *object);
AjPStr Cigar;
EnsEBasealignfeatureType Type;
ajuint Alignmentlength;
ajuint Pairdnaalignfeatureidentifier;
ajuint Padding;
} EnsOBasealignfeature;
#define EnsPBasealignfeature EnsOBasealignfeature*
ID EnsPAssembly
TY public
MO ensassembly
LB ensembl
XX
DE Ensembl Assembly
DE
DE An Ensembl Assembly object encapsulates assembly information how an
DE assembled Ensembl Sequence Region is assembled from a particular
DE component Ensembl Sequence Region.
XX
TN EnsSAssembly
TD
TX
TN EnsOAssembly
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN AssembledIdentifier
AT ajuint
AD Assembled Ensembl Sequence Region
AD identifier
AX
AN AssembledStart
AT ajuint
AD Assembled Ensembl Sequence Region
AD start coordinate
AX
AN AssembledEnd
AT ajuint
AD Assembled Ensembl Sequence Region
AD end coordinate
AX
AN ComponentIdentifier
AT ajuint
AD Component Ensembl Sequence Region
AD identifier
AX
AN ComponentStart
AT ajuint
AD Component Ensembl Sequence Region
AD start coordinate
AX
AN ComponentEnd
AT ajuint
AD Component Ensembl Sequence Region
AD end coordinate
AX
AN Orientation
AT ajint
AD Relative orientation
AX
//
typedef struct EnsSAssembly
{
ajuint Use;
ajuint AssembledIdentifier;
ajuint AssembledStart;
ajuint AssembledEnd;
ajuint ComponentIdentifier;
ajuint ComponentStart;
ajuint ComponentEnd;
ajint Orientation;
} EnsOAssembly;
#define EnsPAssembly EnsOAssembly*
ID EnsEAssemblyexceptionType
TY public
MO ensassemblyexception
LB ensembl
XX
DE Ensembl Assembly Exception Type enumeration
XX
VN ensEAssemblyexceptionTypeNULL
VD Null
VX
VN ensEAssemblyexceptionTypeHAP
VD Haplotype Region
VX
VN ensEAssemblyexceptionTypePAR
VD Pseudo-Autosomal Region
VX
VN ensEAssemblyexceptionTypePatchFix
VD Sequence Patch Region
VX
VN ensEAssemblyexceptionTypePatchNovel
VD Novel Patch Region
VX
VN ensEAssemblyexceptionTypeHAPRef
VD Haplotype Reference Region
VX
VN ensEAssemblyexceptionTypePatchFixRef
VD Sequence Patch Reference Region
VX
VN ensEAssemblyexceptionTypePatchNovelRef
VD Novel Patch Reference Region
VX
//
typedef enum EnsOAssemblyexceptionType
{
ensEAssemblyexceptionTypeNULL,
ensEAssemblyexceptionTypeHAP,
ensEAssemblyexceptionTypePAR,
ensEAssemblyexceptionTypePatchFix,
ensEAssemblyexceptionTypePatchNovel,
ensEAssemblyexceptionTypeHAPRef,
ensEAssemblyexceptionTypePatchFixRef,
ensEAssemblyexceptionTypePatchNovelRef
} EnsEAssemblyexceptionType;
ID EnsPAssemblyexceptionadaptor
TY public
MO ensassemblyexception
LB ensembl
XX
DE Ensembl Assembly Exception Adaptor.
XX
TN EnsSAssemblyexceptionadaptor
TD
TX
TN EnsOAssemblyexceptionadaptor
TD
TX
AN Adaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
AN CacheByReferenceSeqregion
AT AjPTable
AD AJAX Table of AJAX unsigned integer (Ensembl Sequence Region identifier) key
AD and Ensembl Assembly Exception value data
AX
//
typedef struct EnsSAssemblyexceptionadaptor
{
EnsPDatabaseadaptor Adaptor;
AjPTable CacheByReferenceSeqregion;
} EnsOAssemblyexceptionadaptor;
#define EnsPAssemblyexceptionadaptor EnsOAssemblyexceptionadaptor*
ID EnsPAssemblyexception
TY public
MO ensassemblyexception
LB ensembl
XX
DE Ensembl Assembly Exception.
DE
DE An Ensembl Assembly Exception object encapsulates information about
DE exceptions in the reference assembly path. Currently, the Ensembl system
DE models two types of assembly exceptions.
DE
DE Haplotype (HAPs) assemblies represent alternative assembly paths of regions
DE of increased genetic variablility.
DE Pseudo-autosomal regions (PARs) are paired stretches at either tip of
DE (mammalian) sex chromosomes where frequent chrossing over events occur.
DE Due to the frequent exchange of genetic material those sequences represent
DE exact copies of each other.
XX
TN EnsSAssemblyexception
TD
TX
TN EnsOAssemblyexception
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPAssemblyexceptionadaptor
AD Ensembl Assembly
AD Exception Adaptor
AX
AN ReferenceSeqregion
AT ajuint
AD Ensembl Sequence Region identifier
AX
AN ReferenceStart
AT ajuint
AD Ensembl Sequence Region start
AX
AN ReferenceEnd
AT ajuint
AD Ensembl Sequence Region end
AX
AN ExceptionSeqregion
AT ajuint
AD Ensembl Sequence Region identifier
AX
AN ExceptionStart
AT ajuint
AD Ensembl Sequence Region start
AX
AN ExceptionEnd
AT ajuint
AD Ensembl Sequence Region end
AX
AN Orientation
AT ajint
AD Orientation
AX
AN Type
AT EnsEAssemblyexceptionType
AD Type
AX
//
typedef struct EnsSAssemblyexception
{
ajuint Use;
ajuint Identifier;
EnsPAssemblyexceptionadaptor Adaptor;
ajuint ReferenceSeqregion;
ajuint ReferenceStart;
ajuint ReferenceEnd;
ajuint ExceptionSeqregion;
ajuint ExceptionStart;
ajuint ExceptionEnd;
ajint Orientation;
EnsEAssemblyexceptionType Type;
} EnsOAssemblyexception;
#define EnsPAssemblyexception EnsOAssemblyexception*
ID EnsECacheType
TY public
MO enscache
LB ensembl
XX
DE Ensembl Cache Type enumeration
XX
VN ensECacheTypeNULL
VD Null
VX
VN ensECacheTypeNumeric
VD Numeric
VX
VN ensECacheTypeAlphaNumeric
VD Alphanumeric
VX
//
typedef enum EnsOCacheType
{
ensECacheTypeNULL,
ensECacheTypeNumeric,
ensECacheTypeAlphaNumeric
} EnsECacheType;
ID EnsPCache
TY public
MO enscache
LB ensembl
XX
DE Ensembl Cache.
XX
TN EnsSCache
TD
TX
TN EnsOCache
TD
TX
AN Label
AT AjPStr
AD Cache label for statistics output
AX
AN List
AT AjPList
AD AJAX List implementing LRU functionality
AX
AN Table
AT AjPTable
AD AJAX Table implementing lookup functionality
AX
AN Freference
AT void* function
AD Object-specific referencing function
AX
AN Fdelete
AT void function
AD Object-specific deletion function
AX
AN Fsize
AT size_t function
AD Object-specific memory sizing function
AX
AN Fread
AT void* function
AD Object-specific reading function
AX
AN Fwrite
AT AjBool function
AD Object-specific writing function
AX
AN Type
AT EnsECacheType
AD Ensembl Cache type
AX
AN Synchron
AT AjBool
AD ajTrue: Immediately write-back value data
AD ajFalse: Write-back value data later
AX
AN Bytes
AT size_t
AD Current number of cached bytes
AX
AN MaxBytes
AT size_t
AD Maximum number of allowed bytes
AX
AN MaxSize
AT size_t
AD Maximum memory size of an object
AX
AN Count
AT ajuint
AD Current number of cached entry
AX
AN MaxCount
AT ajuint
AD Maximum number of allowed entries
AX
AN Dropped
AT ajuint
AD Number of entries dropped by the LRU algorithm
AX
AN Removed
AT ajuint
AD Number of entries explicitly removed
AX
AN Stored
AT ajuint
AD Number of entries currently stored
AX
AN Hit
AT ajuint
AD Number of cache hits
AX
AN Miss
AT ajuint
AD Number of cache misses
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSCache
{
AjPStr Label;
AjPList List;
AjPTable Table;
void *(*Freference) (void *value);
void (*Fdelete) (void **Pvalue);
size_t (*Fsize) (const void *value);
void *(*Fread) (const void *key);
AjBool (*Fwrite) (const void *value);
EnsECacheType Type;
AjBool Synchron;
size_t Bytes;
size_t MaxBytes;
size_t MaxSize;
ajuint Count;
ajuint MaxCount;
ajuint Dropped;
ajuint Removed;
ajuint Stored;
ajuint Hit;
ajuint Miss;
ajuint Padding;
} EnsOCache;
#define EnsPCache EnsOCache*
ID EnsPCoordsystemadaptor
TY public
MO enscoordsystem
LB ensembl
XX
DE Ensembl Coordinate System Adaptor
XX
TN EnsSCoordsystemadaptor
TD
TX
TN EnsOCoordsystemadaptor
TD
TX
AN Adaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AD cc Bio::EnsEMBL::DBSQL::CoordSystemAdaptor
AX
AN CacheByIdentifier
AT AjPTable
AD Database identifier cache
AX
AN CacheByName
AT AjPTable
AD Name cache
AX
AN CacheByRank
AT AjPTable
AD Rank cache
AX
AN CacheByDefault
AT AjPTable
AD Default Ensembl Coordinate Systems
AX
AN MappingPaths
AT AjPTable
AD Mapping paths between coordinate systems
AX
AN ExternalToInternal
AT AjPTable
AD External to internal Sequence Regions
AX
AN InternalToExternal
AT AjPTable
AD Internal to external Sequence Regions
AX
AN Seqlevel
AT struct EnsSCoordsystem*
AD Sequence-level Ensembl Coordinate System
AX
AN Toplevel
AT struct EnsSCoordsystem*
AD Top-level Ensembl Coordinate System
AX
//
typedef struct EnsSCoordsystemadaptor
{
EnsPDatabaseadaptor Adaptor;
AjPTable CacheByIdentifier;
AjPTable CacheByName;
AjPTable CacheByRank;
AjPTable CacheByDefault;
AjPTable MappingPaths;
AjPTable ExternalToInternal;
AjPTable InternalToExternal;
struct EnsSCoordsystem *Seqlevel;
struct EnsSCoordsystem *Toplevel;
} EnsOCoordsystemadaptor;
#define EnsPCoordsystemadaptor EnsOCoordsystemadaptor*
ID EnsPCoordsystem
TY public
MO enscoordsystem
LB ensembl
XX
DE Ensembl Coordinate System
XX
TN EnsSCoordsystem
TD
TX
TN EnsOCoordsystem
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPCoordsystemadaptor
AD Ensembl Coordinate System Adaptor
AX
AN Name
AT AjPStr
AD Coordinate System name
AX
AN Version
AT AjPStr
AD Coordinate System version
AX
AN Default
AT AjBool
AD Default Coordinate System version of this name
AX
AN SequenceLevel
AT AjBool
AD Sequence-level attribute
AX
AN Toplevel
AT AjBool
AD Top-level attribute
AX
AN Rank
AT ajuint
AD Coordinate System rank
AX
//
typedef struct EnsSCoordsystem
{
ajuint Use;
ajuint Identifier;
EnsPCoordsystemadaptor Adaptor;
AjPStr Name;
AjPStr Version;
AjBool Default;
AjBool SequenceLevel;
AjBool Toplevel;
ajuint Rank;
} EnsOCoordsystem;
#define EnsPCoordsystem EnsOCoordsystem*
ID EnsEExternaldatabaseStatus
TY public
MO ensdata
LB ensembl
XX
DE Ensembl External Database Status enumeration
XX
VN ensEExternaldatabaseStatusNULL
VD Null
VX
VN ensEExternaldatabaseStatusKnownXref
VD Known external reference
VX
VN ensEExternaldatabaseStatusKnown
VD Known
VX
VN ensEExternaldatabaseStatusXref
VD External reference
VX
VN ensEExternaldatabaseStatusPred
VD Predicted
VX
VN ensEExternaldatabaseStatusOrth
VD Orthologue
VX
VN ensEExternaldatabaseStatusPseudo
VD Pseudo
VX
//
typedef enum EnsOExternaldatabaseStatus
{
ensEExternaldatabaseStatusNULL,
ensEExternaldatabaseStatusKnownXref,
ensEExternaldatabaseStatusKnown,
ensEExternaldatabaseStatusXref,
ensEExternaldatabaseStatusPred,
ensEExternaldatabaseStatusOrth,
ensEExternaldatabaseStatusPseudo
} EnsEExternaldatabaseStatus;
ID EnsEExternaldatabaseType
TY public
MO ensdata
LB ensembl
XX
DE Ensembl External Database Type enumeration
XX
VN ensEExternaldatabaseTypeNULL
VD Null
VX
VN ensEExternaldatabaseTypeArray
VD Array
VX
VN ensEExternaldatabaseTypeAltTrans
VD Alternative Translation
VX
VN ensEExternaldatabaseTypeAltGene
VD Alternative Gene
VX
VN ensEExternaldatabaseTypeMisc
VD Miscellaneous
VX
VN ensEExternaldatabaseTypeLit
VD Literature
VX
VN ensEExternaldatabaseTypePrimaryDbSynonym
VD Primary database synonym
VX
VN ensEExternaldatabaseTypeEnsembl
VD Ensembl
VX
VN ensEExternaldatabaseTypeIgnore
VD Ignore
VX
//
typedef enum EnsOExternaldatabaseType
{
ensEExternaldatabaseTypeNULL,
ensEExternaldatabaseTypeArray,
ensEExternaldatabaseTypeAltTrans,
ensEExternaldatabaseTypeAltGene,
ensEExternaldatabaseTypeMisc,
ensEExternaldatabaseTypeLit,
ensEExternaldatabaseTypePrimaryDbSynonym,
ensEExternaldatabaseTypeEnsembl,
ensEExternaldatabaseTypeIgnore
} EnsEExternaldatabaseType;
ID EnsEExternalreferenceInfotype
TY public
MO ensdata
LB ensembl
XX
DE Ensembl External Reference Information Type enumeration
XX
VN ensEExternalreferenceInfotypeNULL
VD Null
VX
VN ensEExternalreferenceInfotypeProjection
VD Projection
VX
VN ensEExternalreferenceInfotypeMisc
VD Miscellaneous
VX
VN ensEExternalreferenceInfotypeDependent
VD Dependent
VX
VN ensEExternalreferenceInfotypeDirect
VD Direct
VX
VN ensEExternalreferenceInfotypeSequenceMatch
VD Sequence Match
VX
VN ensEExternalreferenceInfotypeInferredPair
VD Inferred Pair
VX
VN ensEExternalreferenceInfotypeProbe
VD Probe
VX
VN ensEExternalreferenceInfotypeUnmapped
VD Unmapped
VX
VN ensEExternalreferenceInfotypeCoordinateOverlap
VD Coordinate Overlap
VX
//
typedef enum EnsOExternalreferenceInfotype
{
ensEExternalreferenceInfotypeNULL,
ensEExternalreferenceInfotypeProjection,
ensEExternalreferenceInfotypeMisc,
ensEExternalreferenceInfotypeDependent,
ensEExternalreferenceInfotypeDirect,
ensEExternalreferenceInfotypeSequenceMatch,
ensEExternalreferenceInfotypeInferredPair,
ensEExternalreferenceInfotypeProbe,
ensEExternalreferenceInfotypeUnmapped,
ensEExternalreferenceInfotypeCoordinateOverlap
} EnsEExternalreferenceInfotype;
ID EnsEExternalreferenceObjecttype
TY public
MO ensdata
LB ensembl
XX
DE Ensembl External Reference Object Type enumeration
XX
VN ensEExternalreferenceObjecttypeNULL
VD Null
VX
VN ensEExternalreferenceObjecttypeRawContig
VD Raw Contig
VX
VN ensEExternalreferenceObjectypeTranscript
VD Transcript
VX
VN ensEExternalreferenceObjecttypeGene
VD Gene
VX
VN ensEExternalreferenceObjecttypeTranslation
VD Translation
VX
//
typedef enum EnsOExternalreferenceObjecttype
{
ensEExternalreferenceObjecttypeNULL,
ensEExternalreferenceObjecttypeRawContig,
ensEExternalreferenceObjectypeTranscript,
ensEExternalreferenceObjecttypeGene,
ensEExternalreferenceObjecttypeTranslation
} EnsEExternalreferenceObjecttype;
ID EnsEGeneStatus
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Gene Status enumeration
XX
VN ensEGeneStatusNULL
VD Null
VX
VN ensEGeneStatusKnown
VD Known
VX
VN ensEGeneStatusNovel
VD Novel
VX
VN ensEGeneStatusPutative
VD Putative
VX
VN ensEGeneStatusPredicted
VD Predicted
VX
VN ensEGeneStatusKnownByProjection
VD Known by projection
VX
VN ensEGeneStatusUnknown
VD Unknown
VX
//
typedef enum EnsOGeneStatus
{
ensEGeneStatusNULL,
ensEGeneStatusKnown,
ensEGeneStatusNovel,
ensEGeneStatusPutative,
ensEGeneStatusPredicted,
ensEGeneStatusKnownByProjection,
ensEGeneStatusUnknown
} EnsEGeneStatus;
ID EnsESliceTopology
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Slice Topology enumeration
XX
VN ensESliceTopologyNULL
VD Null
VX
VN ensESliceTopologyLinear
VD Linear
VX
VN ensESliceTopologyCircular
VD Circular
VX
//
typedef enum EnsOSliceTopology
{
ensESliceTopologyNULL,
ensESliceTopologyLinear,
ensESliceTopologyCircular
} EnsESliceTopology;
ID EnsESliceType
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Slice Type enumeration
XX
VN ensESliceTypeNULL
VD Null
VX
VN ensESliceTypeLinear
VD Linear
VX
VN ensESliceTypeCircular
VD Circular
VX
VN ensESliceTypeLrg
VD Locus Reference Genome
VX
//
typedef enum EnsOSliceType
{
ensESliceTypeNULL,
ensESliceTypeLinear,
ensESliceTypeCircular,
ensESliceTypeLrg
} EnsESliceType;
ID EnsETranscriptStatus
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Transcript Status enumeration
XX
VN ensETranscriptStatusNULL
VD Null
VX
VN ensETranscriptStatusKnown
VD Known
VX
VN ensETranscriptStatusNovel
VD Novel
VX
VN ensETranscriptStatusPutative
VD Putative
VX
VN ensETranscriptStatusPredicted
VD Predicted
VX
VN ensETranscriptStatusKnownByProjection
VD Known by projection
VX
VN ensETranscriptStatusUnknown
VD Unknown
VX
VN ensETranscriptStatusAnnotated
VD Annotated
VX
//
typedef enum EnsOTranscriptStatus
{
ensETranscriptStatusNULL,
ensETranscriptStatusKnown,
ensETranscriptStatusNovel,
ensETranscriptStatusPutative,
ensETranscriptStatusPredicted,
ensETranscriptStatusKnownByProjection,
ensETranscriptStatusUnknown,
ensETranscriptStatusAnnotated
} EnsETranscriptStatus;
ID EnsPSeqregionadaptor
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Sequence Region Adaptor
XX
AN Adaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
AN CacheByIdentifier
AT EnsPCache
AD Ensembl Cache to store Ensembl Sequence
AD Region objects with SQL-database identifiers as index
AX
AN CacheByName
AT AjPTable
AD AJAX Table to cache Ensembl Sequence Region
AD objects with "Sequence Region Name:Coordinate System Identifier" AJAX String
AD objects as index
AX
AN CacheLocusReferenceGenomic
AT AjPList
AD AJAX List to cache Ensembl
AD Sequence Region objects, which are associated with an Ensembl Attribute of
AD code "LRG" and correspond to Locus Reference Genomic entries.
AD See http://www.lrg-sequence.org/ for details.
AX
AN CacheNonReference
AT AjPList
AD AJAX List to cache Ensembl Sequence
AD Region objects, which are associated with an Ensembl Attribute of code
AD "non_ref" that is usually set for haplotype assembly paths.
AX
//
typedef struct EnsSSeqregionadaptor
{
EnsPDatabaseadaptor Adaptor;
EnsPCache CacheByIdentifier;
AjPTable CacheByName;
AjPList CacheLocusReferenceGenomic;
AjPList CacheNonReference;
} EnsOSeqregionadaptor;
#define EnsPSeqregionadaptor EnsOSeqregionadaptor*
ID EnsPSeqregion
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Sequence Region
XX
AN Use
AT ajuint
AD Usage counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPSeqregionadaptor
AD Ensembl Sequence Region Adaptor
AX
AN Coordsystem
AT EnsPCoordsystem
AD Ensembl Coordinate System
AX
AN Name
AT AjPStr
AD Name
AX
AN Attributes
AT AjPList
AD AJAX List of Ensembl Attribute objects
AX
AN Seqregionsynonyms
AT AjPList
AD AJAX List of Ensembl Sequence Region Synonym objects
AX
AN Length
AT ajint
AD Length
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSSeqregion
{
ajuint Use;
ajuint Identifier;
EnsPSeqregionadaptor Adaptor;
EnsPCoordsystem Coordsystem;
AjPStr Name;
AjPList Attributes;
AjPList Seqregionsynonyms;
ajint Length;
ajuint Padding;
} EnsOSeqregion;
#define EnsPSeqregion EnsOSeqregion*
ID EnsPSliceadaptor
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Slice Adaptor
XX
AN Adaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
AN CacheByIdentifier
AT EnsPCache
AD Caches Ensembl Slice objects by their
AD Ensembl Sequence Region identifier, start, end and strand coordinate
AX
AN CacheByName
AT AjPTable
AD Caches Ensembl Slice objects by their
AD Ensembl Sequence Region name, start, end and strand coordinate
AX
//
typedef struct EnsSSliceadaptor
{
EnsPDatabaseadaptor Adaptor;
EnsPCache CacheByIdentifier;
AjPTable CacheByName;
} EnsOSliceadaptor;
#define EnsPSliceadaptor EnsOSliceadaptor*
ID EnsPSlice
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Slice
DE
DE Holds information about a genome sequence slice.
XX
TN EnsSSlice
TD
TX
TN EnsOSlice
TD
TX
AN Adaptor
AT EnsPSliceadaptor
AD Ensembl Slice Adaptor
AX
AN Seqregion
AT EnsPSeqregion
AD Ensembl Sequence Region
AX
AN Sequence
AT AjPStr
AD Sequence
AX
AN Topology
AT EnsESliceTopology
AD Slice Topology enumeration
AX
AN Type
AT EnsESliceType
AD Ensembl Slice Type enumeration
AX
AN Start
AT ajint
AD Start coordinate
AX
AN End
AT ajint
AD End coordinate
AX
AN Strand
AT ajint
AD Strand information (+1|-1)
AX
AN Use
AT ajuint
AD Use counter
AX
//
typedef struct EnsSSlice
{
EnsPSliceadaptor Adaptor;
EnsPSeqregion Seqregion;
AjPStr Sequence;
EnsESliceTopology Topology;
EnsESliceType Type;
ajint Start;
ajint End;
ajint Strand;
ajuint Use;
} EnsOSlice;
#define EnsPSlice EnsOSlice*
ID EnsPAssemblymapperadaptor
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Assembly Mapper Adaptor
DE
DE The Ensembl Assembly Mapper Adaptor is used to retrieve Ensembl Mapper
DE objects between any two Ensembl Coordinate System objects which makeup is
DE described by the "assembly" table. Currently, one-step (explicit) and
DE two-step (implict) pairwise mapping is supported. In one-step mapping an
DE explicit relationship between the Coordinate System objects is defined in
DE the "assembly" table. In two-step "chained" mapping no explicit mapping is
DE present, but the Coordinate System objects must share a common mapping to
DE an intermediate Coordinate System.
XX
TN EnsSAssemblymapperadaptor
TD
TX
TN EnsOAssemblymapperadaptor
TD
TX
AN Adaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
AN AsmMapperCache
AT AjPTable
AD Ensembl Assembly Mapper cache
AX
AN MultipleMappings
AT AjPTable
AD Sequence Regions that have more than one
AD entry in the Ensembl Core "assembly"
AD table, i. e. they map to more than one
AD location.
AX
//
typedef struct EnsSAssemblymapperadaptor
{
EnsPDatabaseadaptor Adaptor;
AjPTable AsmMapperCache;
AjPTable MultipleMappings;
} EnsOAssemblymapperadaptor;
#define EnsPAssemblymapperadaptor EnsOAssemblymapperadaptor*
ID EnsPGenericassemblymapper
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Generic Assembly Mapper
DE
DE The Ensembl Generic Assembly Mapper handles mappings between two Ensembl
DE Coordinate System objects using the information stored in the "assembly"
DE SQL table of an Ensembl Core database.
DE
DE The Ensembl Generic Assembly Mapper is a database aware mapper, which
DE facilitates conversion of coordinates between any two Ensembl Coordinate
DE System objects with a relationship explicitly defined in the "assembly"
DE SQL table. In future, it may be possible to perform multiple step (implicit)
DE mapping between Ensembl Coordinate System objects.
DE
DE It is implemented using the Ensembl Mapper object, which is a generic mapper
DE object between disjoint Ensembl Coordinate System objects.
XX
TN EnsSGenericassemblymapper
TD
TX
TN EnsOGenericassemblymapper
TD
TX
AN Adaptor
AT EnsPAssemblymapperadaptor
AD Ensembl Assembly Mapper Adaptor
AX
AN CoordsystemAssembled
AT EnsPCoordsystem
AD Assembled Ensembl Coordinate
AD System
AX
AN CoordsystemComponent
AT EnsPCoordsystem
AD Component Ensembl Coordinate
AD System
AX
AN RegisterAssembled
AT AjPTable
AD Assembled Register
AX
AN RegisterComponent
AT AjPTable
AD Component Register
AX
AN Mapper
AT EnsPMapper
AD Ensembl Mapper
AX
AN Maximum
AT ajuint
AD Maximum Ensembl Mapper Pair count
AX
AN Use
AT ajuint
AD Use counter
AX
//
typedef struct EnsSGenericassemblymapper
{
EnsPAssemblymapperadaptor Adaptor;
EnsPCoordsystem CoordsystemAssembled;
EnsPCoordsystem CoordsystemComponent;
AjPTable RegisterAssembled;
AjPTable RegisterComponent;
EnsPMapper Mapper;
ajuint Maximum;
ajuint Use;
} EnsOGenericassemblymapper;
#define EnsPGenericassemblymapper EnsOGenericassemblymapper*
ID EnsPChainedassemblymapper
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Chained Assembly Mapper
DE
DE The Ensembl Chained Assembly Mapper is an extension of the regular
DE Ensembl Generic Assembly Mapper that allows for mappings between
DE Ensembl Coordinate System objects that require multi-step mapping.
DE For example if explicit mappings are defined between the following
DE Coordinate System objects, chromosome/contig and contig/clone,
DE the Ensembl Chained Assembly Mapper would be able to perform implicit
DE mapping between the "chromosome" and "clone" Ensembl Coordinate System
DE objects. This should be transparent to the user of this module, and users
DE should not even realise that they are using an Ensembl Chained Assembly
DE Mapper as opposed to an Ensembl Generic Assembly Mapper.
XX
TN EnsSChainedassemblymapper
TD
TX
TN EnsOChainedassemblymapper
TD
TX
AN Adaptor
AT EnsPAssemblymapperadaptor
AD Ensembl Assembly Mapper Adaptor
AX
AN CoordsystemSource
AT EnsPCoordsystem
AD Source Ensembl Coordinate System
AX
AN CoordsystemMiddle
AT EnsPCoordsystem
AD Middle Ensembl Coordinate System
AX
AN CoordsystemTarget
AT EnsPCoordsystem
AD Target Ensembl Coordinate System
AX
AN MapperSourceMiddle
AT EnsPMapper
AD Source to middle Ensembl Mapper
AX
AN MapperTargetMiddle
AT EnsPMapper
AD Target to middle Ensembl Mapper
AX
AN MapperSourceTarget
AT EnsPMapper
AD Source to target Ensembl Mapper
AX
AN RegistrySource
AT EnsPMapperrangeregistry
AD Source Ensembl Mapper Range Registry
AX
AN RegistryTarget
AT EnsPMapperrangeregistry
AD Target Ensembl Mapper Range Registry
AX
AN Maximum
AT ajuint
AD Maximum Ensembl Mapper Pair count
AX
AN Use
AT ajuint
AD Use counter
AX
//
typedef struct EnsSChainedassemblymapper
{
EnsPAssemblymapperadaptor Adaptor;
EnsPCoordsystem CoordsystemSource;
EnsPCoordsystem CoordsystemMiddle;
EnsPCoordsystem CoordsystemTarget;
EnsPMapper MapperSourceMiddle;
EnsPMapper MapperTargetMiddle;
EnsPMapper MapperSourceTarget;
EnsPMapperrangeregistry RegistrySource;
EnsPMapperrangeregistry RegistryTarget;
ajuint Maximum;
ajuint Use;
} EnsOChainedassemblymapper;
#define EnsPChainedassemblymapper EnsOChainedassemblymapper*
ID EnsPToplevelassemblymapper
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Top-Level Assembly Mapper
DE
DE The Ensembl Top-Level Assembly Mapper performs mapping between a provided
DE Ensembl Coordinate System and the top-level pseudo Cooordinate System.
DE The top-level Coordinate System is not a real Coordinate System, but
DE represents the highest Coordinate System that can be mapped to in a given
DE Sequence Region. It is only possible to perform unidirectional mapping
DE using this Mapper, because it does not make sense to map from the top-level
DE Coordinate System to another Coordinate System.
XX
TN EnsSToplevelassemblymapper
TD
TX
TN EnsOToplevelassemblymapper
TD
TX
AN Adaptor
AT EnsPAssemblymapperadaptor
AD Ensembl Assembly Mapper Adaptor
AX
AN Coordsystems
AT AjPList
AD AJAX List of Ensembl Coordinate System objects
AX
AN CoordsystemAssembled
AT EnsPCoordsystem
AD Top-level Ensembl Coordinate System
AX
AN CoordsystemComponent
AT EnsPCoordsystem
AD Other Ensembl Coordinate System
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSToplevelassemblymapper
{
EnsPAssemblymapperadaptor Adaptor;
AjPList Coordsystems;
EnsPCoordsystem CoordsystemAssembled;
EnsPCoordsystem CoordsystemComponent;
ajuint Use;
ajuint Padding;
} EnsOToplevelassemblymapper;
#define EnsPToplevelassemblymapper EnsOToplevelassemblymapper*
ID EnsPAssemblymapper
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Assembly Mapper
DE
DE The Ensembl Assembly Mapper is a wrapper for specialised
DE Ensembl Assembly Mapper objects.
XX
TN EnsSAssemblymapper
TD
TX
TN EnsOAssemblymapper
TD
TX
AN Adaptor
AT EnsPAssemblymapperadaptor
AD Ensembl Assembly Mapper Adaptor
AX
AN Generic
AT EnsPGenericassemblymapper
AD Ensembl Generic Assembly Mapper
AX
AN Chained
AT EnsPChainedassemblymapper
AD Ensembl Chained Assembly Mapper
AX
AN Toplevel
AT EnsPToplevelassemblymapper
AD Ensembl Top-Level Assembly Mapper
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSAssemblymapper
{
EnsPAssemblymapperadaptor Adaptor;
EnsPGenericassemblymapper Generic;
EnsPChainedassemblymapper Chained;
EnsPToplevelassemblymapper Toplevel;
ajuint Use;
ajuint Padding;
} EnsOAssemblymapper;
#define EnsPAssemblymapper EnsOAssemblymapper*
ID EnsPBaseadaptorLeftjoin
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Base Adaptor Left Join conditions
XX
TN EnsSBaseadaptorLeftjoin
TD
TX
TN EnsOBaseadaptorLeftjoin
TD
TX
AN Table
AT const char*
AD SQL table name
AX
AN Condition
AT const char*
AD SQL LEFT JOIN condition
AX
//
typedef struct EnsSBaseadaptorLeftjoin
{
const char *Table;
const char *Condition;
} EnsOBaseadaptorLeftjoin;
#define EnsPBaseadaptorLeftjoin EnsOBaseadaptorLeftjoin*
ID EnsPBaseadaptor
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Base Adaptor
XX
TN EnsSBaseadaptor
TD
TX
TN EnsOBaseadaptor
TD
TX
TN EnsPDitagadaptor
TD
TX
TN EnsPGvindividualadaptor
TD
TX
TN EnsPGvpopulationadaptor
TD
TX
TN EnsPGvsampleadaptor
TD
TX
TN EnsPGvvariationsetadaptor
TD
TX
TN EnsPMarkeradaptor
TD
TX
TN EnsPProteinfeatureadaptor
TD
TX
TN EnsPQcalignmentadaptor
TD
TX
TN EnsPQcdasfeatureadaptor
TD
TX
TN EnsPQcsubmissionadaptor
TD
TX
TN EnsPQcvariationadaptor
TD
TX
TN EnsPRepeatconsensusadaptor
TD
TX
TN EnsPSeqregionsynonymadaptor
TD
TX
TN EnsPTranslationadaptor
TD
TX
AN Adaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
AN Tables
AT const char* const*
AD Table names
AX
AN Columns
AT const char* const*
AD Column names
AX
AN Leftjoin
AT const EnsPBaseadaptorLeftjoin
AD Ensembl Base Adaptor SQL LEFT JOIN conditions
AX
AN Defaultcondition
AT const char*
AD SQL SELECT default condition
AX
AN Finalcondition
AT const char*
AD SQL SELECT final condition
AX
AN StraightJoin
AT AjBool
AD Set the MySQL-specific SQL SELECT STRAIGHT_JOIN option
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN Fstatement
AT AjBool function
AD Statement function address
AX
//
typedef struct EnsSBaseadaptor
{
EnsPDatabaseadaptor Adaptor;
const char *const *Tables;
const char *const *Columns;
const EnsPBaseadaptorLeftjoin Leftjoin;
const char *Defaultcondition;
const char *Finalcondition;
AjBool StraightJoin;
ajuint Padding;
AjBool (*Fstatement) (struct EnsSBaseadaptor *dba,
const AjPStr sql,
EnsPAssemblymapper mapper,
EnsPSlice slice,
AjPList objects);
} EnsOBaseadaptor;
#define EnsPBaseadaptor EnsOBaseadaptor*
ID EnsPAnalysisadaptor
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Analysis Adaptor
XX
TN EnsSAnalysisadaptor
TD
TX
TN EnsOAnalysisadaptor
TD
TX
AN Adaptor
AT EnsPBaseadaptor
AD Ensembl Base Adaptor
AX
AN CacheByIdentifier
AT AjPTable
AD Identifier cache
AX
AN CacheByName
AT AjPTable
AD Name cache
AX
//
typedef struct EnsSAnalysisadaptor
{
EnsPBaseadaptor Adaptor;
AjPTable CacheByIdentifier;
AjPTable CacheByName;
} EnsOAnalysisadaptor;
#define EnsPAnalysisadaptor EnsOAnalysisadaptor*
ID EnsPAnalysis
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Analysis
DE
DE An Ensembl Analysis object stores details of an analysis within the
DE Ensembl genome analysis and annotation pipeline.
XX
TN EnsSAnalysis
TD
TX
TN EnsOAnalysis
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPAnalysisadaptor
AD Ensembl Analysis Adaptor
AX
AN DateCreation
AT AjPStr
AD Creation date
AX
AN Name
AT AjPStr
AD Name
AX
AN Databasename
AT AjPStr
AD Database name
AX
AN Databaseversion
AT AjPStr
AD Database version
AX
AN Databasefile
AT AjPStr
AD Database file
AX
AN Programname
AT AjPStr
AD Program name
AX
AN Programversion
AT AjPStr
AD Program version
AX
AN Programfile
AT AjPStr
AD Program file
AX
AN Parameters
AT AjPStr
AD Parameters
AX
AN Modulename
AT AjPStr
AD Module name
AX
AN Moduleversion
AT AjPStr
AD Module version
AX
AN Gffsource
AT AjPStr
AD GFF source
AX
AN Gfffeature
AT AjPStr
AD GFF feature
AX
AN Description
AT AjPStr
AD Description
AX
AN Displaylabel
AT AjPStr
AD Display label for the Ensembl website
AX
AN Webdata
AT AjPStr
AD Configuration information for the Ensembl web site
AX
AN Displayable
AT AjBool
AD Displayable on the Ensembl web site
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSAnalysis
{
ajuint Use;
ajuint Identifier;
EnsPAnalysisadaptor Adaptor;
AjPStr DateCreation;
AjPStr Name;
AjPStr Databasename;
AjPStr Databaseversion;
AjPStr Databasefile;
AjPStr Programname;
AjPStr Programversion;
AjPStr Programfile;
AjPStr Parameters;
AjPStr Modulename;
AjPStr Moduleversion;
AjPStr Gffsource;
AjPStr Gfffeature;
AjPStr Description;
AjPStr Displaylabel;
AjPStr Webdata;
AjBool Displayable;
ajuint Padding;
} EnsOAnalysis;
#define EnsPAnalysis EnsOAnalysis*
ID EnsPExternaldatabaseadaptor
TY public
MO ensdata
LB ensembl
XX
DE Ensembl External Database Adaptor
XX
TN EnsSExternaldatabaseadaptor
TD
TX
TN EnsOExternaldatabaseadaptor
TD
TX
AN Adaptor
AT EnsPBaseadaptor
AD Ensembl Base Adaptor
AX
AN CacheByIdentifier
AT AjPTable
AD Identifier cache
AX
AN CacheByName
AT AjPTable
AD Name cache
AX
//
typedef struct EnsSExternaldatabaseadaptor
{
EnsPBaseadaptor Adaptor;
AjPTable CacheByIdentifier;
AjPTable CacheByName;
} EnsOExternaldatabaseadaptor;
#define EnsPExternaldatabaseadaptor EnsOExternaldatabaseadaptor*
ID EnsPAttributetypeadaptor
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Attribute Type Adaptor
XX
TN EnsSAttributetypeadaptor
TD
TX
TN EnsOAttributetypeadaptor
TD
TX
AN Adaptor
AT EnsPBaseadaptor
AD Ensembl Base Adaptor
AX
AN CacheByIdentifier
AT AjPTable
AD Identifier cache
AX
AN CacheByCode
AT AjPTable
AD Code cache
AX
//
typedef struct EnsSAttributetypeadaptor
{
EnsPBaseadaptor Adaptor;
AjPTable CacheByIdentifier;
AjPTable CacheByCode;
} EnsOAttributetypeadaptor;
#define EnsPAttributetypeadaptor EnsOAttributetypeadaptor*
ID EnsPAttributetype
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Attribute Type
XX
TN EnsSAttributetype
TD
TX
TN EnsOAttributetype
TD
TX
AN Use
AT ajuint
AD Usage counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPAttributetypeadaptor
AD Ensembl Attribute Type Adaptor
AX
AN Code
AT AjPStr
AD Code
AX
AN Name
AT AjPStr
AD Name
AX
AN Description
AT AjPStr
AD Description
AX
//
typedef struct EnsSAttributetype
{
ajuint Use;
ajuint Identifier;
EnsPAttributetypeadaptor Adaptor;
AjPStr Code;
AjPStr Name;
AjPStr Description;
} EnsOAttributetype;
#define EnsPAttributetype EnsOAttributetype*
ID EnsPAttribute
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Attribute
XX
TN EnsSAttribute
TD
TX
TN EnsOAttribute
TD
TX
AN Attributetype
AT EnsPAttributetype
AD Ensembl Attribute Type
AX
AN Value
AT AjPStr
AD Value
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSAttribute
{
EnsPAttributetype Attributetype;
AjPStr Value;
ajuint Use;
ajuint Padding;
} EnsOAttribute;
#define EnsPAttribute EnsOAttribute*
ID EnsPExternaldatabase
TY public
MO ensdata
LB ensembl
XX
DE Ensembl External Database
XX
TN EnsSExternaldatabase
TD
TX
TN EnsOExternaldatabase
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPExternaldatabaseadaptor
AD Ensembl External Database Adaptor
AX
AN Name
AT AjPStr
AD Database name
AX
AN Release
AT AjPStr
AD Database release
AX
AN Displayname
AT AjPStr
AD Database display name
AX
AN Secondaryname
AT AjPStr
AD Secondary database name
AX
AN Secondarytable
AT AjPStr
AD Secondary database table
AX
AN Description
AT AjPStr
AD Description
AX
AN Status
AT EnsEExternaldatabaseStatus
AD Status
AX
AN Type
AT EnsEExternaldatabaseType
AD Type
AX
AN Priority
AT ajint
AD Priority
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSExternaldatabase
{
ajuint Use;
ajuint Identifier;
EnsPExternaldatabaseadaptor Adaptor;
AjPStr Name;
AjPStr Release;
AjPStr Displayname;
AjPStr Secondaryname;
AjPStr Secondarytable;
AjPStr Description;
EnsEExternaldatabaseStatus Status;
EnsEExternaldatabaseType Type;
ajint Priority;
ajuint Padding;
} EnsOExternaldatabase;
#define EnsPExternaldatabase EnsOExternaldatabase*
ID EnsPExternalreference
TY public
MO ensdata
LB ensembl
XX
DE Ensembl External Reference
XX
TN EnsSExternalreference
TD
TX
TN EnsOExternalreference
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Analysis
AT EnsPAnalysis
AD Ensembl Analysis
AX
AN Externaldatabase
AT EnsPExternaldatabase
AD Ensembl External Database
AX
AN Primaryidentifier
AT AjPStr
AD Primary identifier
AX
AN Displayidentifier
AT AjPStr
AD Display identifier
AX
AN Version
AT AjPStr
AD Version
AX
AN Description
AT AjPStr
AD Description
AX
AN Linkageannotation
AT AjPStr
AD Linkage annotation
AX
AN Infotext
AT AjPStr
AD Information text
AX
AN Infotype
AT EnsEExternalreferenceInfotype
AD Ensembl External Reference Information Type enumeration
AX
AN Objecttype
AT EnsEExternalreferenceObjecttype
AD Ensembl External Reference Object Type enumeration
AX
AN Objectidentifier
AT ajuint
AD Ensembl Object identifier
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSExternalreference
{
ajuint Use;
ajuint Identifier;
EnsPAnalysis Analysis;
EnsPExternaldatabase Externaldatabase;
AjPStr Primaryidentifier;
AjPStr Displayidentifier;
AjPStr Version;
AjPStr Description;
AjPStr Linkageannotation;
AjPStr Infotext;
EnsEExternalreferenceInfotype Infotype;
EnsEExternalreferenceObjecttype Objecttype;
ajuint Objectidentifier;
ajuint Padding;
} EnsOExternalreference;
#define EnsPExternalreference EnsOExternalreference*
ID EnsPIdentityreference
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Identity Reference
XX
TN EnsSIdentityreference
TD
TX
TN EnsOIdentityreference
TD
TX
AN Cigar
AT AjPStr
AD Cigar line (See exonerate(1))
AX
AN QueryStart
AT ajint
AD Query start
AX
AN QueryEnd
AT ajint
AD Query end
AX
AN QueryIdentity
AT ajint
AD Query sequence identity
AX
AN TargetStart
AT ajint
AD Target start
AX
AN TargetEnd
AT ajint
AD Target end
AX
AN TargetIdentity
AT ajint
AD Target sequence identity
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN Evalue
AT double
AD e-Value
AX
AN Score
AT double
AD Score
AX
//
typedef struct EnsSIdentityreference
{
AjPStr Cigar;
ajint QueryStart;
ajint QueryEnd;
ajint QueryIdentity;
ajint TargetStart;
ajint TargetEnd;
ajint TargetIdentity;
ajuint Use;
ajuint Padding;
double Evalue;
double Score;
} EnsOIdentityreference;
#define EnsPIdentityreference EnsOIdentityreference*
ID EnsPDatabaseentryadaptor
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Database Entry Adaptor
XX
TN EnsSDatabaseentryadaptor
TD
TX
TN EnsODatabaseentryadaptor
TD
TX
AN Adaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
//
typedef struct EnsSDatabaseentryadaptor
{
EnsPDatabaseadaptor Adaptor;
} EnsODatabaseentryadaptor;
#define EnsPDatabaseentryadaptor EnsODatabaseentryadaptor*
ID EnsPDatabaseentry
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Database Entry
XX
TN EnsSDatabaseentry
TD
TX
TN EnsODatabaseentry
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPDatabaseentryadaptor
AD Ensembl Database Entry Adaptor
AX
AN Externalreference
AT EnsPExternalreference
AD Ensembl External Reference
AX
AN Identityreference
AT EnsPIdentityreference
AD Ensembl Identity Reference
AX
AN Synonyms
AT AjPList
AD Synonyms
AX
AN Ontologylinkages
AT AjPList
AD AJAX List of
AD Ensembl Ontology Linkage objects
AX
//
typedef struct EnsSDatabaseentry
{
ajuint Use;
ajuint Identifier;
EnsPDatabaseentryadaptor Adaptor;
EnsPExternalreference Externalreference;
EnsPIdentityreference Identityreference;
AjPList Synonyms;
AjPList Ontologylinkages;
} EnsODatabaseentry;
#define EnsPDatabaseentry EnsODatabaseentry*
ID EnsPOntologylinkage
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Ontology Linkage
XX
TN EnsSOntologylinkage
TD
TX
TN EnsOOntologylinkage
TD
TX
AN LinkageType
AT AjPStr
AD Likage type (Ontology Evidence Code)
AX
AN Source
AT EnsPDatabaseentry
AD Source Ensembl Database Entry
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSOntologylinkage
{
AjPStr LinkageType;
EnsPDatabaseentry Source;
ajuint Use;
ajuint Padding;
} EnsOOntologylinkage;
#define EnsPOntologylinkage EnsOOntologylinkage*
ID EnsPFeature
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Feature
XX
TN EnsSFeature
TD
TX
TN EnsOFeature
TD
TX
AN Analysis
AT EnsPAnalysis
AD Ensembl Analysis
AX
AN Slice
AT EnsPSlice
AD Ensembl Slice
AX
AN Sequencename
AT AjPStr
AD Sequence name
AX
AN Start
AT ajint
AD Start coordinate
AX
AN End
AT ajint
AD End coordinate
AX
AN Strand
AT ajint
AD Strand orientation
AX
AN Use
AT ajuint
AD Use counter
AX
//
typedef struct EnsSFeature
{
EnsPAnalysis Analysis;
EnsPSlice Slice;
AjPStr Sequencename;
ajint Start;
ajint End;
ajint Strand;
ajuint Use;
} EnsOFeature;
#define EnsPFeature EnsOFeature*
ID EnsPFeatureadaptor
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Feature Adaptor
XX
TN EnsSFeatureadaptor
TD
TX
TN EnsOFeatureadaptor
TD
TX
TN EnsPExonadaptor
TD
TX
TN EnsPDnaalignfeatureadaptor
TD
TX
TN EnsPDensityfeatureadaptor
TD
TX
TN EnsPDitagfeatureadaptor
TD
TX
TN EnsPKaryotypebandadaptor
TD
TX
TN EnsPMarkerfeatureadaptor
TD
TX
TN EnsPMiscellaneousfeatureadaptor
TD
TX
TN EnsPPredictionexonadaptor
TD
TX
TN EnsPPredictiontranscriptadaptor
TD
TX
TN EnsPProteinalignfeatureadaptor
TD
TX
TN EnsPRepeatfeatureadaptor
TD
TX
TN EnsPSimplefeatureadaptor
TD
TX
AN Adaptor
AT EnsPBaseadaptor
AD Ensembl Base Adaptor
AX
AN Cache
AT EnsPCache
AD Ensembl LRU Cache
AX
AN Tables
AT char**
AD One-dimensional array of table name character strings,
AD which is used for multi-species databases only.
AD This array is dynamically allocated to extend for
AD "seq_region" and "coord_system" tables. The array is
AD then set in the Ensembl Base Adaptor object.
AX
AN Condition
AT char*
AD SQL SELECT default condition, which is used for
AD multi-species databases only. This character string
AD is dynamically allocated to extend for "seq_region"
AD and "coord_system" conditions. The string is then
AD set in the Ensembl Base Adaptor object.
AX
AN FobjectGetFeature
AT EnsPFeature function
AD Ensembl Object-specific objectGetFeature member function
AX
AN Freference
AT void* function
AD Ensembl Object-specific referencing function
AX
AN Fdelete
AT void function
AD Ensembl Object-specific deletion function
AX
AN Startequalsend
AT AjBool
AD Simplified SQL in featureadaptorSliceFetch
AX
AN Maximumlength
AT ajint
AD Maximum length of a particular Feature type
AX
//
typedef struct EnsSFeatureadaptor
{
EnsPBaseadaptor Adaptor;
EnsPCache Cache;
char **Tables;
char *Condition;
EnsPFeature (*FobjectGetFeature) (const void *object);
void *(*Freference) (void *value);
void (*Fdelete) (void **Pvalue);
AjBool Startequalsend;
ajint Maximumlength;
} EnsOFeatureadaptor;
#define EnsPFeatureadaptor EnsOFeatureadaptor*
ID EnsPExonadaptor
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Exon Adaptor
XX
TN EnsSExonadaptor
TD
TX
TN EnsOExonadaptor
TD
TX
AN Exonadaptor
AT EnsPFeatureadaptor
AD Ensembl Feature Adaptor
AX
AN Exontranscriptadaptor
AT EnsPFeatureadaptor
AD Ensembl Feature Adaptor
AX
//
typedef struct EnsSExonadaptor
{
EnsPFeatureadaptor Exonadaptor;
EnsPFeatureadaptor Exontranscriptadaptor;
} EnsOExonadaptor;
#define EnsPExonadaptor EnsOExonadaptor*
ID EnsPExon
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Exon
XX
TN EnsSExon
TD
TX
TN EnsOExon
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPExonadaptor
AD Ensembl Exon Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN PhaseStart
AT ajint
AD Phase of Exon start
AX
AN PhaseEnd
AT ajint
AD Phase of Exon end
AX
AN Current
AT AjBool
AD Current
AX
AN Constitutive
AT AjBool
AD Consitutive
AX
AN Stableidentifier
AT AjPStr
AD Stable identifier
AX
AN Version
AT ajuint
AD Version
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN DateCreation
AT AjPStr
AD Creation date
AX
AN DateModification
AT AjPStr
AD Modification date
AX
AN SequenceCache
AT AjPStr
AD Sequence Cache
AX
AN Supportingfeatures
AT AjPList
AD AJAX List of Ensembl Base Align Feature objects
AX
//
typedef struct EnsSExon
{
ajuint Use;
ajuint Identifier;
EnsPExonadaptor Adaptor;
EnsPFeature Feature;
ajint PhaseStart;
ajint PhaseEnd;
AjBool Current;
AjBool Constitutive;
AjPStr Stableidentifier;
ajuint Version;
ajuint Padding;
AjPStr DateCreation;
AjPStr DateModification;
AjPStr SequenceCache;
AjPList Supportingfeatures;
} EnsOExon;
#define EnsPExon EnsOExon*
ID EnsPIntron
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Intron
XX
TN EnsSIntron
TD
TX
TN EnsOIntron
TD
TX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN PreviousExon
AT EnsPExon
AD Previous Ensembl Exon
AX
AN NextExon
AT EnsPExon
AD Next Ensembl Exon
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSIntron
{
EnsPFeature Feature;
EnsPExon PreviousExon;
EnsPExon NextExon;
ajuint Use;
ajuint Padding;
} EnsOIntron;
#define EnsPIntron EnsOIntron*
ID EnsPTranslation
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Translation
XX
TN EnsSTranslation
TD
TX
TN EnsOTranslation
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPTranslationadaptor
AD Ensembl Translation Adaptor
AX
AN Startexon
AT EnsPExon
AD Ensembl Exon in which the Translation start coordinate is annotated
AX
AN Endexon
AT EnsPExon
AD Ensembl Exon in which the Translation end coordinate is annotated
AX
AN Start
AT ajuint
AD Start coordinate relative to the start Ensembl Exon
AX
AN End
AT ajuint
AD End coordinate relative to the end Ensembl Exon
AX
AN Stableidentifier
AT AjPStr
AD Stable identifier
AX
AN DateCreation
AT AjPStr
AD Creation date
AX
AN DateModification
AT AjPStr
AD Modification date
AX
AN Version
AT ajuint
AD Version
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN Attributes
AT AjPList
AD AJAX List of Ensembl Attribute objects
AX
AN Databaseentries
AT AjPList
AD AJAX List of Ensembl Database Entry objects
AX
AN Proteinfeatures
AT AjPList
AD AJAX List of Ensembl Protein Feature objects
AX
AN Sequence
AT AjPStr
AD Sequence
AX
AN TranscriptStart
AT ajuint
AD Start coordinate relative to the Ensembl Transcript (cDNA)
AX
AN TranscriptEnd
AT ajuint
AD End coordinate relative to the Ensembl Transcript (cDNA)
AX
AN SliceStart
AT ajint
AD Start coordinate relative to the Ensembl Slice
AX
AN SliceEnd
AT ajint
AD End coordinate relative to the Ensembl Slice
AX
//
typedef struct EnsSTranslation
{
ajuint Use;
ajuint Identifier;
EnsPTranslationadaptor Adaptor;
EnsPExon Startexon;
EnsPExon Endexon;
ajuint Start;
ajuint End;
AjPStr Stableidentifier;
AjPStr DateCreation;
AjPStr DateModification;
ajuint Version;
ajuint Padding;
AjPList Attributes;
AjPList Databaseentries;
AjPList Proteinfeatures;
AjPStr Sequence;
ajuint TranscriptStart;
ajuint TranscriptEnd;
ajint SliceStart;
ajint SliceEnd;
} EnsOTranslation;
#define EnsPTranslation EnsOTranslation*
ID EnsPTranscript
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Transcript
XX
TN EnsSTranscript
TD
TX
TN EnsOTranscript
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPTranscriptadaptor
AD Ensembl Transcript Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN Displayreference
AT EnsPDatabaseentry
AD Display External Reference
AX
AN Description
AT AjPStr
AD Description
AX
AN Biotype
AT AjPStr
AD Biological type
AX
AN Status
AT EnsETranscriptStatus
AD Status
AX
AN Current
AT AjBool
AD Current attribute
AX
AN Stableidentifier
AT AjPStr
AD Stable identifier
AX
AN DateCreation
AT AjPStr
AD Creation date
AX
AN DateModification
AT AjPStr
AD Modification date
AX
AN Version
AT ajuint
AD Version
AX
AN Geneidentifier
AT ajuint
AD Ensembl Gene identifier
AX
AN Alternativetranslations
AT AjPList
AD AJAX List of alternative Ensembl Translation objects
AX
AN Attributes
AT AjPList
AD AJAX List of Ensembl Attribute objects
AX
AN Databaseentries
AT AjPList
AD AJAX List of Ensembl Database Entry objects
AX
AN Exons
AT AjPList
AD AJAX List of Ensembl Exon objects
AX
AN Supportingfeatures
AT AjPList
AD AJAX List of Ensembl Base Align Feature objects
AX
AN Translation
AT EnsPTranslation
AD Ensembl Translation
AX
AN Sequenceedits
AT AjBool
AD Enable Ensembl Sequence Edit objects
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN Canonical
AT AjBool*
AD Canonical attribute
AX
AN ExonCoordMapper
AT EnsPMapper
AD Ensembl Mapper
AX
//
typedef struct EnsSTranscript
{
ajuint Use;
ajuint Identifier;
EnsPTranscriptadaptor Adaptor;
EnsPFeature Feature;
EnsPDatabaseentry Displayreference;
AjPStr Description;
AjPStr Biotype;
EnsETranscriptStatus Status;
AjBool Current;
AjPStr Stableidentifier;
AjPStr DateCreation;
AjPStr DateModification;
ajuint Version;
ajuint Geneidentifier;
AjPList Alternativetranslations;
AjPList Attributes;
AjPList Databaseentries;
AjPList Exons;
AjPList Supportingfeatures;
EnsPTranslation Translation;
AjBool Sequenceedits;
ajuint Padding;
AjBool *Canonical;
EnsPMapper ExonCoordMapper;
} EnsOTranscript;
#define EnsPTranscript EnsOTranscript*
ID EnsPGeneadaptor
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Gene Adaptor
XX
TN EnsSGeneadaptor
TD
TX
TN EnsOGeneadaptor
TD
TX
AN Adaptor
AT EnsPFeatureadaptor
AD Ensembl Feature Adaptor
AX
//
typedef struct EnsSGeneadaptor
{
EnsPFeatureadaptor Adaptor;
} EnsOGeneadaptor;
#define EnsPGeneadaptor EnsOGeneadaptor*
ID EnsPGene
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Gene
XX
TN EnsSGene
TD
TX
TN EnsOGene
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPGeneadaptor
AD Ensembl Gene Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN Displayreference
AT EnsPDatabaseentry
AD Display External Reference
AX
AN Description
AT AjPStr
AD Description
AX
AN Source
AT AjPStr
AD Source
AX
AN Biotype
AT AjPStr
AD Biological type
AX
AN Status
AT EnsEGeneStatus
AD Status
AX
AN Current
AT AjBool
AD Current attribute
AX
AN Canonicalannotation
AT AjPStr
AD Canonical annotation
AX
AN Canonicaltranscriptidentifier
AT ajuint
AD Canonical Ensembl Transcript identifier
AX
AN Version
AT ajuint
AD Version
AX
AN Stableidentifier
AT AjPStr
AD Stable identifier
AX
AN DateCreation
AT AjPStr
AD Creation date
AX
AN DateModification
AT AjPStr
AD Modification date
AX
AN Attributes
AT AjPList
AD AJAX List of Ensembl Attribute objects
AX
AN Databaseentries
AT AjPList
AD AJAX List of Ensembl Database Entry objects
AX
AN Transcripts
AT AjPList
AD AJAX List of Ensembl Transcript objects
AX
//
typedef struct EnsSGene
{
ajuint Use;
ajuint Identifier;
EnsPGeneadaptor Adaptor;
EnsPFeature Feature;
EnsPDatabaseentry Displayreference;
AjPStr Description;
AjPStr Source;
AjPStr Biotype;
EnsEGeneStatus Status;
AjBool Current;
AjPStr Canonicalannotation;
ajuint Canonicaltranscriptidentifier;
ajuint Version;
AjPStr Stableidentifier;
AjPStr DateCreation;
AjPStr DateModification;
AjPList Attributes;
AjPList Databaseentries;
AjPList Transcripts;
} EnsOGene;
#define EnsPGene EnsOGene*
ID EnsPSeqregionsynonym
TY public
MO ensdata
LB ensembl
XX
DE Ensembl Sequence Region Synonym
XX
AN Use
AT ajuint
AD Usage counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPSeqregionsynonymadaptor
AD Ensembl Sequence Region Synonym Adaptor
AX
AN Externaldatabase
AT EnsPExternaldatabase
AD Ensembl External Database
AX
AN Name
AT AjPStr
AD Name
AX
AN Seqregionidentifier
AT ajuint
AD Ensembl Sequence Region identifier
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSSeqregionsynonym
{
ajuint Use;
ajuint Identifier;
EnsPSeqregionsynonymadaptor Adaptor;
EnsPExternaldatabase Externaldatabase;
AjPStr Name;
ajuint Seqregionidentifier;
ajuint Padding;
} EnsOSeqregionsynonym;
#define EnsPSeqregionsynonym EnsOSeqregionsynonym*
ID EnsEDatabaseadaptorGroup
TY public
MO ensdatabaseadaptor
LB ensembl
XX
DE Ensembl Database Adaptor Group enumeration
XX
VN ensEDatabaseadaptorGroupNULL
VD Null
VX
VN ensEDatabaseadaptorGroupCore
VD Core
VX
VN ensEDatabaseadaptorGroupVega
VD Vega
VX
VN ensEDatabaseadaptorGroupOtherFeatures
VD Other features
VX
VN ensEDatabaseadaptorGroupCopyDNA
VD DNA reference
VX
VN ensEDatabaseadaptorGroupGeneticVariation
VD Genetic variation
VX
VN ensEDatabaseadaptorGroupFunctionalGenomics
VD Functional genomics
VX
VN ensEDatabaseadaptorGroupComparativeGenomics
VD Comparative genomics
VX
VN ensEDatabaseadaptorGroupOntology
VD Ontology
VX
VN ensEDatabaseadaptorGroupQualityCheck
VD Quality check
VX
VN ensEDatabaseadaptorGroupPipeline
VD Pipleine
VX
VN ensEDatabaseadaptorGroupHive
VD Hive
VX
VN ensEDatabaseadaptorGroupCoreExpressionEST
VD Core expression EST
VX
VN ensEDatabaseadaptorGroupCoreExpressionGNF
VD Core expression GNF
VX
VN ensEDatabaseadaptorGroupAncestral
VD Ancestral
VX
VN ensEDatabaseadaptorGroupWebsite
VD Webiste
VX
VN ensEDatabaseadaptorGroupProduction
VD Production
VX
//
typedef enum EnsODatabaseadaptorGroup
{
ensEDatabaseadaptorGroupNULL,
ensEDatabaseadaptorGroupCore,
ensEDatabaseadaptorGroupVega,
ensEDatabaseadaptorGroupOtherFeatures,
ensEDatabaseadaptorGroupCopyDNA,
ensEDatabaseadaptorGroupGeneticVariation,
ensEDatabaseadaptorGroupFunctionalGenomics,
ensEDatabaseadaptorGroupComparativeGenomics,
ensEDatabaseadaptorGroupOntology,
ensEDatabaseadaptorGroupQualityCheck,
ensEDatabaseadaptorGroupPipeline,
ensEDatabaseadaptorGroupHive,
ensEDatabaseadaptorGroupCoreExpressionEST,
ensEDatabaseadaptorGroupCoreExpressionGNF,
ensEDatabaseadaptorGroupAncestral,
ensEDatabaseadaptorGroupWebsite,
ensEDatabaseadaptorGroupProduction
} EnsEDatabaseadaptorGroup;
ID EnsPDatabaseadaptor
TY public
MO ensdatabaseadaptor
LB ensembl
XX
DE Ensembl Database Adaptor.
DE
DE Holds the Ensembl Database Group, the species name and the Ensembl
DE Database Connection object connected to this SQL database.
XX
TN EnsSDatabaseadaptor
TD
TX
TN EnsODatabaseadaptor
TD
TX
TN EnsPAttributeadaptor
TD
TX
TN EnsPGvgenotypeadaptor
TD
TX
TN EnsPGvsynonymadaptor
TD
TX
AN Databaseconnection
AT EnsPDatabaseconnection
AD Ensembl Database Connection
AX
AN Species
AT AjPStr
AD Species
AX
AN SpeciesNames
AT AjPList
AD AJAX List of AJAX String (species name) objects
AX
AN Group
AT EnsEDatabaseadaptorGroup
AD Ensembl Database Adaptor Group enumeration
AX
AN Multispecies
AT AjBool
AD Multi-species database
AX
AN Identifier
AT ajuint
AD Species identifier, defaults to 1U
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSDatabaseadaptor
{
EnsPDatabaseconnection Databaseconnection;
AjPStr Species;
AjPList SpeciesNames;
EnsEDatabaseadaptorGroup Group;
AjBool Multispecies;
ajuint Identifier;
ajuint Padding;
} EnsODatabaseadaptor;
#define EnsPDatabaseadaptor EnsODatabaseadaptor*
ID EnsPDatabaseconnection
TY public
MO ensdatabaseconnection
LB ensembl
XX
DE Ensembl Database Connection.
DE
DE Holds information to connect to a particular SQL database on a
DE relational database management system (RDBMS) instance.
XX
TN EnsSDatabaseconnection
TD
TX
TN EnsODatabaseconnection
TD
TX
AN Sqlconnection
AT AjPSqlconnection
AD AJAX SQL Connection
AX
AN Username
AT AjPStr
AD User name
AX
AN Password
AT AjPStr
AD Password
AX
AN Hostname
AT AjPStr
AD Host name or IP address
AX
AN Hostport
AT AjPStr
AD Host TCP/IP port
AX
AN Socketfile
AT AjPStr
AD UNIX socket file
AX
AN Databasename
AT AjPStr
AD SQL database name
AX
AN Autodisconnect
AT AjBool
AD Automatic disconnections
AX
AN Sqlconnectionclient
AT AjESqlconnectionClient
AD AJAX SQL
AD Connection client
AX
AN Timeout
AT ajuint
AD Timeout in seconds for closing idle, non-interactive
AD connections
AX
AN Use
AT ajuint
AD Use counter
AX
//
typedef struct EnsSDatabaseconnection
{
AjPSqlconnection Sqlconnection;
AjPStr Username;
AjPStr Password;
AjPStr Hostname;
AjPStr Hostport;
AjPStr Socketfile;
AjPStr Databasename;
AjBool Autodisconnect;
AjESqlconnectionClient Sqlconnectionclient;
ajuint Timeout;
ajuint Use;
} EnsODatabaseconnection;
#define EnsPDatabaseconnection EnsODatabaseconnection*
ID EnsEOntologylinkageType
TY public
MO ensdatabaseentry
LB ensembl
XX
DE Ensembl Ontology Linkage Type enumeration
XX
VN ensEOntologylinkageTypeNULL
VD Null
VX
VN ensEOntologylinkageTypeIC
VD Inferred by Curator
VX
VN ensEOntologylinkageTypeIDA
VD Inferred from Direct Assay
VX
VN ensEOntologylinkageTypeIEA
VD Inferred from Electronic Annotation
VX
VN ensEOntologylinkageTypeIEP
VD Inferred from Expression Pattern
VX
VN ensEOntologylinkageTypeIGI
VD Inferred from Genetic Interaction
VX
VN ensEOntologylinkageTypeIMP
VD Inferred from Mutant Phenotype
VX
VN ensEOntologylinkageTypeIPI
VD Inferred from Physical Interaction
VX
VN ensEOntologylinkageTypeISS
VD Inferred from Sequence or Structural Similarity
VX
VN ensEOntologylinkageTypeNAS
VD Non-traceable Author Statement
VX
VN ensEOntologylinkageTypeND
VD No biological Data available
VX
VN ensEOntologylinkageTypeTAS
VD Traceable Author Statement
VX
VN ensEOntologylinkageTypeNR
VD Not Recorded
VX
VN ensEOntologylinkageTypeRCA
VD Inferred from Reviewed Computational Analysis
VX
VN ensEOntologylinkageTypeEXP
VD Inferred from Experiment
VX
VN ensEOntologylinkageTypeISO
VD Inferred from Sequence Orthology
VX
VN ensEOntologylinkageTypeISA
VD Inferred from Sequence Alignment
VX
VN ensEOntologylinkageTypeISM
VD Inferred from Sequence Model
VX
VN ensEOntologylinkageTypeIGC
VD Inferred from Genomic Context
VX
//
typedef enum EnsOOntologylinkageType
{
ensEOntologylinkageTypeNULL,
ensEOntologylinkageTypeIC,
ensEOntologylinkageTypeIDA,
ensEOntologylinkageTypeIEA,
ensEOntologylinkageTypeIEP,
ensEOntologylinkageTypeIGI,
ensEOntologylinkageTypeIMP,
ensEOntologylinkageTypeIPI,
ensEOntologylinkageTypeISS,
ensEOntologylinkageTypeNAS,
ensEOntologylinkageTypeND,
ensEOntologylinkageTypeTAS,
ensEOntologylinkageTypeNR,
ensEOntologylinkageTypeRCA,
ensEOntologylinkageTypeEXP,
ensEOntologylinkageTypeISO,
ensEOntologylinkageTypeISA,
ensEOntologylinkageTypeISM,
ensEOntologylinkageTypeIGC
} EnsEOntologylinkageType;
ID EnsEDensitytypeType
TY public
MO ensdensity
LB ensembl
XX
DE Ensembl Density Type type enumeration
XX
VN ensEDensitytypeTypeNULL
VD Null
VX
VN ensEDensitytypeTypeSum
VD Sum
VX
VN ensEDensitytypeTypeRatio
VD Ratio
VX
//
typedef enum EnsODensitytypeType
{
ensEDensitytypeTypeNULL,
ensEDensitytypeTypeSum,
ensEDensitytypeTypeRatio
} EnsEDensitytypeType;
ID EnsPDensitytypeadaptor
TY public
MO ensdensity
LB ensembl
XX
DE Ensembl Density Type Adaptor.
XX
TN EnsSDensitytypeadaptor
TD
TX
TN EnsODensitytypeadaptor
TD
TX
AN Adaptor
AT EnsPBaseadaptor
AD Ensembl Base Adaptor
AX
AN CacheByIdentifier
AT AjPTable
AD Identifier cache
AX
//
typedef struct EnsSDensitytypeadaptor
{
EnsPBaseadaptor Adaptor;
AjPTable CacheByIdentifier;
} EnsODensitytypeadaptor;
#define EnsPDensitytypeadaptor EnsODensitytypeadaptor*
ID EnsPDensitytype
TY public
MO ensdensity
LB ensembl
XX
DE Ensembl Density Type.
XX
TN EnsSDensitytype
TD
TX
TN EnsODensitytype
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPDensitytypeadaptor
AD Ensembl Density Type Adaptor
AX
AN Analysis
AT EnsPAnalysis
AD Ensembl Analysis
AX
AN Type
AT EnsEDensitytypeType
AD Type enumeration
AX
AN Size
AT ajuint
AD Block size
AX
AN Features
AT ajuint
AD Number of Ensembl Density Features per
AD Ensembl Sequence Region
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSDensitytype
{
ajuint Use;
ajuint Identifier;
EnsPDensitytypeadaptor Adaptor;
EnsPAnalysis Analysis;
EnsEDensitytypeType Type;
ajuint Size;
ajuint Features;
ajuint Padding;
} EnsODensitytype;
#define EnsPDensitytype EnsODensitytype*
ID EnsPDensityfeature
TY public
MO ensdensity
LB ensembl
XX
DE Ensembl Density Feature.
XX
TN EnsSDensityfeature
TD
TX
TN EnsODensityfeature
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPDensityfeatureadaptor
AD Ensembl Density Feature Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN Densitytype
AT EnsPDensitytype
AD Ensembl Density Type
AX
AN Value
AT float
AD Value
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSDensityfeature
{
ajuint Use;
ajuint Identifier;
EnsPDensityfeatureadaptor Adaptor;
EnsPFeature Feature;
EnsPDensitytype Densitytype;
float Value;
ajuint Padding;
} EnsODensityfeature;
#define EnsPDensityfeature EnsODensityfeature*
ID EnsEDitagfeatureSide
TY public
MO ensditag
LB ensembl
XX
DE Ensembl Ditag Feature Side enumeration
XX
VN ensEDitagfeatureSideNULL
VD Null
VX
VN ensEDitagfeatureSideLeft
VD Left side
VX
VN ensEDitagfeatureSideRight
VD Right side
VX
VN ensEDitagfeatureSideFull
VD Full
VX
//
typedef enum EnsODitagfeatureSide
{
ensEDitagfeatureSideNULL,
ensEDitagfeatureSideLeft,
ensEDitagfeatureSideRight,
ensEDitagfeatureSideFull
} EnsEDitagfeatureSide;
ID EnsPDitag
TY public
MO ensditag
LB ensembl
XX
DE Ensembl Ditag
XX
TN EnsSDitag
TD
TX
TN EnsODitag
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPDitagadaptor
AD Ensembl Ditag Adaptor
AX
AN Name
AT AjPStr
AD Name
AX
AN Type
AT AjPStr
AD Source
AX
AN Sequence
AT AjPStr
AD Sequence
AX
AN Count
AT ajuint
AD Count
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSDitag
{
ajuint Use;
ajuint Identifier;
EnsPDitagadaptor Adaptor;
AjPStr Name;
AjPStr Type;
AjPStr Sequence;
ajuint Count;
ajuint Padding;
} EnsODitag;
#define EnsPDitag EnsODitag*
ID EnsPDitagfeature
TY public
MO ensditag
LB ensembl
XX
DE Ensembl Ditag Feature
XX
TN EnsSDitagfeature
TD
TX
TN EnsODitagfeature
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPDitagfeatureadaptor
AD Ensembl Ditag Feature Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN Ditag
AT EnsPDitag
AD Ditag
AX
AN Cigar
AT AjPStr
AD CIGAR line
AX
AN Side
AT EnsEDitagfeatureSide
AD Side
AX
AN TargetStart
AT ajint
AD Target start
AX
AN TargetEnd
AT ajint
AD Target end
AX
AN TargetStrand
AT ajint
AD Target strand
AX
AN Pairidentifier
AT ajuint
AD Pair identifier
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSDitagfeature
{
ajuint Use;
ajuint Identifier;
EnsPDitagfeatureadaptor Adaptor;
EnsPFeature Feature;
EnsPDitag Ditag;
AjPStr Cigar;
EnsEDitagfeatureSide Side;
ajint TargetStart;
ajint TargetEnd;
ajint TargetStrand;
ajuint Pairidentifier;
ajuint Padding;
} EnsODitagfeature;
#define EnsPDitagfeature EnsODitagfeature*
ID EnsPFeaturepair
TY public
MO ensfeature
LB ensembl
XX
DE Ensembl Feature Pair.
XX
TN EnsSFeaturepair
TD
TX
TN EnsOFeaturepair
TD
TX
AN SourceFeature
AT EnsPFeature
AD Source Ensembl Feature (Query)
AX
AN TargetFeature
AT EnsPFeature
AD Target Ensembl Feature (Target)
AX
AN Externaldatabase
AT EnsPExternaldatabase
AD Ensembl External Database
AX
AN Extradata
AT AjPStr
AD Extra data
AX
AN SourceSpecies
AT AjPStr
AD Source species name
AX
AN TargetSpecies
AT AjPStr
AD Target species name
AX
AN Groupidentifier
AT ajuint
AD Group identifier
AX
AN Levelidentifier
AT ajuint
AD Level identifier
AX
AN Evalue
AT double
AD e- or p-value
AX
AN Score
AT double
AD Score
AX
AN SourceCoverage
AT float
AD Source coverage in percent
AX
AN TargetCoverage
AT float
AD Target coverage in percent
AX
AN Identity
AT float
AD Sequence identity in percent
AX
AN Use
AT ajuint
AD Use counter
AX
//
typedef struct EnsSFeaturepair
{
EnsPFeature SourceFeature;
EnsPFeature TargetFeature;
EnsPExternaldatabase Externaldatabase;
AjPStr Extradata;
AjPStr SourceSpecies;
AjPStr TargetSpecies;
ajuint Groupidentifier;
ajuint Levelidentifier;
double Evalue;
double Score;
float SourceCoverage;
float TargetCoverage;
float Identity;
ajuint Use;
} EnsOFeaturepair;
#define EnsPFeaturepair EnsOFeaturepair*
ID EnsPAssemblyexceptionfeatureadaptor
TY public
MO ensfeature
LB ensembl
XX
DE Ensembl Assembly Exception Feature Adaptor.
XX
TN EnsSAssemblyexceptionfeatureadaptor
TD
TX
TN EnsOAssemblyexceptionfeatureadaptor
TD
TX
AN Adaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
AN Cache
AT AjPList
AD AJAX List of Ensembl Assembly Exception Feature objects
AX
AN CacheByIdentifier
AT AjPTable
AD AJAX Table of Ensembl Assembly Exception Feature objects
AX
AN CacheBySlice
AT EnsPCache
AD Ensembl Cache by Ensembl Slice names
AX
//
typedef struct EnsSAssemblyexceptionfeatureadaptor
{
EnsPDatabaseadaptor Adaptor;
AjPList Cache;
AjPTable CacheByIdentifier;
EnsPCache CacheBySlice;
} EnsOAssemblyexceptionfeatureadaptor;
#define EnsPAssemblyexceptionfeatureadaptor EnsOAssemblyexceptionfeatureadaptor*
ID EnsPAssemblyexceptionfeature
TY public
MO ensfeature
LB ensembl
XX
DE Ensembl Assembly Exception Feature.
XX
TN EnsSAssemblyexceptionfeature
TD
TX
TN EnsOAssemblyexceptionfeature
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPAssemblyexceptionfeatureadaptor
AD Ensembl Assembly Exception Feature Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN ExceptionSlice
AT EnsPSlice
AD Exception Ensembl Slice
AX
AN Type
AT EnsEAssemblyexceptionType
AD Ensembl Assembly Exception type
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSAssemblyexceptionfeature
{
ajuint Use;
ajuint Identifier;
EnsPAssemblyexceptionfeatureadaptor Adaptor;
EnsPFeature Feature;
EnsPSlice ExceptionSlice;
EnsEAssemblyexceptionType Type;
ajuint Padding;
} EnsOAssemblyexceptionfeature;
#define EnsPAssemblyexceptionfeature EnsOAssemblyexceptionfeature*
ID EnsEGvattributetypeCode
TY public
MO ensgvattribute
LB ensembl
XX
DE Ensembl Genetic Variation Attribute Type Code enumeration
XX
VN ensEGvattributetypeCodeNULL
VD Null
VX
VN ensEGvattributetypeCodeSoaccession
VD Sequence Ontology Accession
VX
VN ensEGvattributetypeCodeSoterm
VD Sequence Ontology Term
VX
VN ensEGvattributetypeCodeDisplayterm
VD Display Term
VX
//
typedef enum EnsOGvattributetypeCode
{
ensEGvattributetypeCodeNULL,
ensEGvattributetypeCodeSoaccession,
ensEGvattributetypeCodeSoterm,
ensEGvattributetypeCodeDisplayterm
} EnsEGvattributetypeCode;
ID EnsEGvindividualGender
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Individual Gender enumeration
XX
VN ensEGvindividualGenderNULL
VD Null
VX
VN ensEGvindividualGenderMale
VD Male
VX
VN ensEGvindividualGenderFemale
VD Female
VX
VN ensEGvindividualGenderUnknown
VD Unknown
VX
//
typedef enum EnsOGvindividualGender
{
ensEGvindividualGenderNULL,
ensEGvindividualGenderMale,
ensEGvindividualGenderFemale,
ensEGvindividualGenderUnknown
} EnsEGvindividualGender;
ID EnsEGvindividualType
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Individual Type enumeration
XX
VN ensEGvindividualTypeNULL
VD Null
VX
VN ensEGvindividualTypeFullyInbred
VD Fully inbred
VX
VN ensEGvindividualTypePartlyInbred
VD Partly inbred
VX
VN ensEGvindividualTypeOutbred
VD Outbred
VX
VN ensEGvindividualTypeMutant
VD Mutant
VX
VN ensEGvindividualTypeUnknown
VD Unknown
VX
//
typedef enum EnsOGvindividualType
{
ensEGvindividualTypeNULL,
ensEGvindividualTypeFullyInbred,
ensEGvindividualTypePartlyInbred,
ensEGvindividualTypeOutbred,
ensEGvindividualTypeMutant,
ensEGvindividualTypeUnknown
} EnsEGvindividualType;
ID EnsEGvsampleDisplay
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Sample Display enumeration
XX
VN ensEGvsampleDisplayNULL
VD Null
VX
VN ensEGvsampleDisplayReference
VD Reference
VX
VN ensEGvsampleDisplayDefault
VD Default
VX
VN ensEGvsampleDisplayDisplayable
VD Displayable
VX
VN ensEGvsampleDisplayUndisplayable
VD Undisplayable
VX
VN ensEGvsampleDisplayLD
VD Linkage Disequilibrium
VX
VN ensEGvsampleMartdisplayable
VD Displayable in BioMart
VX
//
typedef enum EnsOGvsampleDisplay
{
ensEGvsampleDisplayNULL,
ensEGvsampleDisplayReference,
ensEGvsampleDisplayDefault,
ensEGvsampleDisplayDisplayable,
ensEGvsampleDisplayUndisplayable,
ensEGvsampleDisplayLD,
ensEGvsampleMartdisplayable
} EnsEGvsampleDisplay;
ID EnsEGvsourceSomatic
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Source Somatic enumeration
XX
VN ensEGvsourceSomaticNULL
VD Null
VX
VN ensEGvsourceSomaticGermline
VD Germline
VX
VN ensEGvsourceSomaticSomatic
VD Somatic
VX
VN ensEGvsourceSomaticMixed
VD Mixed
VX
//
typedef enum EnsOGvsourceSomatic
{
ensEGvsourceSomaticNULL,
ensEGvsourceSomaticGermline,
ensEGvsourceSomaticSomatic,
ensEGvsourceSomaticMixed
} EnsEGvsourceSomatic;
ID EnsEGvsourceType
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Source Type enumeration
XX
VN ensEGvsourceTypeNULL
VD Null
VX
VN ensEGvsourceTypeChip
VD Chip
VX
//
typedef enum EnsOGvsourceType
{
ensEGvsourceTypeNULL,
ensEGvsourceTypeChip
} EnsEGvsourceType;
ID EnsEGvvariationClass
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Variation Class enumeration
XX
VN ensEGvvariationClassNULL
VD Null
VX
VN ensEGvvariationClassSO0001483
VD SNV
VX
VN ensEGvvariationClassSO1000002
VD substitution
VX
VN ensEGvvariationClassSO0000667
VD insertion
VX
VN ensEGvvariationClassSO0000159
VD deletion
VX
VN ensEGvvariationClassSO0000705
VD tandem_repeat
VX
VN ensEGvvariationClassSO1000032
VD indel
VX
VN ensEGvvariationClassSO0001059
VD sequence_alteration
VX
VN ensEGvvariationClassSO0001019
VD copy_number_variation
VX
//
typedef enum EnsOGvvariationClass
{
ensEGvvariationClassNULL,
ensEGvvariationClassSO0001483,
ensEGvvariationClassSO1000002,
ensEGvvariationClassSO0000667,
ensEGvvariationClassSO0000159,
ensEGvvariationClassSO0000705,
ensEGvvariationClassSO1000032,
ensEGvvariationClassSO0001059,
ensEGvvariationClassSO0001019
} EnsEGvvariationClass;
ID EnsEGvvariationValidation
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Variation Validation enumeration
XX
VN ensEGvvariationValidationNULL
VD Null
VX
VN ensEGvvariationValidationCluster
VD Cluster
VX
VN ensEGvvariationValidationFrequency
VD Frequency
VX
VN ensEGvvariationValidationSubmitter
VD Submitter
VX
VN ensEGvvariationValidationDoublehit
VD Double-hit
VX
VN ensEGvvariationValidationHapMap
VD HAP Map Project
VX
VN ensEGvvariationValidation1000Genomes
VD 1000 Genomes Project
VX
VN ensEGvvariationValidationFailed
VD Failed
VX
VN ensEGvvariationValidationPrecious
VD Precious
VX
//
typedef enum EnsOGvvariationValidation
{
ensEGvvariationValidationNULL,
ensEGvvariationValidationCluster,
ensEGvvariationValidationFrequency,
ensEGvvariationValidationSubmitter,
ensEGvvariationValidationDoublehit,
ensEGvvariationValidationHapMap,
ensEGvvariationValidation1000Genomes,
ensEGvvariationValidationFailed,
ensEGvvariationValidationPrecious
} EnsEGvvariationValidation;
ID EnsPGvdatabaseadaptor
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Database Adaptor.
XX
TN EnsSGvdatabaseadaptor
TD
TX
TN EnsOGvdatabaseadaptor
TD
TX
TN EnsPGvvariationadaptor
TD
TX
AN Adaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor
AX
AN Failedvariations
AT AjBool
AD Failed variation
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSGvdatabaseadaptor
{
EnsPDatabaseadaptor Adaptor;
AjBool Failedvariations;
ajuint Padding;
} EnsOGvdatabaseadaptor;
#define EnsPGvdatabaseadaptor EnsOGvdatabaseadaptor*
ID EnsPGvbaseadaptorLeftjoin
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Base Adaptor Left Join conditions
XX
TN EnsSGvbaseadaptorLeftjoin
TD
TX
TN EnsOGvbaseadaptorLeftjoin
TD
TX
AN Table
AT char*
AD SQL table name
AX
AN Condition
AT char*
AD SQL LEFT JOIN condition
AX
//
typedef struct EnsSGvbaseadaptorLeftjoin
{
char *Table;
char *Condition;
} EnsOGvbaseadaptorLeftjoin;
#define EnsPGvbaseadaptorLeftjoin EnsOGvbaseadaptorLeftjoin*
ID EnsPGvbaseadaptor
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Base Adaptor.
XX
TN EnsSGvbaseadaptor
TD
TX
TN EnsOGvbaseadaptor
TD
TX
TN EnsPGvpopulationgenotypeadaptor
TD
TX
TN EnsPGvtranscriptvariationadaptor
TD
TX
AN Adaptor
AT EnsPGvdatabaseadaptor
AD Ensembl Genetic Variation Database Adaptor
AX
AN Baseadaptor
AT EnsPBaseadaptor
AD Ensembl Base Adaptor
AX
AN Ploidy
AT ajuint
AD Ploidy
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSGvbaseadaptor
{
EnsPGvdatabaseadaptor Adaptor;
EnsPBaseadaptor Baseadaptor;
ajuint Ploidy;
ajuint Padding;
} EnsOGvbaseadaptor;
#define EnsPGvbaseadaptor EnsOGvbaseadaptor*
ID EnsPGvattributeadaptor
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Attribute Adaptor
XX
TN EnsSGvattributeadaptor
TD
TX
TN EnsOGvattributeadaptor
TD
TX
AN Adaptor
AT EnsPBaseadaptor
AD Ensembl Base Adaptor
AX
AN CacheByIdentifier
AT AjPTable
AD Identifier cache
AX
AN CacheBySet
AT AjPVoid
AD Cache by attribute sets
AX
//
typedef struct EnsSGvattributeadaptor
{
EnsPBaseadaptor Adaptor;
AjPTable CacheByIdentifier;
AjPVoid CacheBySet;
} EnsOGvattributeadaptor;
#define EnsPGvattributeadaptor EnsOGvattributeadaptor*
ID EnsPGvattribute
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Attribute
XX
TN EnsSGvattribute
TD
TX
TN EnsOGvattribute
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvattributeadaptor
AD Ensembl Genetic Variation Attribute Adaptor
AX
AN Attributetype
AT EnsPAttributetype
AD Ensembl Attribute Type
AX
AN Value
AT AjPStr
AD Value
AX
//
typedef struct EnsSGvattribute
{
ajuint Use;
ajuint Identifier;
EnsPGvattributeadaptor Adaptor;
EnsPAttributetype Attributetype;
AjPStr Value;
} EnsOGvattribute;
#define EnsPGvattribute EnsOGvattribute*
ID EnsPGvsample
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Sample.
XX
TN EnsSGvsample
TD
TX
TN EnsOGvsample
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvsampleadaptor
AD Ensembl Genetic Variation Sample Adaptor
AX
AN Name
AT AjPStr
AD Name
AX
AN Description
AT AjPStr
AD Description
AX
AN Display
AT EnsEGvsampleDisplay
AD Display
AX
AN Size
AT ajuint
AD Size
AX
//
typedef struct EnsSGvsample
{
ajuint Use;
ajuint Identifier;
EnsPGvsampleadaptor Adaptor;
AjPStr Name;
AjPStr Description;
EnsEGvsampleDisplay Display;
ajuint Size;
} EnsOGvsample;
#define EnsPGvsample EnsOGvsample*
ID EnsPGvindividual
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Individual.
XX
TN EnsSGvindividual
TD
TX
TN EnsOGvindividual
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvindividualadaptor
AD Ensembl Genetic Variation Individual Adaptor
AX
AN Gvsample
AT EnsPGvsample
AD Sample
AX
AN Father
AT struct EnsSGvindividual*
AD Father Individual
AX
AN Mother
AT struct EnsSGvindividual*
AD Mother Individual
AX
AN Gender
AT EnsEGvindividualGender
AD Gender
AX
AN Type
AT EnsEGvindividualType
AD Type
AX
AN Description
AT AjPStr
AD Description
AX
//
typedef struct EnsSGvindividual
{
ajuint Use;
ajuint Identifier;
EnsPGvindividualadaptor Adaptor;
EnsPGvsample Gvsample;
struct EnsSGvindividual *Father;
struct EnsSGvindividual *Mother;
EnsEGvindividualGender Gender;
EnsEGvindividualType Type;
AjPStr Description;
} EnsOGvindividual;
#define EnsPGvindividual EnsOGvindividual*
ID EnsPGvpopulation
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Population.
XX
TN EnsSGvpopulation
TD
TX
TN EnsOGvpopulation
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvpopulationadaptor
AD Ensembl Genetic Variation Population Adaptor
AX
AN Gvsample
AT EnsPGvsample
AD Sample
AX
AN Subgvpopulations
AT AjPList
AD AJAX List of (Sub-) Ensembl Genetic Variation Population objects
AX
//
typedef struct EnsSGvpopulation
{
ajuint Use;
ajuint Identifier;
EnsPGvpopulationadaptor Adaptor;
EnsPGvsample Gvsample;
AjPList Subgvpopulations;
} EnsOGvpopulation;
#define EnsPGvpopulation EnsOGvpopulation*
ID EnsPGvalleleadaptor
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Allele Adaptor.
XX
TN EnsSGvalleleadaptor
TD
TX
TN EnsOGvalleleadaptor
TD
TX
AN Excludeadaptor
AT EnsPGvbaseadaptor
AD Ensembl Genetic Variation Base Adaptor excluding the failed_variation table
AX
AN Includeadaptor
AT EnsPGvbaseadaptor
AD Ensembl Genetic Variation Base Adaptor including the failed_variation table
AX
//
typedef struct EnsSGvalleleadaptor
{
EnsPGvbaseadaptor Excludeadaptor;
EnsPGvbaseadaptor Includeadaptor;
} EnsOGvalleleadaptor;
#define EnsPGvalleleadaptor EnsOGvalleleadaptor*
ID EnsPGvallele
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Allele.
XX
TN EnsSGvallele
TD
TX
TN EnsOGvallele
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvalleleadaptor
AD Ensembl Genetic Variation
AD Allele Adaptor
AX
AN Gvpopulation
AT EnsPGvpopulation
AD Ensembl Genetic Variation Population
AX
AN Allele
AT AjPStr
AD Allele
AX
AN Subhandle
AT AjPStr
AD Subhandle
AX
AN Faileddescriptions
AT AjPList
AD AJAX List of AJAX String (failed description) objects
AX
AN Counter
AT ajuint
AD Counter
AX
AN Gvvariationidentifier
AT ajuint
AD Ensembl Genetic Variation Variation identifier
AX
AN Subidentifier
AT ajuint
AD Subidentifier
AX
AN Frequency
AT float
AD Frequency
AX
//
typedef struct EnsSGvallele
{
ajuint Use;
ajuint Identifier;
EnsPGvalleleadaptor Adaptor;
EnsPGvpopulation Gvpopulation;
AjPStr Allele;
AjPStr Subhandle;
AjPList Faileddescriptions;
ajuint Counter;
ajuint Gvvariationidentifier;
ajuint Subidentifier;
float Frequency;
} EnsOGvallele;
#define EnsPGvallele EnsOGvallele*
ID EnsPGvsourceadaptor
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Source Adaptor.
XX
TN EnsSGvsourceadaptor
TD
TX
TN EnsOGvsourceadaptor
TD
TX
AN Adaptor
AT EnsPBaseadaptor
AD Ensembl Base Adaptor
AX
AN CacheByIdentifier
AT AjPTable
AD Identifier cache
AX
AN CacheByName
AT AjPTable
AD Name cache
AX
AN DefaultGvsource
AT struct EnsSGvsource*
AD Default Ensembl Genetic Variation Source
AX
//
typedef struct EnsSGvsourceadaptor
{
EnsPBaseadaptor Adaptor;
AjPTable CacheByIdentifier;
AjPTable CacheByName;
struct EnsSGvsource *DefaultGvsource;
} EnsOGvsourceadaptor;
#define EnsPGvsourceadaptor EnsOGvsourceadaptor*
ID EnsPGvsource
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Source.
XX
TN EnsSGvsource
TD
TX
TN EnsOGvsource
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvsourceadaptor
AD Ensembl Genetic Variation
AD Source Adaptor
AX
AN Name
AT AjPStr
AD Name
AX
AN Version
AT AjPStr
AD Version
AX
AN Description
AT AjPStr
AD Description
AX
AN URL
AT AjPStr
AD Uniform Resource Locator
AX
AN Somatic
AT EnsEGvsourceSomatic
AD Ensembl Genetic Variation Source Somatic enumeration
AX
AN Type
AT EnsEGvsourceType
AD Ensembl Genetic Variation Source Type enumeration
AX
//
typedef struct EnsSGvsource
{
ajuint Use;
ajuint Identifier;
EnsPGvsourceadaptor Adaptor;
AjPStr Name;
AjPStr Version;
AjPStr Description;
AjPStr URL;
EnsEGvsourceSomatic Somatic;
EnsEGvsourceType Type;
} EnsOGvsource;
#define EnsPGvsource EnsOGvsource*
ID EnsPGvsynonym
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Synonym.
XX
TN EnsSGvsynonym
TD
TX
TN EnsOGvsynonym
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvsynonymadaptor
AD Ensembl Genetic Variation
AD Synonym Adaptor
AX
AN Gvsource
AT EnsPGvsource
AD Ensembl Genetic Variation Source
AX
AN Name
AT AjPStr
AD Name
AX
AN Moleculetype
AT AjPStr
AD Molecule type
AX
AN Gvvariationidentifier
AT ajuint
AD Ensembl Genetic Variation identifier
AX
AN Subidentifier
AT ajuint
AD Subidentifier
AX
//
typedef struct EnsSGvsynonym
{
ajuint Use;
ajuint Identifier;
EnsPGvsynonymadaptor Adaptor;
EnsPGvsource Gvsource;
AjPStr Name;
AjPStr Moleculetype;
ajuint Gvvariationidentifier;
ajuint Subidentifier;
} EnsOGvsynonym;
#define EnsPGvsynonym EnsOGvsynonym*
ID EnsPGvvariationadaptor
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Variation Adaptor.
XX
TN EnsOGvvariationadaptor
TD
TX
TN EnsSGvvariationadaptor
TD
TX
AN Adaptor
AT EnsPGvbaseadaptor
AD Ensembl Genetic Variation Base Adaptor
AX
AN Tables
AT char**
AD One-dimensional array of table name character
AD strings, which is dynamically assigned.
AX
AN Columns
AT char**
AD One-dimensional array of column name character
AD strings, which is dynamically assigned.
AX
AN Condition
AT char*
AD SQL SELECT default condition,
AD which is dynamically assigned.
AX
AN Leftjoin
AT EnsPGvbaseadaptorLeftjoin
AD Ensembl Base Adaptor SQL LEFT JOIN conditions
AX
AN Defaultcondition
AT char*
AD SQL SELECT default condition
AX
//
typedef struct EnsSGvvariationadaptor
{
EnsPGvbaseadaptor Adaptor;
char **Tables;
char **Columns;
char *Condition;
EnsPGvbaseadaptorLeftjoin Leftjoin;
char *Defaultcondition;
} EnsOGvvariationadaptor;
#define EnsPGvvariationadaptor EnsOGvvariationadaptor*
ID EnsPGvvariation
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Variation.
XX
TN EnsSGvvariation
TD
TX
TN EnsOGvvariation
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvvariationadaptor
AD Ensembl Genetic Variation
AD Variation Adaptor
AX
AN Class
AT EnsPGvattribute
AD Class Ensembl Genetic Variation Attribute
AX
AN Clinical
AT EnsPGvattribute
AD Clinical Significance Ensembl Genetic Variation Attribute
AX
AN Gvsource
AT EnsPGvsource
AD Ensembl Genetic Variation Source
AX
AN Name
AT AjPStr
AD Name
AX
AN Handles
AT AjPTable
AD Handles
AX
AN Ancestralallele
AT AjPStr
AD Ancestral allele
AX
AN MinoralleleAllele
AT AjPStr
AD Minor allele allele
AX
AN Gvalleles
AT AjPList
AD AJAX List of
AD Ensembl Genetic Variation Allele objects
AX
AN Gvsynonyms
AT AjPList
AD AJAX List of
AD Ensembl Genetic Variation Synonym objects
AX
AN Faileddescriptions
AT AjPList
AD AJAX List of
AD AJAX String (failed description) objects
AX
AN Moleculetype
AT AjPStr
AD Molecule type
AX
AN FlankFive
AT AjPStr
AD Five-prime flanking sequence
AX
AN FlankThree
AT AjPStr
AD Three-prime flanking sequence
AX
AN FlankExists
AT AjBool
AD A five-prime or three-prime flank exists
AX
AN Flipped
AT AjBool
AD Flipped
AX
AN Somatic
AT AjBool
AD Somatic or germline flag
AX
AN Validations
AT ajuint
AD Bit field of validation states
AX
AN MinoralleleCount
AT ajuint
AD Minor allele count
AX
AN MinoralleleFrequency
AT float
AD Minor allele frequency
AX
//
typedef struct EnsSGvvariation
{
ajuint Use;
ajuint Identifier;
EnsPGvvariationadaptor Adaptor;
EnsPGvattribute Class;
EnsPGvattribute Clinical;
EnsPGvsource Gvsource;
AjPStr Name;
AjPTable Handles;
AjPStr Ancestralallele;
AjPStr MinoralleleAllele;
AjPList Gvalleles;
AjPList Gvsynonyms;
AjPList Faileddescriptions;
AjPStr Moleculetype;
AjPStr FlankFive;
AjPStr FlankThree;
AjBool FlankExists;
AjBool Flipped;
AjBool Somatic;
ajuint Validations;
ajuint MinoralleleCount;
float MinoralleleFrequency;
} EnsOGvvariation;
#define EnsPGvvariation EnsOGvvariation*
ID EnsPGvvariationfeatureadaptor
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Variation Feature Adaptor.
XX
TN EnsSGvvariationfeatureadaptor
TD
TX
TN EnsOGvvariationfeatureadaptor
TD
TX
AN Adaptor
AT EnsPGvdatabaseadaptor
AD Ensembl Genetic Variation Database Adaptor
AX
AN Featureadaptor
AT EnsPFeatureadaptor
AD Ensembl Feature Adaptor
AX
//
typedef struct EnsSGvvariationfeatureadaptor
{
EnsPGvdatabaseadaptor Adaptor;
EnsPFeatureadaptor Featureadaptor;
} EnsOGvvariationfeatureadaptor;
#define EnsPGvvariationfeatureadaptor EnsOGvvariationfeatureadaptor*
ID EnsPGvvariationfeature
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Variation Feature.
XX
TN EnsSGvvariationfeature
TD
TX
TN EnsOGvvariationfeature
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvvariationfeatureadaptor
AD Ensembl Genetic Variation
AD Genotype Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN Gvsource
AT EnsPGvsource
AD Ensembl Genetic Variation Source
AX
AN Gvvariation
AT EnsPGvvariation
AD Ensembl Genetic Variation Variation
AX
AN Allele
AT AjPStr
AD Allele, denormalisation from allele.allele
AX
AN Name
AT AjPStr
AD Name, denormalisation from variation.name
AX
AN Validationcode
AT AjPStr
AD Validation code
AX
AN Consequencetype
AT AjPStr
AD Consequence type
AX
AN Mapweight
AT ajuint
AD Map weight or the number of times that the
AD Variation associated with this Feature has hit
AD the genome. If this was the only Feature associated
AD with this Variation Feature the map weight would be
AD 1.
AX
AN Gvvariationidentifier
AT ajuint
AD Ensembl Genetic Variation Variation
AD identifier
AX
AN GvvariationClass
AT EnsEGvvariationClass
AD Ensembl Genetic Variation Variation Class enumeration
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSGvvariationfeature
{
ajuint Use;
ajuint Identifier;
EnsPGvvariationfeatureadaptor Adaptor;
EnsPFeature Feature;
EnsPGvsource Gvsource;
EnsPGvvariation Gvvariation;
AjPStr Allele;
AjPStr Name;
AjPStr Validationcode;
AjPStr Consequencetype;
ajuint Mapweight;
ajuint Gvvariationidentifier;
EnsEGvvariationClass GvvariationClass;
ajuint Padding;
} EnsOGvvariationfeature;
#define EnsPGvvariationfeature EnsOGvvariationfeature*
ID EnsPGvvariationset
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Variation Set.
XX
TN EnsSGvvariationset
TD
TX
TN EnsOGvvariationset
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvvariationsetadaptor
AD Ensembl Genetic Variation
AD Set Adaptor
AX
AN Name
AT AjPStr
AD Name
AX
AN Description
AT AjPStr
AD Description
AX
AN Shortname
AT AjPStr
AD Short name
AX
//
typedef struct EnsSGvvariationset
{
ajuint Use;
ajuint Identifier;
EnsPGvvariationsetadaptor Adaptor;
AjPStr Name;
AjPStr Description;
AjPStr Shortname;
} EnsOGvvariationset;
#define EnsPGvvariationset EnsOGvvariationset*
ID EnsPGvgenotype
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Genotype.
XX
TN EnsSGvgenotype
TD
TX
TN EnsOGvgenotype
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvgenotypeadaptor
AD Ensembl Genetic Variation
AD Genotype Adaptor
AX
AN Gvvariation
AT EnsPGvvariation
AD Ensembl Genetic Variation Variation
AX
AN Alleles
AT AjPList
AD AJAX List of AJAX String objects
AX
AN Subhandle
AT AjPStr
AD Subhandle
AX
AN Subidentifier
AT ajuint
AD Subidentifier
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSGvgenotype
{
ajuint Use;
ajuint Identifier;
EnsPGvgenotypeadaptor Adaptor;
EnsPGvvariation Gvvariation;
AjPList Alleles;
AjPStr Subhandle;
ajuint Subidentifier;
ajuint Padding;
} EnsOGvgenotype;
#define EnsPGvgenotype EnsOGvgenotype*
ID EnsPGvgenotypecode
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Genotype Code.
XX
TN EnsSGvgenotypecode
TD
TX
TN EnsOGvgenotypecode
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvgenotypecodeadaptor
AD Ensembl Genetic Variation Genotype Code Adaptor
AX
AN Alleles
AT AjPList
AD AJAX List of AJAX String (allele) objects
AX
//
typedef struct EnsSGvgenotypecode
{
ajuint Use;
ajuint Identifier;
EnsPGvgenotypecodeadaptor Adaptor;
AjPList Alleles;
} EnsOGvgenotypecode;
#define EnsPGvgenotypecode EnsOGvgenotypecode*
ID EnsPGvpopulationgenotype
TY public
MO ensgvdata
LB ensembl
XX
DE Ensembl Genetic Variation Population Genotype.
XX
TN EnsSGvpopulationgenotype
TD
TX
TN EnsOGvpopulationgenotype
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvpopulationgenotypeadaptor
AD Ensembl Genetic
AD Variation Population Genotype Adaptor
AX
AN Gvpopulation
AT EnsPGvpopulation
AD Ensembl Genetic Variation Population
AX
AN Gvgenotype
AT EnsPGvgenotype
AD Ensembl Genetic Variation Genotype
AX
AN Counter
AT ajuint
AD Counter
AX
AN Frequency
AT float
AD Frequency
AX
//
typedef struct EnsSGvpopulationgenotype
{
ajuint Use;
ajuint Identifier;
EnsPGvpopulationgenotypeadaptor Adaptor;
EnsPGvpopulation Gvpopulation;
EnsPGvgenotype Gvgenotype;
ajuint Counter;
float Frequency;
} EnsOGvpopulationgenotype;
#define EnsPGvpopulationgenotype EnsOGvpopulationgenotype*
ID EnsPKaryotypeband
TY public
MO enskaryotype
LB ensembl
XX
DE Ensembl Karyotype Band
XX
TN EnsSKaryotypeband
TD
TX
TN EnsOKaryotypeband
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPKaryotypebandadaptor
AD Ensembl Karyotype Band Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN Name
AT AjPStr
AD Name
AX
AN Stain
AT AjPStr
AD Stain
AX
//
typedef struct EnsSKaryotypeband
{
ajuint Use;
ajuint Identifier;
EnsPKaryotypebandadaptor Adaptor;
EnsPFeature Feature;
AjPStr Name;
AjPStr Stain;
} EnsOKaryotypeband;
#define EnsPKaryotypeband EnsOKaryotypeband*
ID EnsEMapperunitType
TY public
MO ensmapper
LB ensembl
XX
DE Ensembl Mapper Unit Type enumeration
XX
VN ensEMapperunitTypeNULL
VD Null
VX
VN ensEMapperunitTypeSource
VD Source
VX
VN ensEMapperunitTypeTarget
VD Target
VX
//
typedef enum EnsOMapperunitType
{
ensEMapperunitTypeNULL,
ensEMapperunitTypeSource,
ensEMapperunitTypeTarget
} EnsEMapperunitType;
ID EnsEMapperresultType
TY public
MO ensmapper
LB ensembl
XX
DE Ensembl Mapper Result Type enumeration
XX
VN ensEMapperresultTypeNULL
VD Null
VX
VN ensEMapperresultTypeCoordinate
VD Coordinate
VX
VN ensEMapperresultTypeGap
VD Gap
VX
VN ensEMapperresultTypeInDel
VD Insertion or Deletion
VX
//
typedef enum EnsOMapperresultType
{
ensEMapperresultTypeNULL,
ensEMapperresultTypeCoordinate,
ensEMapperresultTypeGap,
ensEMapperresultTypeInDel
} EnsEMapperresultType;
ID EnsPMapperunit
TY public
MO ensmapper
LB ensembl
XX
DE Ensembl Mapper Unit.
DE
DE One unit of an Ensembl Mapper Pair.
XX
TN EnsSMapperunit
TD
TX
TN EnsOMapperunit
TD
TX
AN Objectidentifier
AT ajuint
AD Ensembl Object identifier
AX
AN Start
AT ajint
AD Start coordinate
AX
AN End
AT ajint
AD End coordinate
AX
AN Use
AT ajuint
AD Use counter
AX
//
typedef struct EnsSMapperunit
{
ajuint Objectidentifier;
ajint Start;
ajint End;
ajuint Use;
} EnsOMapperunit;
#define EnsPMapperunit EnsOMapperunit*
ID EnsPMapperpair
TY public
MO ensmapper
LB ensembl
XX
DE Ensembl Mapper Pair.
DE
DE An Ensembl Mapper Pair consists of two Ensembl Mapper Units.
XX
TN EnsSMapperpair
TD
TX
TN EnsOMapperpair
TD
TX
AN Source
AT EnsPMapperunit
AD Source Ensembl Mapper Unit
AX
AN Target
AT EnsPMapperunit
AD Target Ensembl Mapper Unit
AX
AN Orientation
AT ajint
AD Relative orientation of the Ensembl Mapper Units
AX
AN Indel
AT AjBool
AD Insertion or deletion attribute
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSMapperpair
{
EnsPMapperunit Source;
EnsPMapperunit Target;
ajint Orientation;
AjBool Indel;
ajuint Use;
ajuint Padding;
} EnsOMapperpair;
#define EnsPMapperpair EnsOMapperpair*
ID EnsPMapperresult
TY public
MO ensmapper
LB ensembl
XX
DE Ensembl Mapper Result.
DE
DE Representation of a mapped Ensembl Object returned by an Ensembl Mapper when
DE the source region maps to valid sequence. Depending on the type element
DE this can also represent a gap.
XX
TN EnsSMapperresult
TD
TX
TN EnsOMapperresult
TD
TX
AN Coordsystem
AT EnsPCoordsystem
AD Ensembl Coordinate System
AX
AN Type
AT EnsEMapperresultType
AD Result type
AX
AN Objectidentifier
AT ajuint
AD Ensembl Object identifier
AX
AN CoordinateStart
AT ajint
AD Coordinate start
AX
AN CoordinateEnd
AT ajint
AD Coordinate end
AX
AN CoordinateStrand
AT ajint
AD Coordinate strand
AX
AN GapStart
AT ajint
AD Start coordinate of a gap
AX
AN GapEnd
AT ajint
AD End coordinate of a gap
AX
AN Rank
AT ajuint
AD Rank
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSMapperresult
{
EnsPCoordsystem Coordsystem;
EnsEMapperresultType Type;
ajuint Objectidentifier;
ajint CoordinateStart;
ajint CoordinateEnd;
ajint CoordinateStrand;
ajint GapStart;
ajint GapEnd;
ajuint Rank;
ajuint Use;
ajuint Padding;
} EnsOMapperresult;
#define EnsPMapperresult EnsOMapperresult*
ID EnsPMapperrange
TY public
MO ensmapper
LB ensembl
XX
DE Ensembl Mapper Range.
DE
DE An Ensembl Mapper Range defines start and end ccordinates of genome ranges.
XX
TN EnsSMapperrange
TD
TX
TN EnsOMapperrange
TD
TX
AN Start
AT ajint
AD Start coordinate
AX
AN End
AT ajint
AD End coordinate
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSMapperrange
{
ajint Start;
ajint End;
ajuint Use;
ajuint Padding;
} EnsOMapperrange;
#define EnsPMapperrange EnsOMapperrange*
ID EnsPMapperrangeregistry
TY public
MO ensmapper
LB ensembl
XX
DE Ensembl Mapper Range Registry.
DE
DE An Ensembl Mapper Range Registry maintains a table of registered regions.
XX
TN EnsSMapperrangeregistry
TD
TX
TN EnsOMapperrangeregistry
TD
TX
AN Registry
AT AjPTable
AD Registry Table
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSMapperrangeregistry
{
AjPTable Registry;
ajuint Use;
ajuint Padding;
} EnsOMapperrangeregistry;
#define EnsPMapperrangeregistry EnsOMapperrangeregistry*
ID EnsPMapper
TY public
MO ensmapper
LB ensembl
XX
DE Ensembl Mapper.
DE
DE Generic mapper to provide coordinate transforms between two
DE disjoint Ensembl Coordinate Systems.
XX
TN EnsSMapper
TD
TX
TN EnsOMapper
TD
TX
AN TypeSource
AT AjPStr
AD Source type
AX
AN TypeTarget
AT AjPStr
AD Target type
AX
AN CoordsystemSource
AT EnsPCoordsystem
AD Source Ensembl Coordinate System
AX
AN CoordsystemTarget
AT EnsPCoordsystem
AD Target Ensembl Coordinate System
AX
AN Mapperpairs
AT AjPTable
AD AJAX Table of AJAX Table objects with
AD Ensembl Mapper Pair objects
AX
AN Sorted
AT AjBool
AD Ensembl Mapper Pair objects are sorted
AX
AN Count
AT ajuint
AD Number of Ensembl Mapper Pair objects
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSMapper
{
AjPStr TypeSource;
AjPStr TypeTarget;
EnsPCoordsystem CoordsystemSource;
EnsPCoordsystem CoordsystemTarget;
AjPTable Mapperpairs;
AjBool Sorted;
ajuint Count;
ajuint Use;
ajuint Padding;
} EnsOMapper;
#define EnsPMapper EnsOMapper*
ID EnsEMarkerType
TY public
MO ensmarker
LB ensembl
XX
DE Ensembl Marker Type enumeration
XX
VN ensEMarkerTypeNULL
VD Null
VX
VN ensEMarkerTypeEST
VD Expressed Sequence Tag
VX
VN ensEMarkerTypeMicroSatellite
VD Micro-Satellite
VX
//
typedef enum EnsOMarkerType
{
ensEMarkerTypeNULL,
ensEMarkerTypeEST,
ensEMarkerTypeMicroSatellite
} EnsEMarkerType;
ID EnsPMarkersynonym
TY public
MO ensmarker
LB ensembl
XX
DE Ensembl Marker Synonym
XX
TN EnsSMarkersynonym
TD
TX
TN EnsOMarkersynonym
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Source
AT AjPStr
AD Source
AX
AN Name
AT AjPStr
AD Name
AX
//
typedef struct EnsSMarkersynonym
{
ajuint Use;
ajuint Identifier;
AjPStr Source;
AjPStr Name;
} EnsOMarkersynonym;
#define EnsPMarkersynonym EnsOMarkersynonym*
ID EnsPMarkermaplocation
TY public
MO ensmarker
LB ensembl
XX
DE Ensembl Marker Map Location
XX
TN EnsSMarkermaplocation
TD
TX
TN EnsOMarkermaplocation
TD
TX
AN Markersynonym
AT EnsPMarkersynonym
AD Ensembl Marker Synonym
AX
AN Mapname
AT AjPStr
AD Map name
AX
AN Chromosomename
AT AjPStr
AD Chromosome name
AX
AN Position
AT AjPStr
AD Position
AX
AN Lodscore
AT float
AD LOD score
AX
AN Use
AT ajuint
AD Use counter
AX
//
typedef struct EnsSMarkermaplocation
{
EnsPMarkersynonym Markersynonym;
AjPStr Mapname;
AjPStr Chromosomename;
AjPStr Position;
float Lodscore;
ajuint Use;
} EnsOMarkermaplocation;
#define EnsPMarkermaplocation EnsOMarkermaplocation*
ID EnsPMarker
TY public
MO ensmarker
LB ensembl
XX
DE Ensembl Marker
XX
TN EnsSMarker
TD
TX
TN EnsOMarker
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPMarkeradaptor
AD Ensembl Marker Adaptor
AX
AN Displaysynonym
AT EnsPMarkersynonym
AD Display Ensembl Marker Synonym
AX
AN PrimerLeft
AT AjPStr
AD Left primer
AX
AN PrimerRight
AT AjPStr
AD Right primer
AX
AN Markersynonyms
AT AjPList
AD AJAX List of Ensembl Marker Synonyms
AX
AN Markermaplocations
AT AjPList
AD AJAX List of Ensembl Marker Map Locations
AX
AN DistanceMinimum
AT ajuint
AD Minimum primer distance
AX
AN DistanceMaximum
AT ajuint
AD Maximum primer distance
AX
AN Type
AT EnsEMarkerType
AD Type
AX
AN Priority
AT ajint
AD Priority
AX
//
typedef struct EnsSMarker
{
ajuint Use;
ajuint Identifier;
EnsPMarkeradaptor Adaptor;
EnsPMarkersynonym Displaysynonym;
AjPStr PrimerLeft;
AjPStr PrimerRight;
AjPList Markersynonyms;
AjPList Markermaplocations;
ajuint DistanceMinimum;
ajuint DistanceMaximum;
EnsEMarkerType Type;
ajint Priority;
} EnsOMarker;
#define EnsPMarker EnsOMarker*
ID EnsPMarkerfeature
TY public
MO ensmarker
LB ensembl
XX
DE Ensembl Marker Feature
XX
TN EnsSMarkerfeature
TD
TX
TN EnsOMarkerfeature
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPMarkerfeatureadaptor
AD Ensembl Marker Feature Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN Marker
AT EnsPMarker
AD Ensembl Marker
AX
AN Mapweight
AT ajint
AD Map weight
AX
AN Padding
AT ajint
AD Padding to alignment boundary
AX
//
typedef struct EnsSMarkerfeature
{
ajuint Use;
ajuint Identifier;
EnsPMarkerfeatureadaptor Adaptor;
EnsPFeature Feature;
EnsPMarker Marker;
ajint Mapweight;
ajint Padding;
} EnsOMarkerfeature;
#define EnsPMarkerfeature EnsOMarkerfeature*
ID EnsPMetacoordinateadaptor
TY public
MO ensmetacoordinate
LB ensembl
XX
DE Ensembl Meta-Coordinate Adaptor.
XX
TN EnsSMetacoordinateadaptor
TD
TX
TN EnsOMetacoordinateadaptor
TD
TX
AN Adaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor.
AX
AN CacheByName
AT AjPTable
AD Ensembl Feature name (i.e. table name) cache.
AX
AN CacheByLength
AT AjPTable
AD Maximum length cache.
AX
//
typedef struct EnsSMetacoordinateadaptor
{
EnsPDatabaseadaptor Adaptor;
AjPTable CacheByName;
AjPTable CacheByLength;
} EnsOMetacoordinateadaptor;
#define EnsPMetacoordinateadaptor EnsOMetacoordinateadaptor*
ID EnsPMetainformationadaptor
TY public
MO ensmetainformation
LB ensembl
XX
DE Ensembl Meta-Information Adaptor
XX
TN EnsSMetainformationadaptor
TD
TX
TN EnsOMetainformationadaptor
TD
TX
AN Adaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor.
AX
AN CacheByIdentifier
AT AjPTable
AD Cache by Meta-Information SQL identifier.
AX
AN CacheByKey
AT AjPTable
AD Cache by Meta-Information key data.
AX
//
typedef struct EnsSMetainformationadaptor
{
EnsPDatabaseadaptor Adaptor;
AjPTable CacheByIdentifier;
AjPTable CacheByKey;
} EnsOMetainformationadaptor;
#define EnsPMetainformationadaptor EnsOMetainformationadaptor*
ID EnsPMetainformation
TY public
MO ensmetainformation
LB ensembl
XX
DE Ensembl Meta-Information
XX
TN EnsSMetainformation
TD
TX
TN EnsOMetainformation
TD
TX
AN Use
AT ajuint
AD Use counter.
AX
AN Identifier
AT ajuint
AD SQL Database-internal identifier.
AX
AN Adaptor
AT EnsPMetainformationadaptor
AD Ensembl Meta-Information Adaptor.
AX
AN Key
AT AjPStr
AD Key.
AX
AN Value
AT AjPStr
AD Value.
AX
AN Species
AT ajuint
AD Species identifier.
AX
AN Padding
AT ajuint
AD Padding to alignment boundary.
AX
//
typedef struct EnsSMetainformation
{
ajuint Use;
ajuint Identifier;
EnsPMetainformationadaptor Adaptor;
AjPStr Key;
AjPStr Value;
ajuint Species;
ajuint Padding;
} EnsOMetainformation;
#define EnsPMetainformation EnsOMetainformation*
ID EnsPMiscellaneoussetadaptor
TY public
MO ensmiscellaneous
LB ensembl
XX
DE Ensembl Miscellaneous Set Adaptor.
XX
TN EnsSMiscellaneoussetadaptor
TD
TX
TN EnsOMiscellaneoussetadaptor
TD
TX
AN Adaptor
AT EnsPBaseadaptor
AD Ensembl Base Adaptor
AX
AN CacheByIdentifier
AT AjPTable
AD Identifier cache
AX
AN CacheByCode
AT AjPTable
AD Code cache
AX
//
typedef struct EnsSMiscellaneoussetadaptor
{
EnsPBaseadaptor Adaptor;
AjPTable CacheByIdentifier;
AjPTable CacheByCode;
} EnsOMiscellaneoussetadaptor;
#define EnsPMiscellaneoussetadaptor EnsOMiscellaneoussetadaptor*
ID EnsPMiscellaneousset
TY public
MO ensmiscellaneous
LB ensembl
XX
DE Ensembl Miscellaneous Set.
XX
TN EnsSMiscellaneousset
TD
TX
TN EnsOMiscellaneousset
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPMiscellaneoussetadaptor
AD Ensembl Miscellaneous
AD Set Adaptor
AX
AN Code
AT AjPStr
AD Code
AX
AN Name
AT AjPStr
AD Name
AX
AN Description
AT AjPStr
AD Description
AX
AN MaximumLength
AT ajuint
AD Maximum Feature length
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSMiscellaneousset
{
ajuint Use;
ajuint Identifier;
EnsPMiscellaneoussetadaptor Adaptor;
AjPStr Code;
AjPStr Name;
AjPStr Description;
ajuint MaximumLength;
ajuint Padding;
} EnsOMiscellaneousset;
#define EnsPMiscellaneousset EnsOMiscellaneousset*
ID EnsPMiscellaneousfeature
TY public
MO ensmiscellaneous
LB ensembl
XX
DE Ensembl Miscellaneous Feature.
XX
TN EnsSMiscellaneousfeature
TD
TX
TN EnsOMiscellaneousfeature
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPMiscellaneousfeatureadaptor
AD Ensembl Miscellaneous
AD Feature Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN Attributes
AT AjPList
AD AJAX List of Ensembl Attribute objects
AX
AN Miscellaneoussets
AT AjPList
AD AJAX List of
AD Ensembl Miscellaneous Set objects
AX
//
typedef struct EnsSMiscellaneousfeature
{
ajuint Use;
ajuint Identifier;
EnsPMiscellaneousfeatureadaptor Adaptor;
EnsPFeature Feature;
AjPList Attributes;
AjPList Miscellaneoussets;
} EnsOMiscellaneousfeature;
#define EnsPMiscellaneousfeature EnsOMiscellaneousfeature*
ID EnsPOntologyadaptor
TY public
MO ensontology
LB ensembl
XX
DE Ensembl Ontology Adaptor
XX
TN EnsSOntologyadaptor
TD
TX
TN EnsOOntologyadaptor
TD
TX
AN Adaptor
AT EnsPBaseadaptor
AD Ensembl Base Adaptor
AX
AN CacheByIdentifier
AT AjPTable
AD Identifier cache
AX
AN CacheByNamespace
AT AjPTable
AD Name space cache
AX
//
typedef struct EnsSOntologyadaptor
{
EnsPBaseadaptor Adaptor;
AjPTable CacheByIdentifier;
AjPTable CacheByNamespace;
} EnsOOntologyadaptor;
#define EnsPOntologyadaptor EnsOOntologyadaptor*
ID EnsPOntology
TY public
MO ensontology
LB ensembl
XX
DE Ensembl Ontology
XX
TN EnsSOntology
TD
TX
TN EnsOOntology
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPOntologyadaptor
AD Ensembl Ontology Adaptor
AX
AN Name
AT AjPStr
AD Name
AX
AN Space
AT AjPStr
AD Name space
AX
//
typedef struct EnsSOntology
{
ajuint Use;
ajuint Identifier;
EnsPOntologyadaptor Adaptor;
AjPStr Name;
AjPStr Space;
} EnsOOntology;
#define EnsPOntology EnsOOntology*
ID EnsPOntologysynonym
TY public
MO ensontology
LB ensembl
XX
DE Ensembl Ontology Synonym
XX
TN EnsSOntologysynonym
TD
TX
TN EnsOOntologysynonym
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPOntologytermadaptor
AD Ensembl Ontology Term Adaptor
AX
AN Name
AT AjPStr
AD Name
AX
//
typedef struct EnsSOntologysynonym
{
ajuint Use;
ajuint Identifier;
EnsPOntologytermadaptor Adaptor;
AjPStr Name;
} EnsOOntologysynonym;
#define EnsPOntologysynonym EnsOOntologysynonym*
ID EnsPOntologyterm
TY public
MO ensontology
LB ensembl
XX
DE Ensembl Ontology Term
XX
TN EnsSOntologyterm
TD
TX
TN EnsOOntologyterm
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPOntologytermadaptor
AD Ensembl Ontology Term Adaptor
AX
AN Ontology
AT EnsPOntology
AD Ensembl Ontology
AX
AN Accession
AT AjPStr
AD Accession
AX
AN Definition
AT AjPStr
AD Definition
AX
AN Name
AT AjPStr
AD Name
AX
AN Subsets
AT AjPStr
AD Subsets
AX
AN Children
AT AjPTable
AD AJAX Table of child Ensembl Ontology Term objects
AX
AN Parents
AT AjPTable
AD AJAX Table of parent Ensembl Ontology Term objects
AX
AN Ontologysynonyms
AT AjPList
AD AJAX List of Ensembl Ontology Synonym objects
AX
//
typedef struct EnsSOntologyterm
{
ajuint Use;
ajuint Identifier;
EnsPOntologytermadaptor Adaptor;
EnsPOntology Ontology;
AjPStr Accession;
AjPStr Definition;
AjPStr Name;
AjPStr Subsets;
AjPTable Children;
AjPTable Parents;
AjPList Ontologysynonyms;
} EnsOOntologyterm;
#define EnsPOntologyterm EnsOOntologyterm*
ID EnsPPredictionexon
TY public
MO ensprediction
LB ensembl
XX
DE Ensembl Prediction Exon.
XX
TN EnsSPredictionexon
TD
TX
TN EnsOPredictionexon
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT EnsPPredictionexonadaptor
AD Ensembl Prediction Exon Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN Score
AT double
AD Score
AX
AN Pvalue
AT double
AD P-value
AX
AN PhaseStart
AT ajint
AD Start phase
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
AN SequenceCache
AT AjPStr
AD Sequence cache
AX
//
typedef struct EnsSPredictionexon
{
ajuint Use;
ajuint Identifier;
EnsPPredictionexonadaptor Adaptor;
EnsPFeature Feature;
double Score;
double Pvalue;
ajint PhaseStart;
char Padding[4];
AjPStr SequenceCache;
} EnsOPredictionexon;
#define EnsPPredictionexon EnsOPredictionexon*
ID EnsPPredictiontranscript
TY public
MO ensprediction
LB ensembl
XX
DE Ensembl Prediction Transcript.
XX
TN EnsSPredictiontranscript
TD
TX
TN EnsOPredictiontranscript
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPPredictiontranscriptadaptor
AD Ensembl Prediction
AD Transcript Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN Displaylabel
AT AjPStr
AD Display label
AX
AN Predictionexons
AT AjPList
AD AJAX List of Ensembl Prediction Exon objects
AX
//
typedef struct EnsSPredictiontranscript
{
ajuint Use;
ajuint Identifier;
EnsPPredictiontranscriptadaptor Adaptor;
EnsPFeature Feature;
AjPStr Displaylabel;
AjPList Predictionexons;
} EnsOPredictiontranscript;
#define EnsPPredictiontranscript EnsOPredictiontranscript*
ID EnsPProjectionsegment
TY public
MO ensprojectionsegment
LB ensembl
XX
DE Ensembl Projection Segment
XX
TN EnsSProjectionsegment
TD
TX
TN EnsOProjectionsegment
TD
TX
AN SourceStart
AT ajuint
AD Source start coordinate
AX
AN SourceEnd
AT ajuint
AD Source end coordinate
AX
AN TargetSlice
AT EnsPSlice
AD Target Ensembl Slice
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSProjectionsegment
{
ajuint SourceStart;
ajuint SourceEnd;
EnsPSlice TargetSlice;
ajuint Use;
ajuint Padding;
} EnsOProjectionsegment;
#define EnsPProjectionsegment EnsOProjectionsegment*
ID EnsPProteinfeature
TY public
MO ensprotein
LB ensembl
XX
DE Ensembl Protein Feature.
XX
TN EnsSProteinfeature
TD
TX
TN EnsOProteinfeature
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPProteinfeatureadaptor
AD Ensembl Protein Feature Adaptor
AX
AN Featurepair
AT EnsPFeaturepair
AD Ensembl Feature Pair
AX
AN Accession
AT AjPStr
AD (InterPro) Accession
AX
AN Description
AT AjPStr
AD (InterPro) Description
AX
//
typedef struct EnsSProteinfeature
{
ajuint Use;
ajuint Identifier;
EnsPProteinfeatureadaptor Adaptor;
EnsPFeaturepair Featurepair;
AjPStr Accession;
AjPStr Description;
} EnsOProteinfeature;
#define EnsPProteinfeature EnsOProteinfeature*
ID EnsPQcalignment
TY public
MO ensqcalignment
LB ensembl
XX
DE Ensembl Quality Check Alignment
XX
TN EnsSQcalignment
TD
TX
TN EnsOQcalignment
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPQcalignmentadaptor
AD Ensembl Alignment Adaptor
AX
AN Analysis
AT EnsPAnalysis
AD Ensembl Analysis
AX
AN QuerySequence
AT EnsPQcsequence
AD Query Ensembl Quality Check Sequence
AX
AN TargetSequence
AT EnsPQcsequence
AD Target Ensembl Quality Check Sequence
AX
AN Vulgar
AT AjPStr
AD Vulgar line
AX
AN QueryStart
AT ajuint
AD Query start
AX
AN QueryEnd
AT ajuint
AD Query end
AX
AN QueryStrand
AT ajint
AD Query strand
AX
AN TargetStart
AT ajuint
AD Target start
AX
AN TargetEnd
AT ajuint
AD Target end
AX
AN TargetStrand
AT ajint
AD Target strand
AX
AN Splicestrand
AT ajint
AD Splice strand
AX
AN Coverage
AT ajuint
AD Coverage score
AX
AN Score
AT double
AD Score
AX
AN Identity
AT float
AD Identity
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct EnsSQcalignment
{
ajuint Use;
ajuint Identifier;
EnsPQcalignmentadaptor Adaptor;
EnsPAnalysis Analysis;
EnsPQcsequence QuerySequence;
EnsPQcsequence TargetSequence;
AjPStr Vulgar;
ajuint QueryStart;
ajuint QueryEnd;
ajint QueryStrand;
ajuint TargetStart;
ajuint TargetEnd;
ajint TargetStrand;
ajint Splicestrand;
ajuint Coverage;
double Score;
float Identity;
char Padding[4];
} EnsOQcalignment;
#define EnsPQcalignment EnsOQcalignment*
ID EnsEQcdasfeatureCategory
TY public
MO ensqcdasfeature
LB ensembl
XX
DE Ensembl Quality Check DAS Feature Category enumeration
XX
VN ensEQcdasfeatureCategoryNULL
VD
VX
VN ensEQcdasfeatureCategoryUnknown
VD
VX
VN ensEQcdasfeatureCategoryTranscriptPerfect
VD
VX
VN ensEQcdasfeatureCategoryTranscriptTolerance
VD
VX
VN ensEQcdasfeatureCategoryTranscriptPartial
VD
VX
VN ensEQcdasfeatureCategoryTranscriptMissing
VD
VX
VN ensEQcdasfeatureCategoryTranscript
VD
VX
VN ensEQcdasfeatureCategoryTranslationPerfect
VD
VX
VN ensEQcdasfeatureCategoryTranslationTolerance
VD
VX
VN ensEQcdasfeatureCategoryTranslationPartial
VD
VX
VN ensEQcdasfeatureCategoryTranslationMissing
VD
VX
VN ensEQcdasfeatureCategoryTranslation
VD
VX
//
typedef enum EnsOQcdasfeatureCategory
{
ensEQcdasfeatureCategoryNULL,
ensEQcdasfeatureCategoryUnknown,
ensEQcdasfeatureCategoryTranscriptPerfect,
ensEQcdasfeatureCategoryTranscriptTolerance,
ensEQcdasfeatureCategoryTranscriptPartial,
ensEQcdasfeatureCategoryTranscriptMissing,
ensEQcdasfeatureCategoryTranscript,
ensEQcdasfeatureCategoryTranslationPerfect,
ensEQcdasfeatureCategoryTranslationTolerance,
ensEQcdasfeatureCategoryTranslationPartial,
ensEQcdasfeatureCategoryTranslationMissing,
ensEQcdasfeatureCategoryTranslation
} EnsEQcdasfeatureCategory;
ID EnsEQcdasfeatureType
TY public
MO ensqcdasfeature
LB ensembl
XX
DE Ensembl Quality Check DAS Feature Type enumeration
XX
VN ensEQcdasfeatureTypeNULL
VD
VX
VN ensEQcdasfeatureTypeUnknown
VD
VX
VN ensEQcdasfeatureTypeExonPerfect
VD
VX
VN ensEQcdasfeatureTypeExonPartial
VD
VX
VN ensEQcdasfeatureTypeExonMissing
VD
VX
VN ensEQcdasfeatureTypeExonFrameshift
VD
VX
VN ensEQcdasfeatureTypeExonGap
VD
VX
VN ensEQcdasfeatureTypeExon
VD
VX
//
typedef enum EnsOQcdasfeatureType
{
ensEQcdasfeatureTypeNULL,
ensEQcdasfeatureTypeUnknown,
ensEQcdasfeatureTypeExonPerfect,
ensEQcdasfeatureTypeExonPartial,
ensEQcdasfeatureTypeExonMissing,
ensEQcdasfeatureTypeExonFrameshift,
ensEQcdasfeatureTypeExonGap,
ensEQcdasfeatureTypeExon
} EnsEQcdasfeatureType;
ID EnsPQcdasfeature
TY public
MO ensqcdasfeature
LB ensembl
XX
DE Ensembl Quality Check DAS Feature
XX
TN EnsSQcdasfeature
TD
TX
TN EnsOQcdasfeature
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPQcdasfeatureadaptor
AD Ensembl Quality Check DAS Feature Adaptor
AX
AN Qcalignment
AT EnsPQcalignment
AD Ensembl Quality Check Alignment
AX
AN Analysis
AT EnsPAnalysis
AD Ensembl Analysis
AX
AN SegmentSequence
AT EnsPQcsequence
AD Segment Ensembl Quality Check Sequence
AX
AN FeatureSequence
AT EnsPQcsequence
AD Feature Ensembl Quality Check Sequence
AX
AN SegmentStart
AT ajuint
AD Segment start
AX
AN SegmentEnd
AT ajuint
AD Segment end
AX
AN SegmentStrand
AT ajint
AD Segment strand
AX
AN FeatureStart
AT ajuint
AD Feature start
AX
AN FeatureEnd
AT ajuint
AD Feature end
AX
AN Phase
AT ajint
AD Phase
AX
AN Category
AT EnsEQcdasfeatureCategory
AD Category
AX
AN Type
AT EnsEQcdasfeatureType
AD Type
AX
//
typedef struct EnsSQcdasfeature
{
ajuint Use;
ajuint Identifier;
EnsPQcdasfeatureadaptor Adaptor;
EnsPQcalignment Qcalignment;
EnsPAnalysis Analysis;
EnsPQcsequence SegmentSequence;
EnsPQcsequence FeatureSequence;
ajuint SegmentStart;
ajuint SegmentEnd;
ajint SegmentStrand;
ajuint FeatureStart;
ajuint FeatureEnd;
ajint Phase;
EnsEQcdasfeatureCategory Category;
EnsEQcdasfeatureType Type;
} EnsOQcdasfeature;
#define EnsPQcdasfeature EnsOQcdasfeature*
ID EnsEQcdatabaseClass
TY public
MO ensqcdatabase
LB ensembl
XX
DE Ensembl Quality Check Database Class enumeration
XX
VN ensEQcdatabaseClassNULL
VD Null
VX
VN ensEQcdatabaseClassUnknown
VD Unknown
VX
VN ensEQcdatabaseClassReference
VD Reference database
VX
VN ensEQcdatabaseClassTest
VD Test database
VX
VN ensEQcdatabaseClassBoth
VD Reference and test database
VX
VN ensEQcdatabaseClassGenome
VD Genome database
VX
//
typedef enum EnsOQcdatabaseClass
{
ensEQcdatabaseClassNULL,
ensEQcdatabaseClassUnknown,
ensEQcdatabaseClassReference,
ensEQcdatabaseClassTest,
ensEQcdatabaseClassBoth,
ensEQcdatabaseClassGenome
} EnsEQcdatabaseClass;
ID EnsEQcdatabaseType
TY public
MO ensqcdatabase
LB ensembl
XX
DE Ensembl Quality Check Database Type enumeration
XX
VN ensEQcdatabaseTypeNULL
VD Null
VX
VN ensEQcdatabaseTypeUnknown
VD Unknown sequence database
VX
VN ensEQcdatabaseTypeDNA
VD DNA sequence database
VX
VN ensEQcdatabaseTypeProtein
VD Protein sequence database
VX
//
typedef enum EnsOQcdatabaseType
{
ensEQcdatabaseTypeNULL,
ensEQcdatabaseTypeUnknown,
ensEQcdatabaseTypeDNA,
ensEQcdatabaseTypeProtein
} EnsEQcdatabaseType;
ID EnsPQcdatabaseadaptor
TY public
MO ensqcdatabase
LB ensembl
XX
DE Ensembl Quality Check Database Adaptor
XX
TN EnsSQcdatabaseadaptor
TD
TX
TN EnsOQcdatabaseadaptor
TD
TX
AN Adaptor
AT EnsPBaseadaptor
AD Ensembl Base Adaptor
AX
AN CacheByIdentifier
AT AjPTable
AD Identifier cache
AX
AN CacheByName
AT AjPTable
AD Name cache
AX
//
typedef struct EnsSQcdatabaseadaptor
{
EnsPBaseadaptor Adaptor;
AjPTable CacheByIdentifier;
AjPTable CacheByName;
} EnsOQcdatabaseadaptor;
#define EnsPQcdatabaseadaptor EnsOQcdatabaseadaptor*
ID EnsPQcdatabase
TY public
MO ensqcdatabase
LB ensembl
XX
DE Ensembl Quality Check Database
XX
TN EnsSQcdatabase
TD
TX
TN EnsOQcdatabase
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPQcdatabaseadaptor
AD Ensembl Database Adaptor
AX
AN Analysis
AT EnsPAnalysis
AD Ensembl Analysis
AX
AN Name
AT AjPStr
AD Name
AX
AN Release
AT AjPStr
AD Release
AX
AN Date
AT AjPStr
AD Date
AX
AN Format
AT AjPStr
AD Format
AX
AN Class
AT EnsEQcdatabaseClass
AD Class
AX
AN Type
AT EnsEQcdatabaseType
AD Type
AX
AN DatabaseadaptorSpecies
AT AjPStr
AD Ensembl Database Adaptor species
AX
AN DatabaseadaptorGroup
AT EnsEDatabaseadaptorGroup
AD Ensembl Database
AD Adaptor Group enumeration
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
AN Host
AT AjPStr
AD Host
AX
AN Directory
AT AjPStr
AD Directory
AX
AN File
AT AjPStr
AD File
AX
AN UrlExternal
AT AjPStr
AD External URL
AX
AN UrlInternal
AT AjPStr
AD Internal URL
AX
//
typedef struct EnsSQcdatabase
{
ajuint Use;
ajuint Identifier;
EnsPQcdatabaseadaptor Adaptor;
EnsPAnalysis Analysis;
AjPStr Name;
AjPStr Release;
AjPStr Date;
AjPStr Format;
EnsEQcdatabaseClass Class;
EnsEQcdatabaseType Type;
AjPStr DatabaseadaptorSpecies;
EnsEDatabaseadaptorGroup DatabaseadaptorGroup;
ajuint Padding;
AjPStr Host;
AjPStr Directory;
AjPStr File;
AjPStr UrlExternal;
AjPStr UrlInternal;
} EnsOQcdatabase;
#define EnsPQcdatabase EnsOQcdatabase*
ID EnsPQcsequenceadaptor
TY public
MO ensqcsequence
LB ensembl
XX
DE Ensembl Quality Check Sequence Adaptor
XX
TN EnsSQcsequenceadaptor
TD
TX
TN EnsOQcsequenceadaptor
TD
TX
AN Adaptor
AT EnsPBaseadaptor
AD Ensembl Base Adaptor
AX
AN CacheByIdentifier
AT AjPTable
AD Identifier cache
AX
AN CacheByName
AT AjPTable
AD Name cache
AX
//
typedef struct EnsSQcsequenceadaptor
{
EnsPBaseadaptor Adaptor;
AjPTable CacheByIdentifier;
AjPTable CacheByName;
} EnsOQcsequenceadaptor;
#define EnsPQcsequenceadaptor EnsOQcsequenceadaptor*
ID EnsPQcsequence
TY public
MO ensqcsequence
LB ensembl
XX
DE Ensembl Quality Check Sequence
XX
TN EnsSQcsequence
TD
TX
TN EnsOQcsequence
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPQcsequenceadaptor
AD Ensembl Sequence Adaptor
AX
AN Qcdatabase
AT EnsPQcdatabase
AD Ensembl Quality Check Database
AX
AN Name
AT AjPStr
AD Name
AX
AN Accession
AT AjPStr
AD Accession
AX
AN Description
AT AjPStr
AD Description
AX
AN Type
AT AjPStr
AD Type
AX
AN Version
AT ajuint
AD Version
AX
AN Length
AT ajuint
AD Length
AX
AN CdsStart
AT ajuint
AD Coding sequence start
AX
AN CdsEnd
AT ajuint
AD Coding sequence end
AX
AN CdsStrand
AT ajint
AD Coding sequence strand
AX
AN Polya
AT ajuint
AD Poly A+ tail length
AX
//
typedef struct EnsSQcsequence
{
ajuint Use;
ajuint Identifier;
EnsPQcsequenceadaptor Adaptor;
EnsPQcdatabase Qcdatabase;
AjPStr Name;
AjPStr Accession;
AjPStr Description;
AjPStr Type;
ajuint Version;
ajuint Length;
ajuint CdsStart;
ajuint CdsEnd;
ajint CdsStrand;
ajuint Polya;
} EnsOQcsequence;
#define EnsPQcsequence EnsOQcsequence*
ID EnsPQcsubmission
TY public
MO ensqcsubmission
LB ensembl
XX
DE Ensembl Quality Check Submission
XX
TN EnsSQcsubmission
TD
TX
TN EnsOQcsubmission
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPQcsubmissionadaptor
AD Ensembl Quality Check Submission Adaptor
AX
AN Analysis
AT EnsPAnalysis
AD Ensembl Analysis
AX
AN QuerySequence
AT EnsPQcsequence
AD Query Ensembl Quality Check Sequence
AX
AN TargetSequence
AT EnsPQcsequence
AD Target Ensembl Quality Check Sequence
AX
AN QueryStart
AT ajuint
AD Query start
AX
AN QueryEnd
AT ajuint
AD Query end
AX
AN QueryStrand
AT ajint
AD Query strand
AX
AN TargetStart
AT ajuint
AD Target start
AX
AN TargetEnd
AT ajuint
AD Target end
AX
AN TargetStrand
AT ajint
AD Target strand
AX
AN Analysisjobidentifier
AT ajuint
AD Ensembl Hive Analysis Job identifier
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSQcsubmission
{
ajuint Use;
ajuint Identifier;
EnsPQcsubmissionadaptor Adaptor;
EnsPAnalysis Analysis;
EnsPQcsequence QuerySequence;
EnsPQcsequence TargetSequence;
ajuint QueryStart;
ajuint QueryEnd;
ajint QueryStrand;
ajuint TargetStart;
ajuint TargetEnd;
ajint TargetStrand;
ajuint Analysisjobidentifier;
ajuint Padding;
} EnsOQcsubmission;
#define EnsPQcsubmission EnsOQcsubmission*
ID EnsEQcvariationClass
TY public
MO ensqcvariation
LB ensembl
XX
DE Ensembl Quality Check Variation Class enumeration
XX
VN ensEQcvariationClassNULL
VD Null
VX
VN ensEQcvariationClassNone
VD None
VX
VN ensEQcvariationClassSimple
VD Simple
VX
VN ensEQcvariationClassSplice
VD Splice
VX
VN ensEQcvariationClassExon
VD Exon
VX
//
typedef enum EnsOQcvariationClass
{
ensEQcvariationClassNULL,
ensEQcvariationClassNone,
ensEQcvariationClassSimple,
ensEQcvariationClassSplice,
ensEQcvariationClassExon
} EnsEQcvariationClass;
ID EnsEQcvariationState
TY public
MO ensqcvariation
LB ensembl
XX
DE Ensembl Quality Check Variation State enumeration
XX
VN ensEQcvariationStateNULL
VD Null
VX
VN ensEQcvariationStateNone
VD None
VX
VN ensEQcvariationStateMatch
VD Match
VX
VN ensEQcvariationStateGap
VD Gap
VX
VN ensEQcvariationStateFrameshift
VD Frameshift
VX
VN ensEQcvariationState5ss
VD 5-prime Splice Site
VX
VN ensEQcvariationState3ss
VD 3-prime Splice Site
VX
VN EnsEQcvariationStateSplit
VD Split
VX
//
typedef enum EnsOQcvariationState
{
ensEQcvariationStateNULL,
ensEQcvariationStateNone,
ensEQcvariationStateMatch,
ensEQcvariationStateGap,
ensEQcvariationStateFrameshift,
ensEQcvariationState5ss,
ensEQcvariationState3ss,
EnsEQcvariationStateSplit
} EnsEQcvariationState;
ID EnsEQcvariationType
TY public
MO ensqcvariation
LB ensembl
XX
DE Ensembl Quality Check Variation Type enumeration
XX
VN ensEQcvariationTypeNULL
VD Null
VX
VN ensEQcvariationTypeNone
VD None
VX
VN ensEQcvariationTypeSingle
VD Single
VX
VN ensEQcvariationTypeMulti
VD Multi
VX
//
typedef enum EnsOQcvariationType
{
ensEQcvariationTypeNULL,
ensEQcvariationTypeNone,
ensEQcvariationTypeSingle,
ensEQcvariationTypeMulti
} EnsEQcvariationType;
ID EnsPQcvariation
TY public
MO ensqcvariation
LB ensembl
XX
DE Ensembl Quality Check Variation
XX
TN EnsSQcvariation
TD
TX
TN EnsOQcvariation
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPQcvariationadaptor
AD Ensembl Quality Check Variation Adaptor
AX
AN Analysis
AT EnsPAnalysis
AD Ensembl Analysis
AX
AN Qcalignment
AT EnsPQcalignment
AD Ensembl Quality Check Alignment
AX
AN QuerySequence
AT EnsPQcsequence
AD Query Ensembl Quality Check Sequence
AX
AN QueryStart
AT ajuint
AD Query start
AX
AN QueryEnd
AT ajuint
AD Query end
AX
AN QueryString
AT AjPStr
AD Query string
AX
AN TargetSequence
AT EnsPQcsequence
AD Target Ensembl Quality Check Sequence
AX
AN TargetStart
AT ajuint
AD Target start
AX
AN TargetEnd
AT ajuint
AD Target end
AX
AN TargetString
AT AjPStr
AD Target string
AX
AN Class
AT EnsEQcvariationClass
AD Class
AX
AN Type
AT EnsEQcvariationType
AD Type
AX
AN State
AT EnsEQcvariationState
AD State
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct EnsSQcvariation
{
ajuint Use;
ajuint Identifier;
EnsPQcvariationadaptor Adaptor;
EnsPAnalysis Analysis;
EnsPQcalignment Qcalignment;
EnsPQcsequence QuerySequence;
ajuint QueryStart;
ajuint QueryEnd;
AjPStr QueryString;
EnsPQcsequence TargetSequence;
ajuint TargetStart;
ajuint TargetEnd;
AjPStr TargetString;
EnsEQcvariationClass Class;
EnsEQcvariationType Type;
EnsEQcvariationState State;
char Padding[4];
} EnsOQcvariation;
#define EnsPQcvariation EnsOQcvariation*
ID EnsPRepeatconsensus
TY public
MO ensrepeat
LB ensembl
XX
DE Ensembl Repeat Consensus.
XX
TN EnsSRepeatconsensus
TD
TX
TN EnsORepeatconsensus
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD The SQL database-internal identifier
AX
AN Adaptor
AT EnsPRepeatconsensusadaptor
AD Ensembl Repeat Consensus Adaptor
AX
AN Name
AT AjPStr
AD Repeat Consensus name
AX
AN Class
AT AjPStr
AD Repeat Consensus class
AX
AN Type
AT AjPStr
AD Repeat Consensus type
AX
AN Consensus
AT AjPStr
AD Repeat Consensus sequence
AX
AN Length
AT ajuint
AD Repeat Consensus sequence length
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSRepeatconsensus
{
ajuint Use;
ajuint Identifier;
EnsPRepeatconsensusadaptor Adaptor;
AjPStr Name;
AjPStr Class;
AjPStr Type;
AjPStr Consensus;
ajuint Length;
ajuint Padding;
} EnsORepeatconsensus;
#define EnsPRepeatconsensus EnsORepeatconsensus*
ID EnsPRepeatfeature
TY public
MO ensrepeat
LB ensembl
XX
DE Ensembl Repeat Feature.
XX
TN EnsSRepeatfeature
TD
TX
TN EnsORepeatfeature
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD The SQL database-internal identifier
AX
AN Adaptor
AT EnsPRepeatfeatureadaptor
AD Ensembl Repeat Feature Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN Repeatconsensus
AT EnsPRepeatconsensus
AD Ensembl Repeat Consensus
AX
AN HitStart
AT ajint
AD The hit start on he consensus sequence
AX
AN HitEnd
AT ajint
AD The hit end on the consensus sequence
AX
AN Score
AT double
AD Score
AX
//
typedef struct EnsSRepeatfeature
{
ajuint Use;
ajuint Identifier;
EnsPRepeatfeatureadaptor Adaptor;
EnsPFeature Feature;
EnsPRepeatconsensus Repeatconsensus;
ajint HitStart;
ajint HitEnd;
double Score;
} EnsORepeatfeature;
#define EnsPRepeatfeature EnsORepeatfeature*
ID EnsPSequenceadaptor
TY public
MO enssequence
LB ensembl
XX
DE Ensembl Sequence Adaptor.
XX
TN EnsSSequenceadaptor
TD
TX
TN EnsOSequenceadaptor
TD
TX
AN Adaptor
AT EnsPDatabaseadaptor
AD Ensembl Database Adaptor.
AX
AN Cache
AT EnsPCache
AD Ensembl LRU Cache.
AX
//
typedef struct EnsSSequenceadaptor
{
EnsPDatabaseadaptor Adaptor;
EnsPCache Cache;
} EnsOSequenceadaptor;
#define EnsPSequenceadaptor EnsOSequenceadaptor*
ID EnsPSequenceedit
TY public
MO enssequenceedit
LB ensembl
XX
DE Ensembl Sequence Edit.
XX
TN EnsSSequenceedit
TD
TX
TN EnsOSequenceedit
TD
TX
AN Attribute
AT EnsPAttribute
AD Ensembl Attribute
AX
AN Sequence
AT AjPStr
AD Alternative sequence
AX
AN Start
AT ajuint
AD Start coordinate
AX
AN End
AT ajuint
AD End coordinate
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSSequenceedit
{
EnsPAttribute Attribute;
AjPStr Sequence;
ajuint Start;
ajuint End;
ajuint Use;
ajuint Padding;
} EnsOSequenceedit;
#define EnsPSequenceedit EnsOSequenceedit*
ID EnsPSimplefeature
TY public
MO enssimple
LB ensembl
XX
DE Ensembl Simple Feature.
XX
TN EnsSSimplefeature
TD
TX
TN EnsOSimplefeature
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPSimplefeatureadaptor
AD Ensembl Simple Feature Adaptor
AX
AN Feature
AT EnsPFeature
AD Ensembl Feature
AX
AN Displaylabel
AT AjPStr
AD Display label
AX
AN Score
AT double
AD Score
AX
//
typedef struct EnsSSimplefeature
{
ajuint Use;
ajuint Identifier;
EnsPSimplefeatureadaptor Adaptor;
EnsPFeature Feature;
AjPStr Displaylabel;
double Score;
} EnsOSimplefeature;
#define EnsPSimplefeature EnsOSimplefeature*
ID EnsERepeatMaskType
TY public
MO ensslice
LB ensembl
XX
DE Ensembl Repeat Mask Type enumeration
XX
VN ensERepeatMaskTypeNULL
VD Null
VX
VN ensERepeatMaskTypeNone
VD None
VX
VN ensERepeatMaskTypeSoft
VD Soft-masking
VX
VN ensERepeatMaskTypeHard
VD Hard-masking
VX
//
typedef enum EnsORepeatMaskType
{
ensERepeatMaskTypeNULL,
ensERepeatMaskTypeNone,
ensERepeatMaskTypeSoft,
ensERepeatMaskTypeHard
} EnsERepeatMaskType;
ID EnsPRepeatmaskedslice
TY public
MO ensslice
LB ensembl
XX
DE Ensembl Repeat-Masked Slice.
DE
DE Holds information about a masked genome sequence slice.
XX
TN EnsSRepeatmaskedslice
TD
TX
TN EnsORepeatmaskedslice
TD
TX
AN Slice
AT EnsPSlice
AD Ensembl Slice.
AX
AN Analysisnames
AT AjPList
AD AJAX List of AJAX String objects
AD (Ensembl Analysis names)
AX
AN Masking
AT AjPTable
AD AJAX Table of Repeat Consensus types, classes or
AD names and sequence masking types
AX
AN Use
AT ajuint
AD Use counter
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSRepeatmaskedslice
{
EnsPSlice Slice;
AjPList Analysisnames;
AjPTable Masking;
ajuint Use;
ajuint Padding;
} EnsORepeatmaskedslice;
#define EnsPRepeatmaskedslice EnsORepeatmaskedslice*
ID EnsEStorableType
TY public
MO ensstorable
LB ensembl
XX
DE Ensembl Storable Type enumeration
XX
VN ensEStorableTypeNULL
VD Null
VX
VN ensEStorableTypeAnalysis
VD Analysis
VX
VN ensEStorableTypeRepeatconsensus
VD Repeat consensus
VX
//
typedef enum EnsOStorableType
{
ensEStorableTypeNULL,
ensEStorableTypeAnalysis,
ensEStorableTypeRepeatconsensus
} EnsEStorableType;
ID EnsPStorable
TY public
MO ensstorable
LB ensembl
XX
DE Ensembl Storable.
XX
TN EnsSStorable
TD
TX
TN EnsOStorable
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD Internal SQL database identifier (primary key)
AX
AN Adaptor
AT void*
AD Ensembl Object Adaptor
AX
AN Type
AT EnsEStorableType
AD Ensembl Storable Object Type
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSStorable
{
ajuint Use;
ajuint Identifier;
void *Adaptor;
EnsEStorableType Type;
ajuint Padding;
} EnsOStorable;
#define EnsPStorable EnsOStorable*
ID EnsEGvconsequenceType
TY public
MO ensvariation
LB ensembl
XX
DE Ensembl Genetic Variation Consequence Type enumeration
XX
VN ensEGvconsequenceTypeNULL
VD Null
VX
VN ensEGvconsequenceTypeEssentialsplicesite
VD Essential splice site
VX
VN ensEGvconsequenceTypeStopgained
VD Stop codon gained
VX
VN ensEGvconsequenceTypeStoplost
VD Top codon lost
VX
VN ensEGvconsequenceTypeComplexindel
VD Complex insertion or deletion
VX
VN ensEGvconsequenceTypeFrameshiftcoding
VD Frameshift in coding sequence
VX
VN ensEGvconsequenceTypeSplicesite
VD Splice site
VX
VN ensEGvconsequenceTypePartialcodon
VD Partial codon
VX
VN ensEGvconsequenceTypeSynonymouscoding
VD Synonymous
VX
VN ensEGvconsequenceTypeRegulatoryregion
VD Regulatory region
VX
VN ensEGvconseqeunceTypeWithinmaturemirna
VD Within a mature miRNA
VX
VN ensEGvconsequenceType5primeutr
VD 5-prime untranslated region
VX
VN ensEGvconsequenceType3primeutr
VD 3-prime untranslated region
VX
VN ensEGvconsequenceTypeUtr
VD Untranslated region
VX
VN ensEGvconsequenceTypeIntronic
VD Intronic
VX
VN ensEGvconsequenceTypeNmdtranscript
VD Nonsense-mediated decay transcript
VX
VN ensEGvconsequenceTypeWithinnoncodinggene
VD Non-coding gene
VX
VN ensEGvconsequenceTypeUpstream
VD Upstream
VX
VN ensEGvconsequenceTypeDownstream
VD Downstream
VX
VN ensEGvconsequenceTypeHgmdmutation
VD HGMD Mutation
VX
VN ensEGvconsequenceTypeNoconsequence
VD No consequence
VX
VN ensEGvconsequenceTypeIntergenic
VD Intergenic
VX
VN ensEGvconsequenceType_
VD _
VX
//
typedef enum EnsOGvconsequenceType
{
ensEGvconsequenceTypeNULL,
ensEGvconsequenceTypeEssentialsplicesite,
ensEGvconsequenceTypeStopgained,
ensEGvconsequenceTypeStoplost,
ensEGvconsequenceTypeComplexindel,
ensEGvconsequenceTypeFrameshiftcoding,
ensEGvconsequenceTypeSplicesite,
ensEGvconsequenceTypePartialcodon,
ensEGvconsequenceTypeSynonymouscoding,
ensEGvconsequenceTypeRegulatoryregion,
ensEGvconseqeunceTypeWithinmaturemirna,
ensEGvconsequenceType5primeutr,
ensEGvconsequenceType3primeutr,
ensEGvconsequenceTypeUtr,
ensEGvconsequenceTypeIntronic,
ensEGvconsequenceTypeNmdtranscript,
ensEGvconsequenceTypeWithinnoncodinggene,
ensEGvconsequenceTypeUpstream,
ensEGvconsequenceTypeDownstream,
ensEGvconsequenceTypeHgmdmutation,
ensEGvconsequenceTypeNoconsequence,
ensEGvconsequenceTypeIntergenic,
ensEGvconsequenceType_
} EnsEGvconsequenceType;
ID EnsPGvconsequence
TY public
MO ensvariation
LB ensembl
XX
DE Ensembl Genetic Variation Consequence.
XX
TN EnsSGvconsequence
TD
TX
TN EnsOGvconsequence
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Transcriptidentifier
AT ajuint
AD Ensembl Transcript identifier
AX
AN Gvvariationfeatureidentifier
AT ajuint
AD Ensembl Genetic Variation
AD Variation Feature identifier
AX
AN Start
AT ajuint
AD Start
AX
AN End
AT ajuint
AD End
AX
AN Strand
AT ajuint
AD Strand
AX
AN Alleles
AT AjPList
AD AJAX List of AJAX String objects
AX
AN Types
AT AjPList
AD AJAX List of AJAX String objects
AX
//
typedef struct EnsSGvconsequence
{
ajuint Use;
ajuint Transcriptidentifier;
ajuint Gvvariationfeatureidentifier;
ajuint Start;
ajuint End;
ajuint Strand;
AjPList Alleles;
AjPList Types;
} EnsOGvconsequence;
#define EnsPGvconsequence EnsOGvconsequence*
ID EnsPGvtranscriptvariation
TY public
MO ensvariation
LB ensembl
XX
DE Ensembl Genetic Variation Transcript Variation.
XX
TN EnsSGvtranscriptvariation
TD
TX
TN EnsOGvtranscriptvariation
TD
TX
AN Use
AT ajuint
AD Use counter
AX
AN Identifier
AT ajuint
AD SQL database-internal identifier
AX
AN Adaptor
AT EnsPGvtranscriptvariationadaptor
AD Ensembl Genetic Variation Transcript Variation Adaptor
AX
AN Gvvariationfeature
AT EnsPGvvariationfeature
AD Ensembl Genetic Variation Variation Feature
AX
AN TranscriptObject
AT EnsPTranscript
AD Ensembl Transcript
AX
AN TranslationAllele
AT AjPStr
AD Ensembl Translation allele
AX
AN TranscriptStart
AT ajuint
AD Transcript start
AX
AN TranscriptEnd
AT ajuint
AD Transcript end
AX
AN CodingStart
AT ajuint
AD Coding start
AX
AN CodingEnd
AT ajuint
AD Coding end
AX
AN TranslationStart
AT ajuint
AD Translation start
AX
AN TranslationEnd
AT ajuint
AD Translation end
AX
AN GvconsequenceTypes
AT ajuint
AD Ensembl Genetic Variation Consequence Type
AD bit field
AX
AN Padding
AT ajuint
AD Padding to alignment boundary
AX
//
typedef struct EnsSGvtranscriptvariation
{
ajuint Use;
ajuint Identifier;
EnsPGvtranscriptvariationadaptor Adaptor;
EnsPGvvariationfeature Gvvariationfeature;
EnsPTranscript TranscriptObject;
AjPStr TranslationAllele;
ajuint TranscriptStart;
ajuint TranscriptEnd;
ajuint CodingStart;
ajuint CodingEnd;
ajuint TranslationStart;
ajuint TranslationEnd;
ajuint GvconsequenceTypes;
ajuint Padding;
} EnsOGvtranscriptvariation;
#define EnsPGvtranscriptvariation EnsOGvtranscriptvariation*
ID EmbPComTrace
TY public
MO embcom
LB nucleus
XX
DE Complex utility trace object
XX
AN ind
AT ajint
AD Index
AX
AN pc
AT float
AD Percent
AX
//
typedef struct EmbSComTrace {
ajint ind;
float pc;
} EmbOComTrace;
#define EmbPComTrace EmbOComTrace*
ID EmbPComUjwin
TY public
MO embcom
LB nucleus
XX
DE Complex utility UJwin object
XX
AN Ujwin
AT float*
AD UJ windows
AX
//
typedef struct EmbSComUjwin {
float *Ujwin;
} EmbOComUjwin;
#define EmbPComUjwin EmbOComUjwin*
ID EmbPComUjsim
TY public
MO embcom
LB nucleus
XX
DE Complex utility UJsim object
XX
AN Ujsim
AT EmbPComUjwin
AD UJ sim
AX
//
typedef struct EmbSComUjsim {
EmbPComUjwin Ujsim;
} EmbOComUjsim;
#define EmbPComUjsim EmbOComUjsim*
ID EmbPComSeqsim
TY public
MO embcom
LB nucleus
XX
DE Complex utility SEQsim object
XX
AN Sqsim
AT char*
AD Sequence sim
AX
//
typedef struct EmbSComSeqsim {
char *Sqsim;
} EmbOComSeqsim;
#define EmbPComSeqsim EmbOComSeqsim*
ID EmbPField
TY public
MO embdbi
LB nucleus
XX
DE NUCLEUS internal structure for database indexing applications
DE to store field tokens with links to the entry index number.
XX
AN field
AT char*
AD field token
AX
AN entry
AT char*
AD entry name
AX
AN nid
AT ajuint
AD entry number
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct EmbSField {
char* field;
char* entry;
ajuint nid;
char Padding[4];
} EmbOField;
#define EmbPField EmbOField*
ID EmbPEntry
TY public
MO embdbi
LB nucleus
XX
DE NUCLEUS internal structure for database indexing applications
DE to store an entry id with a list of field tokens and file
DE positions for writing to the index files.
XX
AN entry
AT char*
AD entry name
AX
AN filenum
AT ajuint
AD record in division file
AX
AN rpos
AT ajuint
AD entry offset in data file
AX
AN spos
AT ajuint
AD entry offset in sequence file
AX
AN nfields
AT ajuint
AD number of fields
AX
AN nfield
AT ajuint*
AD number of tokens for each field
AX
AN field
AT char***
AD array of tokens for each field
AX
//
typedef struct EmbSEntry {
char* entry;
ajuint filenum;
ajuint rpos;
ajuint spos;
ajuint nfields;
ajuint* nfield;
char*** field;
} EmbOEntry;
#define EmbPEntry EmbOEntry*
ID EmbPDmxNrseq
TY public
MO embdmx
LB nucleus
XX
DE NUCLEUS data structure for non-redundant sequence testing
XX
AN Seq
AT AjPSeq
AD Sequence to be tested for redundancy
AX
AN Garbage
AT AjBool
AD True if sequence is to be ignored
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct EmbSDmxNrseq {
AjPSeq Seq;
AjBool Garbage;
char Padding[4];
} EmbODmxNrseq;
#define EmbPDmxNrseq EmbODmxNrseq*
ID hash_list
TY public
MO embest
LB nucleus
XX
DE NUCLEUS internal data structure for est2genome EMBOSS application
DE to maintain internal hash lists.
XX
AN name
AT char*
AD Name
AX
AN offset
AT unsigned long
AD Offset
AX
AN text_offset
AT unsigned long
AD Text offset
AX
AN next
AT struct hash_list*
AD Next in list
AX
//
typedef struct hash_list
{
char *name;
unsigned long offset;
unsigned long text_offset;
struct hash_list *next;
}
HASH_LIST;
ID directions
TY public
MO embest
LB nucleus
XX
DE Path matrix cell type and direction
XX
VN INTRON
VD Intron
VX
VN DIAGONAL
VD Diagonal in path
VX
VN DELETE_EST
VD Delete in EST sequence
VX
VN DELETE_GENOME
VD Delete in genome sequence
VX
VN FORWARD_SPLICED_INTRON
VD Forward spliced intron
VX
VN REVERSE_SPLICED_INTRON
VD Reverse spliced intron
VX
//
typedef enum { INTRON=0, DIAGONAL=1, DELETE_EST=2, DELETE_GENOME=3,
FORWARD_SPLICED_INTRON=-1, REVERSE_SPLICED_INTRON=-2
} directions;
ID donor_acceptor
TY public
MO embest
LB nucleus
XX
DE Donors and acceptors for slice site junctions
XX
VN NOT_A_SITE
VD Not a splice site
VX
VN DONOR
VD Donor site
VX
VN ACCEPTOR
VD Acceptor site
VX
//
typedef enum { NOT_A_SITE=1, DONOR=2, ACCEPTOR=4 } donor_acceptor;
/* @data EmbPEstAlign *********************************************************
**
** NUCLEUS data structure for EST alignments (originally for est2genome)
**
** @attr gstart [ajint] Genomic start
** @attr estart [ajint] EST start
** @attr gstop [ajint] Genomic stop
** @attr estop [ajint] EST stop
** @attr score [ajint] Score
** @attr len [ajint] Length
** @attr align_path [ajint*] Path
** @@
******************************************************************************/
typedef struct EmbSEstAlign
{
ajint gstart;
ID EmbPEstAlign
TY public
MO embest
LB nucleus
XX
DE NUCLEUS data structure for EST alignments (originally for est2genome)
XX
AN gstart
AT ajint
AD Genomic start
AX
AN estart
AT ajint
AD EST start
AX
AN gstop
AT ajint
AD Genomic stop
AX
AN estop
AT ajint
AD EST stop
AX
AN score
AT ajint
AD Score
AX
AN len
AT ajint
AD Length
AX
AN align_path
AT ajint*
AD Path
AX
//
typedef struct EmbSEstAlign
{
ajint gstart;
ajint estart;
ajint gstop;
ajint estop;
ajint score;
ajint len;
ajint *align_path;
} EmbOEstAlign;
#define EmbPEstAlign EmbOEstAlign*
ID EmbPGroupProg
TY public
MO embgroup
LB nucleus
XX
DE Hold details of programs (names and documentation) and the package
DE they belong to.
XX
TN EmbOGroupProg
TD
TX
TN EmbSGroupProg
TD
TX
AN name
AT AjPStr
AD Name of group or of program
AX
AN doc
AT AjPStr
AD Documentation for this program
AX
AN keywords
AT AjPStr
AD keywords for this program
AX
AN package
AT AjPStr
AD EMBASSY package, empty for main package
AX
AN groups
AT AjPList
AD List of group(s) this program belongs to.
AX
AN acdtopics
AT AjPList
AD List of relation topic attributes
AX
AN acdoperations
AT AjPList
AD List of relation operation attributes
AX
AN acdinputs
AT AjPList
AD List of relation input attributes
AX
AN acdoutputs
AT AjPList
AD List of relation output attributes
AX
AN acdparams
AT AjPList
AD List of relation parameter attributes
AX
//
typedef struct EmbSGroupProg {
AjPStr name;
AjPStr doc;
AjPStr keywords;
AjPStr package;
AjPList groups;
AjPList acdtopics;
AjPList acdoperations;
AjPList acdinputs;
AjPList acdoutputs;
AjPList acdparams;
} EmbOGroupProg;
#define EmbPGroupProg EmbOGroupProg*
ID EmbPGroupRelation
TY public
MO embgroup
LB nucleus
XX
DE Hold details of relation attributes and the qualifiers they appear in.
XX
TN EmbOGroupRelation
TD
TX
TN EmbSGroupRelation
TD
TX
AN type
AT AjPStr
AD Type of qualifier
AX
AN qual
AT AjPStr
AD Name of qualifier
AX
AN acdgroup
AT AjPStr
AD ACD group for qualifier type
AX
AN id
AT AjPStr
AD EDAM term id
AX
AN namespace
AT AjPStr
AD EDAM namespace
AX
AN name
AT AjPStr
AD EDAM term name
AX
//
typedef struct EmbSGroupRelation {
AjPStr type;
AjPStr qual;
AjPStr acdgroup;
AjPStr id;
AjPStr namespace;
AjPStr name;
} EmbOGroupRelation;
#define EmbPGroupRelation EmbOGroupRelation*
ID EmbPGroupTop
TY public
MO embgroup
LB nucleus
XX
DE This serves as both a node in a list of names of groups which each hold
DE a list of details of programs (names and documentation) and also
DE it is a node in a list of the details of programs (names and documentation).
DE
DE Using the same structure for both is a bit confusing, but it simplifies
DE some of the routines which search and output the lists of gnodes of
DE groups and program data.
DE
DE GROUP LIST nodes point to PROGRAM LISTS
DE ---------- -------------
DE
DE group gnode -> program gnode - program gnode - program gnode - etc.
DE |
DE group gnode -> program gnode - program gnode - program gnode - etc.
DE |
DE etc.
DE
DE The layout of the 'alpha' list of alphabetic listing of applications is
DE a bit different - instead of applications being grouped, as in 'glist'
DE above, the applications all come under one major group and each
DE application holds a list of the groups it belongs to:
DE
DE ALPHA LIST
DE ----------
DE
DE group gnode -> program gnode -> group gnode - group gnode - etc.
DE |
DE program gnode -> group gnode - group gnode - group gnode - etc.
DE |
DE program gnode -> group gnode - group gnode - group gnode - etc.
DE |
DE program gnode -> group gnode - group gnode - group gnode - etc.
DE |
DE program gnode -> group gnode - group gnode - group gnode - etc.
DE |
DE etc.
XX
TN EmbOGroup
TD
TX
TN EmbSGroup
TD
TX
AN name
AT AjPStr
AD name of group or of program
AX
AN doc
AT AjPStr
AD documentation for this program (used by list of programs)
AX
AN progs
AT AjPList
AD list of programs in this group (used by groups list)
AX
//
typedef struct EmbSGroupTop {
AjPStr name;
AjPStr doc;
AjPList progs;
} EmbOGroupTop;
#define EmbPGroupTop EmbOGroupTop*
ID EmbPBtreeEntry
TY public
MO embindex
LB nucleus
XX
DE Index tree entries
XX
TN EmbOBtreeEntry
TD
TX
TN EmbSBtreeEntry
TD
TX
AN dbname
AT AjPStr
AD Database name
AX
AN dbrs
AT AjPStr
AD Index resource definition
AX
AN release
AT AjPStr
AD Release number
AX
AN date
AT AjPStr
AD Release date
AX
AN dbtype
AT AjPStr
AD Database type
AX
AN directory
AT AjPStr
AD Database directory
AX
AN idirectory
AT AjPStr
AD Index directory
AX
AN idextension
AT AjPStr
AD Id index extension
AX
AN maxid
AT AjPStr
AD Longest id in data
AX
AN files
AT AjPList
AD List of data filenames
AX
AN reffiles
AT AjPList*
AD Lists of data reference filenames
AX
AN fields
AT AjPList
AD EMBOSS index field structures
AX
AN id
AT AjPStr
AD Entry identifier
AX
AN idcache
AT AjPBtcache
AD Id cache structure
AX
AN pripagecount
AT ajlong
AD Cache primary page count
AX
AN secpagecount
AT ajlong
AD Cache secondary page count
AX
AN do_id
AT AjBool
AD If true, build id index
AX
AN compressed
AT AjBool
AD If true, compress id index
AX
AN nfiles
AT ajuint
AD Data file count
AX
AN refcount
AT ajuint
AD Reference file(s) for each entry
AX
AN idlen
AT ajuint
AD Maximum id length in index
AX
AN idmaxlen
AT ajuint
AD Maximum id length in data
AX
AN idtruncate
AT ajuint
AD Number of ids truncated
AX
AN pripagesize
AT ajuint
AD Default page size
AX
AN pricachesize
AT ajuint
AD Defalt cache size
AX
AN idorder
AT ajuint
AD Id index primary order
AX
AN idfill
AT ajuint
AD Id index primary fill count
AX
AN secpagesize
AT ajuint
AD Default page size
AX
AN seccachesize
AT ajuint
AD Defalt cache size
AX
AN idsecorder
AT ajuint
AD Id index secondary order
AX
AN idsecfill
AT ajuint
AD Id index secondary fill count
AX
AN fpos
AT ajlong
AD Input file position
AX
AN reffpos
AT ajlong*
AD Input extra (reference) file positions
AX
//
typedef struct EmbSBtreeEntry
{
AjPStr dbname;
AjPStr dbrs;
AjPStr release;
AjPStr date;
AjPStr dbtype;
AjPStr directory;
AjPStr idirectory;
AjPStr idextension;
AjPStr maxid;
AjPList files;
AjPList *reffiles;
AjPList fields;
AjPStr id;
AjPBtcache idcache;
ajlong pripagecount;
ajlong secpagecount;
AjBool do_id;
AjBool compressed;
ajuint nfiles;
ajuint refcount;
ajuint idlen;
ajuint idmaxlen;
ajuint idtruncate;
ajuint pripagesize;
ajuint pricachesize;
ajuint idorder;
ajuint idfill;
ajuint secpagesize;
ajuint seccachesize;
ajuint idsecorder;
ajuint idsecfill;
ajlong fpos;
ajlong *reffpos;
} EmbOBtreeEntry;
#define EmbPBtreeEntry EmbOBtreeEntry*
ID EmbPBtreeField
TY public
MO embindex
LB nucleus
XX
DE Index tree entries
XX
TN EmbSBtreeField
TD
TX
TN EmbOBtreeField
TD
TX
AN cache
AT AjPBtcache
AD Cache structure
AX
AN data
AT AjPList
AD Keywords to index
AX
AN name
AT AjPStr
AD File basename
AX
AN extension
AT AjPStr
AD File extension
AX
AN maxkey
AT AjPStr
AD Longest keyword found
AX
AN freelist
AT AjPStr*
AD Free data elements for reuse
AX
AN pripagecount
AT ajulong
AD Index primary page count
AX
AN secpagecount
AT ajulong
AD Index secondary page count
AX
AN pripagesize
AT ajuint
AD Index primary page size
AX
AN secpagesize
AT ajuint
AD Index secondary page size
AX
AN pricachesize
AT ajuint
AD Index primary cache size
AX
AN seccachesize
AT ajuint
AD Index secondary cache size
AX
AN order
AT ajuint
AD Primary page order
AX
AN fill
AT ajuint
AD Primary page fill count
AX
AN secorder
AT ajuint
AD Secondary page order
AX
AN secfill
AT ajuint
AD Secondary page fill count
AX
AN refcount
AT ajuint
AD Number of reference file(s) per entry
AX
AN len
AT ajuint
AD Maximum keyword length in index
AX
AN idlen
AT ajuint
AD Maximum id length in index
AX
AN maxlen
AT ajuint
AD Maximum keyword length in data
AX
AN truncate
AT ajuint
AD Number of keywords truncated
AX
AN freecount
AT ajuint
AD Free list used
AX
AN freesize
AT ajuint
AD Free list size
AX
AN secondary
AT AjBool
AD Secondary index if true
AX
AN compressed
AT AjBool
AD Compress index if true
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct EmbSBtreeField
{
AjPBtcache cache;
ID EmbPMatPrints
TY public
MO embmat
LB nucleus
XX
DE NUCLEUS data structure for PRINTS protein fingerprints
XX
AN cod
AT AjPStr
AD gc line
AX
AN acc
AT AjPStr
AD gx line
AX
AN tit
AT AjPStr
AD gt line
AX
AN len
AT ajuint*
AD Lengths of motifs
AX
AN thresh
AT ajuint*
AD % of maximum score for matrix
AX
AN max
AT ajuint*
AD Maximum score for matrix
AX
AN matrix
AT PMAT_INT*
AD Matrices
AX
AN n
AT ajuint
AD Number of motifs in fingerprint
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct EmbSMatPrints
{
AjPStr cod;
AjPStr acc;
AjPStr tit;
ajuint *len;
ajuint *thresh;
ajuint *max;
PMAT_INT *matrix;
ajuint n;
char Padding[4];
} EmbOMatPrint;
#define EmbPMatPrints EmbOMatPrint*
ID EmbPMatMatch
TY public
MO embmat
LB nucleus
XX
DE NUCLEUS data structure for sequence matrix matches
XX
AN seqname
AT AjPStr
AD Sequence name
AX
AN cod
AT AjPStr
AD Matrix name
AX
AN acc
AT AjPStr
AD Matrix accession number
AX
AN tit
AT AjPStr
AD Matrix title
AX
AN pat
AT AjPStr
AD Pattern
AX
AN n
AT ajuint
AD Number of motifs in fingerprint
AX
AN len
AT ajuint
AD Lengths of motifs
AX
AN thresh
AT ajuint
AD % of maximum score for matrix
AX
AN max
AT ajuint
AD Maximum score for matrix
AX
AN element
AT ajuint
AD Number of matching element
AX
AN start
AT ajuint
AD Start of match
AX
AN end
AT ajuint
AD End of match
AX
AN score
AT ajuint
AD Score of match
AX
AN hpe
AT ajuint
AD Hits per element (so far)
AX
AN hpm
AT ajuint
AD Hits per motif (so far)
AX
AN all
AT AjBool
AD Can be set if all elements match
AX
AN ordered
AT AjBool
AD Can be set if "all" and in order
AX
AN forward
AT AjBool
AD on forward strand
AX
AN mm
AT ajuint
AD Number of mismatches
AX
AN cut1
AT ajint
AD Undocumented
AX
AN cut2
AT ajint
AD Undocumented
AX
AN cut3
AT ajint
AD Undocumented
AX
AN cut4
AT ajint
AD Undocumented
AX
AN circ12
AT AjBool
AD Circular for cut1 and/or cut2
AX
AN circ34
AT AjBool
AD Circular for cut3 and/or cut4
AX
AN iso
AT AjPStr
AD Holds names of isoschizomers
AX
//
typedef struct EmbSMatMatch
{
AjPStr seqname;
AjPStr cod;
AjPStr acc;
AjPStr tit;
AjPStr pat;
ajuint n;
ajuint len;
ajuint thresh;
ajuint max;
ajuint element;
ajuint start;
ajuint end;
ajuint score;
ajuint hpe;
ajuint hpm;
AjBool all;
AjBool ordered;
AjBool forward;
ajuint mm;
ajint cut1;
ajint cut2;
ajint cut3;
ajint cut4;
AjBool circ12;
AjBool circ34;
AjPStr iso;
} EmbOMatMatch;
#define EmbPMatMatch EmbOMatMatch*
ID EmbPMolFrag
TY public
MO embmol
LB nucleus
XX
DE Nucleus sequence molecular fragment object.
XX
AN begin
AT ajint
AD Start
AX
AN end
AT ajint
AD End
AX
AN mwt
AT double
AD Molecular weight
AX
//
typedef struct EmbSMolFrag
{
ajint begin;
ajint end;
double mwt;
} EmbOMolFrag;
#define EmbPMolFrag EmbOMolFrag*
ID EmbPPatMatch
TY public
MO embpat
LB nucleus
XX
DE NUCLEUS data structure for pattern matches
XX
AN start
AT ajuint*
AD Match start positions
AX
AN len
AT ajuint*
AD Match lengths
AX
AN number
AT ajuint
AD Number of matches
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct EmbSPatMatch {
ajuint *start;
ajuint *len;
ajuint number;
char Padding[4];
} EmbOPatMatch;
#define EmbPPatMatch EmbOPatMatch*
ID EmbPPatRestrict
TY public
MO embpat
LB nucleus
XX
DE NUCLEUS data structure for pattern matches
XX
AN cod
AT AjPStr
AD Restriction Enzyme name
AX
AN pat
AT AjPStr
AD Recognition site
AX
AN bin
AT AjPStr
AD Binary converted site
AX
AN len
AT ajuint
AD Pattern length
AX
AN blunt
AT AjBool
AD Blunt true, sticky false
AX
AN cut1
AT ajint
AD First 3' cut
AX
AN cut2
AT ajint
AD First 5' cut
AX
AN cut3
AT ajint
AD Second 3' cut
AX
AN cut4
AT ajint
AD Second 5' cut
AX
AN org
AT AjPStr
AD Organism
AX
AN iso
AT AjPStr
AD Isoschizomers
AX
AN meth
AT AjPStr
AD Methylation
AX
AN sou
AT AjPStr
AD Source
AX
AN sup
AT AjPStr
AD Suppliers
AX
AN ncuts
AT ajuint
AD Number of cuts
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct EmbSPatRestrict
{
AjPStr cod;
AjPStr pat;
AjPStr bin;
ajuint len;
AjBool blunt;
ajint cut1;
ajint cut2;
ajint cut3;
ajint cut4;
AjPStr org;
AjPStr iso;
AjPStr meth;
AjPStr sou;
AjPStr sup;
ajuint ncuts;
char Padding[4];
} EmbOPatRestrict;
#define EmbPPatRestrict EmbOPatRestrict*
ID EmbPPropAmino
TY public
MO embprop
LB nucleus
XX
DE Amino acid properties
XX
AN tiny
AT ajint
AD tiny
AX
AN sm_all
AT ajint
AD small
AX
AN aliphatic
AT ajint
AD aliphatic
AX
AN aromatic
AT ajint
AD aromatic
AX
AN nonpolar
AT ajint
AD non-polar
AX
AN polar
AT ajint
AD polar
AX
AN charge
AT float
AD charge
AX
AN pve
AT ajint
AD positive
AX
AN nve
AT ajint
AD negative
AX
AN extcoeff
AT ajint
AD extinction coefficient
AX
AN Padding
AT char[4]
AD padding to alignment boundary
AX
//
typedef struct EmbSPropAmino
{
ajint tiny;
ajint sm_all;
ajint aliphatic;
ajint aromatic;
ajint nonpolar;
ajint polar;
float charge;
ajint pve;
ajint nve;
ajint extcoeff;
char Padding[4];
} EmbOPropAmino;
#define EmbPPropAmino EmbOPropAmino*
ID EmbPPropMolwt
TY public
MO embprop
LB nucleus
XX
DE Molecular weights
XX
AN average
AT double
AD average molwt
AX
AN mono
AT double
AD monoisotopic molwt
AX
//
typedef struct EmbSPropMolwt
{
double average;
double mono;
} EmbOPropMolwt;
#define EmbPPropMolwt EmbOPropMolwt*
ID ShowEValtype
TY public
MO embshow
LB nucleus
XX
DE Descriptor object types
XX
VN SH_SEQ
VD Sequence
VX
VN SH_BLANK
VD Blank line
VX
VN SH_TICK
VD Tick marks
VX
VN SH_TICKNUM
VD Tick numbers
VX
VN SH_COMP
VD Complementary strand
VX
VN SH_TRAN
VD Protein translation
VX
VN SH_RE
VD Restriction enzyme cut sites
VX
VN SH_FT
VD Features
VX
VN SH_NOTE
VD Notes
VX
//
typedef enum
{
SH_SEQ,
SH_BLANK,
SH_TICK,
SH_TICKNUM,
SH_COMP,
SH_TRAN,
SH_RE,
SH_FT,
SH_NOTE
} ShowEValtype;
ID EmbPShow
TY public
MO embshow
LB nucleus
XX
DE NUCLEUS data structure for EmbPShow object for a sequence
XX
AN list
AT AjPList
AD list of EmbPShowInfo structures
AX
AN seq
AT const AjPSeq
AD the sequence
AX
AN nucleic
AT AjBool
AD ajTrue = the sequence is nucleic
AX
AN offset
AT ajuint
AD offset to start numbering at
AX
AN start
AT ajuint
AD sequence position to start printing at
AX
AN end
AT ajuint
AD sequence position to stop printing at
AX
AN width
AT ajuint
AD width of sequence to display on each line
AX
AN length
AT ajuint
AD length of a page (0 = indefinite)
AX
AN margin
AT ajuint
AD margin for numbers
AX
AN html
AT AjBool
AD ajTrue = format page for HTML
AX
//
typedef struct EmbSShow {
AjPList list;
const AjPSeq seq;
AjBool nucleic;
ajuint offset;
ajuint start;
ajuint end;
ajuint width;
ajuint length;
ajuint margin;
AjBool html;
} EmbOShow;
#define EmbPShow EmbOShow*
ID EmbPShowInfo
TY public
MO embshow
LB nucleus
XX
DE The sequence and associated things to show are held in an ordered list
DE of type EmbPShowInfo. This list is held in the structure EmbPShow.
DE
DE The things to show are displayed around the sequence in the order that
DE they are held on the list.
DE
DE EmbPShowInfo holds the descriptor (one of EmbPShowBlank, EmbPShowTicks,
DE EmbPShowSeq, EmbPShowComp, etc.) and the type of the descriptor (one of
DE SH_BLANK, SH_TICKS, SH_SEQ, SH_COMP, etc. )
DE
DE Each descriptor (EmbPShowSeq, EmbPShowBlank, EmbPShowTicks, etc.) holds
DE information that could be useful in displaying its type of information.
DE
DE So, for example:
DE
DE EmbPShow could have a list of:
DE ----------------------------
DE
DE EmbPShowInfo->type=SH_BLANK
DE | ->info=EmbPShowBlank
DE |
DE EmbPShowInfo->type=SH_TICKS
DE | ->info=EmbPShowTicks
DE |
DE EmbPShowInfo->type=SH_SEQ
DE | ->info=EmbPShowSeq
DE |
DE EmbPShowInfo->type=SH_COMP
DE | ->info=EmbPShowComp
DE |
DE EmbPShowInfo->type=etc.
DE | ->info=etc.
DE |
DE etc.
XX
AN info
AT void*
AD Information descriptor (set of available descriptors)
AX
AN type
AT ajint
AD Type of information (enumerated list)
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct EmbSShowInfo {
void * info;
ajint type;
char Padding[4];
} EmbOShowInfo;
#define EmbPShowInfo EmbOShowInfo*
ID EmbPShowSeq
TY public
MO embshow
LB nucleus
XX
DE NUCLEUS data structure for sequence information, type = SH_SEQ
XX
AN number
AT AjBool
AD ajTrue = number the sequence
AX
AN threeletter
AT AjBool
AD ajTrue = display proteins in three letter code
AX
AN upperrange
AT const AjPRange
AD range of sequence to uppercase
AX
AN highlight
AT const AjPRange
AD range of sequence to colour in HTML
AX
//
typedef struct EmbSShowSeq {
AjBool number;
AjBool threeletter;
const AjPRange upperrange;
const AjPRange highlight;
} EmbOShowSeq;
#define EmbPShowSeq EmbOShowSeq*
ID EmbPShowBlank
TY public
MO embshow
LB nucleus
XX
DE NUCLEUS data structure for blank line information, type = SH_BLANK
XX
AN dummy
AT AjBool
AD Dummy attribute - no specific information needed
AD AJNEW0() falls over if 0 bytes are allocated, so
AD put in this dummy to pad the structure out
AX
//
typedef struct EmbSShowBlank {
AjBool dummy;
} EmbOShowBlank;
#define EmbPShowBlank EmbOShowBlank*
ID EmbPShowTicks
TY public
MO embshow
LB nucleus
XX
DE NUCLEUS data structure for tick line information, type = SH_TICK
XX
AN dummy
AT AjBool
AD Dummy attribute - no specific information needed
AD AJNEW0() falls over if 0 bytes are allocated, so
AD put in this dummy to pad the structure out
AX
//
typedef struct EmbSShowTicks {
AjBool dummy;
} EmbOShowTicks;
#define EmbPShowTicks EmbOShowTicks*
ID EmbPShowTicknum
TY public
MO embshow
LB nucleus
XX
DE NUCLEUS data structure for tick number line information, type = SH_TICKNUM
XX
AN dummy
AT AjBool
AD Dummy attribute - no specific information needed
AD AJNEW0() falls over if 0 bytes are allocated, so
AD put in this dummy to pad the structure out
AX
//
typedef struct EmbSShowTicknum {
AjBool dummy;
} EmbOShowTicknum;
#define EmbPShowTicknum EmbOShowTicknum*
ID EmbPShowTran
TY public
MO embshow
LB nucleus
XX
DE NUCLEUS data structure for translation information, type = SH_TRAN
XX
AN transeq
AT AjPSeq
AD Copy of our stored translation
AX
AN trnTable
AT const AjPTrn
AD translation table
AX
AN frame
AT ajint
AD 1,2,3,-1,-2 or -3 = frame to translate
AX
AN threeletter
AT AjBool
AD ajTrue = display in three letter code
AX
AN number
AT AjBool
AD ajTrue = number the translation
AX
AN tranpos
AT ajuint
AD store of translation position for numbering
AX
AN regions
AT const AjPRange
AD only translate in these regions,
AD NULL = do all
AX
AN orfminsize
AT ajuint
AD minimum size of ORF to display
AX
AN lcinterorf
AT AjBool
AD ajTrue = put the inter-orf regions in lower case
AX
AN firstorf
AT AjBool
AD ajTrue = beginning of the seq is a possible ORF
AX
AN lastorf
AT AjBool
AD ajTrue = end of the seq is a possible ORF
AX
AN showframe
AT AjBool
AD ajTrue = write the frame number
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct EmbSShowTran {
AjPSeq transeq;
const AjPTrn trnTable;
ajint frame;
AjBool threeletter;
AjBool number;
ajuint tranpos;
const AjPRange regions;
ajuint orfminsize;
AjBool lcinterorf;
AjBool firstorf;
AjBool lastorf;
AjBool showframe;
char Padding[4];
} EmbOShowTran;
#define EmbPShowTran EmbOShowTran*
ID EmbPShowComp
TY public
MO embshow
LB nucleus
XX
DE NUCLEUS data structure for sequence complement information, type = SH_COMP
XX
AN number
AT AjBool
AD ajTrue = number the complement
AX
//
typedef struct EmbSShowComp {
AjBool number;
} EmbOShowComp;
#define EmbPShowComp EmbOShowComp*
ID EmbPShowRE
TY public
MO embshow
LB nucleus
XX
DE NUCLEUS data structure for RE cut site information, type = SH_RE
XX
AN sense
AT ajint
AD 1 or -1 = sense to display
AX
AN flat
AT AjBool
AD ajTrue = display in flat format with recognition sites
AX
AN matches
AT AjPList
AD list of AjPMatmatch matches
AX
AN plasmid
AT AjBool
AD ajTrue = Circular (plasmid) sequence. Needed so
AD that when we display sequences we can decide whether
AD to show cuts that go past the origin in either
AD direction
AX
AN hits
AT ajuint
AD number of hits in list
AX
AN sitelist
AT AjPList
AD list of EmbSShowREsite
AX
//
typedef struct EmbSShowRE {
ajint sense;
AjBool flat;
AjPList matches;
AjBool plasmid;
ajuint hits;
AjPList sitelist;
} EmbOShowRE;
#define EmbPShowRE EmbOShowRE*
ID EmbPShowFT
TY public
MO embshow
LB nucleus
XX
DE NUCLEUS data structure for Feature information, type = SH_FT
XX
AN feat
AT AjPFeattable
AD Feature table
AX
//
typedef struct EmbSShowFT {
AjPFeattable feat;
} EmbOShowFT;
#define EmbPShowFT EmbOShowFT*
ID EmbPShowNote
TY public
MO embshow
LB nucleus
XX
DE NUCLEUS data structure for annotation information, type = SH_NOTE
XX
AN regions
AT const AjPRange
AD regions to annotate, NULL = no regions
AX
//
typedef struct EmbSShowNote {
const AjPRange regions;
} EmbOShowNote;
#define EmbPShowNote EmbOShowNote*
ID EmbPShowREsite
TY public
MO embshow
LB nucleus
XX
DE NUCLEUS data structure for Restriction Enzyme cut site position list node
XX
AN name
AT AjPStr
AD name of Restriction Enzyme
AX
AN pos
AT ajint
AD cut site position
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct EmbSShowREsite {
AjPStr name;
ajint pos;
char Padding[4];
} EmbOShowREsite;
#define EmbPShowREsite EmbOShowREsite*
ID EmbESignatureType
TY public
MO embsig
LB nucleus
XX
DE NUCLEUS Signature Type enumeration
XX
VN embESignatureTypeNULL
VD NULL
VX
VN embESignatureTypeCATH
VD CATH for domain signatures
VX
VN embESignatureTypeSCOP
VD SCOP for domain signatures
VX
VN embESignatureTypeLIGAND
VD Ligand for ligand signatures
VX
//
typedef enum EmbOSignatureType
{
embESignatureTypeNULL,
embESignatureTypeCATH,
embESignatureTypeSCOP,
embESignatureTypeLIGAND
} EmbESignatureType;
ID EmbESignatureTypesig
TY public
MO embsig
LB nucleus
XX
DE NUCLEUS Signature Type enumeration
XX
VN embESignatureTypesigNULL
VD NULL
VX
VN embESignatureTypesig1D
VD 1D
VX
VN embESignatureTypesig3D
VD 3D
VX
//
typedef enum EmbOSignatureTypesig
{
embESignatureTypesigNULL,
embESignatureTypesig1D,
embESignatureTypesig3D
} EmbESignatureTypesig;
ID EmbPSigpos
TY public
MO embsig
LB nucleus
XX
DE Nucleus Sigpos object.
DE
DE Holds data for compiled signature position
DE
DE EmbPSigpos is implemented as a pointer to a C data structure.
XX
TN EmbSSigpos
TD
TX
TN EmbOSigpos
TD
TX
AN gsiz
AT ajuint*
AD Gap sizes
AX
AN gpen
AT float*
AD Gap penalties
AX
AN subs
AT float*
AD Residue match values
AX
AN ngaps
AT ajuint
AD No. of gaps
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
NN embSigposNew
ND Default Sigdat object constructor
NX
DN embSigposDel
DD Default Sigdat object destructor
DX
//
typedef struct EmbSSigpos
{
ajuint *gsiz;
float *gpen;
float *subs;
ajuint ngaps;
char Padding[4];
} EmbOSigpos;
#define EmbPSigpos EmbOSigpos*
ID EmbPSigdat
TY public
MO embsig
LB nucleus
XX
DE Nucleus Sigdat object.
DE
DE Holds empirical data for an (uncompiled) signature position.
DE Important: Functions which manipulate this structure rely on the data in
DE the gap arrays (gsiz and grfq) being filled in order of increasing gap
DE size.
DE
DE EmbPSigdat is implemented as a pointer to a C data structure.
XX
TN EmbSSigdat
TD
TX
TN EmbOSigdat
TD
TX
AN rids
AT AjPChar
AD Residue id's
AX
AN rfrq
AT AjPUint
AD Residue frequencies
AX
AN nres
AT ajuint
AD No. diff. types of residue
AX
AN nenv
AT ajuint
AD No. diff. types of environment
AX
AN eids
AT AjPStr*
AD Environment id's
AX
AN efrq
AT AjPUint
AD Environment frequencies
AX
AN gsiz
AT AjPUint
AD Gap sizes
AX
AN gfrq
AT AjPUint
AD Frequencies of gaps of each size
AX
AN ngap
AT ajuint
AD No. diff. sizes of empirical gap
AX
AN wsiz
AT ajuint
AD Window size for this gap
AX
NN embSigdatNew
ND Default Sigdat object constructor
NX
DN embSigdatDel
DD Default Sigdat object destructor
DX
//
typedef struct EmbSSigdat
{
AjPChar rids;
AjPUint rfrq;
ajuint nres;
ajuint nenv;
AjPStr *eids;
AjPUint efrq;
AjPUint gsiz;
AjPUint gfrq;
ajuint ngap;
ajuint wsiz;
} EmbOSigdat;
#define EmbPSigdat EmbOSigdat*
ID EmbPSignature
TY public
MO embsig
LB nucleus
XX
DE Nucleus Signature object.
DE
DE EmbPSignature is implemented as a pointer to a C data structure.
XX
TN EmbSSignature
TD
TX
TN EmbOSignature
TD
TX
AN Type
AT EmbESignatureType
AD NUCLEUS Signature Type enumeration
AX
AN Typesig
AT EmbESignatureTypesig
AD NUCLEUS Signature Typesig enumeration
AD for sequence or structure-based signatures respectively.
AX
AN Class
AT AjPStr
AD SCOP classification.
AX
AN Architecture
AT AjPStr
AD CATH classification.
AX
AN Topology
AT AjPStr
AD CATH classification.
AX
AN Fold
AT AjPStr
AD SCOP classification.
AX
AN Superfamily
AT AjPStr
AD SCOP classification.
AX
AN Family
AT AjPStr
AD SCOP classification.
AX
AN Sunid_Family
AT ajuint
AD SCOP sunid for family.
AX
AN npos
AT ajuint
AD No. of signature positions.
AX
AN pos
AT EmbPSigpos*
AD Array of derived data for puropses of
AD alignment.
AX
AN dat
AT EmbPSigdat*
AD Array of empirical data.
AX
AN Id
AT AjPStr
AD Protein id code.
AX
AN Domid
AT AjPStr
AD Domain id code.
AX
AN Ligid
AT AjPStr
AD Ligand id code.
AX
AN Desc
AT AjPStr
AD Description of ligand (ajLIGAND only)
AX
AN ns
AT ajuint
AD No. of sites (ajLIGAND only)
AX
AN sn
AT ajuint
AD Site number (ajLIGAND only)
AX
AN np
AT ajuint
AD No. of patches (ajLIGAND only)
AX
AN pn
AT ajuint
AD Patch number (ajLIGAND only)
AX
AN minpatch
AT ajuint
AD Max. patch size (residues) (ajLIGAND only)
AX
AN maxgap
AT ajuint
AD Min. gap distance (residues) (ajLIGAND only)
AX
NN embSignatureNew
ND Default Signature constructor
NX
DN embSignatureDel
DD Default Signature destructor
DX
PN embSignatureWrite
PD Write signature to file.
PX
JN embSignatureReadNew
JD Construct a Signature object from reading a
JD file in embl-like format (see documentation for the DOMAINATRIX
JD "sigscan" application).
JX
PN embSignatureWrite
PD Write a Signature object to a file in embl-like
PD format (see documentation for the DOMAINATRIX "sigscan"
PD application).
PX
JN embSignatureHitsRead
JD Construct a Hitlist object from reading a
JD signature hits file (see documentation for the DOMAINATRIX
JD "sigscan" application).
JX
PN embSignatureHitsWrite
PD Writes a list of Hit objects to a
PD signature hits file (see documentation for the DOMAINATRIX
PD "sigscan" application).
PX
MN embSignatureCompile
MD Compiles a Signature object. The signature
MD must first have been allocated by using the embSignatureNew
MD function.
MX
ON embSignatureAlignSeq
OD Performs an alignment of a signature to a
OD protein sequence. The signature must have first been compiled by
OD calling embSignatureCompile. Write a Hit object with the result.
OX
ON embSignatureAlignSeqall
OD Performs an alignment of a signature to
OD protein sequences. The signature must have first been compiled by
OD calling embSignatureCompile. Write a list of Hit objects with
OD the result.
OX
//
typedef struct EmbSSignature
{
EmbESignatureType Type;
EmbESignatureTypesig Typesig;
AjPStr Class;
AjPStr Architecture;
AjPStr Topology;
AjPStr Fold;
AjPStr Superfamily;
AjPStr Family;
ajuint Sunid_Family;
ajuint npos;
EmbPSigpos *pos;
EmbPSigdat *dat;
AjPStr Id;
AjPStr Domid;
AjPStr Ligid;
AjPStr Desc;
ajuint ns;
ajuint sn;
ajuint np;
ajuint pn;
ajuint minpatch;
ajuint maxgap;
} EmbOSignature;
#define EmbPSignature EmbOSignature*
ID EmbPHit
TY public
MO embsig
LB nucleus
XX
DE Nucleus hit object.
DE
DE Holds data associated with a protein / domain sequence that is generated
DE and or manipulated by the EMBOSS applications seqsearch, seqsort, and
DE sigscan.
DE
DE EmbPHit is implemented as a pointer to a C data structure.
XX
TN EmbSHit
TD
TX
TN EmbOHit
TD
TX
AN Seq
AT AjPStr
AD Sequence as string.
AX
AN Start
AT ajuint
AD Start of sequence or signature alignment relative
AD to full length swissprot sequence, this is an
AD index so starts at 0.
AX
AN End
AT ajuint
AD End of sequence or signature alignment relative
AD to full length swissprot sequence, this is an
AD index so starts at 0.
AX
AN Acc
AT AjPStr
AD Accession number of sequence entry.
AX
AN Spr
AT AjPStr
AD Swissprot code of sequence entry.
AX
AN Dom
AT AjPStr
AD SCOP or CATH database identifier code of entry.
AX
AN Rank
AT ajuint
AD Rank order of hit
AX
AN Score
AT float
AD Score of hit
AX
AN Eval
AT float
AD E-value of hit
AX
AN Pval
AT float
AD p-value of hit
AX
AN Typeobj
AT AjPStr
AD Primary (objective) classification of hit.
AX
AN Typesbj
AT AjPStr
AD Secondary (subjective) classification of hit
AX
AN Model
AT AjPStr
AD String for model type if used, one of
AD PSIBLAST, HMMER, SAM, SPARSE, HENIKOFF or GRIBSKOV
AX
AN Alg
AT AjPStr
AD Alignment, e.g. of a signature to the sequence
AX
AN Group
AT AjPStr
AD Grouping of hit, e.g. 'REDUNDANT' or
AD 'NON_REDUNDANT'
AX
AN Target
AT AjBool
AD Used for garbage collection.
AX
AN Target2
AT AjBool
AD Also used for garbage collection.
AX
AN Sig
AT EmbPSignature
AD Pointer to signature object for which hit
AX
AN Priority
AT AjBool
AD Also used for garbage collection.
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AD was generated. Used as a pointer only - memory is never freed or allocated
AD to it.
AX
NN embHitNew
ND Default Hit constructor
NX
NN embHitReadFasta
ND Construct Hit object from reading the next entry
ND from a file in extended FASTA format (see documentation for the
ND DOMAINATRIX "seqsearch" application).
NX
DN embHitDel
DD Default Hit destructor
DX
EN embHitMerge
ED Create new Hit from merging two Hit objects
EX
ON embMatchScore
OD Sort Hit objects by Score element.
OX
ON embMatchinvScore
OD Sort (inverted order) Hit objects by Score
OD element.
OX
ON embMatchLigid
OD Sort Hit objects by Ligid element in Sig element.
OX
ON embMatch
OD Sort Hit objects by Ligid element in Sig element.
OX
ON embHitsOverlap
OD Checks for overlap between two Hit objects.
OX
//
typedef struct EmbSHit
{
AjPStr Seq;
ajuint Start;
ajuint End;
AjPStr Acc;
AjPStr Spr;
AjPStr Dom;
ajuint Rank;
float Score;
float Eval;
float Pval;
AjPStr Typeobj;
AjPStr Typesbj;
AjPStr Model;
AjPStr Alg;
AjPStr Group;
AjBool Target;
AjBool Target2;
EmbPSignature Sig;
AjBool Priority;
char Padding[4];
} EmbOHit;
#define EmbPHit EmbOHit*
ID EmbPHitlist
TY public
MO embsig
LB nucleus
XX
DE Nucleus hitlist object.
DE
DE Holds an array of hit structures and associated SCOP classification
DE records.
DE
DE EmbPHitlist is implemented as a pointer to a C data structure.
XX
TN EmbSHitlist
TD
TX
TN EmbOHitlist
TD
TX
AN Class
AT AjPStr
AD SCOP classification.
AX
AN Architecture
AT AjPStr
AD CATH classification.
AX
AN Topology
AT AjPStr
AD CATH classification.
AX
AN Fold
AT AjPStr
AD SCOP classification.
AX
AN Superfamily
AT AjPStr
AD SCOP classification.
AX
AN Family
AT AjPStr
AD SCOP classification.
AX
AN Model
AT AjPStr
AD SCOP classification.
AX
AN Sunid_Family
AT ajuint
AD SCOP sunid for family.
AX
AN Priority
AT AjBool
AD True if the Hitlist is high priority.
AX
AN hits
AT EmbPHit*
AD Array of hits.
AX
AN Type
AT EmbESignatureType
AD NUCLEUS Signature Type enumeration
AX
AN N
AT ajuint
AD No. of hits.
AX
NN embHitlistNew
ND Default Hitlist constructor
NX
DN embHitlistDel
DD Default Hitlist destructor
DX
ON embHitlistMatchFold
OD Sort Hitlist objects by Fold element
OX
JN embHitlistRead
JD Construct Hitlist object from reading the next entry
JD from a file in embl-like format (see documentation for the
JD DOMAINATRIX "seqsearch" application).
JX
NN embHitlistReadFasta
ND Construct Hitlist object from reading
ND the next entry
ND from a file in extended FASTA format (see documentation for the
ND DOMAINATRIX "seqsearch" application).
NX
JN embHitlistReadNode
JD Construct Hitlist object from reading a specific
JD entry from a file in embl-like format (see documentation for the
JD DOMAINATRIX "seqsearch" application).
JX
NN embHitlistReadNodeFasta
ND Construct Hitlist object from reading
ND a specific entry from a file in extended FASTA format
ND (see documentation for the DOMAINATRIX "seqsearch" application).
NX
PN embHitlistWrite
PD Write Hitlist to file in embl-like format (see
PD documentation for the DOMAINATRIX "seqsearch" application).
PX
PN embHitlistWriteSubset
PD Write a subset of a Hitlist to file in
PD embl-like format (see documentation for the DOMAINATRIX "seqsearch"
PD application).
PX
PN embHitlistWriteFasta
PD Write Hitlist to file in extended FASTA format
PD (see documentation for the DOMAINATRIX "seqsearch" application).
PX
PN embHitlistWriteSubsetFasta
PD Write a subset of a Hitlist to file in
PD extended FASTA format (see documentation for the DOMAINATRIX
PD "seqsearch" application).
PX
PN embHitlistWriteHitFasta
PD Write a single Hit from a Hitlist to file
PD in extended FASTA format (see documentation for the DOMAINATRIX
PD "seqsearch" application).
PX
ON embHitlistClassify
OD Classifies a list of signature-sequence hits
OD (held in a Hitlist object) according to list of target sequences
OD (a list of Hitlist objects).
OX
//
typedef struct EmbSHitlist
{
AjPStr Class;
AjPStr Architecture;
AjPStr Topology;
AjPStr Fold;
AjPStr Superfamily;
AjPStr Family;
AjPStr Model;
ajuint Sunid_Family;
AjBool Priority;
EmbPHit *hits;
EmbESignatureType Type;
ajuint N;
} EmbOHitlist;
#define EmbPHitlist EmbOHitlist*
ID EmbPWordMatch
TY public
MO embword
LB nucleus
XX
DE NUCLEUS data structure for word matches
XX
AN seq1start
AT ajuint
AD match start point in original sequence
AX
AN seq2start
AT ajuint
AD match start point in comparison sequence
AX
AN sequence
AT const AjPSeq
AD need in case we build multiple matches here
AD so we know which one the match belongs to
AX
AN length
AT ajint
AD length of match
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct EmbSWordMatch {
ajuint seq1start;
ajuint seq2start;
const AjPSeq sequence;
ajint length;
char Padding[4];
} EmbOWordMatch;
#define EmbPWordMatch EmbOWordMatch*
ID EmbPWord
TY public
MO embword
LB nucleus
XX
DE NUCLEUS data structure for words
XX
AN fword
AT const char*
AD Original word
AX
AN seqlocs
AT AjPTable
AD Table of word start positions in multiple sequences
AX
AN count
AT ajint
AD Total number of locations in all sequences
AX
AN Padding
AT char[4]
AD Padding to alignment boundary
AX
//
typedef struct EmbSWord {
const char *fword;
AjPTable seqlocs;
ajint count;
char Padding[4];
} EmbOWord;
#define EmbPWord EmbOWord*
ID EmbPWordSeqLocs
TY public
MO embword
LB nucleus
XX
DE NUCLEUS data structure for word locations in a given sequence
XX
AN seq
AT const AjPSeq
AD Sequence for word start positions
AX
AN locs
AT AjPList
AD List of word start positions in the sequence
AX
//
typedef struct EmbSWordSeqLocs {
const AjPSeq seq;
AjPList locs;
} EmbOWordSeqLocs;
#define EmbPWordSeqLocs EmbOWordSeqLocs*
ID EmbPWordRK
TY public
MO embword
LB nucleus
XX
DE Data structure that extends EmbPWord objects for efficient access
DE by Rabin-Karp search. It is constructed using embWordInitRabinKarpSearch
DE method for a given sequence-set.
DE
DE Possible improvements could be achieved by scanning all other words
DE during preprocessing to find out a minimum length that can be skipped
DE safely when a word is matched.
DE
DE The first 5 fields (seqindxs-nseqs) are set during initialisation,
DE and the last 3 fields (nMatches, lenMatches, nSeqMatches) are calculated
DE during search.
XX
AN word
AT const EmbPWord
AD Original word object
AX
AN seqindxs
AT ajuint*
AD Positions in the seqset
AD for each sequence the word has been seen
AX
AN nnseqlocs
AT ajuint*
AD Number of word start positions for each sequence
AX
AN locs
AT ajuint**
AD List of word start positions for each sequence
AX
AN hash
AT ajulong
AD Hash value for the word
AX
AN nseqs
AT ajuint
AD Number of pattern-sequences word has been seen
AX
AN nMatches
AT ajuint
AD Number of matches in query sequences
AX
AN lenMatches
AT ajulong
AD Total length of extended matches
AX
AN nSeqMatches
AT ajuint*
AD Number of matches
AD recorded on per pattern-sequence base
AX
//
typedef struct EmbSWordRK {
const EmbPWord word;
ajuint* seqindxs;
ajuint* nnseqlocs;
ajuint** locs;
ajulong hash;
ajuint nseqs;
ajuint nMatches;
ajulong lenMatches;
ajuint* nSeqMatches;
} EmbOWordRK;
#define EmbPWordRK EmbOWordRK*