#include <iostream>
using namespace std;

#ifndef CSIMPLELIST_H
#define CSIMPLELIST_H
#include "CSimpleList.h"
#endif //CSIMPLELIST_H


int		main(void)
{
	auto	CSimpleList<char>	charObj;
        ERROR: Expected initializer before '<' token 

	auto	CSimpleList<int>	intObj;
        ERROR: Expected initializer before '<' token 

	auto	char				inChar = 'y';
	auto	int					inInt = 1;
	
	cout << "Number of items in charObj: " << charObj.m_numItems << endl;
        ERROR: 'charObj' was not declared in this scope 

	cout << "Number of items in intObj: " << intObj.m_numItems << endl;
        ERROR: 'intObj' was not declared in this scope 

	
	charObj.InsertItem(inChar, 1);
	intObj.InsertItem(inInt, 1);
	
	cout << "New number of items in charObj: " << charObj.m_numItems << endl;
	cout << "New number of items in intObj: " << intObj.m_numItems << endl;
	
	charObj.RemoveItem(1);
	intObj.RemoveItem(1);
	
	cout << "Final number of items in charObj: " << charObj.m_numItems << endl;
	cout << "Final number of items in intObj: " << intObj.m_numItems << endl;	
	
	return 0;
}

#ifndef CSIMPLELIST_H
#define CSIMPLELIST_H


// linked list structure
template<typename Type>
struct  LNode
{
    Type			item;
    LNode<Type>		*next;
	
};

// trivial exception class for CSimpleList
class   CListEx
	{
	};

// class declaration
template <class Type>
class   CSimpleList
	{
	public: 
		// constructors
		CSimpleList(void) : m_headPtr(0), m_numItems(0) {}
		CSimpleList(const CSimpleList  &object);
		~CSimpleList(void) { DestroyList(); }
		
		// other member functions
		void    CreateList(void);
		int     DestroyList(void);
		void    GetListItem(int  index, Type  &item) const ;
		int     GetNumItems(void) const { return (m_numItems); }
		void    InsertItem(Type  newItem, int  index);
		bool    IsListEmpty(void) const { return (0 == m_numItems); }
		void    RemoveItem(int  index);
		
		// overloaded operators
		CSimpleList&    operator=(const CSimpleList<Type>  &rhs);
		
                // this is here for testing purpouses only, will be in private section 
		int          m_numItems;
		
	private:
		// data members
		LNode<Type>		*m_headPtr;
		//int				m_numItems;
		
		// member functions
		int				CopyList(const CSimpleList<Type>  &otherList);
		LNode<Type>*	GetNodePtr(int  index) const;
	};


#include "CSimpleList.cpp"

#endif  // CSIMPLELIST_H 

#include    <iostream>
using   namespace   std;
#include "CSimpleList.h"



// ==== CSimpleList ===========================================================
// 
// This copy constructor makes a copy of the object provided by the caller,
// node for node.
//
// Input:
//		&otherList	--	a const reference to the caller's CSimpleList object to
//						be copied.
//
// Output:
//		If all goes well, a copy of the user's CSimpleList object is created
//		and the number of nodes copied is returned to the caller.
//
// ============================================================================

template<typename Type>
CSimpleList<Type>::CSimpleList(const CSimpleList<Type>  &object)
{
	m_numItems = 0;
	m_headPtr = NULL;
	CopyList(object);
	
} // end of "CSimpleList"



// ==== CreateList ============================================================
// 
// This function creates an empty list.
//
// Input:
//		None.
//
// Output:
//		An empty list is created and a return value of LIST_SUCCESS is returned
//      to the caller if all goes well.
//
// ============================================================================

template<typename Type>
void        CSimpleList<Type>::CreateList(void)
{
    // destroy list in case there is a pre-existing list
    DestroyList();
    
    // null headPtr and zero numItems then return success
    m_numItems = 0;
    m_headPtr = NULL;
    return;
	
} // end of "CreatList"



// ==== DestroyList ===========================================================


template<typename Type>
int         CSimpleList<Type>::DestroyList(void)
{
    auto    int     index = NULL;
    
    // free all nodes in the list
    for (index = 0; index < m_numItems; index++)
    {
        RemoveItem(index);
    }
    
    // zero out data members and return
    m_numItems = 0;
    m_headPtr = NULL;
    return index;
	
} // end of "DestroyList"



// ==== GetListItem ===========================================================


template<typename Type>
void        CSimpleList<Type>::GetListItem(int  index, Type  &item) const 
{
    auto    LNode<Type>           *nodePtr = NULL;
    
    // check for empty list
    if (true == IsListEmpty())
    {
        //throw CListEx(LIST_EMPTY);
		cout << "Error: GetListItem" << endl;
		return;
    }
    
    if (NULL == (nodePtr = GetNodePtr(index)))
    {
        // throw exception if invalid index is provided
        //throw CListEx(INVALID_INDEX);
		cout << "Error: GetListItem" << endl;
		return;
    }
    
    // else set item equal to value in corresponding LNode and return success
    else
    {
        item = nodePtr->item;
    }
    
} // end of "GetListItem"



// ==== InsertItem ============================================================


template<typename Type>
void        CSimpleList<Type>::InsertItem(Type  newItem, int  index)
{
	auto	LNode<Type>		*nodePtr = NULL;
	auto	LNode<Type>		*prevPtr = NULL;
	
	// if item is to be inserted into front of the list
    if (0 == index)
	{
		nodePtr = new LNode<Type>;
		nodePtr->item = newItem;
		nodePtr->next = m_headPtr;
		m_headPtr = nodePtr;
		m_numItems++;
		return;
	}
	
	// else if item is to be inserted into end of the list, do so
	else if (m_numItems == index)
	{
		nodePtr = GetNodePtr(index - 1);
		nodePtr->next = new LNode<Type>;
		nodePtr->next->item = newItem;
		nodePtr->next->next = NULL;
		m_numItems++;
		return;
	}
	
	// else handle insertion into middle of the list
	else if ((index < m_numItems) && (index > 0))
	{
		nodePtr = new LNode<Type>;
		nodePtr->item = newItem;
		nodePtr->next = GetNodePtr(index);
		prevPtr = GetNodePtr(index - 1);
		prevPtr->next = nodePtr;
		m_numItems++;
		return;
	}
	
	// else throw exception due to invalid index
	else
	{
	    //throw CListEx(INVALID_INDEX);
		cout << "Error: InsertItem" << endl;
		return;
	}
	
} // end of "InsertItem"



// ==== RemoveItem ============================================================
// 
// This function removes an item at target index location.
//
// Input:
//		index	--	an int storing the index to the node the caller wants to
//					remove.
//
// Output:
//
// ============================================================================

template<typename Type>
void        CSimpleList<Type>::RemoveItem(int  index)
{
    auto    LNode<Type>		*nodePtr = NULL;
    auto    LNode<Type>		*tempPtr = NULL;
    
    // if the list is empty, throw an exception
    if (true == IsListEmpty())
    {
        //throw CListEx(LIST_EMPTY);
		cout << "Error: RemoveItem: " << endl;
		return;
    }
    
    // get pointer for zero-based node to be removed
    nodePtr = GetNodePtr(index);
    
    // if invalid pointer is returned, throw error
    if (NULL == nodePtr)
    {
        //throw CListEx(INVALID_INDEX);
		cout << "Error: RemoveItem: " << endl;
		return;
    }
    
    // else remove that item
    else
    {
        tempPtr = GetNodePtr(index - 1);
        
        // handle removal from head of the list
        if (NULL == tempPtr)
        {
            m_headPtr = nodePtr->next;
            delete nodePtr;
            m_numItems--;
        }
        
        // else remove item from the middle/end of the list
        else
        {
            tempPtr->next = nodePtr->next;
            delete nodePtr;
            m_numItems--;
        }
    }
	
    return;
	
} // end of "RemoveItem"



// ==== CopyList ==============================================================


template<typename Type>
int             CSimpleList<Type>::CopyList(const CSimpleList<Type>  &otherList)
{
	auto	int		index;
	auto	Type	otherItem;
	
	DestroyList();
	CreateList();
	m_numItems = otherList.m_numItems;
	
	for (index = 0; index < m_numItems; index++)
	{
	    otherList.GetListItem(index, otherItem);
		InsertItem(index, otherItem); 
	}
	
	return index;
	
} // end of "CopyList"



// ==== GetNodePtr ============================================================
// 
// This function is used to gain indexed access into the linked list.  If an
// invalid index is provided (beyond the allocated amount of nodes), a NULL
// pointer is returned.
//
// Input:
//		index	--	an int storing the index to the node the caller wants a
//					pointer to.
//
// Output:
//		If a valid index is provided, a reference to the LNode at the caller's
//		index is returned, otherwise a NULL pointer is returned.
//
// ============================================================================

template<typename Type>
LNode<Type>*          CSimpleList<Type>::GetNodePtr(int  index) const
{
    auto    LNode<Type>		*leadPtr = m_headPtr;
    auto    int				counter;
    
    // if invalid (negative index) is provided, return null
    if (index < 0)
    {
        return NULL;
    }
    
    // index through the array until either target index or end of list is
    // reached
    for (counter = 0; ((counter < index) && (leadPtr != NULL)); counter++)
    {
        leadPtr = leadPtr->next;
    }
    
    // leadPtr now contains either a pointer to the target LNode or NULL, so
    // return leadPtr
    return leadPtr;
	
} // end of "GetNodePtr;



// ==== operator= =============================================================


template<typename Type>
CSimpleList<Type>&    CSimpleList<Type>::operator=(const CSimpleList<Type>  &rhs)
{
	if (this != &rhs)
	{
		CopyList(rhs);
	}
	
	return *this;	
} // end of "operator=" 

#include <iostream>


#include "CSimpleList.h"

using namespace std;


int		main(void)
{
		CSimpleList<char>	charObj;

		CSimpleList<int>	intObj;

		char				inChar = 'y';
		int					inInt = 1;
	
	cout << "Number of items in charObj: " << charObj.m_numItems << endl;

	cout << "Number of items in intObj: " << intObj.m_numItems << endl;

	
	charObj.InsertItem(inChar, 1);
	intObj.InsertItem(inInt, 1);
	
	cout << "New number of items in charObj: " << charObj.m_numItems << endl;
	cout << "New number of items in intObj: " << intObj.m_numItems << endl;
	
	charObj.RemoveItem(1);
	intObj.RemoveItem(1);
	
	cout << "Final number of items in charObj: " << charObj.m_numItems << endl;
	cout << "Final number of items in intObj: " << intObj.m_numItems << endl;	
	
	return 0;
}