/*
insert the following values into a hashLink, you must create this hashLink but
only after you confirm that this key does not already exist in the table. For example, you
cannot have two hashLinks for the word "taco".
if a hashLink already exists in the table for the key provided you should
replace that hashLink--this requires freeing up the old memory pointed by hashLink->value
and then pointing hashLink->value to value v.
also, you must monitor the load factor and resize when the load factor is greater than
or equal LOAD_FACTOR_THRESHOLD (defined in hashMap.h).
*/
void insertMap (struct hashMap * ht, KeyType k, ValueType v)
{
int hash;
if(HASHING_FUNCTION == 1){
hash = stringHash1(k);
}
if(HASHING_FUNCTION == 2){
hash = stringHash2(k);
}
if(tableLoad(ht) >= LOAD_FACTOR_THRESHOLD){
_setTableSize(ht, ht->tableSize *2);
}
int idx;
idx = hash % ht->tableSize;
if (containsKey(ht, k)) {
ht->table[idx]->value++;
}
else {
struct hashLink *newLink = (struct hashLink *)malloc(sizeof(struct hashLink));
newLink->value = v;
newLink->key = k;
newLink->next = ht->table[idx];
ht->table[idx] = newLink;
ht->count++;
}
}
bool
sd::core::AttributeKey::addNewKey(const std::string& name) {
if(containsKey(name))
return false;
m_existingKeys.push_back(AttributeKey(name));
return true;
}
/*
find the hashlink for the supplied key and remove it, also freeing the memory
for that hashlink. it is not an error to be unable to find the hashlink, if it
cannot be found do nothing (or print a message) but do not use an assert which
will end your program.
*/
void removeKey (struct hashMap * ht, KeyType k)
{
assert(ht != NULL);
int loc = stringHash1(k) % ht->tableSize;
if(containsKey(ht, k)){
struct hashLink* pLink = ht->table[loc];
struct hashLink* pLink2 = pLink;
while(strcmp(pLink->key,k)){
pLink2 = pLink;
pLink = pLink->next;
}
if(pLink == pLink2){
ht->table[loc] = pLink->next;
} else {
pLink2->next = pLink->next;
}
free(pLink->key);
free(pLink);
} else {
//Do nothing
}
}
/*
this returns the value (which is void*) stored in a hashLink specified by the key k.
if the user supplies the key "taco" you should find taco in the hashTable, then
return the value member of the hashLink that represents taco.
if the supplied key is not in the hashtable return NULL.
*/
ValueType atMap (struct hashMap * ht, KeyType k)
{
hashLink * cur;
int hashVal;
assert(ht != NULL);
if (!containsKey(ht, k))
return NULL;
else {
if (HASHING_FUNCTION == 1)
hashVal = stringHash1(k) % ht->tableSize;
else if (HASHING_FUNCTION == 2)
hashVal = stringHash2(k) % ht->tableSize;
if (hashVal < 0)
hashVal += ht->tableSize;
cur = ht->table[hashVal];
while (strcmp(cur->key, k) != 0)
cur = cur->next;
return cur->value;
}
}
/*
this returns the value (which is void*) stored in a hashLink specified by the key k.
if the user supplies the key "taco" you should find taco in the hashTable, then
return the value member of the hashLink that represents taco.
if the supplied key is not in the hashtable return NULL.
*/
ValueType atMap (struct hashMap *ht, KeyType k)
{
/*write this*/
int hash;
int idx;
struct hashLink *link;
//printf("TableSize:%d\n",ht->tableSize);
if(HASHING_FUNCTION == 1){
hash = stringHash1(k);
}
if(HASHING_FUNCTION == 2){
hash = stringHash2(k);
}
idx = hash % ht->tableSize;
//printf("hash:%d\nIndex:%d\n", hash, Index);
if(containsKey(ht,k)!=0){
link = ht->table[idx];
while (link != NULL){
if (strcmp(link->key, k) == 0){
//printf("Found It\n");
//printf("hash:%d\nIndex:%d\n", hash, Index);
return link->value;
}
else{
link = link->next;
//printf("Checking Next\n");
}
}
}
//printf("Exiting AtMap now\n");
//assert(0);
return NULL;
}
template<typename T> T config::getParam(string key, T def)
{
//Checks for key in the file.
T val = def;
bool exists = containsKey(key);
//If it exists grab the value.
if (exists == true)
{
val = dynamic_cast<T>(options[key]);
}
//If we want output then write what happened.
if (suppressOutput == false)
{
if (exists == false)
{
std::cout << "-Option: '" << key << "' missing\n";
std::cout << "-Using default.\n";
}
std::cout << "---" << key << ": " << val << "\n";
}
return val;
}
/*
insert the following values into a hashLink, you must create this hashLink but
only after you confirm that this key does not already exist in the table. For example, you
cannot have two hashLinks for the word "taco".
if a hashLink already exists in the table for the key provided you should
replace that hashLink--this requires freeing up the old memory pointed by hashLink->value
and then pointing hashLink->value to value v.
also, you must monitor the load factor and resize when the load factor is greater than
or equal LOAD_FACTOR_THRESHOLD (defined in hashMap.h).
*/
void insertMap (struct hashMap * ht, KeyType k, ValueType v){
int hashIndex;
struct hashLink * newHashLink = (struct hashLink *) malloc(sizeof(struct hashLink));
char * newKeyType = (char *) malloc(strlen(k) + 1); //Allocate memory for new char string
/* Create hash index using one of two hashing function supplied */
if(HASHING_FUNCTION == 1)
hashIndex = stringHash1(k) % ht->tableSize;
else
hashIndex = stringHash2(k) % ht->tableSize;
/* Ensure hashIndex is positive */
if(hashIndex < 0)
hashIndex += ht->tableSize;
assert(newHashLink);
/* Remove duplicate keys so new key replaces old key */
if(containsKey(ht, k))
removeKey(ht, k);
/* Initialize new hashLink and add to appropriate hash index */
strcpy(newKeyType, k); //copy string stream into allocated memory reserved for this hashLink
newHashLink->key = newKeyType;
newHashLink->value = v;
newHashLink->next = ht->table[hashIndex];
ht->table[hashIndex] = newHashLink;
ht->count++;
/* Test table load and resize if necessary */
if(tableLoad(ht) >= LOAD_FACTOR_THRESHOLD)
_setTableSize(ht, ht->tableSize * 2);
}
/* Desc: Inserts key, value pair into the hash map
* Pre: ht is not null
* Post: new link with key k and value v added
*/
void insertMap (struct hashMap * ht, KeyType k, ValueType v)
{
assert( ht != NULL );
int idx = findKeyIndex( ht, k );
/* Check if key is already in table */
if( containsKey( ht, k ) )
{
/* Replace the hash link as it already exists */
ht->table[ idx ]->value = v;
}
else
{
/* Not in table, so create a hashLink */
struct hashLink *new_lnk = malloc( sizeof( struct hashLink ) );
/* Fill hashLink with data */
new_lnk->value = v;
new_lnk->key = k;
new_lnk->next = ht->table[ idx ];
/* Add the new link to the table */
ht->table[ idx ] = new_lnk;
ht->count += 1;
}
}
/*
insert the following values into a hashLink, you must create this hashLink but
only after you confirm that this key does not already exist in the table. For example, you
cannot have two hashLinks for the word "taco".
if a hashLink already exists in the table for the key provided you should
replace that hashLink--this requires freeing up the old memory pointed by hashLink->value
and then pointing hashLink->value to value v.
also, you must monitor the load factor and resize when the load factor is greater than
or equal LOAD_FACTOR_THRESHOLD (defined in hashMap.h).
*/
void insertMap(struct hashMap * ht, KeyType k, ValueType v)
{
int hashIndex;
if (HASHING_FUNCTION == 1)
{
hashIndex = stringHash1(k) % ht->tableSize; //reduce the index
}
else if (HASHING_FUNCTION == 2)
{
hashIndex = stringHash2(k) % ht->tableSize;
}
if (hashIndex < 0) //check to make sure indez is not negative
{
hashIndex = hashIndex + ht->tableSize;
}
//Check if hashLink already exists and delete if it does not
if (containsKey(ht, k))
{
removeKey(ht, k);
}
//add a new link in
hashLink *newLink = malloc(sizeof(struct hashLink));
assert(newLink != NULL);
newLink->key = k;
newLink->value = v;
newLink->next = NULL;
if (ht->table[hashIndex] != NULL)
{
hashLink *temp = ht->table[hashIndex];
//find the end of chain
while (temp->next != NULL)
{
temp = temp->next;
}
temp->next = newLink;
}
else
{
ht->table[hashIndex] = newLink;
}
ht->count++;
// monitor the load factor
if (tableLoad(ht) >= LOAD_FACTOR_THRESHOLD)
{
_setTableSize(ht, ht->tableSize * 2);
}
}
/* Desc: Removes the hashlink with key k
* Pre: ht is not null
* Post: link freed
*/
void removeKey (struct hashMap * ht, KeyType k)
{
assert( ht != NULL );
if( containsKey( ht, k ) )
{
free( ht->table[ findKeyIndex( ht, k ) ] );
ht->count -= 1;
}
}
void testMapModule(void) {
Map map, map2;
string key;
string str;
trace(map = newMap());
test(size(map), 0);
test(isEmpty(map), true);
trace(put(map, "H", "Hydrogen"));
test(size(map), 1);
test(isEmpty(map), false);
trace(put(map, "He", "Helium"));
trace(put(map, "Al", "Aluminum"));
test(containsKey(map, "H"), true);
test(get(map, "H"), "Hydrogen");
test(get(map, "He"), "Helium");
test(get(map, "Al"), "Aluminum");
test(containsKey(map, "Li"), false);
test(get(map, "Li"), NULL);
trace(put(map, "Al", "Aluminium"));
test(get(map, "Al"), "Aluminium");
trace(remove(map, "Al"));
test(containsKey(map, "Al"), false);
test(get(map, "He"), "Helium");
trace(put(map, "Li", "Lithium"));
test(get(map, "Li"), "Lithium");
trace(put(map, "Be", "Beryllium"));
test(size(map), 4);
trace(str = "");
trace (foreach (key in map) str = concat(str, key));
test(str, "BeHHeLi");
trace(str = "");
trace(foreach (key in map) str = concat(str, get(map, key)));
test(str, "BerylliumHydrogenHeliumLithium");
trace(map2 = clone(map));
trace(str = "");
trace(foreach (key in map2) str = concat(str, get(map2, key)));
test(str, "BerylliumHydrogenHeliumLithium");
}
/*
insert the following values into a hashLink, you must create this hashLink but
only after you confirm that this key does not already exist in the table. For example, you
cannot have two hashLinks for the word "taco".
if a hashLink already exists in the table for the key provided you should
replace that hashLink--this requires freeing up the old memory pointed by hashLink->value
and then pointing hashLink->value to value v.
also, you must monitor the load factor and resize when the load factor is greater than
or equal LOAD_FACTOR_THRESHOLD (defined in hashMap.h).
*/
void insertMap (struct hashMap * ht, KeyType k, ValueType v){
/*write this*/
assert (ht != 0);
if (containsKey(ht, k))
ht->table[_findKey(ht, k)]->value = v;
else {
struct hashLink *newLink = malloc(sizeof(struct hashLink));
newLink->value = v;
newLink->key = k;
newLink->next = ht->table[_findKey(ht, k)];
ht->table[_findKey(ht, k)] = newLink;
ht->count++;
}
if (tableLoad(ht) > LOAD_FACTOR_THRESHOLD)
_setTableSize(ht, ht->tableSize * 2);
}
void removeKey (struct hashMap * ht, KeyType k)
{
struct hashLink* curr, prev;
if(containsKey(k))
{
curr = ht->table[stringHash2(k) % ht->tableSize];
while(curr->key != k)
{
prev = curr;
curr = curr->next;
}
prev->next = curr->next;
free(curr);
ht->count --;
}
}
XMLSize_t NameIdPool<TElem>::put(TElem* const elemToAdopt)
{
// First see if the key exists already. If so, its an error
if(containsKey(elemToAdopt->getKey()))
{
ThrowXMLwithMemMgr1
(
IllegalArgumentException
, XMLExcepts::Pool_ElemAlreadyExists
, elemToAdopt->getKey()
, fMemoryManager
);
}
fBucketList.put((void*)elemToAdopt->getKey(), elemToAdopt);
//
// Give this new one the next available id and add to the pointer list.
// Expand the list if that is now required.
//
if (fIdCounter + 1 == fIdPtrsCount)
{
// Create a new count 1.5 times larger and allocate a new array
XMLSize_t newCount = (XMLSize_t)(fIdPtrsCount * 1.5);
TElem** newArray = (TElem**) fMemoryManager->allocate
(
newCount * sizeof(TElem*)
); //new TElem*[newCount];
// Copy over the old contents to the new array
memcpy(newArray, fIdPtrs, fIdPtrsCount * sizeof(TElem*));
// Ok, toss the old array and store the new data
fMemoryManager->deallocate(fIdPtrs); //delete [] fIdPtrs;
fIdPtrs = newArray;
fIdPtrsCount = newCount;
}
const XMLSize_t retId = ++fIdCounter;
fIdPtrs[retId] = elemToAdopt;
// Set the id on the passed element
elemToAdopt->setId(retId);
// Return the id that we gave to this element
return retId;
}
/*
find the hashlink for the supplied key and remove it, also freeing the memory
for that hashlink. it is not an error to be unable to find the hashlink, if it
cannot be found do nothing (or print a message) but do not use an assert which
will end your program.
*/
void removeKey (struct hashMap * ht, KeyType k)
{
hashLink * cur, * temp;
assert(ht != NULL);
if (containsKey(ht, k)) {
int hashVal;
if (HASHING_FUNCTION == 1)
hashVal = stringHash1(k) % ht->tableSize;
else if (HASHING_FUNCTION == 2)
hashVal = stringHash2(k) % ht->tableSize;
if (hashVal < 0)
hashVal += ht->tableSize;
cur = ht->table[hashVal];
//if node to remove is at a parent link
if (strcmp(cur->key, k) == 0) {
temp = cur->next;
free(cur->key);
free(cur);
ht->table[hashVal] = temp;
ht->count--;
return;
}
//If node to remove is at a child link
while (cur->next != NULL) {
if (strcmp(cur->next->key, k) == 0) {
temp = cur->next->next;
free(cur->next->key);
free(cur->next);
cur->next = temp;
ht->count--;
return;
}
cur = cur->next;
}
}
else {
printf("\nError: tried to remove a key that is not in the map.");
return;
}
}
/*
insert the following values into a hashLink, you must create this hashLink but
only after you confirm that this key does not already exist in the table. For example, you
cannot have two hashLinks for the word "taco".
if a hashLink already exists in the table for the key provided you should
replace that hashLink--this requires freeing up the old memory pointed by hashLink->value
and then pointing hashLink->value to value v.
also, you must monitor the load factor and resize when the load factor is greater than
or equal LOAD_FACTOR_THRESHOLD (defined in hashMap.h).
*/
void insertMap (struct hashMap * ht, KeyType k, ValueType v)
{
int index;
if(tableLoad(ht) >= LOAD_FACTOR_THRESHOLD)
{
_setTableSize(ht, (2 * ht -> tableSize));
}
struct hashLink *link = malloc(sizeof(struct hashLink));
index = stringHash2(k) % ht -> tableSize;
if(index < 0)
{
index += ht -> tableSize;
}
assert(link);
link -> next = 0;
link -> key = k;
link -> value = v;
if(containsKey(ht, k))
{
removeKey(ht, k);
}
if(!ht -> table[index])
{
ht -> table[index] = link;
}
else
{
struct hashLink *current = ht -> table[index];
while(current -> next)
{
current = current -> next;
}
current -> next = link;
}
ht -> count++;
}
/*
this returns the value (which is void*) stored in a hashLink specified by the key k.
if the user supplies the key "taco" you should find taco in the hashTable, then
return the value member of the hashLink that represents taco.
if the supplied key is not in the hashtable return NULL.
*/
ValueType* atMap (struct hashMap * ht, KeyType k)
{
assert(ht != NULL);
int loc = stringHash1(k);
if(containsKey(ht, k)){
struct hashLink* pLink = ht->table[loc];
while(strcmp(pLink->key, k)){
pLink = pLink->next;
}
ValueType* temp;
temp = &(pLink->value);
return temp;
} else {
return NULL;
}
}
int main (int argc, const char * argv[]) {
clock_t timer;
int tableSize = 1000;
struct hashMap* hashTable;
hashTable = createMap(tableSize);
timer = clock();
//createMap(tableSize);
//_initMap(hashTable,tableSize);
FILE* dictionary; // = malloc(sizeof(FILE));
loadDictionary(dictionary,hashTable);
timer = clock() - timer;
printf("Dictionary loaded in %f seconds\n", (float)timer / (float)CLOCKS_PER_SEC);
char* word = (char*)malloc(256*sizeof(char));
int quit=0;
while(!quit){
printf("Enter a word: ");
scanf("%s",word);
/*
... spell checker code goes here ...
... You write this ...
*/
if (containsKey(hashTable, word) == 0)
{
printf("%s is NOT a word in the dictionary\n", word);
}
else
{
printf("%s is a word in the dictionary\n", word);
}
/* Don't remove this. It is used for grading*/
if(strcmp(word,"quit")==0)
quit=!quit;
}
free(word);
return 0;
}
int main (int argc, const char * argv[]) {
const char *filename;
clock_t timer;
int tableSize = 1000;
struct hashMap* hashTable = createMap(tableSize);
timer = clock();
if(argc >= 2)
filename = argv[1];
else
filename = "dictionary.txt"; /*specify your input text file here*/
FILE* dictionary = fopen(filename, "r");
if(dictionary == NULL) {
char err[255];
sprintf(err, "Failure opening file %s; exiting.\n", filename);
perror(err);
exit(EXIT_FAILURE);
}
loadDictionary(dictionary,hashTable);
timer = clock() - timer;
printf("Dictionary loaded in %f seconds\n", (float)timer / (float)CLOCKS_PER_SEC);
char* word = (char*)malloc(256*sizeof(char));
int quit=0;
while(!quit) {
printf("Enter a word: ");
scanf("%s",word);
if(containsKey(hashTable, lowercase(word)))
printf("'%s' is spelled correctly.\n", word);
else
printf("'%s' is spelled incorrectly; please try again.\n", word);
/* Don't remove this. It is used for grading*/
if(strcmp(word,"quit")==0)
quit=!quit;
}
free(word);
fclose(dictionary);
return 0;
}
void processFile(FILE *file)
{
int i;
char *word;
struct hashMap *map;
struct hashLink *cur;
word = 0;
map = (struct hashMap *) malloc(sizeof(struct hashMap));
initMap(map, 100);
while(1)
{
word = getWord(file);
if(!word)
break;
/*printf("Words! %s\n", word);*/
if(containsKey(map, word))
insertMap(map, word, *atMap(map, word) + 1);
else
insertMap(map, word, 1);
}
i = 0;
for(i = 0; i < map->tableSize; i++)
{
cur = map->table[i];
while(cur)
{
printf("%s: %d\n", cur->key, cur->value);
cur = cur->next;
}
}
freeMap(map);
free(map);
}
/*
insert the following values into a hashLink, you must create this hashLink but
only after you confirm that this key does not already exist in the table. For example, you
cannot have two hashLinks for the word "taco".
if a hashLink already exists in the table for the key provided you should
replace that hashLink--this requires freeing up the old memory pointed by hashLink->value
and then pointing hashLink->value to value v.
also, you must monitor the load factor and resize when the load factor is greater than
or equal LOAD_FACTOR_THRESHOLD (defined in hashMap.h).
*/
void insertMap (struct hashMap * ht, KeyType k, ValueType v)
{
/*write this*/
int index = HASH(k) % ht->tableSize;
if (containsKey(ht, k))
{
// DO NOT removeKey(ht, k) and add newLink; Instead, only replace value and return
*atMap(ht, k) = v;
return;
}
struct hashLink * newLink = (struct hashLink *) malloc(sizeof(struct hashLink));
assert(newLink != 0);
newLink->key = k;
newLink->value = v;
newLink->next = ht->table[index];
ht->table[index] = newLink;
ht->count++;
if ((float)ht->count / (float)ht->tableSize > LOAD_FACTOR_THRESHOLD)
_setTableSize(ht, 2 * ht->tableSize);
}
/*
insert the following values into a hashLink, you must create this hashLink but
only after you confirm that this key does not already exist in the table. For example, you
cannot have two hashLinks for the word "taco".
if a hashLink already exists in the table for the key provided you should
replace that hashLink--this requires freeing up the old memory pointed by hashLink->value
and then pointing hashLink->value to value v.
also, you must monitor the load factor and resize when the load factor is greater than
or equal LOAD_FACTOR_THRESHOLD (defined in hashMap.h).
*/
void insertMap (struct hashMap * ht, KeyType k, ValueType v)
{
assert(ht != NULL);
int loc = stringHash1(k) % ht->tableSize;
if(containsKey(ht, k)){
struct hashLink* pLink = ht->table[loc];
while(strcmp(pLink->key, k)){
pLink = pLink->next;
}
pLink->value = pLink->value + v;
} else {
struct hashLink* newLink = (struct hashLink*)malloc(sizeof(struct hashLink));
newLink->key = (char*)malloc((1 + strlen(k)) * sizeof(char));
strcpy(newLink->key, k);
newLink->value = v;
newLink->next = NULL;
struct hashLink* pLink = ht->table[loc];
if(pLink == NULL){
ht->table[loc] = newLink;
} else {
while(pLink->next != NULL){
pLink = pLink->next;
}
pLink->next = newLink;
}
ht->count++;
}
if(tableLoad(ht) >= LOAD_FACTOR_THRESHOLD){
_setTableSize(ht, 2 * ht->tableSize);
}
return;
}
OntologyBase * OntologyBase::get_or_create_ontology(QString _acronym){
//if(this->ontologies-)
std::cerr << "entering get_or_create_ontology(QString " <<_acronym.toStdString()<<")"<< std::endl;
if (containsKey(_acronym)==false){
std::cerr << "this ontology not exists" << std::endl;
OntologyBase * ontology = new OntologyBase();
ontology->set_acronym(_acronym);
ontology->registering();
}
if (_acronym == "XEO_Positioning")
{
return get_ontology_by_key("XPO");
}
return get_ontology_by_key(_acronym);
}
/*
find the hashlink for the supplied key and remove it, also freeing the memory
for that hashlink. it is not an error to be unable to find the hashlink, if it
cannot be found do nothing (or print a message) but do not use an assert which
will end your program.
*/
void removeKey (struct hashMap * ht, KeyType k)
{
/*write this*/
int hash;
if(HASHING_FUNCTION == 1){
hash = stringHash1(k);
}
if(HASHING_FUNCTION == 2){
hash = stringHash2(k);
}
struct hashLink *cur, *prev;
int idx = hash % ht->tableSize;
prev = 0;
cur = ht->table[idx];
if(containsKey(ht, k)!=0){
while(cur)
{
if(strcmp(cur->key, k)==0)
{
printf("###########Removing:%s ##############\n", cur->key);
if(!prev){
ht->table[idx] = cur->next;
}
else{
prev->next = cur->next;
}
free(cur);
ht->count--;
return;
}
prev = cur;
cur = cur->next;
}
}
}
/*
removeKey: find the hash link for the key and remove it, also free the memory for the hash link
If unable to find the key, then print an appropriate message
param1: ht - the map
param2: k - the key to remove
pre: ht is not NULL
post: key has been removed from the table
post: count has been decremented
HINT - If the map only contains a single hash link, it is a special case
removing the solitary link should set the table entry to NULL
*/
void removeKey(struct hashMap *ht, KeyType k) {
/* FIX ME */
assert(ht!=NULL);
int hash;
struct hashLink *cur;
struct hashLink *prev;
/* check for the key, if not found, then print message and return */
if(!containsKey(ht, k)){
printf("key '%s' not found!\n", k);
return;
}
/* hash the key */
hash = _hashValue(k, ht->hashID);
hash = hash % ht->tableSize;
/* special case for single link */
if(ht->table[hash]->next==NULL && strcmp(ht->table[hash]->key, k)==0){
ht->table[hash] = NULL;
}
/* find key and remove it */
/*if it is a top key with links*/
if(strcmp(ht->table[hash]->key, k)==0 && ht->table[hash]->next !=NULL){
ht->table[hash] = ht->table[hash]->next;
}
/*some other level other than 0*/
cur=ht->table[hash];
while(strcmp(cur->key, k)!= 0){
prev=cur;
cur= cur->next;
}
prev->next = prev->next->next;
}
void ConfigFile::extractContents(const std::string &line)
{
// called from parse_line(), validated there
std::string tmp = line;
// remove leading whitespace
tmp.erase(0, tmp.find_first_not_of("\t "));
size_t sep_pos = tmp.find('=');
std::string key, value;
extractKey(key, sep_pos, tmp);
extractValue(value, sep_pos, tmp);
if (!containsKey(key))
{
contents.insert(std::pair<std::string, std::string>(key, value));
}
else
{
ConfigUtil::warn(key + " was declared at least twice in configuration file.");
}
}
/*
valAtKey: return the value stored at the key
param1: ht - the map
param2: k - the key to search for
pre: ht is not null
pre: if key not found, then display an appropriate message
post: none
return: return the value found at the key
*/
ValueType valAtKey(struct hashMap *ht, KeyType k) {
/* FIX ME */
int hash;
struct hashLink *cur;
/* check for the key, if not found, then print message */
if(!containsKey(ht, k)){
//printf("key '%s' not found!\n", k);
return -1;
}
/* hash the key */
hash = _hashValue(k, ht->hashID);
hash = hash % ht->tableSize;
/* search table for the key and return the current value */
cur = ht->table[hash];
while(strcmp(cur->key, k)!=0){
cur=cur->next;
}
return cur->value;
}
template<> string config::getParam<string>(string key, string def)
{
string val = def;
bool exists = containsKey(key);
if (exists == true)
{
val = options[key];
}
if (suppressOutput == false)
{
if (exists == false)
{
std::cout << "-Option: '" << key << "' missing\n";
std::cout << "-Using default.\n";
}
std::cout << "---" << key << ": " << val << "\n";
}
return val;
}
template<> float config::getParam<float>(string key, float def)
{
float val = def;
bool exists = containsKey(key);
if (exists == true)
{
val = std::stof(options[key],nullptr);
}
if (suppressOutput == false)
{
if (exists == false)
{
std::cout << "-Option: '" << key << "' missing\n";
std::cout << "-Using default.\n";
}
std::cout << "---" << key << ": " << val << "\n";
}
return val;
}
int main(int argc, const char * argv[]) {
clock_t timer;
int tableSize = 1000;
struct hashMap* hashTable = createMap(tableSize);
timer = clock();
//initMap(hashTable, tableSize); no longer in header
FILE* dictionary = fopen("dictionary.txt", "r"); //open the dicitionary file for reading
loadDictionary(dictionary, hashTable);
timer = clock() - timer;
printf("Dictionary loaded in %f seconds\n", (float)timer / (float)CLOCKS_PER_SEC);
char* word = (char*)malloc(256 * sizeof(char));
int quit = 0;
while (!quit) {
printf("Enter a word: "); //prompt to enter a word
scanf("%s", word); //read the given input
//if the input value can be found in the hash table, then it was spelled correctly
if (!containsKey(hashTable, word))
{
printf("%s is spelled wrong.\n", word);
}
else
{
printf("%s is spelled correctly.\n", word);
}
/* Don't remove this. It is used for grading*/
if (strcmp(word, "quit") == 0)
quit = !quit;
}
free(word);
return 0;
}
