struct psl *mirrorLmPsl(struct psl *psl, struct lm *lm)
/* Reflect a psl into local memory. */
{
struct psl *p = lmCloneMem(lm, psl, sizeof(*psl));
p->qNumInsert = psl->tNumInsert;
p->tNumInsert = psl->qNumInsert;
p->qBaseInsert = psl->tBaseInsert;
p->tBaseInsert = psl->qBaseInsert;
p->qName = lmCloneString(lm, psl->tName);
p->tName = lmCloneString(lm, psl->qName);
p->qSize = psl->tSize;
p->tSize = psl->qSize;
p->qStart = psl->tStart;
p->tStart = psl->qStart;
p->qEnd = psl->tEnd;
p->tEnd = psl->qEnd;
p->blockSizes = lmCloneMem(lm, psl->blockSizes, psl->blockCount*sizeof(psl->blockSizes[0]));
p->qStarts = lmCloneMem(lm, psl->tStarts, psl->blockCount*sizeof(psl->tStarts[0]));
p->tStarts = lmCloneMem(lm, psl->qStarts, psl->blockCount*sizeof(psl->tStarts[0]));
if (p->strand[0] == '-')
{
reverseStartList(psl->qStarts, p->tStarts, p->blockSizes, p->blockCount, p->tSize);
reverseStartList(psl->tStarts, p->qStarts, p->blockSizes, p->blockCount, p->qSize);
reverseSizeList(psl->blockSizes, p->blockSizes, p->blockCount);
}
return p;
}
struct annoRow *annoRowWigNew(char *chrom, uint start, uint end, boolean rightJoinFail,
float *values, struct lm *lm)
/* Allocate & return an annoRowWig, with clone of values; length of values is (end-start). */
{
struct annoRow *row;
lmAllocVar(lm, row);
row->chrom = lmCloneString(lm, chrom);
row->start = start;
row->end = end;
row->data = lmCloneMem(lm, values, (end - start) * sizeof(values[0]));
row->rightJoinFail = rightJoinFail;
return row;
}
static struct rTree *rTreeFromChromRangeArray( struct lm *lm, int blockSize, int itemsPerSlot,
void *itemArray, int itemSize, bits64 itemCount, void *context,
struct cirTreeRange (*fetchKey)(const void *va, void *context),
bits64 (*fetchOffset)(const void *va, void *context), bits64 endFileOffset,
int *retLevelCount)
{
char *items = itemArray;
struct rTree *el, *list=NULL, *tree = NULL;
/* Make first level above leaf. */
bits64 i;
bits64 nextOffset = (*fetchOffset)(items, context);
for (i=0; i<itemCount; i += itemsPerSlot)
{
/* Figure out if we are on final iteration through loop, and the
* count of items in this iteration. */
boolean finalIteration = FALSE;
int oneSize = itemCount-i;
if (oneSize > itemsPerSlot)
oneSize = itemsPerSlot;
else
finalIteration = TRUE;
/* Allocate element and put on list. */
lmAllocVar(lm, el);
slAddHead(&list, el);
/* Fill out most of element from first item in element. */
char *startItem = items + itemSize * i;
struct cirTreeRange key = (*fetchKey)(startItem, context);
el->startChromIx = el->endChromIx = key.chromIx;
el->startBase = key.start;
el->endBase = key.end;
el->startFileOffset = nextOffset;
/* Figure out end of element from offset of next element (or file size
* for final element.) */
if (finalIteration)
nextOffset = endFileOffset;
else
{
char *endItem = startItem + itemSize*oneSize;
nextOffset = (*fetchOffset)(endItem, context);
}
el->endFileOffset = nextOffset;
/* Expand area spanned to include all items in block. */
int j;
for (j=1; j<oneSize; ++j)
{
void *item = items + itemSize*(i+j);
key = (*fetchKey)(item, context);
if (key.chromIx < el->startChromIx)
{
el->startChromIx = key.chromIx;
el->startBase = key.start;
}
else if (key.chromIx == el->startChromIx)
{
if (key.start < el->startBase)
el->startBase = key.start;
}
if (key.chromIx > el->endChromIx)
{
el->endChromIx = key.chromIx;
el->endBase = key.end;
}
else if (key.chromIx == el->endChromIx)
{
if (key.end > el->endBase)
el->endBase = key.end;
}
}
}
slReverse(&list);
verbose(2, "Made %d primary index nodes out of %llu items\n", slCount(list), itemCount);
/* Now iterate through making more and more condensed versions until have just one. */
int levelCount = 1;
tree = list;
while (tree->next != NULL || levelCount < 2)
{
list = NULL;
int slotsUsed = blockSize;
struct rTree *parent = NULL, *next;
for (el = tree; el != NULL; el = next)
{
next = el->next;
if (slotsUsed >= blockSize)
{
slotsUsed = 1;
lmAllocVar(lm, parent);
parent = lmCloneMem(lm, el, sizeof(*el));
parent->children = el;
el->parent = parent;
el->next = NULL;
slAddHead(&list, parent);
}
else
{
++slotsUsed;
slAddHead(&parent->children, el);
el->parent = parent;
if (el->startChromIx < parent->startChromIx)
{
parent->startChromIx = el->startChromIx;
parent->startBase = el->startBase;
}
else if (el->startChromIx == parent->startChromIx)
{
if (el->startBase < parent->startBase)
parent->startBase = el->startBase;
}
if (el->endChromIx > parent->endChromIx)
{
parent->endChromIx = el->endChromIx;
parent->endBase = el->endBase;
}
else if (el->endChromIx == parent->endChromIx)
{
if (el->endBase > parent->endBase)
parent->endBase = el->endBase;
}
}
}
slReverse(&list);
for (el = list; el != NULL; el = el->next)
slReverse(&el->children);
tree = list;
levelCount += 1;
}
*retLevelCount = levelCount;
return tree;
}
