4898794edd81be5285ea6e544acbedeaeb31bf78
max
  Tue Nov 23 08:10:57 2021 -0800
Fixing pointers to README file for license in all source code files. refs #27614

diff --git src/hg/hgLinkIn/linkInHandlers.c src/hg/hgLinkIn/linkInHandlers.c
index ecf000d..83c88f6 100644
--- src/hg/hgLinkIn/linkInHandlers.c
+++ src/hg/hgLinkIn/linkInHandlers.c
@@ -1,104 +1,104 @@
 /* Copyright (C) 2017 The Regents of the University of California
- * See README in this or parent directory for licensing information. */
+ * See kent/LICENSE or http://genome.ucsc.edu/license/ for licensing information. */
 
 /* linkInHandler - supports registering and invoking handlers for linking
  * identifiers to positions via a resource.
  * To define a new handler, add it to handlerList.c and then add a new
  * handler registration line to registerLinkInHandlers().  A single
  * resource handler can be run using the name it's registered by in a call
  * to checkLinkInHandlerForResource.  All handlers can be checked in sequence
  * with checkAllLinkInHandlers(); */
 
 #include "common.h"
 #include "hash.h"
 #include "jksql.h"
 #include "linkInHandlers.h"
 #include "handlerList.h"
 
 struct hash *gLinkInHandlers = NULL;
 
 
 void registerLinkInHandlers()
 /* Register handlers for linking in IDs from all implemented databases */
 {
 //registerLinkInHandler("name", handlerFunction);
 registerLinkInHandler("uniProt", uniProtHandler);
 }
 
 
 void registerLinkInHandler(char *name, LinkInHandler handler)
 /* Add a linkIn handler for a particular database name.
  * Names are case-sensitive. */
 {
 char *hashName = cloneString(name);
 touppers(hashName);
 if (gLinkInHandlers == NULL)
     gLinkInHandlers = newHash(6);
 if (hashLookupUpperCase(gLinkInHandlers, hashName))
     warn("Handler duplicated for database %s", name);
 else
     {
     struct linkInHandlerEntry *newEntry;
     AllocVar(newEntry);
     newEntry->next = NULL;
     newEntry->resourceName = cloneString(name);
     newEntry->handler = handler;
     hashAdd(gLinkInHandlers, hashName, newEntry);
     }
 }
 
 
 struct linkInResult *checkLinkInHandlerForResource(char *linkInResource, char *linkInId)
 /* Attempt to locate a handler for the provided linkInResource name, and then use
  * it to locate position results for the provided linkInId identifier.  E.g.,
  * linkInResource='uniProt' and linkInId='Q6GZX4' */
 {
 struct linkInHandlerEntry *thisEntry = hashFindValUpperCase(gLinkInHandlers, linkInResource);
 if (thisEntry == NULL)
     {
     warn("No handler found for resource %s", linkInResource);
     return NULL;
     }
 else
     {
     struct sqlConnection *conn = sqlConnect(NULL);
     return thisEntry->handler(conn, linkInId);
     }
 }
 
 
 struct linkInResult *checkAllLinkInHandlers(char *linkInId)
 /* Iterate over the list of registered linkIn handlers, checking all of them
  * for position results for the supplied linkInId identifier */
 {
 struct linkInResult *results = NULL;
 struct hashCookie hashIterator = hashFirst(gLinkInHandlers);
 struct sqlConnection *conn = sqlConnect(NULL);
 struct hashEl *thisHandler = NULL;
 while ((thisHandler = hashNext(&hashIterator)) != NULL)
     {
     struct linkInHandlerEntry *entry = thisHandler->val;
     struct linkInResult *moreResults = entry->handler(conn, linkInId);
     results = slCat(results, moreResults);
     }
 return results;
 }
 
 
 char **listLinkInHandlers()
 /* Return the list of registered resource handler names.
  * Leaks memory from the hashEl list used to get the list
  * of names. Last name in the list is a NULL pointer. */
 {
 struct hashEl *handler = hashElListHash(gLinkInHandlers);
 if (handler == NULL)
     return NULL;
 int elCount = slCount(handler), i;
 char **results = NULL;
 AllocArray(results, elCount+1);
 for (i=0; i<elCount; i++)
     {
     results[i] = cloneString(handler->name);
     }
 return results;
 }