inc/twoBit.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	twoBit
struct	twoBitIndex
struct	twoBitFile
struct	twoBitSpec
struct	twoBitSeqSpec
Functions
twoBitFile *	twoBitOpen (char *fileName)
void	twoBitClose (struct twoBitFile **pTbf)
int	twoBitSeqSize (struct twoBitFile *tbf, char *name)
long long	twoBitTotalSize (struct twoBitFile *tbf)
dnaSeq *	twoBitReadSeqFragExt (struct twoBitFile *tbf, char *name, int fragStart, int fragEnd, boolean doMask, int *retFullSize)
dnaSeq *	twoBitReadSeqFrag (struct twoBitFile *tbf, char *name, int fragStart, int fragEnd)
dnaSeq *	twoBitReadSeqFragLower (struct twoBitFile *tbf, char *name, int fragStart, int fragEnd)
dnaSeq *	twoBitLoadAll (char *spec)
slName *	twoBitSeqNames (char *fileName)
twoBit *	twoBitFromDnaSeq (struct dnaSeq *seq, boolean doMask)
twoBit *	twoBitFromFile (char *fileName)
void	twoBitWriteOne (struct twoBit *twoBit, FILE *f)
void	twoBitWriteHeader (struct twoBit *twoBitList, FILE *f)
boolean	twoBitIsFile (char *fileName)
boolean	twoBitParseRange (char *rangeSpec, char **retFile, char **retSeq, int *retStart, int *retEnd)
boolean	twoBitIsRange (char *rangeSpec)
boolean	twoBitIsFileOrRange (char *spec)
boolean	twoBitIsSpec (char *spec)
twoBitSpec *	twoBitSpecNew (char *specStr)
twoBitSpec *	twoBitSpecNewFile (char *twoBitFile, char *specFile)
void	twoBitSpecFree (struct twoBitSpec **specPtr)
void	twoBitOutNBeds (struct twoBitFile *tbf, char *seqName, FILE *outF)
int	twoBitSeqSizeNoNs (struct twoBitFile *tbf, char *seqName)

---

Function Documentation

void twoBitClose

(

struct twoBitFile **

pTbf

)

Definition at line 263 of file twoBit.c.

References carefulClose(), twoBitFile::f, twoBitFile::fileName, freez(), twoBitFile::hash, and hashFree.

Referenced by dnaLoadSingle(), dnaLoadStackFree(), gfCountTilesInTwoBit(), gfFileCacheFreeEl(), gfIndexNibsAndTwoBits(), gfIndexTransNibsAndTwoBits(), nibTwoCacheFree(), nibTwoLoadOne(), readSeqFrag(), searchOneIndex(), twoBitFromFile(), twoBitLoadAll(), and twoBitSeqNames().

{
struct twoBitFile *tbf = *pTbf;
if (tbf != NULL)
    {
    freez(&tbf->fileName);
    carefulClose(&tbf->f);
    hashFree(&tbf->hash);
    /* The indexList is allocated out of the hash's memory pool. */
    freez(pTbf);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct twoBit* twoBitFromDnaSeq	(	struct dnaSeq *	seq,
		boolean	doMask
	)			[read]

Definition at line 122 of file twoBit.c.

References AllocArray, AllocVar, cloneString(), countBlocksOfLower(), countBlocksOfN(), twoBit::data, dnaSeq::dna, twoBit::maskBlockCount, twoBit::maskSizes, twoBit::maskStarts, twoBit::name, dnaSeq::name, twoBit::nBlockCount, twoBit::nSizes, twoBit::nStarts, packDna4(), packedSize(), dnaSeq::size, twoBit::size, storeBlocksOfLower(), storeBlocksOfN(), and UBYTE.

{
int ubyteSize = packedSize(seq->size);
UBYTE *pt;
struct twoBit *twoBit;
DNA last4[4];   /* Holds few bases. */
DNA *dna;
int i, end;

/* Allocate structure and fill in name. */
AllocVar(twoBit);
pt = AllocArray(twoBit->data, ubyteSize);
twoBit->name = cloneString(seq->name);
twoBit->size = seq->size;

/* Convert to 4-bases per byte representation. */
dna = seq->dna;
end = seq->size - 4;
for (i=0; i<end; i += 4)
    {
    *pt++ = packDna4(dna+i);
    }

/* Take care of conversion of last few bases. */
last4[0] = last4[1] = last4[2] = last4[3] = 'T';
memcpy(last4, dna+i, seq->size-i);
*pt = packDna4(last4);

/* Deal with blocks of N. */
twoBit->nBlockCount = countBlocksOfN(dna, seq->size);
if (twoBit->nBlockCount > 0)
    {
    AllocArray(twoBit->nStarts, twoBit->nBlockCount);
    AllocArray(twoBit->nSizes, twoBit->nBlockCount);
    storeBlocksOfN(dna, seq->size, twoBit->nStarts, twoBit->nSizes);
    }

/* Deal with masking */
if (doMask)
    {
    twoBit->maskBlockCount = countBlocksOfLower(dna, seq->size);
    if (twoBit->maskBlockCount > 0)
        {
        AllocArray(twoBit->maskStarts, twoBit->maskBlockCount);
        AllocArray(twoBit->maskSizes, twoBit->maskBlockCount);
        storeBlocksOfLower(dna, seq->size, 
                twoBit->maskStarts, twoBit->maskSizes);
        }
    }
return twoBit;
}

Here is the call graph for this function:

struct twoBit* twoBitFromFile

(

char *

fileName

)

[read]

Definition at line 404 of file twoBit.c.

References AllocVar, bits32, cloneString(), twoBitFile::f, twoBitFile::indexList, twoBitFile::isSwapped, mustRead(), name, twoBitIndex::name, needLargeMem(), twoBitIndex::next, packedSize(), readBits32(), readBlockCoords(), slAddHead, slReverse(), twoBitClose(), twoBitOpen(), and twoBitSeekTo().

{
struct twoBitFile *tbf = twoBitOpen(fileName);
struct twoBitIndex *index;
struct twoBit *twoBitList = NULL, *twoBit = NULL;
boolean isSwapped = tbf->isSwapped;
FILE *f = tbf->f;

for (index = tbf->indexList; index != NULL; index = index->next)
    {
    char *name = index->name;
    bits32 packByteCount;

    AllocVar(twoBit);
    twoBit->name = cloneString(name);

    /* Find offset in index and seek to it */
    twoBitSeekTo(tbf, name);

    /* Read in seqSize. */
    twoBit->size = readBits32(f, isSwapped);

    /* Read in blocks of N. */
    readBlockCoords(f, isSwapped, &(twoBit->nBlockCount),
                    &(twoBit->nStarts), &(twoBit->nSizes));

    /* Read in masked blocks. */
    readBlockCoords(f, isSwapped, &(twoBit->maskBlockCount),
                    &(twoBit->maskStarts), &(twoBit->maskSizes));

    /* Reserved word. */
    twoBit->reserved = readBits32(f, isSwapped);

    /* Read in data. */
    packByteCount = packedSize(twoBit->size);
    twoBit->data = needLargeMem(packByteCount);
    mustRead(f, twoBit->data, packByteCount);

    slAddHead(&twoBitList, twoBit);
    }

twoBitClose(&tbf);
slReverse(&twoBitList);
return twoBitList;
}

Here is the call graph for this function:

boolean twoBitIsFile

(

char *

fileName

)

Definition at line 711 of file twoBit.c.

References endsWith().

Referenced by dnaLoadStackNew(), gfIndexNibsAndTwoBits(), gfIndexTransNibsAndTwoBits(), gfMakeOoc(), nibTwoCacheNew(), nibTwoLoadOne(), twoBitIsFileOrRange(), and twoBitIsRange().

{
return endsWith(fileName, ".2bit");
}

Here is the call graph for this function:

Here is the caller graph for this function:

boolean twoBitIsFileOrRange

(

char *

spec

)

Definition at line 794 of file twoBit.c.

References twoBitIsFile(), and twoBitIsRange().

{
return twoBitIsFile(spec) || twoBitIsRange(spec);
}

Here is the call graph for this function:

boolean twoBitIsRange

(

char *

rangeSpec

)

Definition at line 781 of file twoBit.c.

References cloneString(), freeMem(), twoBitIsFile(), and twoBitParseRange().

Referenced by dnaLoadSingle(), and twoBitIsFileOrRange().

{
char *dupe = cloneString(rangeSpec);
char *file, *seq;
int start, end;
boolean isRange = twoBitParseRange(dupe, &file, &seq, &start, &end);
if (isRange)
    isRange = twoBitIsFile(file);
freeMem(dupe);
return isRange;
}

Here is the call graph for this function:

Here is the caller graph for this function:

boolean twoBitIsSpec

(

char *

spec

)

Definition at line 830 of file twoBit.c.

References twoBitSpecFree(), and twoBitSpecNew().

Referenced by gfClientFileArray(), gfClientSeqList(), and searchOneIndex().

{
struct twoBitSpec *tbs = twoBitSpecNew(spec);
boolean isSpec = (tbs != NULL);
twoBitSpecFree(&tbs);
return isSpec;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct dnaSeq* twoBitLoadAll

(

char *

spec

)

[read]

Definition at line 662 of file twoBit.c.

References twoBitSeqSpec::end, twoBitSpec::fileName, twoBitFile::indexList, twoBitSeqSpec::name, twoBitIndex::name, twoBitSeqSpec::next, twoBitIndex::next, twoBitSpec::seqs, slReverse(), slSafeAddHead(), twoBitSeqSpec::start, twoBitClose(), twoBitOpen(), twoBitReadSeqFrag(), twoBitSpecFree(), and twoBitSpecNew().

Referenced by gfClientSeqList(), and gfMakeOoc().

           :
 *
 *    file/path/input.2bit[:seqSpec1][,seqSpec2,...]
 *
 * where seqSpec is either
 *     seqName
 *  or
 *     seqName:start-end */
{
struct twoBitSpec *tbs = twoBitSpecNew(spec);
struct twoBitFile *tbf = twoBitOpen(tbs->fileName);
struct dnaSeq *list = NULL;
if (tbs->seqs != NULL)
    {
    struct twoBitSeqSpec *tbss;
    for (tbss = tbs->seqs; tbss != NULL; tbss = tbss->next)
        slSafeAddHead(&list, twoBitReadSeqFrag(tbf, tbss->name,
                                               tbss->start, tbss->end));
    }
else
    {
    struct twoBitIndex *index;
    for (index = tbf->indexList; index != NULL; index = index->next)
        slSafeAddHead(&list, twoBitReadSeqFrag(tbf, index->name, 0, 0));
    }
slReverse(&list);
twoBitClose(&tbf);
twoBitSpecFree(&tbs);
return list;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct twoBitFile* twoBitOpen

(

char *

fileName

)

[read]

Definition at line 287 of file twoBit.c.

References AllocVar, bits32, cloneString(), digitsBaseTwo(), errAbort(), twoBitFile::f, FALSE, fastReadString(), twoBitFile::fileName, twoBitFile::hash, hashAddSaveName(), hashNew, twoBitFile::indexList, twoBitFile::isSwapped, hash::lm, lmAllocVar, mustOpen(), mustReadOne, name, twoBitIndex::name, twoBitIndex::offset, readBits32(), twoBitFile::reserved, twoBitFile::seqCount, slAddHead, slReverse(), TRUE, twoBitSig, twoBitSwapSig, and twoBitFile::version.

Referenced by dnaLoadSingle(), dnaLoadStackNew(), gfCountTilesInTwoBit(), gfiExpandAndLoadCached(), gfIndexNibsAndTwoBits(), gfIndexTransNibsAndTwoBits(), nibTwoCacheNew(), nibTwoLoadOne(), readSeqFrag(), searchOneIndex(), twoBitFromFile(), twoBitLoadAll(), and twoBitSeqNames().

{
bits32 sig;
struct twoBitFile *tbf;
struct twoBitIndex *index;
boolean isSwapped = FALSE;
int i;
struct hash *hash;
FILE *f = mustOpen(fileName, "rb");

/* Allocate header verify signature, and read in
 * the constant-length bits. */
AllocVar(tbf);
mustReadOne(f, sig);
if (sig == twoBitSwapSig)
    isSwapped = tbf->isSwapped = TRUE;
else if (sig != twoBitSig)
    errAbort("%s doesn't have a valid twoBitSig", fileName);
tbf->fileName = cloneString(fileName);
tbf->f = f;
tbf->version = readBits32(f, isSwapped);
if (tbf->version != 0)
    {
    errAbort("Can only handle version 0 of this file. This is version %d",
        (int)tbf->version);
    }
tbf->seqCount = readBits32(f, isSwapped);
tbf->reserved = readBits32(f, isSwapped);

/* Read in index. */
hash = tbf->hash = hashNew(digitsBaseTwo(tbf->seqCount));
for (i=0; i<tbf->seqCount; ++i)
    {
    char name[256];
    if (!fastReadString(f, name))
        errAbort("%s is truncated", fileName);
    lmAllocVar(hash->lm, index);
    index->offset = readBits32(f, isSwapped);
    hashAddSaveName(hash, name, index, &index->name);
    slAddHead(&tbf->indexList, index);
    }
slReverse(&tbf->indexList);
return tbf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void twoBitOutNBeds	(	struct twoBitFile *	tbf,
		char *	seqName,
		FILE *	outF
	)

Definition at line 933 of file twoBit.c.

References AllocArray, bits32, byteSwap32(), twoBitFile::f, freez(), twoBitFile::isSwapped, readBits32(), and twoBitSeekTo().

{
int nBlockCount;

twoBitSeekTo(tbf, seqName);

readBits32(tbf->f, tbf->isSwapped);

/* Read in blocks of N. */
nBlockCount = readBits32(tbf->f, tbf->isSwapped);

if (nBlockCount > 0)
    {
    bits32 *nStarts = NULL, *nSizes = NULL;
    int i;

    AllocArray(nStarts, nBlockCount);
    AllocArray(nSizes, nBlockCount);
    fread(nStarts, sizeof(nStarts[0]), nBlockCount, tbf->f);
    fread(nSizes, sizeof(nSizes[0]), nBlockCount, tbf->f);
    if (tbf->isSwapped)
        {
        for (i=0; i<nBlockCount; ++i)
            {
            nStarts[i] = byteSwap32(nStarts[i]);
            nSizes[i] = byteSwap32(nSizes[i]);
            }
        }

    for (i=0; i<nBlockCount; ++i)
        {
        fprintf(outF, "%s\t%d\t%d\n", seqName, nStarts[i], nStarts[i] + nSizes[i]);
        }

    freez(&nStarts);
    freez(&nSizes);
    }
}

Here is the call graph for this function:

boolean twoBitParseRange	(	char *	rangeSpec,
		char **	retFile,
		char **	retSeq,
		int *	retStart,
		int *	retEnd
	)

Definition at line 717 of file twoBit.c.

References FALSE, and TRUE.

Referenced by dnaLoadSingle(), and twoBitIsRange().

                    :seqName:start-end
 * or
 *    file/path/name:seqName
 * or
 *    file/path/name:seqName1,seqName2,seqName3,...
 * This will destroy the input 'rangeSpec' in the process.  Returns FALSE if
 * it doesn't fit this format, setting retFile to rangeSpec, and retSet to
 * null.  If it is the shorter form then start and end will both be returned
 * as zero, which is ok by twoBitReadSeqFrag.  Any of the return arguments
 * maybe NULL.
 */
{
char *s, *e;
int n;

/* default returns */
if (retFile != NULL)
    *retFile = rangeSpec;
if (retSeq != NULL)
    *retSeq = NULL;
if (retStart != NULL)
    *retStart = 0;
if (retEnd != NULL)
    *retEnd = 0;

/* start with final name  */
s = strrchr(rangeSpec, '/');
if (s == NULL)
    s = rangeSpec;
else
    s++;

/* Grab seqName, zero terminate fileName. */
s = strchr(s, ':');
if (s == NULL)
    return FALSE;
*s++ = 0;
if (retSeq != NULL)
    *retSeq = s;

/* Grab start, zero terminate seqName. */
s = strchr(s, ':');
if (s == NULL)
    return TRUE;  /* no range spec */
*s++ = 0;
n = strtol(s, &e, 0);
if (*e != '-')
    return FALSE; /* not a valid range */
if (retStart != NULL)
    *retStart = n;
s = e+1;

/* Grab end. */
n = strtol(s, &e, 0);
if (*e != '\0')
    return FALSE; /* not a valid range */
if (retEnd != NULL)
    *retEnd = n;
return TRUE;
}

Here is the caller graph for this function:

struct dnaSeq* twoBitReadSeqFrag	(	struct twoBitFile *	tbf,
		char *	name,
		int	fragStart,
		int	fragEnd
	)			[read]

Definition at line 625 of file twoBit.c.

References TRUE, and twoBitReadSeqFragExt().

Referenced by dnaLoadNextFromStack(), dnaLoadSingle(), nibTwoCacheSeq(), nibTwoLoadOne(), readMaskedTwoBit(), searchOneIndex(), and twoBitLoadAll().

{
return twoBitReadSeqFragExt(tbf, name, fragStart, fragEnd, TRUE, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct dnaSeq* twoBitReadSeqFragExt	(	struct twoBitFile *	tbf,
		char *	name,
		int	fragStart,
		int	fragEnd,
		boolean	doMask,
		int *	retFullSize
	)			[read]

Definition at line 451 of file twoBit.c.

References AllocVar, bits32, cloneString(), dnaSeq::dna, dnaUtilOpen(), errAbort(), twoBitFile::f, findGreatestLowerBound(), freez(), twoBitFile::isSwapped, mustRead(), dnaSeq::name, needLargeMem(), readBits32(), readBlockCoords(), safef(), SEEK_CUR, dnaSeq::size, toLowerN(), toUpperN(), twoBitSeekTo(), UBYTE, and valToNt.

Referenced by nibTwoCacheSeqPartExt(), twoBitReadSeqFrag(), and twoBitReadSeqFragLower().

{
struct dnaSeq *seq;
bits32 seqSize;
bits32 nBlockCount, maskBlockCount;
bits32 *nStarts = NULL, *nSizes = NULL;
bits32 *maskStarts = NULL, *maskSizes = NULL;
boolean isSwapped = tbf->isSwapped;
FILE *f = tbf->f;
int i;
int packByteCount, packedStart, packedEnd, remainder, midStart, midEnd;
int outSize;
UBYTE *packed, *packedAlloc;
DNA *dna;

/* Find offset in index and seek to it */
dnaUtilOpen();
twoBitSeekTo(tbf, name);

/* Read in seqSize. */
seqSize = readBits32(f, isSwapped);
if (fragEnd == 0)
    fragEnd = seqSize;
if (fragEnd > seqSize)
    errAbort("twoBitReadSeqFrag in %s end (%d) >= seqSize (%d)", name, fragEnd, seqSize);
outSize = fragEnd - fragStart;
if (outSize < 1)
    errAbort("twoBitReadSeqFrag in %s start (%d) >= end (%d)", name, fragStart, fragEnd);

/* Read in blocks of N. */
readBlockCoords(f, isSwapped, &nBlockCount, &nStarts, &nSizes);

/* Read in masked blocks. */
readBlockCoords(f, isSwapped, &maskBlockCount, &maskStarts, &maskSizes);

/* Skip over reserved word. */
readBits32(f, isSwapped);

/* Allocate dnaSeq, and fill in zero tag at end of sequence. */
AllocVar(seq);
if (outSize == seqSize)
    seq->name = cloneString(name);
else
    {
    char buf[256*2];
    safef(buf, sizeof(buf), "%s:%d-%d", name, fragStart, fragEnd);
    seq->name = cloneString(buf);
    }
seq->size = outSize;
dna = seq->dna = needLargeMem(outSize+1);
seq->dna[outSize] = 0;


/* Skip to bits we need and read them in. */
packedStart = (fragStart>>2);
packedEnd = ((fragEnd+3)>>2);
packByteCount = packedEnd - packedStart;
packed = packedAlloc = needLargeMem(packByteCount);
fseek(f, packedStart, SEEK_CUR);
mustRead(f, packed, packByteCount);

/* Handle case where everything is in one packed byte */
if (packByteCount == 1)
    {
    int pOff = (packedStart<<2);
    int pStart = fragStart - pOff;
    int pEnd = fragEnd - pOff;
    UBYTE partial = *packed;
    assert(pEnd <= 4);
    assert(pStart >= 0);
    for (i=pStart; i<pEnd; ++i)
        *dna++ = valToNt[(partial >> (6-i-i)) & 3];
    }
else
    {
    /* Handle partial first packed byte. */
    midStart = fragStart;
    remainder = (fragStart&3);
    if (remainder > 0)
        {
        UBYTE partial = *packed++;
        int partCount = 4 - remainder;
        for (i=partCount-1; i>=0; --i)
            {
            dna[i] = valToNt[partial&3];
            partial >>= 2;
            }
        midStart += partCount;
        dna += partCount;
        }

    /* Handle middle bytes. */
    remainder = fragEnd&3;
    midEnd = fragEnd - remainder;
    for (i=midStart; i<midEnd; i += 4)
        {
        UBYTE b = *packed++;
        dna[3] = valToNt[b&3];
        b >>= 2;
        dna[2] = valToNt[b&3];
        b >>= 2;
        dna[1] = valToNt[b&3];
        b >>= 2;
        dna[0] = valToNt[b&3];
        dna += 4;
        }

    if (remainder >0)
        {
        UBYTE part = *packed;
        part >>= (8-remainder-remainder);
        for (i=remainder-1; i>=0; --i)
            {
            dna[i] = valToNt[part&3];
            part >>= 2;
            }
        }
    }
freez(&packedAlloc);

if (nBlockCount > 0)
    {
    int startIx = findGreatestLowerBound(nBlockCount, nStarts, fragStart);
    for (i=startIx; i<nBlockCount; ++i)
        {
        int s = nStarts[i];
        int e = s + nSizes[i];
        if (s >= fragEnd)
            break;
        if (s < fragStart)
           s = fragStart;
        if (e > fragEnd)
           e = fragEnd;
        if (s < e)
            memset(seq->dna + s - fragStart, 'n', e - s);
        }
    }

if (doMask)
    {
    toUpperN(seq->dna, seq->size);
    if (maskBlockCount > 0)
        {
        int startIx = findGreatestLowerBound(maskBlockCount, maskStarts, 
                fragStart);
        for (i=startIx; i<maskBlockCount; ++i)
            {
            int s = maskStarts[i];
            int e = s + maskSizes[i];
            if (s >= fragEnd)
                break;
            if (s < fragStart)
                s = fragStart;
            if (e > fragEnd)
                e = fragEnd;
            if (s < e)
                toLowerN(seq->dna + s - fragStart, e - s);
            }
        }
    }
freez(&nStarts);
freez(&nSizes);
freez(&maskStarts);
freez(&maskSizes);
if (retFullSize != NULL)
    *retFullSize = seqSize;
return seq;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct dnaSeq* twoBitReadSeqFragLower	(	struct twoBitFile *	tbf,
		char *	name,
		int	fragStart,
		int	fragEnd
	)			[read]

Definition at line 635 of file twoBit.c.

References FALSE, and twoBitReadSeqFragExt().

Referenced by gfCountTilesInTwoBit(), gfiExpandAndLoadCached(), gfIndexNibsAndTwoBits(), readMaskedTwoBit(), and readSeqFrag().

{
return twoBitReadSeqFragExt(tbf, name, fragStart, fragEnd, FALSE, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct slName* twoBitSeqNames

(

char *

fileName

)

[read]

Definition at line 695 of file twoBit.c.

References twoBitFile::indexList, name, twoBitIndex::name, twoBitIndex::next, slAddHead, slNameNew, slReverse(), twoBitClose(), and twoBitOpen().

{
struct twoBitFile *tbf = twoBitOpen(fileName);
struct twoBitIndex *index;
struct slName *name, *list = NULL;
for (index = tbf->indexList; index != NULL; index = index->next)
    {
    name = slNameNew(index->name);
    slAddHead(&list, name);
    }
twoBitClose(&tbf);
slReverse(&list);
return list;
}

Here is the call graph for this function:

int twoBitSeqSize	(	struct twoBitFile *	tbf,
		char *	name
	)

Definition at line 642 of file twoBit.c.

References twoBitFile::f, twoBitFile::isSwapped, readBits32(), and twoBitSeekTo().

Referenced by dnaLoadSingle(), and gfiExpandAndLoadCached().

{
twoBitSeekTo(tbf, name);
return readBits32(tbf->f, tbf->isSwapped);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int twoBitSeqSizeNoNs	(	struct twoBitFile *	tbf,
		char *	seqName
	)

Definition at line 973 of file twoBit.c.

References AllocArray, bits32, byteSwap32(), twoBitFile::f, freez(), twoBitFile::isSwapped, readBits32(), and twoBitSeekTo().

{
int nBlockCount;
int size;

twoBitSeekTo(tbf, seqName);

size = readBits32(tbf->f, tbf->isSwapped);

/* Read in blocks of N. */
nBlockCount = readBits32(tbf->f, tbf->isSwapped);

if (nBlockCount > 0)
    {
    bits32 *nStarts = NULL, *nSizes = NULL;
    
    int i;

    AllocArray(nStarts, nBlockCount);
    AllocArray(nSizes, nBlockCount);
    fread(nStarts, sizeof(nStarts[0]), nBlockCount, tbf->f);
    fread(nSizes, sizeof(nSizes[0]), nBlockCount, tbf->f);
    if (tbf->isSwapped)
        {
        for (i=0; i<nBlockCount; ++i)
            {
            nStarts[i] = byteSwap32(nStarts[i]);
            nSizes[i] = byteSwap32(nSizes[i]);
            }
        }

    for (i=0; i<nBlockCount; ++i)
        {
        size -= nSizes[i];
        }

    freez(&nStarts);
    freez(&nSizes);
    }

return(size);
}

Here is the call graph for this function:

void twoBitSpecFree

(

struct twoBitSpec **

specPtr

)

Definition at line 915 of file twoBit.c.

References twoBitSpec::fileName, freeMem(), twoBitSeqSpec::name, twoBitSpec::seqs, and slPopHead().

Referenced by twoBitIsSpec(), twoBitLoadAll(), and twoBitSpecNew().

{
struct twoBitSpec *spec = *specPtr;
if (spec != NULL)
    {
    struct twoBitSeqSpec *seq;
    while ((seq = slPopHead(&spec->seqs)) != NULL)
        {
        freeMem(seq->name);
        freeMem(seq);
        }
    freeMem(spec->fileName);
    freeMem(spec);
    *specPtr = NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct twoBitSpec* twoBitSpecNew

(

char *

specStr

)

[read]

Definition at line 839 of file twoBit.c.

References AllocArray, AllocVar, chopString(), cloneString(), endsWith(), twoBitSpec::fileName, parseSeqSpec(), twoBitSpec::seqs, slReverse(), slSafeAddHead(), and twoBitSpecFree().

Referenced by searchOneIndex(), twoBitIsSpec(), and twoBitLoadAll().

                                   :
 *
 *    file/path/input.2bit[:seqSpec1][,seqSpec2,...]
 *
 * where seqSpec is either
 *     seqName
 *  or
 *     seqName:start-end
 *
 * free result with twoBitSpecFree().
 */
{
char *s, *e;
int i, numSeqs;
char **seqSpecs;
struct twoBitSpec *spec;
AllocVar(spec);
spec->fileName = cloneString(specStr);

/* start with final file name  */
s = strrchr(spec->fileName, '/');
if (s == NULL)
    s = spec->fileName;
else
    s++;

/* find end of file name and zero-terminate */
e = strchr(s, ':');
if (e == NULL)
    s = NULL; /* just file name */
else
    {
    *e++ = '\0';
    s = e;
    }
if (!endsWith(spec->fileName, ".2bit"))
    {
    twoBitSpecFree(&spec);
    return NULL; /* not a 2bit file */
    }

if (s != NULL)
    {
    /* chop seqs at commas and parse */
    numSeqs = chopString(s, ",", NULL, 0);
    AllocArray(seqSpecs, numSeqs);
    chopString(s, ",", seqSpecs, numSeqs);
    for (i = 0; i< numSeqs; i++)
        slSafeAddHead(&spec->seqs, parseSeqSpec(seqSpecs[i]));
    slReverse(&spec->seqs);
    }
return spec;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct twoBitSpec* twoBitSpecNewFile	(	char *	twoBitFile,
		char *	specFile
	)			[read]

Definition at line 895 of file twoBit.c.

References AllocVar, cloneString(), twoBitSpec::fileName, lineFileClose(), lineFileNextReal(), lineFileOpen(), parseSeqSpec(), twoBitSpec::seqs, slReverse(), slSafeAddHead(), trimSpaces(), and TRUE.

                                                                  :
 *     seqName
 *  or
 *     seqName:start-end
 */
{
struct lineFile *lf = lineFileOpen(specFile, TRUE);
char *line;
struct twoBitSpec *spec;
AllocVar(spec);
spec->fileName = cloneString(twoBitFile);
while (lineFileNextReal(lf, &line))
    slSafeAddHead(&spec->seqs, parseSeqSpec(trimSpaces(line)));
slReverse(&spec->seqs);
lineFileClose(&lf);
return spec;
}

Here is the call graph for this function:

long long twoBitTotalSize

(

struct twoBitFile *

tbf

)

Definition at line 649 of file twoBit.c.

References twoBitFile::f, twoBitFile::indexList, twoBitFile::isSwapped, twoBitIndex::next, twoBitIndex::offset, readBits32(), and SEEK_SET.

Referenced by twoBitCheckTotalSize().

{
struct twoBitIndex *index;
long long totalSize = 0;
for (index = tbf->indexList; index != NULL; index = index->next)
    {
    fseek(tbf->f, index->offset, SEEK_SET);
    totalSize += readBits32(tbf->f, tbf->isSwapped);
    }
return totalSize;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void twoBitWriteHeader	(	struct twoBit *	twoBitList,
		FILE *	f
	)

Definition at line 217 of file twoBit.c.

References bits32, errAbort(), twoBit::name, twoBit::next, twoBit::reserved, twoBit::size, slCount(), twoBitSig, twoBitSizeInFile(), writeOne, and writeString().

{
bits32 sig = twoBitSig;
bits32 version = 0;
bits32 seqCount = slCount(twoBitList);
bits32 reserved = 0;
bits32 offset = 0;
struct twoBit *twoBit;
long long counter = 0; /* check for 32 bit overflow */

/* Write out fixed parts of header. */
writeOne(f, sig);
writeOne(f, version);
writeOne(f, seqCount);
writeOne(f, reserved);

/* Figure out location of first byte past index.
 * Each index entry contains 4 bytes of offset information
 * and the name of the sequence, which is variable length. */
offset = sizeof(sig) + sizeof(version) + sizeof(seqCount) + sizeof(reserved);
for (twoBit = twoBitList; twoBit != NULL; twoBit = twoBit->next)
    {
    int nameLen = strlen(twoBit->name);
    if (nameLen > 255)
        errAbort("name %s too long", twoBit->name);
    offset += nameLen + 1 + sizeof(bits32);
    }

/* Write out index. */
for (twoBit = twoBitList; twoBit != NULL; twoBit = twoBit->next)
    {
    int size = twoBitSizeInFile(twoBit);
    writeString(f, twoBit->name);
    writeOne(f, offset);
    offset += size;
    counter += (long long)size;
    if (counter > UINT_MAX )
        errAbort("Error in faToTwoBit, index overflow at %s. The 2bit format "
                "does not support indexes larger than %dGb, \n"
                "please split up into smaller files.\n", 
                twoBit->name, UINT_MAX/1000000000);
    }
}

Here is the call graph for this function:

void twoBitWriteOne	(	struct twoBit *	twoBit,
		FILE *	f
	)

Definition at line 191 of file twoBit.c.

References twoBit::data, twoBit::maskBlockCount, twoBit::maskSizes, twoBit::maskStarts, mustWrite(), twoBit::nBlockCount, twoBit::nSizes, twoBit::nStarts, packedSize(), twoBit::reserved, twoBit::size, and writeOne.

{
writeOne(f, twoBit->size);
writeOne(f, twoBit->nBlockCount);
if (twoBit->nBlockCount > 0)
    {
    fwrite(twoBit->nStarts, sizeof(twoBit->nStarts[0]), 
        twoBit->nBlockCount, f);
    fwrite(twoBit->nSizes, sizeof(twoBit->nSizes[0]), 
        twoBit->nBlockCount, f);
    }
writeOne(f, twoBit->maskBlockCount);
if (twoBit->maskBlockCount > 0)
    {
    fwrite(twoBit->maskStarts, sizeof(twoBit->maskStarts[0]), 
        twoBit->maskBlockCount, f);
    fwrite(twoBit->maskSizes, sizeof(twoBit->maskSizes[0]), 
        twoBit->maskBlockCount, f);
    }
writeOne(f, twoBit->reserved);
mustWrite(f, twoBit->data, packedSize(twoBit->size));
}

Here is the call graph for this function:

---