/*
 * list.h
 *
 * Copyright
 * (C) 2005 VANDERBRUGGEN Thomas <tvanderbruggen@yahoo.fr>
 *
 * Created on 22/05/2005
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 */

 #ifndef __LIST__
 #define __LIST__

#include <stdlib.h>

 namespace list
 {
 template<typename _Tp> class list;
 template<> class list<int>;
 template<> class list<float>;
 template<> class list<double>;
 template<> class list<long double>;

 //retourne la longueur d'une liste :
 template<typename _Tp> unsigned int Longueur(const list<_Tp>&);

 /*
 * On utilise la définition inductive suivante pour les listes :
 * Soient E un ensemble non vide
 * L l'ensemble des listes d'éléments de E
 * On pose L = {{}} u E X L
 * où {} désigne l'ensemble vide.
 */

 template<typename _Tp>
 struct _node
 {
 _Tp _L_Contenu; //le premier élement
 _node<_Tp> *_L_Suivant;//le reste de la liste
 };

 template<typename _Tp>
 class list
 {
 private:
 _node<_Tp> *_L_Noeud;

 public:

 //le constructeur par défaut
 list(_node<_Tp> * const);
 //le constructeur de copies
 list(const list&);

 //retourne le noeud
 _node<_Tp> * Node();
 const _node<_Tp> * Node() const;
 //retourne le premier élément
 _Tp Tete();
 const _Tp Tete() const;
 //retoune le reste de la liste
 list<_Tp> * Suivant();
 const list<_Tp> * Suivant() const;

 //operator :
 //assigne une liste à une autre liste :
 list<_Tp> operator=(const list<_Tp>&);

 //teste si deux listes sont égales
 bool operator==(const list<_Tp>&);
 //teste si deux listes sont différentes
 bool operator!=(const list<_Tp>&);
 };

 //retourne le noeud
 template<typename _Tp>
 inline _node<_Tp>*
 list<_Tp>::Node(){return _L_Noeud;}

 template<typename _Tp>
 inline const _node<_Tp>*
 list<_Tp>::Node() const{return _L_Noeud;}

 //retourne le premier élément
 template<typename _Tp>
 inline _Tp
 list<_Tp>::Tete() {return _L_Noeud._L_Contenu;}

 template<typename _Tp>
 inline const _Tp
 list<_Tp>::Tete() const {return _L_Noeud._L_Contenu;}

 //retoune le reste de la liste
 template<typename _Tp>
 inline list<_Tp>*
 list<_Tp>::Suivant()
 {
 _L_Noeud = _L_Noeud->_L_Suivant;
 return *this;
 }

 template<typename _Tp>
 inline const list<_Tp>*
 list<_Tp>::Suivant() const
 {
 _L_Noeud = _L_Noeud->_L_Suivant;
 return *this;
 }

 //le constructeur par défaut
 template<typename _Tp>
 inline
 list<_Tp>::list(_node<_Tp> * const __noeud)
 :_L_Noeud(*__noeud){ }

 //le constructeur de copies
 template<typename _Tp>
 inline
 list<_Tp>::list(const list &__list)
 :_L_Noeud(__list.Node()){ }


 //operators :
 //assigne une liste à une autre liste :
 template<typename _Tp>
 inline list<_Tp>
 list<_Tp>::operator=(const list<_Tp>& __list)
 {
 _L_Noeud._L_Contenu = __list.Tete();
 _L_Noeud._L_Suivant = __list.Suivant();
 return *this;
 }

 //teste si deux listes sont égales
 //cette fonction est récursive.
 template<typename _Tp>
 bool
 list<_Tp>::operator==(const list<_Tp>& __list)
 {
 if(__list._L_Noeud == NULL && _L_Noeud == NULL)
 return true;
 else if(__list._L_Noeud != NULL && _L_Noeud == NULL)
 return false;
 else if(__list._L_Noeud == NULL && _L_Noeud != NULL)
 return false;
 else
 {
 if(__list.Tete() == _L_Noeud._L_Contenu &&
 __list.Suivant() == _L_Noeud._L_Suivant)
 return true;
 else return false;
 }
 }

 //teste si deux listes sont différentes
 template<typename _Tp>
 bool
 list<_Tp>::operator!=(const list<_Tp>& __list)
 {
 list<_Tp> __lst = list(_L_Noeud);
 return !(__lst == __list);
 }

 //retourne la longueur d'une liste :
 //Cette fonction est récursive.
 template<typename _Tp>
 unsigned int
 Longueur(const list<_Tp>& __list)
 {
 if(__list._L_Noeud == NULL) return 0;
 else return 1 + Longueur(__list.Suivant());
 }

 }//namespace list

#endif /*__LIST__*/