Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version

Chart and Pie for data with hole

, 3 May 2002
Chart and Pie for data with hole.
// List.cpp: implementation of the List class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
//#include "parser.h"
#include <stdio.h>

#include "tzObject.h"
#include "List.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////


//*********************************************************************
// List::List()
//   Constructor
//
List::List()
{
    head = tail = current = (ListNode *)NULL;
    number = 0;
    current_index = -1;
}


//*********************************************************************
// List::~List()
//   Destructor
//
List::~List()
{
    clear();
}


//*********************************************************************
// void List::add(tzObject *object)
//   Add an object to the list.
//
void List::add(tzObject *object)
{
    ListNode *node = (ListNode *)new ListNode;
    
    node->next = (ListNode *)NULL;
    node->prev = tail;
    node->object = object;
    
    if (tail != (ListNode *)NULL)
    {
    	tail->next = node;
    	tail = node;
    }
    else
    	head = tail = node;

    number++;
}


//*********************************************************************
// void List::add(int position, tzObject *object)
//   Adds the specified item to the the scrolling list at the 
//   position indicated by the index.
//
void List::add(int position, tzObject *object)
{
    ListNode *ln = head;
    
    for (int i = 0; i < position && ln; i++, ln = ln->next)
    	;
    
    if (!ln)
    {
        // if position is greater than the current scope, 
        // append the object to the list
        add(object);
    }
    else
    {
        ListNode *node;
		
		node = (ListNode *)new ListNode;
    
        node->next = (ListNode *)NULL;
        node->prev = (ListNode *)NULL;
        node->object = object;
        
    	if (ln == head)
	    {
	        node->next = head;
    	    node->next->prev = node;
	        head = node;
    	}
	    else
    	{
	        node->next = ln;
	        node->prev = ln->prev;
    	    node->prev->next = node;
	        node->next->prev = node;
    	}
        
        if(current_index >= position)
            current_index++;
        
        number++;
    }
    
    return;
}



// Append plist to the current list
void List::add(List *plist)
{
	tzObject *pobject;
	for(int i = 0; i < plist->size(); i++)
	{
		pobject = plist->get(i);
		add(pobject->clone());
	}

	return;
}


//*********************************************************************
// void List::clear()
//   Removes all nodes from this list, and the objects as well.
//
void List::clear()
{
    ListNode *node;
    
    while (head)
    {
    	node = head;
    	head = head->next;
	    delete node->object;
    	delete node;
    }
    
    head = tail = current = (ListNode *)NULL;
    number = 0;
    current_index = -1;
}


//*********************************************************************
// void List::dump()
//   dump all the content in the link list.
//
void List::dump()
{
    for(ListNode *node = head; node != (ListNode *)NULL; node = node->next)
        node->object->dump();
}



//*********************************************************************
// List *List::clone()
//   Return a deep copy of the list.
//
List *List::clone()
{
    List	*list = new List();
    ListNode *node;

    for(node = head; node != (ListNode *)NULL; node = node->next)
        list->add(node->object->clone());
        
    return list;
}



//*********************************************************************
// tzObject *List::get(int index)
//   Gets the item associated with the specified index.
//
tzObject *List::get(int index)
{
    if (index < 0 || index >= number)
        return (tzObject *)NULL;

    // if we want to retrieve exact the current node or the node next to current
    if (current_index == index)
    	return current->object;
    if (current && current_index >= 0 && index == current_index + 1)
    {
    	current = current->next;
	    if (!current)
    	{
	        current_index = -1;
    	    return (tzObject *)NULL;
	    }
    	current_index = index;
	    return current->object;
    }

    ListNode *temp = head;
    
    for (int i = 0; temp && i < index; i++)
    	temp = temp->next;

    if (temp)
    {
    	current_index = index;
	    current = temp;
    	return temp->object;
    }
    
   	return (tzObject *)NULL;
}



//*********************************************************************
// int List::indexOf(tzObject *obj)
//    Searches for the first occurence of the given argument, 
//    testing for equality using the equals method.
//
int List::indexOf(tzObject *obj)
{
    ListNode *temp = head;
    int			index = 0;

    while (temp && obj->compare(temp->object) != 0)
    {
    	temp = temp->next;
	    index++;
    }
    
    if (index >= number)
    	return -1;
    else
    	return index;
}




//*********************************************************************
// void List::remove(int position)
//   Remove the item at the specified position from this scrolling list.
//
void List::remove(int position)
{
    if (position < 0 || position >= number)
        return;
    
    ListNode *node;
    
    if (current_index == position)
        node = current;
    else if (current && current_index >= 0 && position == current_index + 1)
    	node = current->next;
    else
    {
        node = head;
    
        for (int i = 0; node && i < position; i++)
         	node = node->next;
    }
    
    if(node)
        remove(node);

    return;    
}

//*********************************************************************
// void List::remove(tzObject *object)
//   Removes the first occurrence of an item from the list.
//
void List::remove(tzObject *object)
{
    
    for(ListNode *node = head; node != (ListNode *)NULL; node = node->next)
    {
    	if (object->compare(node->object) == 0)
    	{
            remove(node);
            break;
    	}
    }
    
    return;
}


//*********************************************************************
// void List::remove(ListNode *node)
//   Remove the node from this scrolling list.
//
void List::remove(ListNode *node)
{
    
    if (head == tail)
    {
        // if only one node in the list
        head = tail = (ListNode *)NULL;
    }
    else if (head == node)
    {
        head = head->next;
        head->prev = (ListNode *)NULL;
    }
    else if (tail == node)
    {
        tail = tail->prev;
        tail->next = (ListNode *)NULL;
    }
    else
    {
        node->next->prev = node->prev;
        node->prev->next = node->next;
    }

    delete node->object;
    delete node;
    
    number--;
    
    // we should keep the current correctly, but ...
    current_index = -1;
    current = (ListNode *)NULL;
    
    return;
}


//*********************************************************************
// void List::set(int position, tzObject *object)
//   Replaces the item at the specified index in the scrolling list with the new object.
//
void List::set(int position, tzObject *object)
{
    ListNode *temp = head;
    
    //
    // First make sure that there is something there!
    //
    while (number < position + 1)
    	add((tzObject *)NULL);

    //
    // Now find the listnode to put the new object in
    //
    for (int i = 0; temp && i < position; i++)
    	temp = temp->next;

    if(temp->object != (tzObject *)NULL)
        delete temp->object;
    
    temp->object = object;
    
    current = temp;
    current_index = position;
    
    return;
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

Share

About the Author

Tingshao Zhu
Researcher
United States United States
No Biography provided

| Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.150224.1 | Last Updated 4 May 2002
Article Copyright 2002 by Tingshao Zhu
Everything else Copyright © CodeProject, 1999-2015
Layout: fixed | fluid