src/lib/ra.c 1.15
1.15 2009/12/06 20:09:36 kent
Adding optional dyString parameter.
Index: src/lib/ra.c
===================================================================
RCS file: /projects/compbio/cvsroot/kent/src/lib/ra.c,v
retrieving revision 1.14
retrieving revision 1.15
diff -b -B -U 1000000 -r1.14 -r1.15
--- src/lib/ra.c 23 Nov 2009 07:33:44 -0000 1.14
+++ src/lib/ra.c 6 Dec 2009 20:09:36 -0000 1.15
@@ -1,239 +1,260 @@
/* Stuff to parse .ra files. Ra files are simple text databases.
* The database is broken into records by blank lines.
* Each field takes a line. The name of the field is the first
* word in the line. The value of the field is the rest of the line.
*
* This file is copyright 2002 Jim Kent, but license is hereby
* granted for all use - public, private or commercial. */
#include "common.h"
#include "linefile.h"
#include "hash.h"
#include "localmem.h"
+#include "dystring.h"
#include "ra.h"
static char const rcsid[] = "$Id$";
-boolean raSkipLeadingEmptyLines(struct lineFile *lf)
-/* Skip leading empty lines and comments. Returns FALSE at end of file. */
+boolean raSkipLeadingEmptyLines(struct lineFile *lf, struct dyString *dy)
+/* Skip leading empty lines and comments. Returns FALSE at end of file.
+ * Together with raNextTagVal you can construct your own raNextRecord....
+ * If dy parameter is non-null, then the text parsed gets placed into dy. */
{
char *line;
/* Skip leading empty lines and comments. */
+if (dy)
+ dyStringClear(dy);
for (;;)
{
if (!lineFileNext(lf, &line, NULL))
return FALSE;
- line = skipLeadingSpaces(line);
- if (line[0] != 0 )
+ char *tag = skipLeadingSpaces(line);
+ if (tag[0] != 0 )
{
- if (line[0] == '#')
+ if (tag[0] == '#')
+ {
+ if (dy)
+ dyStringAppend(dy, line);
continue;
+ }
else
break;
}
+ else
+ {
+ if (dy)
+ dyStringAppend(dy, line);
+ }
}
lineFileReuse(lf);
return TRUE;
}
-boolean raNextTagVal(struct lineFile *lf, char **retTag, char **retVal)
+boolean raNextTagVal(struct lineFile *lf, char **retTag, char **retVal, struct dyString *dy)
/* Read next line. Return FALSE at end of file or blank line. Otherwise
- * fill in *retTag and *retVal and return TRUE */
+ * fill in *retTag and *retVal and return TRUE.
+ * If dy parameter is non-null, then the text parsed gets appended to dy. */
{
char *line;
for (;;)
{
if (!lineFileNext(lf, &line, NULL))
return FALSE;
- line = skipLeadingSpaces(line);
- if (line[0] == 0)
- return FALSE;;
- if (line[0] == '#')
+ char *tag = skipLeadingSpaces(line);
+ if (tag[0] == 0)
+ return FALSE;
+ if (tag[0] == '#')
{
- if (startsWith("#EOF", line))
+ if (startsWith("#EOF", tag))
return FALSE;
else
+ {
+ if (dy)
+ dyStringAppend(dy, line);
continue;
}
+ }
break;
}
+if (dy)
+ dyStringAppend(dy, line);
*retTag = nextWord(&line);
*retVal = trimSpaces(line);
return TRUE;
}
struct hash *raNextRecord(struct lineFile *lf)
/* Return a hash containing next record.
* Returns NULL at end of file. freeHash this
* when done. Note this will free the hash
* keys and values as well, so you'll have to
* cloneMem them if you want them for later. */
{
struct hash *hash = NULL;
char *key, *val;
-if (!raSkipLeadingEmptyLines(lf))
+if (!raSkipLeadingEmptyLines(lf, NULL))
return NULL;
-while (raNextTagVal(lf, &key, &val))
+while (raNextTagVal(lf, &key, &val, NULL))
{
if (hash == NULL)
hash = newHash(7);
val = lmCloneString(hash->lm, val);
hashAdd(hash, key, val);
}
return hash;
}
struct slPair *raNextRecordAsSlPairList(struct lineFile *lf)
/* Return ra record as a slPair list instead of a hash. Handy if you want to preserve the order.
* Do a slPairFreeValsAndList on result when done. */
{
struct slPair *list = NULL;
char *key, *val;
-if (!raSkipLeadingEmptyLines(lf))
+if (!raSkipLeadingEmptyLines(lf, NULL))
return NULL;
-while (raNextTagVal(lf, &key, &val))
+while (raNextTagVal(lf, &key, &val, NULL))
slPairAdd(&list, key, cloneString(val));
slReverse(&list);
return list;
}
struct hash *raFromString(char *string)
/* Return hash of key/value pairs from string.
* As above freeHash this when done. */
{
char *dupe = cloneString(string);
char *s = dupe, *lineEnd;
struct hash *hash = newHash(7);
char *key, *val;
for (;;)
{
s = skipLeadingSpaces(s);
if (s == NULL || s[0] == 0)
break;
lineEnd = strchr(s, '\n');
if (lineEnd != NULL)
*lineEnd++ = 0;
key = nextWord(&s);
val = skipLeadingSpaces(s);
s = lineEnd;
val = lmCloneString(hash->lm, val);
hashAdd(hash, key, val);
}
freeMem(dupe);
return hash;
}
char *raFoldInOneRetName(struct lineFile *lf, struct hash *hashOfHash)
/* Fold in one record from ra file into hashOfHash.
* This will add ra's and ra fields to whatever already
* exists in the hashOfHash, overriding fields of the
* same name if they exist already. */
{
char *word, *line, *name;
struct hash *ra;
struct hashEl *hel;
/* Get first nonempty non-comment line and make sure
* it contains name. */
if (!lineFileNextReal(lf, &line))
return NULL;
word = nextWord(&line);
if (!sameString(word, "name"))
errAbort("Expecting 'name' line %d of %s, got %s",
lf->lineIx, lf->fileName, word);
name = nextWord(&line);
if (name == NULL)
errAbort("Short name field line %d of %s", lf->lineIx, lf->fileName);
/* Find ra hash associated with name, making up a new
* one if need be. */
if ((ra = hashFindVal(hashOfHash, name)) == NULL)
{
ra = newHash(7);
hashAdd(hashOfHash, name, ra);
hashAdd(ra, "name", lmCloneString(ra->lm, name));
}
/* Fill in fields of ra hash with data up to next
* blank line or end of file. */
for (;;)
{
if (!lineFileNext(lf, &line, NULL))
break;
line = skipLeadingSpaces(line);
if (line[0] == 0)
break;
if (line[0] == '#')
continue;
word = nextWord(&line);
line = skipLeadingSpaces(line);
if (line == NULL)
line = "";
hel = hashLookup(ra, word);
if (hel == NULL)
hel = hashAdd(ra, word, lmCloneString(ra->lm, line));
else
hel->val = lmCloneString(ra->lm, line);
}
return hashFindVal(ra, "name");
}
boolean raFoldInOne(struct lineFile *lf, struct hash *hashOfHash)
{
return raFoldInOneRetName(lf, hashOfHash) != NULL;
}
void raFoldIn(char *fileName, struct hash *hashOfHash)
/* Read ra's in file name and fold them into hashOfHash.
* This will add ra's and ra fields to whatever already
* exists in the hashOfHash, overriding fields of the
* same name if they exist already. */
{
struct lineFile *lf = lineFileMayOpen(fileName, TRUE);
if (lf != NULL)
{
struct hash *uniqHash = hashNew(0);
char *name;
while ((name = raFoldInOneRetName(lf, hashOfHash)) != NULL)
{
if (hashLookup(uniqHash, name))
errAbort("%s duplicated in record ending line %d of %s", name,
lf->lineIx, lf->fileName);
hashAdd(uniqHash, name, NULL);
}
lineFileClose(&lf);
hashFree(&uniqHash);
}
}
struct hash *raReadSingle(char *fileName)
/* Read in first ra record in file and return as hash. */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct hash *hash = raNextRecord(lf);
lineFileClose(&lf);
return hash;
}
struct hash *raReadAll(char *fileName, char *keyField)
/* Return hash that contains all ra records in file keyed
* by given field, which must exist. The values of the
* hash are themselves hashes. */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct hash *bigHash = hashNew(0);
struct hash *hash;
while ((hash = raNextRecord(lf)) != NULL)
{
char *key = hashFindVal(hash, keyField);
if (key == NULL)
errAbort("Couldn't find key field %s line %d of %s",
keyField, lf->lineIx, lf->fileName);
hashAdd(bigHash, key, hash);
}
lineFileClose(&lf);
return bigHash;
}