//MAIN PROGRAM: test.cpp

// Programmer:  Chelsea Putre
// Last modified:  31 August 2009
#include <iostream>
#include <cstdlib>
#include "LinkedList.h"
#include "node.h"

using namespace std;
namespace assign1::LinkedList;

int main()
{
LinkedList list1 = new LinkedList();
	
list1.list_head_insert("The");
list1.list_tail_insert("dog");
list1.list_tail_insert("dog");
list1.list_tail_insert("likes");
list1.list_tail_insert("to");
list1.list_tail_insert("dog");

cout<< list1.size()<< endl;

return 0;
};

                                            //Headerfile: LinkedList.cpp

#include <cassert>
#include <cstdlib>
#include <iostream>
#include "node.h"
#include "LinkedList.h"

using namespace std;
namespace assign
{

LinkedList::LinkedList()
{ 
	head_ptr = NULL, 
	many_nodes = 0;
	}

LinkedList::LinkedList(const LinkedList& source)
	{	
	node *tail_ptr;			//needed for argument of list_copy
	list_copy(source.head_ptr, head_ptr, tail_ptr);
	many_nodes = source.many_nodes;
			}
			
			
LinkedList::~LinkedList()
{
list_clear(head_ptr);
many_nodes = 0
}

size_type LinkedList::count(const value_type& target) const
{
	//counts the number of occurences of a particular string
	size_type answer;
	const node *cursor;
	answer = 0;
	cursor = list_search(head_ptr, target);
	
	while(cursor!=NULL)
	{
		//Each time that cursor is not NULL we add another occurence
		++answer;
		cursor = cursor->get_link();
		cursor = list_search(cursor,target);
	}
	return answer;
}


void LinkedList::list_head_insert(node* head_ptr, const node::value_type entry)
{
	
	list_head_insert(head_ptr,entry);
	++many_nodes;
	
}
void LinkedList::list_tail_insert(node* tail_ptr, const node::value_type& entry)
{
	new_elem = new node();
	new_elem-> set_data(entry);
	new_elem->set_link(NULL);
	tail_ptr->set_link(new_elem);
	tail_ptr = new_elem;
	++many nodes;
	}
void operator +=(const LinkedList& addend)
{
	node *copy_head_ptr;
	node *copy_tail_ptr;

	if (addend.many_nodes > 0)
	{
		list_copy(Addend.head_ptr, copy_head_ptr, copy_tail_ptr);
		copy_tail_ptr->set_link(head_ptr);
		head_ptr = copy_head_ptr;
		many_nodes += addend.many_nodes;
			}	
}
	
}
                                   //CLASS IMPLEMENTATION: LinkedList.h

#ifndef CHELSEA
#define CHELSEA
#include <cstdlib>
#include "node.h"
#include <string>
#include<iostream>

namespace assign1
{

class LinkedList
{

public:

typedef node::value_type value_type;
typedef size_t size_type;

//Constructors
LinkedList();

LinkedList(const LinkedList& source);

//Destructor
~LinkedList();

//Mutating member functions
void  list_head_insert(const value_type& entry) ;//y
void  list_tail_insert(const value_type& entry) ;//y
void operator +=(const LinkedList addend); //y
//void operator =(const LinkedList source);
//Query member functions: Constant member functions
size_type size() const {return many_nodes;}
size_type count(const value_type target) const; //y

private:

size_type many_nodes;
node *head_ptr;
};

LinkedList operator +=(const LinkedList addend);

}
#endif

 //Headerfile: LinkedList.cpp

#include "LinkedList.h"

namespace assign
{

LinkedList::LinkedList()


}

//CLASS IMPLEMENTATION: LinkedList.h
namespace assign1 //<--- different namespace???
{

class LinkedList
{

};
}

namespace assign1