// FICHIER : Reference.h
// CLASSE : Reference
/************************************************************************
 *    UNIVERSITE DE BRETAGNE SUD (UBS)  --- I.U.P/I.U.T. DE LORIENT     *
 ************************************************************************
 *           LABORATOIRE DE GENIE MECANIQUE ET MATERIAUX (LG2M)         *
 * Centre de Recherche Bvd Flandres Dunkerque - 56325 Lorient Cedex     *
 * tel. 02.97.87.45.70 fax. 02.97.87.45.72 http://www-lg2m.univ-ubs.fr  *
 ************************************************************************
 *     DATE:        06/02/00                                            *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerard.rio@univ-ubs.fr)             *
 *                  Tel 0297874571   fax : 02.97.87.45.72               *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT:  classe général virtuel des références. Les classes dérivées*
 *     permettent de définir précisemment les différentes références :  *
 *      de noeuds, d'élément, d'aretes, de faces etc..                  *
 *     Une instance de la classe s'identifie a partir d'un nom          *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/


#ifndef REFERENCE_H
#define REFERENCE_H


#include <iostream>
#include <string>
//#include "Debug.h"
#include "Tableau_T.h"
#include "UtilLecture.h"
#include <list>
#include "MotCle.h"

class Reference 
{
	public :

		// CONSTRUCTEURS :
		
		// Constructeur par defaut
		Reference ( 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 -> arrete 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		
		Reference (int nbmaille , int indic);
				
		// Constructeur fonction d'un nom de  reference
		// du nb de maillage, du type de ref		
		Reference (string nom,int nbmaille , int indic);
				
		// Constructeur de copie
		Reference (const Reference& ref);
		
		
		// DESTRUCTEUR :
		
		virtual ~Reference ();
		
		
		// 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
		virtual Reference* Nevez_Ref_copie() const = 0;
		
		// Surcharge de l'operateur = : realise l'egalite entre deux references
		virtual Reference& operator= (const Reference& ref);
		
		// Retourne le nom associe a la reference
		string Nom () const;
		
		// Retourne le type de reference 
		// = 1 : il s'agit de reference de noeud
		// = 2 : il s'agit de reference d'element
		// =3 -> surface relatives à des éléments, 
		// =4 -> arrete 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
		int Indic () const;
		
		// Retourne le numero du maillage auquelle la reference se rattache 
		int Nbmaille()  const; 
		// change le numéro du maillage associé
		void Change_Nbmaille(int nv_nm) {nbmaille= nv_nm;};
		
		// Remplace l'ancien nom de la reference par nouveau_nom
		void Change_nom (string nouveau_nom);
 
  // supprime les doublons internes éventuels dans la référence
  virtual void Supprime_doublons_internes() = 0;
		
		// Affiche les donnees liees a la reference
		virtual void Affiche () const; 
		
	 // Affiche les donnees des références dans le flux passé en paramètre
	 virtual void Affiche_dans_lis(ofstream&  sort) const =0  ;
  
  // lecture d'une liste de reference
  virtual bool LectureReference(UtilLecture & entreePrinc) =0 ;
  
  // 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
  virtual void Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int cas) =0;
   
  //----- 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)
	 virtual void Lecture_base_info(ifstream& ent,const int cas) =0;
     // cas donne le niveau de sauvegarde
     // = 1 : on sauvegarde tout
     // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
	 virtual void Ecriture_base_info(ofstream& sort,const int cas) =0;

	protected :
		
		string nom_ref; // nom de la reference
		int nbmaille; // numero du maillage auquelle la reference se rapporte
		int indic; // 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 -> arrete 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
  static MotCle motCle; // liste des mots clés
  
        // methodes appellées par les classes dérivées
        	    // 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 Lect_int_base_info(ifstream& ent);
        // cas donne le niveau de sauvegarde
        // = 1 : on sauvegarde tout
        // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
  void Ecrit_int_base_info(ofstream& sort);

};

#ifndef MISE_AU_POINT
  #include "Reference.cc"
  #define  REFERENCE_H_deja_inclus
#endif

#endif
		
				
