void test_stList_nullList(CuTest *testCase) {
stList *empty = NULL;
CuAssertTrue(testCase, stList_length(empty) == 0);
stListIterator *it = stList_getIterator(empty);
CuAssertTrue(testCase, stList_getNext(it) == NULL);
CuAssertTrue(testCase, stList_getPrevious(it) == NULL);
stList_destructIterator(it);
stList_destruct(empty);
}
void test_stList_iterator(CuTest *testCase) {
setup();
stListIterator *it = stList_getIterator(list);
int64_t i;
for(i=0; i<stringNumber; i++) {
CuAssertTrue(testCase, stList_getNext(it) == strings[i]);
}
CuAssertTrue(testCase, stList_getNext(it) == NULL);
CuAssertTrue(testCase, stList_getNext(it) == NULL);
stListIterator *it2 = stList_copyIterator(it);
for(i=0; i<stringNumber; i++) {
CuAssertTrue(testCase, stList_getPrevious(it) == strings[stringNumber-1-i]);
CuAssertTrue(testCase, stList_getPrevious(it2) == strings[stringNumber-1-i]);
}
CuAssertTrue(testCase, stList_getPrevious(it) == NULL);
CuAssertTrue(testCase, stList_getPrevious(it) == NULL);
CuAssertTrue(testCase, stList_getPrevious(it2) == NULL);
stList_destructIterator(it);
teardown();
}
/* write a malnSet to a MAF file */
void malnSet_writeMaf(struct malnSet *malnSet, char *mafFileName) {
malnSet_assert(malnSet);
stList *sorted = buildRootSorted(malnSet);
FILE *mafFh = mustOpen(mafFileName, "w");
mafWriteStart(mafFh, NULL);
stListIterator *iter = stList_getIterator(sorted);
struct malnBlk *blk;
while ((blk = stList_getNext(iter)) != NULL) {
writeBlkToMaf(blk, mafFh);
}
stList_destructIterator(iter);
mafWriteEnd(mafFh);
carefulClose(&mafFh);
stList_destruct(sorted);
}
/*
* This builds an adjacency list structure for the the sequences. Every sequence-position
* has a column in the hash with which it can be aligned with.
*/
static stHash *buildAdjacencyList(stList *pairs, int64_t sequenceNumber) {
stHash *hash = stHash_construct3((uint64_t (*)(const void *))stIntTuple_hashKey,
(int (*)(const void *, const void *))stIntTuple_equalsFn,
(void (*)(void *))stIntTuple_destruct, NULL);
for(int64_t seq=0; seq<sequenceNumber; seq++) {
for(int64_t position=0; position<MAX_SEQUENCE_SIZE; position++) {
stIntTuple *seqPos = stIntTuple_construct2( seq, position);
stSortedSet *column = stSortedSet_construct3((int (*)(const void *, const void *))stIntTuple_cmpFn, NULL);
stSortedSet_insert(column, seqPos);
stHash_insert(hash, seqPos, column);
}
}
stListIterator *it = stList_getIterator(pairs);
stIntTuple *pair;
while((pair = stList_getNext(it)) != NULL) {
stIntTuple *seqPos1 = stIntTuple_construct2( stIntTuple_get(pair, 0), stIntTuple_get(pair, 1));
stIntTuple *seqPos2 = stIntTuple_construct2( stIntTuple_get(pair, 2), stIntTuple_get(pair, 3));
stSortedSet *column1 = stHash_search(hash, seqPos1);
assert(column1 != NULL);
stSortedSet *column2 = stHash_search(hash, seqPos2);
assert(column2 != NULL);
if(column1 != column2) { //Merge the columns
stSortedSetIterator *it2 = stSortedSet_getIterator(column2);
stIntTuple *seqPos3;
while((seqPos3 = stSortedSet_getNext(it2)) != NULL) {
assert(stSortedSet_search(column1, seqPos3) == NULL);
stSortedSet_insert(column1, seqPos3);
assert(stHash_search(hash, seqPos3) == column2);
stHash_insert(hash, seqPos3, column1);
assert(stHash_search(hash, seqPos3) == column1);
}
stSortedSet_destructIterator(it2);
stSortedSet_destruct(column2);
}
//Cleanup loop.
stIntTuple_destruct(seqPos1);
stIntTuple_destruct(seqPos2);
}
stList_destructIterator(it);
return hash;
}
static void cacheSubstringsFromDB(CactusDisk *cactusDisk, stList *substrings) {
/*
* Caches the given set of substrings in the cactusDisk cache.
*/
if (cactusDisk->storeSequencesInAFile) {
if (cactusDisk->sequencesReadFileHandle == NULL) {
if(cactusDisk->sequencesWriteFileHandle != NULL) {
fsync(fileno(cactusDisk->sequencesWriteFileHandle));
fclose(cactusDisk->sequencesWriteFileHandle);
cactusDisk->sequencesWriteFileHandle = NULL;
}
cactusDisk->sequencesReadFileHandle = fopen(cactusDisk->absSequencesFileName, "r");
assert(cactusDisk->sequencesReadFileHandle != NULL);
}
else {
assert(cactusDisk->sequencesWriteFileHandle == NULL);
}
for (int64_t i = 0; i < stList_length(substrings); i++) {
Substring *substring = stList_get(substrings, i);
char *string = getStringFromDisk(cactusDisk->sequencesReadFileHandle, substring->name, substring->start,
substring->length);
stCache_setRecord(cactusDisk->stringCache, substring->name, substring->start, substring->length, string);
#ifndef NDEBUG
int64_t bytesRead;
char *string2 = stCache_getRecord(cactusDisk->stringCache, substring->name, substring->start,
substring->length, &bytesRead);
assert(bytesRead == substring->length);
for (int64_t j = 0; j < substring->length; j++) {
assert(string2[j] == string[j]);
}
free(string2);
#endif
free(string);
}
} else {
stList *getRequests = stList_construct3(0, free);
for (int64_t i = 0; i < stList_length(substrings); i++) {
Substring *substring = stList_get(substrings, i);
int64_t intervalSize = (substring->length + substring->start - 1) / CACTUS_DISK_SEQUENCE_CHUNK_SIZE
- substring->start / CACTUS_DISK_SEQUENCE_CHUNK_SIZE + 1;
Name shiftedName = substring->name + substring->start / CACTUS_DISK_SEQUENCE_CHUNK_SIZE;
for (int64_t j = 0; j < intervalSize; j++) {
int64_t *k = st_malloc(sizeof(int64_t));
k[0] = shiftedName + j;
stList_append(getRequests, k);
}
}
if (stList_length(getRequests) == 0) {
stList_destruct(getRequests);
return;
}
stList *records = NULL;
stTry
{
records = stKVDatabase_bulkGetRecords(cactusDisk->database, getRequests);
}
stCatch(except)
{
stThrowNewCause(except, ST_KV_DATABASE_EXCEPTION_ID,
"An unknown database error occurred when getting a sequence string");
}stTryEnd
;
assert(records != NULL);
assert(stList_length(records) == stList_length(getRequests));
stList_destruct(getRequests);
stListIterator *recordsIt = stList_getIterator(records);
for (int64_t i = 0; i < stList_length(substrings); i++) {
Substring *substring = stList_get(substrings, i);
int64_t intervalSize = (substring->length + substring->start - 1) / CACTUS_DISK_SEQUENCE_CHUNK_SIZE
- substring->start / CACTUS_DISK_SEQUENCE_CHUNK_SIZE + 1;
stList *strings = stList_construct();
while (intervalSize-- > 0) {
int64_t recordSize;
stKVDatabaseBulkResult *result = stList_getNext(recordsIt);
assert(result != NULL);
char *string = stKVDatabaseBulkResult_getRecord(result, &recordSize);
assert(string != NULL);
assert(strlen(string) == recordSize - 1);
stList_append(strings, string);
assert(recordSize <= CACTUS_DISK_SEQUENCE_CHUNK_SIZE + 1);
}
assert(stList_length(strings) > 0);
char *joinedString = stString_join2("", strings);
stCache_setRecord(cactusDisk->stringCache, substring->name,
(substring->start / CACTUS_DISK_SEQUENCE_CHUNK_SIZE) * CACTUS_DISK_SEQUENCE_CHUNK_SIZE,
strlen(joinedString), joinedString);
free(joinedString);
stList_destruct(strings);
}
assert(stList_getNext(recordsIt) == NULL);
stList_destructIterator(recordsIt);
stList_destruct(records);
}
}
