// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL  : gerardrio56@free.fr
//
// 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 3 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, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.

/************************************************************************
*     DATE:        06/03/2023                                          *
*                                                                $     *
*     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
*                                                                $     *
*     PROJET:      Herezh++                                            *
*                                                                $     *
************************************************************************
*     BUT:    def d'une classe relative a l'exportation en variables   *
*         globales de grandeurs définies dans les maillages.           *
*         Cela concerne les constantes utilisateur et les variables    *
*         calculées par Herezh.                                        *
*                                                                $     *
*     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
*     VERIFICATION:                                                    *
*                                                                      *
*     !  date  !   auteur   !       but                          !     *
*     ------------------------------------------------------------     *
*     !        !            !                                    !     *
*                                                                $     *
*     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
*     MODIFICATIONS:                                                   *
*     !  date  !   auteur   !       but                          !     *
*     ------------------------------------------------------------     *
*                                                                $     *
************************************************************************/


#ifndef VARIABLES_EXPORTER_H
#define VARIABLES_EXPORTER_H


#include <iostream>
#include <map>
#ifndef ENLINUX_STREAM
  #include <sstream> // pour le flot en memoire centrale
#else
  #include <strstream> // pour le flot en memoire centrale
#endif
 #include "UtilLecture.h"
#include "Enum_IO_XML.h"


#include "LesMaillages.h"
#include "Basiques.h"


/** @defgroup Les_classes_exportation_en_variables
*
*     BUT:def de classes relatives a l'exportation en variables
*         globales de grandeurs définies dans les maillages.
*         Cela concerne les constantes utilisateur et les variables
*         calculées par Herezh.
*
* \author    Gérard Rio
* \version   1.0
* \date       23/01/97
* \brief       Définition de classes relatives a l'exportation en variables
*
*/

/// @addtogroup Les_classes_exportation_en_variables
///  @{
///

class VariablesExporter
{   
	public :
  friend class LesMaillages;
	
  //=================%%%%%%%% classes de conteneurs %%%%%%%%=================

  // classe conteneur de base pour noeud, élément etc.
  class A_un_NE
    { // surcharge de l'operator de lecture  avec le type
      friend istream & operator >> (istream &, A_un_NE &);
      // surcharge de l'operator d'ecriture
      friend ostream & operator << (ostream &, const A_un_NE &);
      
      public :
         A_un_NE(); // constructeur par défaut
         // constructeur fonction de toutes les grandeurs
         A_un_NE(string ref
                  ,string nom_mail_,string nom_var_);
         // constructeur de copie
         A_un_NE (const A_un_NE& a);
         // DESTRUCTEUR :
         virtual ~A_un_NE ();

         // opérateurs
         A_un_NE& operator= (const A_un_NE& a);
         bool operator== (const A_un_NE& a) const;
         bool operator!= (const A_un_NE& a) const
             {if ( (*this)==a ) return true; else return false;};
         bool operator < (const A_un_NE& a) const;
         bool operator <= (const A_un_NE& a) const;
         bool operator > (const A_un_NE& a) const;
         bool operator >= (const A_un_NE& a) const;
         void Affiche();
         
         // retour des grandeurs
         const string& Ref_const() const {return ref;}; // la ref
         const string& Nom_mail_const() const {return nom_mail;}; // le nom du maillage du noeud
         const string& Nom_var_const() const {return nom_var;}; // nom  de la variable associée
     
         string& Ref_NE()  {return ref;}; // la ref
         string* Pointeur_Ref_NE()  {return &ref;}; // la ref
         string& Nom_mail()  {return nom_mail;}; // le nom du maillage du noeud
         string* Pointeur_Nom_mail()  {return &nom_mail;}; // le nom du maillage du noeud
         string& Nom_var()  {return nom_var;}; // nom  de la variable associée

         // récupération du pointeur de la classe
         const A_un_NE* PointeurClass_const() const {return this;};
         A_un_NE* PointeurClass() {return this;};



      protected :
         string ref; // la ref associée
         string nom_mail; // le nom du maillage du noeud ou élément
         string nom_var; // nom  de la variable associée
    };
    
  // classe conteneur pour un ddl à un noeud
  class Ddl_a_un_noeud
    { // surcharge de l'operator de lecture  avec le type
      friend istream & operator >> (istream &, Ddl_a_un_noeud &);
      // surcharge de l'operator d'ecriture
      friend ostream & operator << (ostream &, const Ddl_a_un_noeud &);
      
      public :
         Ddl_a_un_noeud (); // constructeur par défaut
         // constructeur fonction de toutes les grandeurs
         Ddl_a_un_noeud (Ddl_enum_etendu e,string ref_noeud
                         , string nom_mail_,string nom_var_, Enum_dure tps);
         // constructeur de copie
         Ddl_a_un_noeud (const Ddl_a_un_noeud& a);
         // DESTRUCTEUR :
         virtual ~Ddl_a_un_noeud ();

         // opérateurs
         Ddl_a_un_noeud& operator= (const Ddl_a_un_noeud& a);
         bool operator== (const Ddl_a_un_noeud& a) const;
         bool operator!= (const Ddl_a_un_noeud& a) const
             {if ( (*this)==a ) return true; else return false;};
         bool operator < (const Ddl_a_un_noeud& a) const;
         bool operator <= (const Ddl_a_un_noeud& a) const;
         bool operator > (const Ddl_a_un_noeud& a) const;
         bool operator >= (const Ddl_a_un_noeud& a) const;
         void Affiche();
         
         // retour des grandeurs
         const Ddl_enum_etendu& Enu_const() const {return enu;} ; // le ddl
         const string& Ref_Num_NE_const() const {return ref_num_NE;}; // la ref de num du noeud
         const string& Nom_mail_const() const {return nom_mail;}; // le nom du maillage du noeud
         const string& Nom_var_const() const {return nom_var;}; // nom  de la variable associée
         const Enum_dure& Temps_const() const {return temps;}; // temps de validation du ddl
         string* Pointeur_Nom_mail()  {return &nom_mail;}; // le nom du maillage du noeud

         Ddl_enum_etendu& Enu()  {return enu;} ; // le ddl
         string& Ref_Num_NE()  {return ref_num_NE;}; // la ref de num du noeud
         string& Nom_mail()  {return nom_mail;}; // le nom du maillage du noeud
         string& Nom_var()  {return nom_var;}; // nom  de la variable associée
         Enum_dure& Temps()  {return temps;}; // temps de validation du ddl

      protected :
         Ddl_enum_etendu enu; // le ddl
         string ref_num_NE; // le num du noeud
         string nom_mail; // le nom du maillage du noeud
         string nom_var; // nom  de la variable associée
         Enum_dure temps; // temps de validation du ddl
    };
    
 // classe conteneur pour un ddl étendu  à un noeud
 class Ddl_etendu_a_un_noeud : public A_un_NE
 { // surcharge de l'operator de lecture  avec le type
   friend istream & operator >> (istream &, Ddl_etendu_a_un_noeud &);
   // surcharge de l'operator d'ecriture
   friend ostream & operator << (ostream &, const Ddl_etendu_a_un_noeud &);
   
   public :
      Ddl_etendu_a_un_noeud (); // constructeur par défaut
      // constructeur fonction de toutes les grandeurs
      Ddl_etendu_a_un_noeud (Ddl_enum_etendu e,string ref_noeud
                      , string nom_mail_,string nom_var_);
      // constructeur de copie
      Ddl_etendu_a_un_noeud (const Ddl_etendu_a_un_noeud& a);
      // DESTRUCTEUR :
      virtual ~Ddl_etendu_a_un_noeud ();

      // opérateurs
      Ddl_etendu_a_un_noeud& operator= (const Ddl_etendu_a_un_noeud& a);
      bool operator== (const Ddl_etendu_a_un_noeud& a) const;
      bool operator!= (const Ddl_etendu_a_un_noeud& a) const
          {if ( (*this)==a ) return true; else return false;};
      bool operator < (const Ddl_etendu_a_un_noeud& a) const;
      bool operator <= (const Ddl_etendu_a_un_noeud& a) const;
      bool operator > (const Ddl_etendu_a_un_noeud& a) const;
      bool operator >= (const Ddl_etendu_a_un_noeud& a) const;
      void Affiche();
      
      // retour des grandeurs
      Ddl_enum_etendu Enu_const() const {return enu;} ; // le ddl
      Ddl_enum_etendu& Enu()  {return enu;} ; // le ddl

   protected :
      Ddl_enum_etendu enu; // le ddl
 };
 
 // classe conteneur pour une grandeur quelconque  à un noeud
 class Quelconque_a_un_noeud : public A_un_NE
 { // surcharge de l'operator de lecture  avec le type
   friend istream & operator >> (istream &, Quelconque_a_un_noeud &);
   // surcharge de l'operator d'ecriture
   friend ostream & operator << (ostream &, const Quelconque_a_un_noeud &);
   
   public :
      Quelconque_a_un_noeud (); // constructeur par défaut
      // constructeur fonction de toutes les grandeurs
      Quelconque_a_un_noeud (TypeQuelconque_enum_etendu e,string ref_noeud
                      , string nom_mail_,string nom_var_,int num_ord);
      // constructeur de copie
      Quelconque_a_un_noeud (const Quelconque_a_un_noeud& a);
      // DESTRUCTEUR :
      virtual ~Quelconque_a_un_noeud ();

      // opérateurs
      Quelconque_a_un_noeud& operator= (const Quelconque_a_un_noeud& a);
      bool operator== (const Quelconque_a_un_noeud& a) const;
      bool operator!= (const Quelconque_a_un_noeud& a) const
          {if ( (*this)==a ) return true; else return false;};
      bool operator < (const Quelconque_a_un_noeud& a) const;
      bool operator <= (const Quelconque_a_un_noeud& a) const;
      bool operator > (const Quelconque_a_un_noeud& a) const;
      bool operator >= (const Quelconque_a_un_noeud& a) const;
      void Affiche();
      
      // retour des grandeurs
      const TypeQuelconque_enum_etendu& Quelc_const() const {return quelc;} ; // la grandeur constante
      TypeQuelconque_enum_etendu& Quelc()  {return quelc;} ; // la grandeur en i/o
      
      const int& Num_ordre_const() const {return num_ordre;};
      int& Num_ordre() {return num_ordre;};

   protected :
      TypeQuelconque_enum_etendu quelc; // la grandeur
      int num_ordre; // le numéro de la composante
 };
		
 // classe conteneur pour un pti d'élément
 class A_un_E : public A_un_NE
 { // surcharge de l'operator de lecture  avec le type
   friend istream & operator >> (istream &, A_un_E &);
   // surcharge de l'operator d'ecriture
   friend ostream & operator << (ostream &, const A_un_E &);
   
   public :
      A_un_E (); // constructeur par défaut
      // constructeur fonction de toutes les grandeurs
      A_un_E (int absolu_,string ref_
              ,string nom_mail_,string nom_var_,int nbpti);
      // constructeur de copie
      A_un_E (const A_un_E& a);
      // DESTRUCTEUR :
      virtual ~A_un_E ();

      // opérateurs
      A_un_E& operator= (const A_un_E& a);
      bool operator== (const A_un_E& a) const;
      bool operator!= (const A_un_E& a) const
          {if ( (*this)==a ) return true; else return false;};
      bool operator < (const A_un_E& a) const;
      bool operator <= (const A_un_E& a) const;
      bool operator > (const A_un_E& a) const;
      bool operator >= (const A_un_E& a) const;
      void Affiche();
      
      // récupération du pointeur de la classe
      const A_un_E* PointeurClass_E_const() const {return this;};
      A_un_E* PointeurClass_E() {return this;};

      // retour des grandeurs
      
      const int& NBpti_const() const {return num_pti;}; // num du pti en const
      int& NBpti() {return num_pti;}; // idem direct
      const int& Absolue_const() const {return absolu;}; // absolu ou pas
      int& Absolue() {return absolu;};

   protected :
      int num_pti; // numéro du point d'intégration
      int absolu; // indique si la grandeur est dans un repère absolu ou local
 };
 
// classe conteneur pour un ddl à un élément
 class Ddl_a_un_element : public A_un_E
 { // surcharge de l'operator de lecture  avec le type
   friend istream & operator >> (istream &, Ddl_a_un_element &);
   // surcharge de l'operator d'ecriture
   friend ostream & operator << (ostream &, const Ddl_a_un_element &);
   
   public :
      Ddl_a_un_element (); // constructeur par défaut
      // constructeur fonction de toutes les grandeurs
      Ddl_a_un_element (int absolu_,Ddl_enum_etendu e,string ref_noeud
                        ,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti);
      // constructeur de copie
      Ddl_a_un_element (const Ddl_a_un_element& a);
      // DESTRUCTEUR :
      virtual ~Ddl_a_un_element ();

      // opérateurs
      Ddl_a_un_element& operator= (const Ddl_a_un_element& a);
      bool operator== (const Ddl_a_un_element& a) const;
      bool operator!= (const Ddl_a_un_element& a) const
          {if ( (*this)==a ) return true; else return false;};
      bool operator < (const Ddl_a_un_element& a) const;
      bool operator <= (const Ddl_a_un_element& a) const;
      bool operator > (const Ddl_a_un_element& a) const;
      bool operator >= (const Ddl_a_un_element& a) const;
      void Affiche();
      
      // retour des grandeurs
      const Ddl_enum_etendu& Enu_const() const {return enu;} ; // le ddl en const
      Ddl_enum_etendu& Enu()  {return enu;} ; // le ddl direct
      const Enum_dure& Temps_const() const {return temps;}; // temps de validation du ddl
      Enum_dure& Temps()  {return temps;}; // temps de validation du ddl

   protected :
      Ddl_enum_etendu enu; // le ddl
      Enum_dure temps; // temps de validation du ddl
 };

  // classe conteneur pour un TypeQuelconque à un élément
  class TypeQuelconque_a_un_element : public A_un_E
  { // surcharge de l'operator de lecture  avec le type
    friend istream & operator >> (istream &, TypeQuelconque_a_un_element &);
    // surcharge de l'operator d'ecriture
    friend ostream & operator << (ostream &, const TypeQuelconque_a_un_element &);
  
    public :
       TypeQuelconque_a_un_element (); // constructeur par défaut
       // constructeur fonction de toutes les grandeurs
       TypeQuelconque_a_un_element (int absolu_,TypeQuelconque_enum_etendu e,string ref_NE
                         ,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti,int num_ord);
       // constructeur de copie
       TypeQuelconque_a_un_element (const TypeQuelconque_a_un_element& a);
       // DESTRUCTEUR :
       virtual ~TypeQuelconque_a_un_element ();

       // opérateurs
       TypeQuelconque_a_un_element& operator= (const TypeQuelconque_a_un_element& a);
       bool operator== (const TypeQuelconque_a_un_element& a) const;
       bool operator!= (const TypeQuelconque_a_un_element& a) const
           {if ( (*this)==a ) return true; else return false;};
       bool operator < (const TypeQuelconque_a_un_element& a) const;
       bool operator <= (const TypeQuelconque_a_un_element& a) const;
       bool operator > (const TypeQuelconque_a_un_element& a) const;
       bool operator >= (const TypeQuelconque_a_un_element& a) const;
       void Affiche();
       
       // récupération du pointeur de la classe
       const TypeQuelconque_a_un_element* PointeurClass_Quelc_const() const {return this;};
       TypeQuelconque_a_un_element* PointeurClass_Quelc() {return this;};

       // retour des grandeurs
       const TypeQuelconque_enum_etendu& Quelc_const() const {return quelc;} ; // la grandeur constante
       TypeQuelconque_enum_etendu& Quelc()  {return quelc;} ; // la grandeur en i/o
       const int& Num_ordre_const() const {return num_ordre;};
       int& Num_ordre()  {return num_ordre;};

    protected :
       TypeQuelconque_enum_etendu quelc; // la grandeur
       int num_ordre; // le numéro de la composante
  };

 // classe conteneur pour les grandeurs particulières à un élément
 class TypeParticulier_a_un_element : public TypeQuelconque_a_un_element
 { // surcharge de l'operator de lecture  avec le type
   friend istream & operator >> (istream &, TypeParticulier_a_un_element &);
   // surcharge de l'operator d'ecriture
   friend ostream & operator << (ostream &, const TypeParticulier_a_un_element &);
   
   public :
      TypeParticulier_a_un_element(): TypeQuelconque_a_un_element() {}; // constructeur par défaut
      // constructeur fonction de toutes les grandeurs
      TypeParticulier_a_un_element (int absolu_,TypeQuelconque_enum_etendu e,string ref_noeud
                        ,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti,int num_ord):
           TypeQuelconque_a_un_element(absolu_,e,ref_noeud,nom_mail_,tps,nom_var_,nbpti,num_ord) {} ;
      // constructeur de copie
      TypeParticulier_a_un_element(const TypeParticulier_a_un_element& a):
          TypeQuelconque_a_un_element(a) {};
      // DESTRUCTEUR :
      virtual ~TypeParticulier_a_un_element() {};

      // opérateurs
      TypeParticulier_a_un_element& operator= (const TypeParticulier_a_un_element& a)
       {(*PointeurClass_Quelc())= (*a.PointeurClass_Quelc_const());};
      bool operator== (const TypeParticulier_a_un_element& a) const
       {return ((*PointeurClass_Quelc_const()) == (*a.PointeurClass_Quelc_const()));};
      bool operator!= (const TypeParticulier_a_un_element& a) const
          {if ( (*this)==a ) return true; else return false;};
      bool operator < (const TypeParticulier_a_un_element& a) const
         {return ((*PointeurClass_Quelc_const()) < (*a.PointeurClass_Quelc_const()));};
      bool operator <= (const TypeParticulier_a_un_element& a) const
         {return ((*PointeurClass_Quelc_const()) <= (*a.PointeurClass_Quelc_const()));};
      bool operator > (const TypeParticulier_a_un_element& a) const
         {return ((*PointeurClass_Quelc_const()) > (*a.PointeurClass_Quelc_const()));};
      bool operator >= (const TypeParticulier_a_un_element& a) const
         {return ((*PointeurClass_Quelc_const()) == (*a.PointeurClass_Quelc_const()));};
      void Affiche();
 };

  // classe conteneur pour les grandeurs évoluées à un élément
  class TypeEvoluee_a_un_element : public TypeQuelconque_a_un_element
  { // surcharge de l'operator de lecture  avec le type
    friend istream & operator >> (istream &, TypeEvoluee_a_un_element &);
    // surcharge de l'operator d'ecriture
    friend ostream & operator << (ostream &, const TypeEvoluee_a_un_element &);
    
    public :
       TypeEvoluee_a_un_element(): TypeQuelconque_a_un_element() {}; // constructeur par défaut
       // constructeur fonction de toutes les grandeurs
       TypeEvoluee_a_un_element (int absolu_,TypeQuelconque_enum_etendu e,string ref_noeud
                         ,string nom_mail_,Enum_dure tps,string nom_var_,int nbpti,int num_ord):
            TypeQuelconque_a_un_element(absolu_,e,ref_noeud,nom_mail_,tps,nom_var_,nbpti,num_ord) {} ;
       // constructeur de copie
       TypeEvoluee_a_un_element(const TypeEvoluee_a_un_element& a):
           TypeQuelconque_a_un_element(a) {};
       // DESTRUCTEUR :
       virtual ~TypeEvoluee_a_un_element() {};

       // opérateurs
       TypeEvoluee_a_un_element& operator= (const TypeEvoluee_a_un_element& a)
        {(*PointeurClass_Quelc())= (*a.PointeurClass_Quelc_const());};
       bool operator== (const TypeEvoluee_a_un_element& a) const
        {return ((*PointeurClass_Quelc_const()) == (*a.PointeurClass_Quelc_const()));};
       bool operator!= (const TypeEvoluee_a_un_element& a) const
           {if ( (*this)==a ) return true; else return false;};
       bool operator < (const TypeEvoluee_a_un_element& a) const
          {return ((*PointeurClass_Quelc_const()) < (*a.PointeurClass_Quelc_const()));};
       bool operator <= (const TypeEvoluee_a_un_element& a) const
          {return ((*PointeurClass_Quelc_const()) <= (*a.PointeurClass_Quelc_const()));};
       bool operator > (const TypeEvoluee_a_un_element& a) const
          {return ((*PointeurClass_Quelc_const()) > (*a.PointeurClass_Quelc_const()));};
       bool operator >= (const TypeEvoluee_a_un_element& a) const
          {return ((*PointeurClass_Quelc_const()) == (*a.PointeurClass_Quelc_const()));};
       void Affiche();
  };
  
  // classe conteneur pour un TypeQuelconque à une face ou arête
  class TypeQuelconque_a_Face_arete : public TypeQuelconque_a_un_element
  { public :
       TypeQuelconque_a_Face_arete (); // constructeur par défaut
       // constructeur fonction de toutes les grandeurs
       TypeQuelconque_a_Face_arete (int absolu_,TypeQuelconque_enum_etendu e,string ref_element
                         ,string nom_mail_,int nbFA, Enum_dure tps,string nom_var_,int nbpti,int num_ord);
       // constructeur de copie
       TypeQuelconque_a_Face_arete (const TypeQuelconque_a_Face_arete& a);
       // DESTRUCTEUR :
       virtual ~TypeQuelconque_a_Face_arete ();

       // opérateurs
       TypeQuelconque_a_Face_arete& operator= (const TypeQuelconque_a_Face_arete& a);
       bool operator== (const TypeQuelconque_a_Face_arete& a) const;
       bool operator!= (const TypeQuelconque_a_Face_arete& a) const
           {if ( (*this)==a ) return true; else return false;};
       bool operator < (const TypeQuelconque_a_Face_arete& a) const;
       bool operator <= (const TypeQuelconque_a_Face_arete& a) const;
       bool operator > (const TypeQuelconque_a_Face_arete& a) const;
       bool operator >= (const TypeQuelconque_a_Face_arete& a) const;
       
       // récupération du pointeur de la classe
       const TypeQuelconque_a_Face_arete* PointClass_QuelcFA_const() const {return this;};
       TypeQuelconque_a_Face_arete* PointClass_QuelcFA() {return this;};

       // retour des grandeurs
       const int& Num_FA_const() const {return num_FA;} ; // la grandeur constante
       int& Num_FA() {return num_FA;} ; // la grandeur en i/O

    protected :
       int  num_FA; // ref de numéro de la face ou de l'arête
  };

  // classe conteneur pour les grandeurs quelconque à une face d'élément
  class TypeQuelc_face_a_un_element : public TypeQuelconque_a_Face_arete
  { // surcharge de l'operator de lecture  avec le type
    friend istream & operator >> (istream &, TypeQuelc_face_a_un_element &);
    // surcharge de l'operator d'ecriture
    friend ostream & operator << (ostream &, const TypeQuelc_face_a_un_element &);
    
    public :
       TypeQuelc_face_a_un_element(): TypeQuelconque_a_Face_arete() {}; // constructeur par défaut
       // constructeur fonction de toutes les grandeurs
       TypeQuelc_face_a_un_element (int absolu_,TypeQuelconque_enum_etendu e,string ref_element
                 ,string nom_mail_,int nbFA, Enum_dure tps,string nom_var_,int nbpti,int num_ord):
            TypeQuelconque_a_Face_arete(absolu_,e,ref_element,nom_mail,nbFA,tps,nom_var_,nbpti,num_ord)
             {} ;
       // constructeur de copie
       TypeQuelc_face_a_un_element(const TypeQuelc_face_a_un_element& a):
           TypeQuelconque_a_Face_arete(a) {};
       // DESTRUCTEUR :
       virtual ~TypeQuelc_face_a_un_element() {};

       // opérateurs
       TypeQuelc_face_a_un_element& operator= (const TypeQuelc_face_a_un_element& a)
        {(*PointClass_QuelcFA())= (*a.PointClass_QuelcFA_const());};
       bool operator== (const TypeQuelc_face_a_un_element& a) const
        {return ((*PointClass_QuelcFA_const()) == (*a.PointClass_QuelcFA_const()));};
       bool operator!= (const TypeQuelc_face_a_un_element& a) const
           {if ( (*this)==a ) return true; else return false;};
       bool operator < (const TypeQuelc_face_a_un_element& a) const
          {return ((*PointClass_QuelcFA_const()) < (*a.PointClass_QuelcFA_const()));};
       bool operator <= (const TypeQuelc_face_a_un_element& a) const
          {return ((*PointClass_QuelcFA_const()) <= (*a.PointClass_QuelcFA_const()));};
       bool operator > (const TypeQuelc_face_a_un_element& a) const
          {return ((*PointClass_QuelcFA_const()) > (*a.PointClass_QuelcFA_const()));};
       bool operator >= (const TypeQuelc_face_a_un_element& a) const
          {return ((*PointClass_QuelcFA_const()) == (*a.PointClass_QuelcFA_const()));};
       void Affiche();
  };
  
 // classe conteneur pour les grandeurs quelconque à une arête d'élément
 class TypeQuelc_arete_a_un_element : public TypeQuelconque_a_Face_arete
 { // surcharge de l'operator de lecture  avec le type
   friend istream & operator >> (istream &, TypeQuelc_arete_a_un_element &);
   // surcharge de l'operator d'ecriture
   friend ostream & operator << (ostream &, const TypeQuelc_arete_a_un_element &);
   
   public :
      TypeQuelc_arete_a_un_element(): TypeQuelconque_a_Face_arete() {}; // constructeur par défaut
      // constructeur fonction de toutes les grandeurs
      TypeQuelc_arete_a_un_element (int absolu_,TypeQuelconque_enum_etendu e,string ref_element
                ,string nom_mail_,int nbFA, Enum_dure tps,string nom_var_,int nbpti,int num_ord):
           TypeQuelconque_a_Face_arete(absolu_,e,ref_element,nom_mail,nbFA,tps,nom_var_,nbpti,num_ord)
            {} ;
      // constructeur de copie
      TypeQuelc_arete_a_un_element(const TypeQuelc_arete_a_un_element& a):
          TypeQuelconque_a_Face_arete(a) {};
      // DESTRUCTEUR :
      virtual ~TypeQuelc_arete_a_un_element() {};

      // opérateurs
      TypeQuelc_arete_a_un_element& operator= (const TypeQuelc_arete_a_un_element& a)
       {(*PointClass_QuelcFA())= (*a.PointClass_QuelcFA_const());};
      bool operator== (const TypeQuelc_arete_a_un_element& a) const
       {return ((*PointClass_QuelcFA_const()) == (*a.PointClass_QuelcFA_const()));};
      bool operator!= (const TypeQuelc_arete_a_un_element& a) const
          {if ( (*this)==a ) return true; else return false;};
      bool operator < (const TypeQuelc_arete_a_un_element& a) const
         {return ((*PointClass_QuelcFA_const()) < (*a.PointClass_QuelcFA_const()));};
      bool operator <= (const TypeQuelc_arete_a_un_element& a) const
         {return ((*PointClass_QuelcFA_const()) <= (*a.PointClass_QuelcFA_const()));};
      bool operator > (const TypeQuelc_arete_a_un_element& a) const
         {return ((*PointClass_QuelcFA_const()) > (*a.PointClass_QuelcFA_const()));};
      bool operator >= (const TypeQuelc_arete_a_un_element& a) const
         {return ((*PointClass_QuelcFA_const()) == (*a.PointClass_QuelcFA_const()));};
      void Affiche();
 };

  
  // classe conteneur pour une composante d'une grandeur globale
  class TypeQuelc_Une_composante_Grandeur_globale
  { // surcharge de l'operator de lecture  avec le type
    friend istream & operator >> (istream &, TypeQuelc_Une_composante_Grandeur_globale &);
    // surcharge de l'operator d'ecriture
    friend ostream & operator << (ostream &, const TypeQuelc_Une_composante_Grandeur_globale &);
    
    public :
       TypeQuelc_Une_composante_Grandeur_globale(): var() {}; // constructeur par défaut
       // constructeur fonction de toutes les grandeurs
       TypeQuelc_Une_composante_Grandeur_globale (string nom_var, string nom_glob, int num_ord):
            var(nom_var,nom_glob,num_ord)
             {} ;
       // constructeur de copie
       TypeQuelc_Une_composante_Grandeur_globale(const TypeQuelc_Une_composante_Grandeur_globale& a):
           var(a.var) {};
       // DESTRUCTEUR :
       virtual ~TypeQuelc_Une_composante_Grandeur_globale() {};

       // opérateurs
       TypeQuelc_Une_composante_Grandeur_globale& operator= (const TypeQuelc_Une_composante_Grandeur_globale& a)
        {var = a.var;};
       bool operator== (const TypeQuelc_Une_composante_Grandeur_globale& a) const
        {return (var == a.var);};
       bool operator!= (const TypeQuelc_Une_composante_Grandeur_globale& a) const
           {if ( (*this)==a ) return true; else return false;};
       bool operator < (const TypeQuelc_Une_composante_Grandeur_globale& a) const
          {return (var < a.var);};
       bool operator <= (const TypeQuelc_Une_composante_Grandeur_globale& a) const
          {return (var <= a.var);};
       bool operator > (const TypeQuelc_Une_composante_Grandeur_globale& a) const
          {return (var > a.var);};
       bool operator >= (const TypeQuelc_Une_composante_Grandeur_globale& a) const
          {return (var >= a.var);};
       void Affiche();

       // retour des grandeurs
       const string& Nom_var_const() const {return var.nom1;}; // nom  de la variable associée
       string& Nom_var()  {return var.nom1;}; // nom  de la variable associée
       const string& Nom_grandeur_globale_const() const {return var.nom2;}; // nom de la grandeur globale associé
       string& Nom_grandeur_globale()  {return var.nom2;}; // nom de la grandeur globale associé
       const int& Indice_const() const {return var.n;};
       int& Indice()  {return var.n;};

       Deux_String_un_entier Deux_String_un_entier_const() const {return var;} ;

       Deux_String_un_entier& Deux_String_un_entier_()  {return var;} ;

       protected :
           Deux_String_un_entier  var ;
           // var.nom1 -> nom de la variable
           // var.nom2 -> nom de la grandeur globale
           // var.n -> le numéro de la composante
     };

   

  // METHODES :
		
//=================%%%%%%%% la classe principale %%%%%%%%=================

  // CONSTRUCTEURS :
  
  // Constructeur par defaut
  VariablesExporter ();
    
  // Constructeur de copie, cependant ici il n'y a pas de création de noeud ni d'élément
  // c'est seulement une création de nouveaux conteneurs de pointeurs
  // cependant le numéro de maillage et le nom de maillage n'est pas valide, il faut
  // ensuite les définir
  VariablesExporter (const VariablesExporter& var);
    
  // DESTRUCTEUR :
  ~VariablesExporter ();
		// lecture
		void LectureVariablesExporter(UtilLecture * entreePrinc);
  
  // insertion des constantes et variables utilisateurs vers globales
  void InsertConstVarUtilisateur_dans_globale();
  
  // initialisation des conteneurs quelconques
  // création des conteneurs aux noeuds s'il s'agit d'une variable
  // associée à un vecteur global (au sens des algorithmes globaux)
  void InitialisationConteneursQuelconques(LesMaillages& lesMail,const List_io < TypeQuelconque >& listeVecGlob,const LesReferences& lesRef);
  
  // ramène les liste des infos qui seront consultés pour les noeuds
  const List_io < Ddl_a_un_noeud >&  List_noeud_type_ddl() const {return list_noeud_type_ddl;};  //  ddl pur aux noeuds
  const List_io < Ddl_etendu_a_un_noeud >&  List_noeud_type_ddlEtendu() const {return list_noeud_type_ddlEtendu;};  // idem pour les ddl étendu
  const List_io <Quelconque_a_un_noeud>& List_noeud_type_quelconque() const {return list_noeud_type_quelconque;}; // idem en quelconque

		// affichage et definition interactive des commandes
		void Info_commande_VariablesExporters(UtilLecture * entreePrinc);
		
		// Affiche
		void Affiche () const ;
		 
		// Surcharge de l'operateur = : realise l'egalite de deux instances
		VariablesExporter& operator= (VariablesExporter& var);
				
		// test si toutes les informations sont completes
		// = true -> complet
		// = false -> incomplet
		bool Complet_VariablesExporter(const LesReferences& lesRef);

  // mises à jour de constantes globales définies par l'utilisateur
  // permet de changer les valeurs, lors d'une suite .info par exemple
  void MiseAjourConstantesUtilisateur(UtilLecture& lec);

  // renseigne les variables définies par l'utilisateur
  // via les valeurs calculées par Herezh
  void RenseigneVarUtilisateur(LesMaillages& lesMail,const LesReferences& lesRef);

	 //----- 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);
  // sortie du schemaXML: en fonction de enu
  static void SchemaXML_VariablesExporters(UtilLecture * entreePrinc,const Enum_IO_XML enu) ;
	   
	protected :
 
 // données:
 // ---- les constantes utilisateur
 list<TypeQuelconque>  li_Q; //  les constantes
 list<string> li_nom;  // le nom des constantes
 
 // ------- les variables
 
  // -> noeuds
  List_io < Ddl_a_un_noeud >  list_noeud_type_ddl;  //  ddl pur aux noeuds
  List_io < Ddl_etendu_a_un_noeud >  list_noeud_type_ddlEtendu;  // idem pour les ddl étendu
  List_io <Quelconque_a_un_noeud> list_noeud_type_quelconque; // idem en quelconque

  // -> éléments
  List_io < Ddl_a_un_element >  list_element_type_ddl;  // ddl pur aux pti d'élément
  // idem pour les grandeurs particulières et évoluées
  List_io < TypeParticulier_a_un_element >  list_element_type_particulier;
  List_io < TypeQuelconque > list_quelc_element_type_particulier; // les conteneurs associés
  
  List_io < TypeEvoluee_a_un_element >  list_element_type_evoluee;
  List_io < TypeQuelconque > list_quelc_element_type_evoluee; // les conteneurs associés

  // -> face d'éléments
  List_io <TypeQuelc_face_a_un_element > list_face_element_type_quelc;
  List_io < TypeQuelconque > list_quelc_face_element_type_quelc; // les conteneurs associés

  // -> arête d'éléments
  List_io <TypeQuelc_arete_a_un_element > list_arete_element_type_quelc;
  List_io < TypeQuelconque > list_quelc_arete_element_type_quelc; // les conteneurs associés

  bool initiaConteneurQuelconque; // pour gérer une seule initialisation
  
  // -> une composante d'une variable globale de type multidimentionnel
  List_io <TypeQuelc_Une_composante_Grandeur_globale > list_var_glob_sur_grandeur_globale;

 
 // méthodes
  
 //---- constantes utilisateurs
 // lecture éventuelle de constantes globales définies par l'utilisateur
 void LecConstantesUtilisateur(UtilLecture& lec);
 // insertion des constantes utilisateur dans les variables globales
 void InsertConstUtilisateur_dans_globale();

 //  def de constantes utilisateur pour une sortie sur un fichier de commande
 void Info_commande_ConstantesUtilisateur(UtilLecture * lec);
 
 // ---- variables utilisateur
 // lecture éventuelle des variables globales définies par l'utilisateur
 void LecVariablesUtilisateur(UtilLecture& lec);

 //  def de variables utilisateur pour une sortie sur un fichier de commande
 void Info_commande_VariablesUtilisateur(UtilLecture * lec);

 // insertion et stockage des variables au niveau de ParaGlob
 void Insert_VarUtilisateur_dans_globale();
 
 // vérification que 2 nom de variables ne soient pas identique
 // si avec_sortie = true -> arrêt
 // si avec_sortie = false -> retour du test: true si c'est ok
 //                           false si pb
 bool VerifNomVariable(const string& nom,bool avec_sortie) const;

 // lecture interactive du nom de la variable: hors variable relais
 string Lect_interactive_nom_var();
 
 // lecture interactive du nom d'une variable relais
 string Lect_interactive_nom_var_relais();

 // insertion d'une composante d'une grandeur quelconque en globale
 // sous forme d'un double
 void InsertCompGrandeurQuelc(const string& non_var,const TypeQuelconque_enum_etendu& enu);
                                 
};
/// @}  // end of group



#endif