// FICHIER : ReferenceNE.h
// CLASSE : ReferenceNE

/************************************************************************
 *    UNIVERSITE DE BRETAGNE SUD (UBS)  --- I.U.P/I.U.T. DE LORIENT     *
 ************************************************************************
 *           LABORATOIRE DE GENIE MECANIQUE ET MATERIAUX (LG2M)         *
 * Centre de Recherche Rue de Saint Maudé - 56325 Lorient cedex         *
 * tel. 02.97.87.45.70 fax. 02.97.87.45.72 http://www-lg2m.univ-ubs.fr  *
 ************************************************************************
 *     DATE:        23/01/97                                            *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerard.rio@univ-ubs.fr)             *
 *                  Tel 0297874571   fax : 02.97.87.45.72               *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT:  Def, stockage et manipulation des références pour les      *
 *           noeuds et les éléments.                                    *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/


#ifndef REFERENCENE_H
#define REFERENCENE_H

#include "Reference.h"


class ReferenceNE : public Reference 
{
	public :

		// CONSTRUCTEURS :
		
		// Constructeur par defaut
		ReferenceNE( string nom = "rien_actuellement");
		
		// indic = 1 : il s'agit de reference de noeud
		// indic = 2 : il s'agit de reference d'element
		// =3 -> surface relatives à des éléments, 
		// =4 -> arete relatives à des éléments,
		// =5 -> des noeuds relatifs à des éléments
		// =6 -> de points d'intégrations relatifs à des éléments
  // =7 -> de points d'intégrations relatifs à des surfaces d'éléments
  // =8 -> de points d'intégrations relatifs à des arrete d'éléments

		// Constructeur fonction  du nb de maillage et du type de ref		
		ReferenceNE(int nbmaille , int indic);

		// Constructeur fonction d'un tableau des numeros de la reference
		// du nb de maillage, du type de ref
		ReferenceNE(const Tableau<int>& tab,int nbmaille , int indic, string nom = "rien_actuellement");
		// idem mais avec une liste d'entiers plutôt qu'un tableau
		ReferenceNE(const list <int>& list_entiers,int nbmaille , int indic, string nom = "rien_actuellement");
		
		// Constructeur fonction d'un nom de  reference
		// du nb de maillage, du type de ref		
		ReferenceNE(string nom,int nbmaille , int indic);
				
		// Constructeur de copie
		ReferenceNE(const ReferenceNE& ref);
		
		
		// DESTRUCTEUR :
		
		~ReferenceNE ();
		
		// METHODES :
		
		// création d'une référence du même type contenant les mêmes info
		// que la référence donnée en argument: utilisation du constructeur de copie
		Reference* Nevez_Ref_copie() const
		  {ReferenceNE* ref_ret=new ReferenceNE(*this); return ref_ret;} ;
		
		Reference& operator= (const Reference& ref);
		
		// Retourne le tableau des numeros de la reference en lecture uniquement
		const Tableau<int>& Tab_num() const 
		  {	return tab_num;	};
		
/*		inline int& Numero(int i)
		// Retourne le ieme element du tableau des numeros
		// de la reference (acces lecture et ecriture)
		{	return tab_num(i);	};*/

		// Retourne le ieme element du tableau des numeros
		// de la reference (acces lecture uniquement)
		int Numero(int i) const 
		    {	return tab_num(i);	};
		
		// Retourne le nombre de numeros de la reference
		int Taille()  const 
		      {	return tab_num.Taille();	};
		// change un numéro de référence
		void Change_num_dans_ref(int i,int nv_num)
		    { tab_num(i)=nv_num;}; 
			
	   // change le tableau de numéro de référence	
		void Change_tab_num(const Tableau<int>& tab) 
		    {tab_num = tab;};	     
 
  // supprime les doublons internes éventuels dans la référence
  virtual void Supprime_doublons_internes();

		// Affiche les donnees liees a la reference
		void Affiche() const; 
			
//-------- méthodes découlant de virtuelles ----------------
		
	 // Affiche les donnees des références dans le flux passé en paramètre
	 void Affiche_dans_lis(ofstream&  sort) const  ;
  
  // lecture d'une liste de reference de noeuds ou d'éléments
  bool LectureReference(UtilLecture & entreePrinc);
  
  // affichage et definition interactive des commandes 
  // nbMaxi: nombre maxi de noeud ou d'éléments pour les exemples
  // cas : =1 premier passage, il s'agit de références de noeuds uniquement
  // cas : =2 second passage, il s'agit de l'ensemble des possibilités de références
  void Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int cas);
                   
	 //----- lecture écriture dans base info -----
  // cas donne le niveau de la récupération
     // = 1 : on récupère tout
     // = 2 : on récupère uniquement les données variables (supposées comme telles)
	 void Lecture_base_info(ifstream& ent,const int cas);
     // cas donne le niveau de sauvegarde
     // = 1 : on sauvegarde tout
     // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
	 void Ecriture_base_info(ofstream& sort,const int cas);
        
	protected :
		
		Tableau<int> tab_num; // tableau des numeros de noeuds ou d'élément de la reference	
		
};

#ifndef MISE_AU_POINT
  #include "ReferenceNE.cc"
  #define  REFERENCENE_H_deja_inclus
#endif

#endif