/* =============================================================================
* hashtable_insert
* =============================================================================
*/
bool_t
hashtable_insert (hashtable_t* hashtablePtr, void* keyPtr, void* dataPtr)
{
long numBucket = hashtablePtr->numBucket;
long i = hashtablePtr->hash(keyPtr) % numBucket;
#if defined(HASHTABLE_SIZE_FIELD) || defined(HASHTABLE_RESIZABLE)
long newSize;
#endif
pair_t findPair;
findPair.firstPtr = keyPtr;
pair_t* pairPtr = (pair_t*)list_find(hashtablePtr->buckets[i], &findPair);
if (pairPtr != NULL) {
return FALSE;
}
pair_t* insertPtr = pair_alloc(keyPtr, dataPtr);
if (insertPtr == NULL) {
return FALSE;
}
#ifdef HASHTABLE_SIZE_FIELD
newSize = hashtablePtr->size + 1;
assert(newSize > 0);
#elif defined(HASHTABLE_RESIZABLE)
newSize = hashtable_getSize(hashtablePtr) + 1;
assert(newSize > 0);
#endif
#ifdef HASHTABLE_RESIZABLE
/* Increase number of buckets to maintain size ratio */
if (newSize >= (numBucket * hashtablePtr->resizeRatio)) {
list_t** newBuckets = rehash(hashtablePtr);
if (newBuckets == NULL) {
return FALSE;
}
freeBuckets(hashtablePtr->buckets, numBucket);
numBucket *= hashtablePtr->growthFactor;
hashtablePtr->buckets = newBuckets;
hashtablePtr->numBucket = numBucket;
i = hashtablePtr->hash(keyPtr) % numBucket;
}
#endif
/* Add new entry */
if (list_insert(hashtablePtr->buckets[i], insertPtr) == FALSE) {
pair_free(insertPtr);
return FALSE;
}
#ifdef HASHTABLE_SIZE_FIELD
hashtablePtr->size = newSize;
#endif
return TRUE;
}
/* =============================================================================
* maze_read
* -- Return number of path to route
* =============================================================================
*/
long
maze_read (maze_t* mazePtr, char* inputFileName)
{
FILE* inputFile = fopen(inputFileName, "rt");
if (!inputFile) {
fprintf(stderr, "Error: Could not read %s\n", inputFileName);
exit(1);
}
/*
* Parse input file
*/
long lineNumber = 0;
long height = -1;
long width = -1;
long depth = -1;
char line[256];
list_t* workListPtr = list_alloc(&coordinate_comparePair);
vector_t* wallVectorPtr = mazePtr->wallVectorPtr;
vector_t* srcVectorPtr = mazePtr->srcVectorPtr;
vector_t* dstVectorPtr = mazePtr->dstVectorPtr;
while (fgets(line, sizeof(line), inputFile)) {
char code;
long x1, y1, z1;
long x2, y2, z2;
long numToken = sscanf(line, " %c %li %li %li %li %li %li",
&code, &x1, &y1, &z1, &x2, &y2, &z2);
lineNumber++;
if (numToken < 1) {
continue;
}
switch (code) {
case '#': { /* comment */
/* ignore line */
break;
}
case 'd': { /* dimensions (format: d x y z) */
if (numToken != 4) {
goto PARSE_ERROR;
}
width = x1;
height = y1;
depth = z1;
if (width < 1 || height < 1 || depth < 1) {
goto PARSE_ERROR;
}
break;
}
case 'p': { /* paths (format: p x1 y1 z1 x2 y2 z2) */
if (numToken != 7) {
goto PARSE_ERROR;
}
coordinate_t* srcPtr = coordinate_alloc(x1, y1, z1);
coordinate_t* dstPtr = coordinate_alloc(x2, y2, z2);
assert(srcPtr);
assert(dstPtr);
if (coordinate_isEqual(srcPtr, dstPtr)) {
goto PARSE_ERROR;
}
pair_t* coordinatePairPtr = pair_alloc(srcPtr, dstPtr);
assert(coordinatePairPtr);
bool_t status = list_insert(workListPtr, (void*)coordinatePairPtr);
assert(status == TRUE);
vector_pushBack(srcVectorPtr, (void*)srcPtr);
vector_pushBack(dstVectorPtr, (void*)dstPtr);
break;
}
case 'w': { /* walls (format: w x y z) */
if (numToken != 4) {
goto PARSE_ERROR;
}
coordinate_t* wallPtr = coordinate_alloc(x1, y1, z1);
vector_pushBack(wallVectorPtr, (void*)wallPtr);
break;
}
PARSE_ERROR:
default: { /* error */
fprintf(stderr, "Error: line %li of %s invalid\n",
lineNumber, inputFileName);
exit(1);
}
}
} /* iterate over lines in input file */
fclose(inputFile);
/*
* Initialize grid contents
*/
if (width < 1 || height < 1 || depth < 1) {
fprintf(stderr, "Error: Invalid dimensions (%li, %li, %li)\n",
width, height, depth);
exit(1);
}
grid_t* gridPtr = grid_alloc(width, height, depth);
assert(gridPtr);
mazePtr->gridPtr = gridPtr;
addToGrid(gridPtr, wallVectorPtr, "wall");
addToGrid(gridPtr, srcVectorPtr, "source");
addToGrid(gridPtr, dstVectorPtr, "destination");
printf("Maze dimensions = %li x %li x %li\n", width, height, depth);
printf("Paths to route = %li\n", list_getSize(workListPtr));
/*
* Initialize work queue
*/
queue_t* workQueuePtr = mazePtr->workQueuePtr;
list_iter_t it;
list_iter_reset(&it, workListPtr);
while (list_iter_hasNext(&it)) {
pair_t* coordinatePairPtr = (pair_t*)list_iter_next(&it);
queue_push(workQueuePtr, (void*)coordinatePairPtr);
}
list_free(workListPtr);
return vector_getSize(srcVectorPtr);
}
