97b43803a09f9085190a3af6bb2b7c63d07016bb
tdreszer
  Mon Aug 22 17:12:52 2011 -0700
Added support for cv terms that are searchable='wildList'.  This type of searching allows comma dilimied lists and '%' wild card.
diff --git src/hg/lib/cv.c src/hg/lib/cv.c
index b0ec8c5..4894516 100644
--- src/hg/lib/cv.c
+++ src/hg/lib/cv.c
@@ -11,30 +11,31 @@
 #include "ra.h"
 #include "hui.h"
 #include "mdb.h"
 
 // CV Defines that should not necessarily be public
 
 // CV UGLY TERMS (NOTE: These should be hiddne inside cv.c APIS and callers should use non-UGLY terms)
 #define CV_UGLY_TOT_CELLTYPE    "cellType"
 #define CV_UGLY_TERM_CELL_LINE  "Cell Line"
 #define CV_UGLY_TERM_ANTIBODY   "Antibody"
 
 // Type of Terms searchable defines
 #define CV_SEARCHABLE_SINGLE_SELECT "select"
 #define CV_SEARCHABLE_MULTI_SELECT  "multiSelect"
 #define CV_SEARCHABLE_FREE_TEXT     "freeText"
+#define CV_SEARCHABLE_WILD_LIST     "wildList"
 
 const char *cvTypeNormalized(const char *sloppyTerm)
 // returns the proper term to use when requesting a typeOfTerm
 {
 static const char *badCvSpellingOfCell     = CV_UGLY_TOT_CELLTYPE;
 static const char *badCvSpellingOfAntibody = CV_UGLY_TERM_ANTIBODY;
 if (sameWord((char *)sloppyTerm,CV_TERM_CELL) || sameWord((char *)sloppyTerm,CV_UGLY_TERM_CELL_LINE))
     return badCvSpellingOfCell;
 if (sameWord((char *)sloppyTerm,CV_TERM_ANTIBODY))
     return badCvSpellingOfAntibody;
 
 return sloppyTerm;
 }
 
 const char *cvTermNormalized(const char *sloppyTerm)
@@ -209,31 +210,32 @@
     {
     char *setting = NULL;
     struct hash *typeHash = (struct hash *)hEl->val;
     //if (!includeHidden)
         {
         setting = hashFindVal(typeHash,CV_TOT_HIDDEN);
         if (cvHiddenIsTrue(setting))
             continue;
         }
     if (searchTracks)
         {
         setting = hashFindVal(typeHash,CV_TOT_SEARCHABLE);
         if (setting == NULL
         || (   differentWord(setting,CV_SEARCHABLE_SINGLE_SELECT)
             && differentWord(setting,CV_SEARCHABLE_MULTI_SELECT)
-            && differentWord(setting,CV_SEARCHABLE_FREE_TEXT)))
+            && differentWord(setting,CV_SEARCHABLE_FREE_TEXT)
+            && differentWord(setting,CV_SEARCHABLE_WILD_LIST)))
            continue;
         }
     if (cvDefined)
         {
         setting = hashFindVal(typeHash,CV_TOT_CV_DEFINED);
         if(SETTING_NOT_ON(setting))
             continue;
         }
     char *term  = hEl->name;
     char *label = hashFindVal(typeHash,CV_LABEL);
     if (label == NULL)
         label = term;
     slPairAdd(&whitePairs, term, cloneString(label)); // Term gets cloned in slPairAdd
     }
 if (whitePairs != NULL)
@@ -247,30 +249,32 @@
 {
 // Get the list of term types from thew cv
 struct hash *termTypeHash = (struct hash *)cvTermTypeHash();
 struct hash *termHash = hashFindVal(termTypeHash,(char *)term);
 if (termHash != NULL)
     {
     char *searchable = hashFindVal(termHash,CV_TOT_SEARCHABLE);
     if (searchable != NULL)
         {
         if (sameWord(searchable,CV_SEARCHABLE_SINGLE_SELECT))
             return cvSearchBySingleSelect;
         if (sameWord(searchable,CV_SEARCHABLE_MULTI_SELECT))
             return cvSearchByMultiSelect;
         if (sameWord(searchable,CV_SEARCHABLE_FREE_TEXT))
             return cvSearchByFreeText;
+        if (sameWord(searchable,CV_SEARCHABLE_WILD_LIST))
+            return cvSearchByWildList;
         if (sameWord(searchable,"date"))
             return cvSearchByDateRange;
         if (sameWord(searchable,"numeric"))
             return cvSearchByIntegerRange;
         }
     }
 return cvNotSearchable;
 }
 
 const char *cvValidationRule(const char *term)
 // returns validation rule, trimmed of comment
 {
 // Get the list of term types from thew cv
 struct hash *termTypeHash = (struct hash *)cvTermTypeHash();
 struct hash *termHash = hashFindVal(termTypeHash,(char *)term);