Index: src/hg/inc/bed.h
===================================================================
RCS file: /projects/compbio/cvsroot/kent/src/hg/inc/bed.h,v
retrieving revision 1.50
retrieving revision 1.51
diff -b -B -U 1000000 -r1.50 -r1.51
--- src/hg/inc/bed.h	2 Feb 2009 04:19:38 -0000	1.50
+++ src/hg/inc/bed.h	16 Mar 2009 01:01:12 -0000	1.51
@@ -1,365 +1,368 @@
 /* bed.h was originally generated by the autoSql program, which also 
  * generated bed.c and bed.sql.  This header links the database and the RAM 
  * representation of objects. This file has been extended significantly
  * by hand now. */
 
 #ifndef BED_H
 #define BED_H
 
 #ifndef PSL_H
 #include "psl.h"
 #endif
 
 #ifndef GENEPRED_H
 #include "genePred.h"
 #endif
 
 #ifndef HASH_H
 #include "hash.h"
 #endif
 
 #ifndef RANGETREE_H
 #include "rangeTree.h"
 #endif
 
 struct bed
 /* Browser extensible data */
     {
     struct bed *next;  /* Next in singly linked list. */
     char *chrom;	/* Human chromosome or FPC contig */
     unsigned chromStart;	/* Start position in chromosome */
     unsigned chromEnd;	/* End position in chromosome */
     char *name;	/* Name of item */
 
     /* The following items are not loaded by   the bedLoad routines. */
     int score; /* Score - 0-1000 */
     char strand[2];  /* + or -.  */
     unsigned thickStart; /* Start of where display should be thick (start codon for genes) */
     unsigned thickEnd;   /* End of where display should be thick (stop codon for genes) */
     unsigned itemRgb;    /* RGB 8 bits each */
     unsigned blockCount; /* Number of blocks. */
     int *blockSizes;     /* Comma separated list of block sizes.  */
     int *chromStarts;    /* Start positions inside chromosome.  Relative to chromStart*/
 
 
     int expCount;	/* Experiment count */
     int *expIds;		/* Comma separated list of Experiment ids */
     float *expScores;	/* Comma separated list of Experiment scores. */
     };
 
 #define bedKnownFields 15	/* Maximum known fields in bed */
 
 struct bed3
 /* Browser extensible data - first three fields */
     {
     struct bed3 *next;  /* Next in singly linked list. */
     char *chrom;	/* Human chromosome or FPC contig */
     unsigned chromStart;	/* Start position in chromosome */
     unsigned chromEnd;	/* End position in chromosome */
     };
 
 struct bed3 *bed3New(char *chrom, int start, int end);
 /* Make new bed3. */
 
 struct bed4
 /* Browser extensible data - first four fields */
     {
     struct bed4 *next;  /* Next in singly linked list. */
     char *chrom;	/* Human chromosome or FPC contig */
     unsigned chromStart;	/* Start position in chromosome */
     unsigned chromEnd;	/* End position in chromosome */
     char *name;	/* Name of item */
     };
 
 
 void bedStaticLoad(char **row, struct bed *ret);
 /* Load a row from bed table into ret.  The contents of ret will
  * be replaced at the next call to this function. */
 
 struct bed *bedLoad(char **row);
 /* Load a bed from row fetched with select * from bed
  * from database.  Dispose of this with bedFree(). 
  * This loads first four fields. */
 
 struct bed *bedCommaIn(char **pS, struct bed *ret);
 /* Create a bed out of a comma separated string. 
  * This will fill in ret if non-null, otherwise will
  * return a new bed */
 
 void bedFree(struct bed **pEl);
 /* Free a single dynamically allocated bed such as created
  * with bedLoad(). */
 
 void bedFreeList(struct bed **pList);
 /* Free a list of dynamically allocated bed's */
 
 void bedOutput(struct bed *el, FILE *f, char sep, char lastSep);
 /* Print out bed.  Separate fields with sep. Follow last field with lastSep. */
 
 #define bedTabOut(el,f) bedOutput(el,f,'\t','\n');
 /* Print out bed as a line in a tab-separated file. */
 
 #define bedCommaOut(el,f) bedOutput(el,f,',',',');
 /* Print out bed as a comma separated list including final comma. */
 
 /* --------------- End of AutoSQL generated code. --------------- */
 
 int bedCmp(const void *va, const void *vb);
 /* Compare to sort based on chrom,chromStart. */
 
 int bedCmpEnd(const void *va, const void *vb);
 /* Compare to sort based on chrom,chromEnd. */
 
 int bedCmpScore(const void *va, const void *vb);
 /* Compare to sort based on score - lowest first. */
 
 int bedCmpPlusScore(const void *va, const void *vb);
 /* Compare to sort based on chrom, chromStart and score - lowest first. */
 
 int bedCmpSize(const void *va, const void *vb);
 /* Compare to sort based on size of element (end-start == size) */
 
 int bedCmpChromStrandStart(const void *va, const void *vb);
 /* Compare to sort based on chrom,strand,chromStart. */
 
 struct bedLine
 /* A line in a bed file with chromosome, start position parsed out. */
     {
     struct bedLine *next;	/* Next in list. */
     char *chrom;                /* Chromosome parsed out. */
     int chromStart;             /* Start position (still in rest of line). */
     char *line;                 /* Rest of line. */
     };
 
 struct bedLine *bedLineNew(char *line);
 /* Create a new bedLine based on tab-separated string s. */
 
 void bedLineFree(struct bedLine **pBl);
 /* Free up memory associated with bedLine. */
 
 void bedLineFreeList(struct bedLine **pList);
 /* Free a list of dynamically allocated bedLine's */
 
 int bedLineCmp(const void *va, const void *vb);
 /* Compare to sort based on chrom,chromStart. */
 
 void bedSortFile(char *inFile, char *outFile);
 /* Sort a bed file (in place, overwrites old file. */
 
 struct bed *bedLoad3(char **row);
 /* Load first three fields of bed. */
 
 struct bed *bedLoad5(char **row);
 /* Load first five fields of bed. */
 
 struct bed *bedLoad6(char **row);
 /* Load first six fields of bed. */
 
 struct bed *bedLoad12(char **row);
 /* Load all 12 fields of bed. */
 
 struct bed *bedLoadN(char *row[], int wordCount);
 /* Convert a row of strings to a bed. */
 
 struct bed *bedLoadNAllChrom(char *fileName, int numFields, char* chrom);
 /* Load bed entries from a tab-separated file that have the given chrom.
  * Dispose of this with bedFreeList(). */
 
 struct bed *bedLoadNAll(char *fileName, int numFields);
 /* Load all bed from a tab-separated file.
  * Dispose of this with bedFreeList(). */
 
 struct bed *bedLoadAll(char *fileName);
 /* Determines how many fields are in a bedFile and load all beds from
  * a tab-separated file.  Dispose of this with bedFreeList(). */
 
 struct bed *bedLoadNBin(char *row[], int wordCount);
 /* Convert a row of strings to a bed. */
 
 void bedOutputN(struct bed *el, int wordCount, FILE *f, char sep, char lastSep);
 /* Write a bed of wordCount fields. */
 
 void bedOutputNitemRgb(struct bed *el, int wordCount, FILE *f,
 	char sep, char lastSep);
 /* Write a bed of wordCount fields, interpret column 9 as RGB. */
 
 #define bedTabOutNitemRgb(el,wordCount, f) bedOutputNitemRgb(el,wordCount,f,'\t','\n')
 /* Print out bed as a line in a tab-separated file. Interpret
    column 9 as RGB */
 
 #define bedTabOutN(el,wordCount, f) bedOutputN(el,wordCount,f,'\t','\n')
 /* Print out bed as a line in a tab-separated file. */
 
 #define bedCommaOutN(el,wordCount, f) bedOutputN(el,wordCount,f,',',',')
 /* Print out bed as a comma separated list including final comma. */
 
 int bedTotalBlockSize(struct bed *bed);
 /* Return total size of all blocks. */
 
 int bedTotalThickBlockSize(struct bed *bed);
 /* Return total size of all thick blocks. */
 
 int bedStartThinSize(struct bed *bed);
 /* Return total size of all blocks before thick part. */
 
 int bedEndThinSize(struct bed *bed);
 /* Return total size of all blocks after thick part. */
 
 int bedBlockSizeInRange(struct bed *bed, int rangeStart, int rangeEnd);
 /* Get size of all parts of all exons between rangeStart and rangeEnd. */
 
 struct bed *bedFromPsl(struct psl *psl);
 /* Convert a single psl to a bed structure */
 
 struct genePred *bedToGenePred(struct bed *bed);
 /* Convert a single bed to a genePred structure. */
 
 struct bed *bedFromGenePred(struct genePred *genePred);
 /* Convert a single genePred to a bed structure */
 
 void makeItBed12(struct bed *bedList, int numFields);
 /* If it's less than bed 12, make it bed 12. The numFields */
 /* param is for how many fields the bed *currently* has. */
 
 struct bed *cloneBed(struct bed *bed);
 /* Make an all-newly-allocated copy of a single bed record. */
 
 struct bed *cloneBedList(struct bed *bed);
 /* Make an all-newly-allocated list copied from bed. */
 
 struct bed *lmCloneBed(struct bed *bed, struct lm *lm);
 /* Make a copy of bed in local memory. */
 
 /* Constraints that can be placed on bed fields: */
 enum charFilterType
     {
     cftIgnore = 0,
     cftSingleLiteral = 1,
     cftMultiLiteral = 2,
     };
 
 enum stringFilterType
     {
     sftIgnore = 0,
     sftSingleLiteral = 1,
     sftMultiLiteral = 2,
     sftSingleRegexp = 3,
     sftMultiRegexp = 4,
     };
 
 enum numericFilterType
     {
     nftIgnore = 0,
     nftLessThan = 1,
     nftLTE = 2,
     nftEqual = 3,
     nftNotEqual = 4,
     nftGTE = 5,
     nftGreaterThan = 6,
     nftInRange = 7,
     nftNotInRange = 8,
     };
 
 struct bedFilter
     {
     enum stringFilterType chromFilter;
     char **chromVals;
     boolean chromInvert;
     enum numericFilterType chromStartFilter;
     int *chromStartVals;
     enum numericFilterType chromEndFilter;
     int *chromEndVals;
     enum stringFilterType nameFilter;
     char **nameVals;
     boolean nameInvert;
     enum numericFilterType scoreFilter;
     int *scoreVals;
     enum charFilterType strandFilter;
     char *strandVals;
     boolean strandInvert;
     enum numericFilterType thickStartFilter;
     int *thickStartVals;
     enum numericFilterType thickEndFilter;
     int *thickEndVals;
     enum numericFilterType blockCountFilter;
     int *blockCountVals;
     enum numericFilterType chromLengthFilter;
     int *chromLengthVals;
     enum numericFilterType thickLengthFilter;
     int *thickLengthVals;
     enum numericFilterType compareStartsFilter;
     enum numericFilterType compareEndsFilter;
     };
 
 boolean bedFilterOne(struct bedFilter *bf, struct bed *bed);
 /* Return TRUE if bed passes filter. */
 
 struct bed *bedFilterListInRange(struct bed *bedListIn, struct bedFilter *bf,
 				 char *chrom, int winStart, int winEnd);
 /* Given a bed list, a position range, and a bedFilter which specifies
  * constraints on bed fields, return the list of bed items that meet
  * the constraints.  If chrom is NULL, position range is ignored. */
 
 struct bed *bedFilterList(struct bed *bedListIn, struct bedFilter *bf);
 /* Given a bed list and a bedFilter which specifies constraints on bed 
  * fields, return the list of bed items that meet the constraints. */
 
 struct bed *bedFilterByNameHash(struct bed *bedList, struct hash *nameHash);
 /* Given a bed list and a hash of names to keep, return the list of bed 
  * items whose name is in nameHash. */
 
 struct bed *bedFilterByWildNames(struct bed *bedList, struct slName *wildNames);
 /* Given a bed list and a list of names that may include wildcard characters,
  * return the list of bed items whose name matches at least one wildName. */
 
 
 struct bed *bedCommaInN(char **pS, struct bed *ret, int fieldCount);
 /* Create a bed out of a comma separated string looking for fieldCount
  * fields. This will fill in ret if non-null, otherwise will return a
  * new bed */
 
 struct hash *readBedToBinKeeper(char *sizeFileName, char *bedFileName, int wordCount);
 /* Read a list of beds and return results in hash of binKeeper structure for fast query
  * See also bedsIntoKeeperHash, which takes the beds read into a list already, but
  * dispenses with the need for the sizeFile. */
 
 struct hash *bedsIntoKeeperHash(struct bed *bedList);
 /* Create a hash full of bin keepers (one for each chromosome or contig.
  * The binKeepers are full of beds. */
 
 int bedParseRgb(char *itemRgb);
 /*	parse a string: "r,g,b" into three unsigned char values
 	returned as 24 bit number, or -1 for failure */
 
 long long bedTotalSize(struct bed *bedList);
 /* Add together sizes of all beds in list. */
 
 int bedSameStrandOverlap(struct bed *a, struct bed *b);
 /* Return amount of block-level overlap on same strand between a and b */
 
 boolean bedExactMatch(struct bed *oldBed, struct bed *newBed);
 /* Return TRUE if it's an exact match. */
 
 boolean bedCompatibleExtension(struct bed *oldBed, struct bed *newBed);
 /* Return TRUE if newBed is a compatible extension of oldBed, meaning
  * all internal exons and all introns of old bed are contained, in the 
  * same order in the new bed. */
 
 struct rbTree *bedToRangeTree(struct bed *bed);
 /* Convert bed into a range tree. */
 
 void bedIntoRangeTree(struct bed *bed, struct rbTree *rangeTree);
 /* Add all blocks in bed to range tree.  For beds without blocks,
  * add entire bed. */
 
 int bedRangeTreeOverlap(struct bed *bed, struct rbTree *rangeTree);
 /* Return number of bases bed overlaps with rangeTree. */
 
 struct bed *bedThickOnly(struct bed *in);
 /* Return a bed that only has the thick part. (Which is usually the CDS). */
 
 struct bed *bedThickOnlyList(struct bed *inList);
 /* Return a list of beds that only are the thick part of input. */
 
+char *bedAsDef(int fieldCount);
+/* Return an autoSql definition for a bed of given number of fields. */
+
 #endif /* BED_H */
 

