GenericList.cpp

From Giona

(Difference between revisions)
Line 1: Line 1:
<pre>
<pre>
-
#include <stdlib.h>
+
/****************************************************************************
-
#include "bool.h"
+
*This class represents a generic linked list.
-
#include "GenericListNode.h"
+
*
 +
*
 +
*Author: Rosario Marino
 +
***************************************************************************/
 +
 
#include "GenericList.h"
#include "GenericList.h"
Line 10: Line 14:
GenericList::GenericList()
GenericList::GenericList()
{
{
-
this->head = NULL;
+
    this->head = NULL;
-
this->length = 0;
+
    this->length = 0;
-
this->lastError = GENERIC_LIST_ERR_NO;
+
    this->lastError = GENERIC_LIST_ERR_NO;
}
}
-
 
+
/*
/*
  * Destructor
  * Destructor
Line 20: Line 24:
GenericList::~GenericList()
GenericList::~GenericList()
{
{
-
deleteList();
+
    deleteList();
}
}
/*
/*
-
  * Adds a node in the list
+
  * Adds a node at the end of the list
  * Returns FALSE in case of error, TRUE otherwise
  * Returns FALSE in case of error, TRUE otherwise
  */
  */
-
BOOL GenericList::addNode(GenericListNode* node)
+
bool GenericList::addNode(GenericListNode* node)
{
{
-
if(node == NULL)
+
    if(node == NULL)
-
{
+
    {
-
this->lastError = GENERIC_LIST_ERR_NULL_NODE;
+
        this->lastError = GENERIC_LIST_ERR_NULL_NODE;
-
return FALSE;
+
        return false;
-
}
+
    }
-
this->length++;
+
    this->length++;
-
if(this->head == NULL)
+
    if(this->head == NULL)
-
{
+
    {
-
head=node;
+
        head=node;
-
return TRUE;
+
        return true;
-
}
+
    }
-
GenericListNode *tmp = this->head;
+
    GenericListNode *tmp = this->head;
-
while(tmp->getNext() != NULL)
+
    while(tmp->getNext() != NULL)
-
tmp = tmp->getNext();
+
        tmp = tmp->getNext();
-
tmp->setNext(node);
+
    tmp->setNext(node);
-
return TRUE;
+
    return true;
 +
}
 +
 
 +
/*
 +
* Adds a node on the head of the list
 +
* Returns FALSE in case of error, TRUE otherwise
 +
*/
 +
 
 +
bool GenericList::inHeadNode(GenericListNode* node)
 +
{
 +
    if(node == NULL)
 +
    {
 +
        this->lastError = GENERIC_LIST_ERR_NULL_NODE;
 +
        return false;
 +
    }
 +
    node->setNext(this->getHead());
 +
    this->head = node;
 +
    this->length++;
 +
    return true;  
}
}
Line 52: Line 74:
GenericListNode *GenericList::getHead()
GenericListNode *GenericList::getHead()
{
{
-
return this->head;
+
    return this->head;
 +
}
 +
 
 +
/*
 +
* extracts and returns the head node of the list
 +
*/
 +
GenericListNode *GenericList::extractHead()
 +
{
 +
    if(this->head == NULL)
 +
    {
 +
        this->lastError = GENERIC_LIST_ERR_EMPTY_LIST;
 +
        return NULL;
 +
    }
 +
    GenericListNode* node = this->head;
 +
    this->head =node->getNext();
 +
    this->length--;
 +
    return node;
 +
}
 +
 
 +
/*
 +
* extracts the node at position idx and returns it
 +
*/
 +
GenericListNode* GenericList::extractNode(int idx)
 +
{
 +
    if((idx<0)||(idx>length-1))
 +
    {
 +
        this->lastError = GENERIC_LIST_ERR_OUT_OF_RANGE_INDEX;
 +
        return NULL;
 +
    }
 +
    if(idx==0)
 +
        return(this->extractHead());
 +
    GenericListNode * tmp=this->getHead();
 +
    for(int i=1; i<idx; i++)
 +
        tmp=tmp->getNext();
 +
    GenericListNode* node= tmp->getNext();
 +
    tmp->setNext(node->getNext());
 +
    this->length--;
 +
    return node;
 +
}
 +
 
 +
 
 +
/*
 +
* returns the node at position idx without extracting it from the list
 +
*/
 +
GenericListNode* GenericList::viewNode(int idx)
 +
{
 +
    if((idx<0)||(idx>length-1))
 +
    {
 +
        this->lastError = GENERIC_LIST_ERR_OUT_OF_RANGE_INDEX;
 +
        return NULL;
 +
    }
 +
    if(idx==0)
 +
        return(this->getHead());
 +
    GenericListNode * tmp=this->getHead();
 +
    for(int i=1; i<=idx; i++)
 +
        tmp=tmp->getNext();
 +
    return tmp;
}
}
Line 59: Line 137:
  * of error, TRUE otherwise
  * of error, TRUE otherwise
  */  
  */  
-
BOOL GenericList::deleteNode(GenericListNode *node)
+
bool GenericList::deleteNode(GenericListNode *node)
{
{
-
if(this->head == NULL)
+
    if(this->head == NULL)
-
{
+
    {
-
this->lastError = GENERIC_LIST_ERR_EMPTY_LIST;
+
        this->lastError = GENERIC_LIST_ERR_EMPTY_LIST;
-
return FALSE;
+
        return false;
-
}
+
    }
-
if(node == NULL)
+
    if(node == NULL)
-
{
+
    {
-
this->lastError = GENERIC_LIST_ERR_NULL_NODE;
+
        this->lastError = GENERIC_LIST_ERR_NULL_NODE;
-
return FALSE;
+
        return false;
-
}
+
    }
-
GenericListNode *tmp = this->head;
+
    GenericListNode *tmp = this->head;
-
if (tmp == node)
+
    if (tmp == node)
-
{
+
    {
-
this->head = tmp->getNext();
+
        this->head = tmp->getNext();
-
delete(tmp);
+
        delete(tmp);
-
this->length --;
+
        this->length --;
-
return TRUE;
+
        return true;
-
}
+
    }
-
while((tmp->getNext() !=NULL) AND (tmp->getNext() != node))
+
    while((tmp->getNext() !=NULL) && (tmp->getNext() != node))
-
tmp = tmp->getNext();
+
        tmp = tmp->getNext();
-
if(tmp->getNext() == NULL)
+
    if(tmp->getNext() == NULL)
-
{
+
    {
-
this->lastError = GENERIC_LIST_ERR_NODE_NOT_FOUND;
+
        this->lastError = GENERIC_LIST_ERR_NODE_NOT_FOUND;
-
return FALSE;
+
        return false;
-
}
+
    }
-
GenericListNode* delNode = tmp->getNext();
+
    GenericListNode* delNode = tmp->getNext();
-
tmp->setNext(delNode->getNext());
+
    tmp->setNext(delNode->getNext());
-
delete(delNode);
+
    delete(delNode);
-
this->length--;
+
    this->length--;
-
return TRUE;
+
    return true;
}
}
Line 98: Line 176:
int GenericList::getLastError()
int GenericList::getLastError()
{
{
-
return this->lastError;
+
    return this->lastError;
}
}
Line 106: Line 184:
int GenericList::getLength()
int GenericList::getLength()
{
{
-
return this->length;
+
    return this->length;
}
}
Line 114: Line 192:
void GenericList::deleteList()
void GenericList::deleteList()
{
{
-
GenericListNode * tmp = this->head;
+
    GenericListNode * tmp = this->head;
-
while(tmp)
+
    while(tmp)
-
{
+
    {
-
GenericListNode* tmpNext=tmp->getNext();
+
        GenericListNode* tmpNext=tmp->getNext();
-
delete(tmp);
+
        delete(tmp);
-
tmp = tmpNext;
+
        tmp = tmpNext;
-
}
+
    }
}
}
-
</pre>
 
 +
</pre>
 +
[[Il database Object Oriented Generico|BACK]]
[[Category:Codice Sorgente]]
[[Category:Codice Sorgente]]

Revision as of 11:39, 13 December 2007

/****************************************************************************
 *This class represents a generic linked list.
 *
 *
 *Author: Rosario Marino
 ***************************************************************************/

#include "GenericList.h"

/*
 * Constructor
 */
GenericList::GenericList()
{
    this->head = NULL;
    this->length = 0;
    this->lastError = GENERIC_LIST_ERR_NO;
}
 
/*
 * Destructor
 */
GenericList::~GenericList()
{
    deleteList();
}

/*
 * Adds a node at the end of the list
 * Returns FALSE in case of error, TRUE otherwise
 */
bool GenericList::addNode(GenericListNode* node)
{
    if(node == NULL)
    {
        this->lastError = GENERIC_LIST_ERR_NULL_NODE;
        return false;
    }
    this->length++;
    if(this->head == NULL)
    {
        head=node;
        return true;
    }
    GenericListNode *tmp = this->head;
    while(tmp->getNext() != NULL)
        tmp = tmp->getNext();
    tmp->setNext(node);
    return true;
}

/*
 * Adds a node on the head of the list
 * Returns FALSE in case of error, TRUE otherwise
 */

bool GenericList::inHeadNode(GenericListNode* node)
{
    if(node == NULL)
    {
        this->lastError = GENERIC_LIST_ERR_NULL_NODE;
        return false;
    }
    node->setNext(this->getHead());
    this->head = node;
    this->length++;
    return true;    
}

/*
 * returns the head node of the list
 */
GenericListNode *GenericList::getHead()
{
    return this->head;
}

/*
 * extracts and returns the head node of the list
 */
GenericListNode *GenericList::extractHead()
{
    if(this->head == NULL)
    {
        this->lastError = GENERIC_LIST_ERR_EMPTY_LIST;
        return NULL;
    }
    GenericListNode* node = this->head;
    this->head =node->getNext();
    this->length--;
    return node;
}

/*
 * extracts the node at position idx and returns it
 */
GenericListNode* GenericList::extractNode(int idx)
{
    if((idx<0)||(idx>length-1))
    {
        this->lastError = GENERIC_LIST_ERR_OUT_OF_RANGE_INDEX;
        return NULL;
    }
    if(idx==0)
        return(this->extractHead());
    GenericListNode * tmp=this->getHead();
    for(int i=1; i<idx; i++)
        tmp=tmp->getNext();
    GenericListNode* node= tmp->getNext();
    tmp->setNext(node->getNext());
    this->length--;
    return node;
}


/*
 * returns the node at position idx without extracting it from the list
 */
GenericListNode* GenericList::viewNode(int idx)
{
    if((idx<0)||(idx>length-1))
    {
        this->lastError = GENERIC_LIST_ERR_OUT_OF_RANGE_INDEX;
        return NULL;
    }
    if(idx==0)
        return(this->getHead());
    GenericListNode * tmp=this->getHead();
    for(int i=1; i<=idx; i++)
        tmp=tmp->getNext();
    return tmp;
}

/*
 * Deletes the node from the list. Returns FALSE in case
 * of error, TRUE otherwise
 */ 
bool GenericList::deleteNode(GenericListNode *node)
{
    if(this->head == NULL)
    {
        this->lastError = GENERIC_LIST_ERR_EMPTY_LIST;
        return false;
    }
    if(node == NULL)
    {
        this->lastError = GENERIC_LIST_ERR_NULL_NODE;
        return false;
    }
    GenericListNode *tmp = this->head;
    if (tmp == node)
    {
        this->head = tmp->getNext();
        delete(tmp);
        this->length --;
        return true;
    }
    while((tmp->getNext() !=NULL) && (tmp->getNext() != node))
        tmp = tmp->getNext();
    if(tmp->getNext() == NULL)
    {
        this->lastError = GENERIC_LIST_ERR_NODE_NOT_FOUND;
        return false;
    }
    GenericListNode* delNode = tmp->getNext();
    tmp->setNext(delNode->getNext());
    delete(delNode);
    this->length--;
    return true;
}

/*
 * Returns last error code
 */
int GenericList::getLastError()
{
    return this->lastError;
}

/*
 * Returns the number of list nodes
 */
int GenericList::getLength()
{
    return this->length;
}

/*
 * (Private) deletes all list nodes 
 */
void GenericList::deleteList()
{
    GenericListNode * tmp = this->head;
    while(tmp)
    {
        GenericListNode* tmpNext=tmp->getNext();
        delete(tmp);
        tmp = tmpNext;
    }
}

BACK

Retrieved from "http://editthis.info/giona/GenericList.cpp"
Personal tools