#ifndef LISTITERATOR_C
#define LISTITERATOR_C


//*****************************************************************************
//
//			ListIterator.C
//
//*****************************************************************************
//
//      Copyright (C) 1996 
//
//                      Ronald A. MacCracken
//			Graduate Student
//                      Computer Science Department
//                      University of California
//                      Davis, CA  95616
//
//      Permission is granted to use at your own risk and 
//      distribute this software in source and binary forms 
//      provided the above copyright notice and this paragraph 
//      are preserved on all copies.  This software is provided 
//      "as is" with no express or implied warranty.
//
//*****************************************************************************

#include "TabStream.h"
#include "ListIterator.h"


//
// Constructors and Destructors
//

template<class TYPE>
ListIterator<TYPE> :: ListIterator ( void )
: first_element ( NULL ) , current_element ( NULL )
{ }


template<class TYPE>
ListIterator<TYPE> :: ListIterator ( const List<TYPE>& l , const int x )
{
    Reset ( l , x ) ;
}


template<class TYPE>
ListIterator<TYPE> :: ListIterator ( const ListIterator<TYPE>& l )
{
    Copy ( l ) ;
}


template<class TYPE>
ListIterator<TYPE> :: ~ListIterator ( void )
{
    Delete ( ) ;
}


//
// Private Member Functions
//

template<class TYPE>
void	ListIterator<TYPE> :: Copy ( const ListIterator<TYPE>& l )
{
    first_element   = l.first_element   ;
    current_element = l.current_element ;
}


template<class TYPE>
void	ListIterator<TYPE> :: Delete ( void )
{
    first_element   = NULL ;
    current_element = NULL ;
}


//
// Public Member Functions
//

template<class TYPE>
ListIterator<TYPE>&	ListIterator<TYPE> ::
					operator= ( const ListIterator<TYPE>& l )
{
    if ( this == &l )
	return ( *this ) ;

    Delete ( ) ;

    Copy ( l ) ;

    return ( *this ) ;
}


template<class TYPE>
ListIterator<TYPE>&	ListIterator<TYPE> :: operator++ ( void )
{
    assert ( ! Is_Done ( ) ) ;

    current_element = current_element->Get_Next ( ) ;

    return ( *this ) ;
}


template<class TYPE>
ListIterator<TYPE>&	ListIterator<TYPE> :: operator++ ( int )
{
    assert ( ! Is_Done ( ) ) ;

    current_element = current_element->Get_Next ( ) ;

    return ( *this ) ;
}


template<class TYPE>
const TYPE&	ListIterator<TYPE> :: Get_Current ( void ) const
{
    assert ( ! Is_Done ( ) ) ;

    return ( current_element->Get_Data ( ) ) ;
}


template<class TYPE>
const TYPE&	ListIterator<TYPE> :: Get_Next ( void ) const
{
    assert ( ! Is_Done ( ) ) ;

    ListElement<TYPE>*	next = current_element->Get_Next ( ) ;

    assert ( next != NULL ) ;

    return ( next->Get_Data ( ) ) ;
}


template<class TYPE>
int	ListIterator<TYPE> :: Is_Done ( void ) const
{
    return ( current_element == NULL ) ;
}


template<class TYPE>
void	ListIterator<TYPE> :: Reset ( void )
{
    current_element = first_element ;
}


template<class TYPE>
void	ListIterator<TYPE> :: Reset ( const List<TYPE>& l , const int x )
{
    assert ( x <= l.length ) ;

    first_element = l.first ;

    for ( int i = 0 ; i < x ; ++i )
    {
	if ( first_element == NULL )
	    break ;

	first_element = first_element->Get_Next ( ) ;
    }

    current_element = first_element ;
}


#endif