Esempio n. 1
0
struct gbRelease* gbIndexNewestRelease(struct gbIndex* index,
                                       unsigned state, unsigned srcDb,
                                       unsigned types, char* limitAccPrefix)
/* find the newest release that is either processed or aligned (based on
 * state) for the specified srcDb */
{
struct gbRelease* release = index->rels[gbSrcDbIdx(srcDb)];

if (srcDb == GB_REFSEQ)
    {
    types &= GB_MRNA;  /* only mRNAs for refseq */
    if (types == 0)
        return NULL;  /* no types left */
    }

/* Find the first with at least one aligned index. Note that incomplete
 * alignments will not cause data lose here, if a partation (equal to a
 * *.alidx file is complete, but others aren't, only it will be processed.
 */
while (release != NULL)
    {
    if (types & GB_MRNA)
        {
        if (gbReleaseHasData(release, state, GB_MRNA, limitAccPrefix))
            return release;
        }
    if (types & GB_EST)
        {
        if (gbReleaseHasData(release, state, GB_EST, limitAccPrefix))
            return release;
        }
    release = release->next;
    }
return NULL;  /* didn't find one */
}
Esempio n. 2
0
static struct gbRelease* newestReleaseWithAligns(struct gbIndex* index,
                                                 char* database, unsigned srcDb)
/* find the newest release for srcDb that has alignements */
{
/* can't look at update objects, since they haven't been loaded */
struct gbRelease* release;
char alIdxPat[PATH_LEN];
safef(alIdxPat, sizeof(alIdxPat), "*.%s", ALIDX_EXT);

for (release = index->rels[gbSrcDbIdx(srcDb)]; release != NULL;
     release = release->next)
    {
    char relDir[PATH_LEN];
    struct slName* idxFiles;
    safef(relDir, sizeof(relDir), "%s/%s/%s/%s", GB_ALIGNED_DIR, release->name,
          database, GB_FULL_UPDATE);
    idxFiles = listDir(relDir, alIdxPat);
    if (idxFiles != NULL)
        {
        slFreeList(&idxFiles);
        verbose(1, "checking %s for %s\n", release->name, database);
        return release;
        }
    }
return NULL;
}
Esempio n. 3
0
struct gbIndex* gbIndexNew(char *database, char* gbRoot)
/* Construct a new gbIndex object, finding all of the release directories.  If
 * aligned objects are to be accessed database should be specified. If gbRoot
 * is not null, it should be the path to the root directory.  Otherwise
 * the current directory is assumed.*/
{
struct gbIndex* index;
AllocVar(index);

if (gbRoot == NULL)
    gbRoot = ".";
index->gbRoot = cloneString(gbRoot);
if (database != NULL)
    index->genome = gbGenomeNew(database);
index->rels[gbSrcDbIdx(GB_GENBANK)] = findReleases(index, GB_GENBANK);
index->rels[gbSrcDbIdx(GB_REFSEQ)] = findReleases(index, GB_REFSEQ);
return index;
}