SP_BPQUEUE_MSG spBPQueueEnqueue(SPBPQueue source, SPListElement element){
// variables declaration//
int i;
SPList source_list = source->list;
SPListElement elem_to_comp;
int list_size = spListGetSize(source_list);
// check for bad arguments or allocation problems//
if (!source || !element || !source_list){
return SP_BPQUEUE_INVALID_ARGUMENT;
}
// insertion process//
if (spBPQueueIsEmpty(source)){
spListInsertFirst(source_list, element);
return SP_BPQUEUE_SUCCESS;
}
else{
elem_to_comp = spListGetFirst(source_list);
/*starts from the bottom and loop for next source list element up until
you find the one which is bigger than the inserted one and insert the element
before that one. you will stop after you ran out of elements to look for */
for(i=0; i<list_size; i++){
if (spListElementGetValue(element) <= spListElementGetValue(elem_to_comp)){// element is smaller than next elem, insert before current
if (spBPQueueIsFull(source)){
if (spListInsertBeforeCurrent(source_list, element) == SP_LIST_OUT_OF_MEMORY){
return SP_BPQUEUE_OUT_OF_MEMORY;
}
spListGetLast(source_list);
spListRemoveCurrent(source_list);
return SP_BPQUEUE_SUCCESS;
}
else{
if (spListInsertBeforeCurrent(source_list, element) == SP_LIST_OUT_OF_MEMORY){
return SP_BPQUEUE_OUT_OF_MEMORY;
}
return SP_BPQUEUE_SUCCESS;
}
}else{
elem_to_comp = spListGetNext(source_list);
}
}
}
if (!spBPQueueIsFull(source)){//queue isn't full but this item is the biggest
if (spListInsertLast(source_list, element)== SP_LIST_OUT_OF_MEMORY){
return SP_BPQUEUE_OUT_OF_MEMORY;
}
return SP_BPQUEUE_SUCCESS;
}
return SP_BPQUEUE_SUCCESS; // the element is larger than all others
}
static bool testElementSetValue() {
ASSERT_TRUE(spListElementGetValue(NULL) == -1.0);
ASSERT_TRUE(spListElementSetValue(NULL,-1.0) ==SP_ELEMENT_INVALID_ARGUMENT);
ASSERT_TRUE(spListElementSetValue(NULL,1.0) ==SP_ELEMENT_INVALID_ARGUMENT);
ASSERT_TRUE(spListElementSetValue(NULL,-1.0) ==SP_ELEMENT_INVALID_ARGUMENT);
SPListElement element = spListElementCreate(1, 0.0);
ASSERT_TRUE(
spListElementSetValue(element, -1.0)
== SP_ELEMENT_INVALID_ARGUMENT);
ASSERT_TRUE(spListElementGetValue(element) == 0.0);
ASSERT_TRUE(spListElementSetValue(element, 1.0) == SP_ELEMENT_SUCCESS);
ASSERT_TRUE(spListElementGetValue(element) == 1.0);
spListElementDestroy(element);
return true;
}
static bool testIsElementGetValue() {
SPListElement element1 = spListElementCreate(1, 0.0);
SPListElement element2 = spListElementCreate(2, 1.0);
SPListElement element3 = spListElementCreate(3, 1.0);
SPListElement element4 = spListElementCreate(4, 2.0);
ASSERT_TRUE(spListElementGetValue(element1) == 0.0);
ASSERT_TRUE(spListElementGetValue(element2) == 1.0);
ASSERT_TRUE(spListElementGetValue(element3) == 1.0);
ASSERT_TRUE(spListElementGetValue(element4) == 2.0);
spListElementDestroy(element1);
spListElementDestroy(element2);
spListElementDestroy(element3);
spListElementDestroy(element4);
return true;
}
double spBPQueueMaxValue(SPBPQueue source){
assert(source);
if (spBPQueueIsEmpty(source)){
return -1;
}
return spListElementGetValue(spListGetLast(source->list));
}
double returnValueFrom(SPBPQueue source, SPListElement (*func)(SPBPQueue)) {
SPListElement item;
double returnValue;
spMinimalVerifyArguments(source != NULL, DEFAULT_INVALID_NUMBER);
item = (*func)(source);
returnValue = spListElementGetValue(item);
spListElementDestroy(item);
return returnValue;
}
double spBPQueueMaxValue(SPBPQueue source) {
return spListElementGetValue(spBPQueueLastElement(source));
}
double spBPQueueMinValue(SPBPQueue source) {
return spListElementGetValue(spBPQueueFirstElement(source));
}
/**
* Creates a separate copy of a node
*
* @param node to be copied
* @return
* NULL in case allocation failure occurred
* Otherwise, the new node is returned
*/
struct Qnode* copyNode(struct Qnode *n){
return newNode(spListElementGetIndex(n->element), spListElementGetValue(n->element));
}
double spBPQueueMaxValue(SPBPQueue source){
if (!source || source->size==0) return -1;
return spListElementGetValue(source->last->element);
}
SP_BPQUEUE_MSG spBPQueueEnqueue(SPBPQueue source, SPListElement element){
int i;
struct Qnode* new_node;
struct Qnode* n;
struct Qnode* oldNext;
if (!source || !element){
return SP_BPQUEUE_INVALID_ARGUMENT;
}
// create new node using the element's data
new_node = newNode(spListElementGetIndex(element), spListElementGetValue(element));
if (!new_node){
return SP_BPQUEUE_OUT_OF_MEMORY;
}
n = source->first;
// if queue is full
if (source->size >= source->maxSize){
// compare the new element to the last element
if (spListElementCompare(new_node->element, source->last->element) == 1){
spListElementDestroy(new_node->element);
free(new_node);
return SP_BPQUEUE_FULL;
}
// new element is smaller, therefore destroy current last node
spListElementDestroy(source->last->element);
free(source->last);
// set the new last node pointer to NULL
for(i=0;i<source->size-2;i++){
n=n->next;
}
n->next=NULL;
}
n = source->first;
// if queue is empty
if (!source->first){
source->first = new_node;
source->last = new_node;
} else {
if (spListElementCompare(n->element, new_node->element) == 1){
// in case new node is smallest
source->first = new_node;
new_node->next = n;
} else {
while (n->next && spListElementCompare(n->next->element, new_node->element) == -1){
n = n->next;
}
oldNext = n->next;
n->next = new_node;
new_node->next = oldNext;
}
}
n = source->first;
while (n->next){
n = n->next;
}
source->last = n;
// if queue is not full, increment size
if (source->size != source->maxSize){
source->size += 1;
}
return SP_BPQUEUE_SUCCESS;
}
