stList *mergeSimpleCycles(stList *cycles, stList *nonZeroWeightAdjacencyEdges,
stSortedSet *allAdjacencyEdges) {
/*
* Takes a set of simple cycles (containing only the adjacency edges).
* Returns a single simple cycle, as a list of edges, by doing length(components)-1
* calls to doBestMergeOfTwoSimpleCycles.
*/
/*
* Build a hash of nodes to adjacency edges.
*/
cycles = stList_copy(cycles, NULL);
for (int64_t i = 0; i < stList_length(cycles); i++) { //Clone the complete list
assert(stList_length(stList_get(cycles, i)) > 0);
assert(!stList_contains(stList_get(cycles, i), NULL));
stList_set(cycles, i, stList_copy(stList_get(cycles, i), NULL));
}
while (stList_length(cycles) > 1) {
doBestMergeOfTwoSimpleCycles(cycles, nonZeroWeightAdjacencyEdges,
allAdjacencyEdges);
}
assert(stList_length(cycles) == 1);
stList *mergedComponent = stList_get(cycles, 0);
stList_destruct(cycles);
return mergedComponent;
}
void test_stList_set(CuTest *testCase) {
setup();
int64_t i;
for(i=0; i<stringNumber; i++) {
stList_set(list, i, NULL);
CuAssertTrue(testCase, stList_get(list, i) == NULL);
}
teardown();
}
stList *stSortedSet_getList(stSortedSet *sortedSet) {
stList *list = stList_construct2(stSortedSet_size(sortedSet));
stSortedSetIterator *it = stSortedSet_getIterator(sortedSet);
void *o;
int32_t i=0;
while((o = stSortedSet_getNext(it)) != NULL) {
stList_set(list, i++, o);
}
assert(i == stSortedSet_size(sortedSet));
stSortedSet_destructIterator(it);
return list;
}
static stList *bulkGetRecordsRange(stKVDatabase *database, int64_t firstKey, int64_t numRecords) {
stList* results = stList_construct3(numRecords, (void(*)(void *))stKVDatabaseBulkResult_destruct);
startTransaction(database);
stTry {
for (int32_t i = 0; i < numRecords; ++i)
{
int64_t key = firstKey + i;
int64_t recordSize;
void* record = getRecord2(database, key, &recordSize);
stKVDatabaseBulkResult* result = stKVDatabaseBulkResult_construct(record, recordSize);
stList_set(results, i, result);
}
commitTransaction(database);
}stCatch(ex) {
abortTransaction(database);
stThrowNewCause(ex, ST_KV_DATABASE_EXCEPTION_ID, "tokyo cabinet bulk get records failed");
}stTryEnd;
return results;
}
static stList *getRecords(CactusDisk *cactusDisk, stList *objectNames, char *type) {
if (stList_length(objectNames) == 0) {
return stList_construct3(0, NULL);
}
stList *records = NULL;
stTry
{
records = stKVDatabase_bulkGetRecords(cactusDisk->database, objectNames);
}
stCatch(except)
{
stThrowNewCause(except, ST_KV_DATABASE_EXCEPTION_ID,
"An unknown database error occurred when getting a bulk set of %s", type);
}stTryEnd
;
assert(records != NULL);
assert(stList_length(objectNames) == stList_length(records));
stList_setDestructor(records, free);
for (int64_t i = 0; i < stList_length(objectNames); i++) {
Name objectName = *((int64_t *) stList_get(objectNames, i));
int64_t recordSize;
void *record;
stKVDatabaseBulkResult *result = stList_get(records, i);
assert(result != NULL);
if (!stCache_containsRecord(cactusDisk->cache, objectName, 0, INT64_MAX)) {
record = stKVDatabaseBulkResult_getRecord(result, &recordSize);
assert(recordSize >= 0);
assert(record != NULL);
record = decompress(record, &recordSize);
stCache_setRecord(cactusDisk->cache, objectName, 0, recordSize, record);
} else {
record = stCache_getRecord(cactusDisk->cache, objectName, 0, INT64_MAX, &recordSize);
assert(recordSize >= 0);
assert(record != NULL);
}
stKVDatabaseBulkResult_destruct(result);
stList_set(records, i, record);
}
return records;
}
static void testBulkGetRecords(CuTest* testCase) {
/*
* Tests the new bulk get functions
*/
setup();
int64_t i = 100, j = 110, k = 120, l = 130;
int64_t bigRecSize = 184500800;
int64_t* m = (int64_t*)st_malloc(bigRecSize);
int64_t ki = 4, kj = 5, kk = 3, kl = 1, km = 2;
stKVDatabase_insertRecord(database, 1, &i, sizeof(int64_t));
stList *requests = stList_construct3(0, (void(*)(void *)) stKVDatabaseBulkRequest_destruct);
stList_append(requests, stKVDatabaseBulkRequest_constructInsertRequest(ki, &i, sizeof(int64_t)));
stList_append(requests, stKVDatabaseBulkRequest_constructInsertRequest(kj, &j, sizeof(int64_t)));
stList_append(requests, stKVDatabaseBulkRequest_constructSetRequest(kk, &k, sizeof(int64_t)));
stList_append(requests, stKVDatabaseBulkRequest_constructUpdateRequest(kl, &l, sizeof(int64_t)));
stKVDatabase_bulkSetRecords(database, requests);
stList_destruct(requests);
stKVDatabase_setRecord(database, km, m, bigRecSize);
stList* keys = stList_construct2(5);
stList_set(keys, 0, &ki);
stList_set(keys, 1, &kj);
stList_set(keys, 2, &kk);
stList_set(keys, 3, &kl);
stList_set(keys, 4, &km);
stList* results = stKVDatabase_bulkGetRecords(database, keys);
CuAssertTrue(testCase, stList_length(results) == 5);
void* record;
int64_t size;
stKVDatabaseBulkResult* res0 = (stKVDatabaseBulkResult*)stList_get(results, 0);
record = stKVDatabaseBulkResult_getRecord(res0, &size);
CuAssertTrue(testCase, record != NULL);
CuAssertTrue(testCase, *(int64_t*)record == i && size == sizeof(int64_t));
stKVDatabaseBulkResult* res1 = (stKVDatabaseBulkResult*)stList_get(results, 1);
record = stKVDatabaseBulkResult_getRecord(res1, &size);
CuAssertTrue(testCase, record != NULL);
CuAssertTrue(testCase, *(int64_t*)record == j && size == sizeof(int64_t));
stKVDatabaseBulkResult* res2 = (stKVDatabaseBulkResult*)stList_get(results, 2);
record = stKVDatabaseBulkResult_getRecord(res2, &size);
CuAssertTrue(testCase, record != NULL);
CuAssertTrue(testCase, *(int64_t*)record == k && size == sizeof(int64_t));
stKVDatabaseBulkResult* res3 = (stKVDatabaseBulkResult*)stList_get(results, 3);
record = stKVDatabaseBulkResult_getRecord(res3, &size);
CuAssertTrue(testCase, record != NULL);
CuAssertTrue(testCase, *(int64_t*)record == l && size == sizeof(int64_t));
stKVDatabaseBulkResult* res4 = (stKVDatabaseBulkResult*)stList_get(results, 4);
record = stKVDatabaseBulkResult_getRecord(res4, &size);
CuAssertTrue(testCase, record != NULL);
CuAssertTrue(testCase, size == bigRecSize);
stList_destruct(results);
results = stKVDatabase_bulkGetRecordsRange(database, 1, 6);
CuAssertTrue(testCase, stList_length(results) == 6);
res0 = (stKVDatabaseBulkResult*)stList_get(results, 0);
record = stKVDatabaseBulkResult_getRecord(res0, &size);
CuAssertTrue(testCase, record != NULL);
CuAssertTrue(testCase, *(int64_t*)record == l && size == sizeof(int64_t));
res1 = (stKVDatabaseBulkResult*)stList_get(results, 1);
record = stKVDatabaseBulkResult_getRecord(res1, &size);
CuAssertTrue(testCase, record != NULL);
CuAssertTrue(testCase, size == bigRecSize);
res2 = (stKVDatabaseBulkResult*)stList_get(results, 2);
record = stKVDatabaseBulkResult_getRecord(res2, &size);
CuAssertTrue(testCase, record != NULL);
CuAssertTrue(testCase, *(int64_t*)record == k && size == sizeof(int64_t));
res3 = (stKVDatabaseBulkResult*)stList_get(results, 3);
record = stKVDatabaseBulkResult_getRecord(res3, &size);
CuAssertTrue(testCase, record != NULL);
CuAssertTrue(testCase, *(int64_t*)record == i && size == sizeof(int64_t));
res4 = (stKVDatabaseBulkResult*)stList_get(results, 4);
record = stKVDatabaseBulkResult_getRecord(res4, &size);
CuAssertTrue(testCase, record != NULL);
CuAssertTrue(testCase, *(int64_t*)record == j && size == sizeof(int64_t));
stKVDatabaseBulkResult* res5 = (stKVDatabaseBulkResult*)stList_get(results, 5);
record = stKVDatabaseBulkResult_getRecord(res5, &size);
CuAssertTrue(testCase, record == NULL);
stList_destruct(results);
free(m);
teardown();
}
void stTree_setChild(stTree *tree, int64_t i, stTree *child) {
assert(i >= 0);
assert(i < stTree_getChildNumber(tree));
stList_set(tree->nodes, i, child);
}
