geometrie/src/mg_gestionnaire.cpp

//------------------------------------------------------------
//------------------------------------------------------------
//  MAGiC
//  Jean Christophe Cuilli�re et Vincent FRANCOIS
//  D�partement de G�nie M�canique - UQTR
//------------------------------------------------------------
//  Le projet MAGIC est un projet de recherche du d�partement
//  de g�nie m�canique de l'Universit� du Qu�bec �
//  Trois Rivi�res
//  Les librairies ne peuvent �tre utilis�es sans l'accord
//  des auteurs (contact : francois@uqtr.ca)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       mg_gestionnaire.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 � 11H22
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"


#include "mg_gestionnaire.h"
#include "mg_cg_modele.h"


#include <fstream>
//#include "affiche.h"
//#include "message.h"


//using namespace std;

MG_GESTIONNAIRE::MG_GESTIONNAIRE():entiteidmax(0),ouvertsld(0),version_fichier(VERSIONFICHIER)
{


}

MG_GESTIONNAIRE::~MG_GESTIONNAIRE()
{
    supprimer_tout_fem_solution();
    supprimer_tout_mg_solution();
    supprimer_tout_mg_maillage();
    supprimer_tout_fem_maillage();
    supprimer_tout_mgcg_modele();
    supprimer_tout_mg_geometrie();
    supprimer_tout_mg_construction();
    supprimer_tout_mg_arbre();    
}

void MG_GESTIONNAIRE::vide(void)
{
    supprimer_tout_fem_solution();
    supprimer_tout_mg_solution();
    supprimer_tout_mg_maillage();
    supprimer_tout_fem_maillage();
    supprimer_tout_mgcg_modele();
    supprimer_tout_mg_geometrie();
    supprimer_tout_mg_construction();
    supprimer_tout_mg_arbre();    
    entiteidmax=1;
}

void MG_GESTIONNAIRE::recherche_bonid(MG_IDENTIFICATEUR &ident)
{
    if (ident.get_id()==0)
    {
        entiteidmax++;
        ident.change_id(entiteidmax);
    }
    else
    {
        if (ident.get_id()>entiteidmax) entiteidmax=ident.get_id();
    }
}

void MG_GESTIONNAIRE::recherche_bonidvisuel(MG_IDENTIFICATEUR &ident)
{
    if (ident.get_id()==0)
    {
        entitevisuelidmax++;
        ident.change_id(entitevisuelidmax);
    }
    else
    {
        if (ident.get_id()>entitevisuelidmax) entitevisuelidmax=ident.get_id();
    }
}

// ENTITE MG_CG_MODELE

int MG_GESTIONNAIRE::ajouter_mgcg_modele(MG_CG_MODELE* mgcg_modele)
{
  recherche_bonid(*mgcg_modele);
  MG_IDENTIFICATEUR *id=mgcg_modele;
  std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
  if (!p.second) return FAIL;
  std::pair<const unsigned long,MG_CG_MODELE*> tmp(mgcg_modele->get_id(),mgcg_modele);
  lst_mgcg_modele.insert(tmp);
  mgcg_modele->change_mg_gestionnaire(this);
  return OK;
}

MG_CG_MODELE* MG_GESTIONNAIRE::get_mgcg_modeleid(long unsigned int num)
{
  LISTE_MGCG_MODELE::iterator i=lst_mgcg_modele.find(num);
  if (i==lst_mgcg_modele.end())
  {
      return NULL;
  }
  return ((*i).second);
}

MG_CG_MODELE* MG_GESTIONNAIRE::get_mgcg_modele(unsigned int num)
{
  if (!(num<lst_mgcg_modele.size()))
  {
      return NULL;
  }
  LISTE_MGCG_MODELE::iterator i=lst_mgcg_modele.begin();
  for (unsigned long j=0;j<num;j++) i++;
  return ((*i).second);
}

unsigned int MG_GESTIONNAIRE::get_nb_mgcg_modele(void)
{
  return lst_mgcg_modele.size();
}

MG_CG_MODELE* MG_GESTIONNAIRE::get_premier_mgcg_modele(LISTE_MGCG_MODELE::iterator& it)
{
  it = lst_mgcg_modele.begin();
  if (it == lst_mgcg_modele.end())
      return NULL;
  return it->second ;
}

MG_CG_MODELE* MG_GESTIONNAIRE::get_suivant_mgcg_modele(LISTE_MGCG_MODELE::iterator& it)
{
  it++;
  if (it==lst_mgcg_modele.end())
      return NULL;
  return it->second;
}

int MG_GESTIONNAIRE::supprimer_mgcg_modele(unsigned int num)
{
  MG_CG_MODELE* mgcg_modele=get_mgcg_modele(num);
  if (mgcg_modele==NULL)
  {
      return FAIL;
  }
  MG_IDENTIFICATEUR* id=mgcg_modele;
  LISTE_ENTITE::iterator i=lst_entite.find(id);
  lst_entite.erase(i);
  LISTE_MGCG_MODELE::iterator j=lst_mgcg_modele.find(id->get_id());
  lst_mgcg_modele.erase(j);
  delete mgcg_modele;
  return OK;
}

int MG_GESTIONNAIRE::supprimer_mgcg_modeleid(long unsigned int num)
{
  MG_CG_MODELE* mgcg_modele=get_mgcg_modeleid(num);
  if (mgcg_modele==NULL)
  {
      return FAIL;
  }
  MG_IDENTIFICATEUR* id=mgcg_modele;
  LISTE_ENTITE::iterator i=lst_entite.find(id);
  lst_entite.erase(i);
  LISTE_MGCG_MODELE::iterator j=lst_mgcg_modele.find(num);
  lst_mgcg_modele.erase(j);
  delete mgcg_modele;
  return OK;
}

void MG_GESTIONNAIRE::supprimer_tout_mgcg_modele(void)
{
  while (get_nb_mgcg_modele()!=0)
  {
      LISTE_MGCG_MODELE::iterator j=lst_mgcg_modele.begin();
      MG_CG_MODELE* mgcg_modele=(*j).second;
      MG_IDENTIFICATEUR* id=mgcg_modele;
      LISTE_ENTITE::iterator i=lst_entite.find(id);
      lst_entite.erase(i);
      lst_mgcg_modele.erase(j);
      delete mgcg_modele;
  }
}


// FIN ENTITE MG_CG_MODELE


// ENTITE MG_ARBRE
int MG_GESTIONNAIRE::ajouter_mg_arbre(MG_ARBRE *mgarbre)
{
    recherche_bonid(*mgarbre);
    MG_IDENTIFICATEUR *id=mgarbre;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second) return FAIL;
    std::pair<const unsigned long,MG_ARBRE*> tmp(mgarbre->get_id(),mgarbre);
    lst_mg_arbre.insert(tmp);
    mgarbre->change_gestionnaire(this);
    return OK;
}


MG_ARBRE* MG_GESTIONNAIRE::get_mg_arbreid(unsigned long num)
{
    LISTE_MG_ARBRE::iterator i=lst_mg_arbre.find(num);
    if (i==lst_mg_arbre.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_ARBRE* MG_GESTIONNAIRE::get_mg_arbre(unsigned int num)
{
    if (!(num<lst_mg_arbre.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_ARBRE::iterator i=lst_mg_arbre.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}

MG_ARBRE* MG_GESTIONNAIRE::get_premier_arbre(LISTE_MG_ARBRE::iterator &it)
{
    it = lst_mg_arbre.begin();
    if (it == lst_mg_arbre.end())
        return NULL;
    return it->second ;
}

MG_ARBRE* MG_GESTIONNAIRE::get_suivant_arbre(LISTE_MG_ARBRE::iterator &it)
{
    it++;
    if (it==lst_mg_arbre.end())
        return NULL;
    return it->second;
}

unsigned int MG_GESTIONNAIRE::get_nb_mg_arbre(void)
{
    return lst_mg_arbre.size();
}


int MG_GESTIONNAIRE::supprimer_mg_arbreid(unsigned long num)
{
    MG_ARBRE* mgarbre=get_mg_arbreid(num);
    if (mgarbre==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgarbre;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_ARBRE::iterator j=lst_mg_arbre.find(num);
    lst_mg_arbre.erase(j);
    delete mgarbre;
    return OK;
}


int MG_GESTIONNAIRE::supprimer_mg_arbre(unsigned int num)
{
    MG_ARBRE* mgarbre=get_mg_arbre(num);
    if (mgarbre==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgarbre;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_ARBRE::iterator j=lst_mg_arbre.find(id->get_id());
    lst_mg_arbre.erase(j);
    delete mgarbre;
    return OK;
}


void MG_GESTIONNAIRE::supprimer_tout_mg_arbre(void)
{
    while (get_nb_mg_arbre()!=0)
    {
        LISTE_MG_ARBRE::iterator j=lst_mg_arbre.begin();
        MG_ARBRE* mgarbre=(*j).second;
        MG_IDENTIFICATEUR* id=mgarbre;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_arbre.erase(j);
        delete mgarbre;
    }
}
// ENTITE MG_GEOMETRIE
int MG_GESTIONNAIRE::ajouter_mg_geometrie(MG_GEOMETRIE *mggeo)
{
    recherche_bonid(*mggeo);
    MG_IDENTIFICATEUR *id=mggeo;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second) return FAIL;
    std::pair<const unsigned long,MG_GEOMETRIE*> tmp(mggeo->get_id(),mggeo);
    lst_mg_geometrie.insert(tmp);
    mggeo->change_gestionnaire(this);
    return OK;
}


MG_GEOMETRIE* MG_GESTIONNAIRE::get_mg_geometrieid(unsigned long num)
{
    LISTE_MG_GEOMETRIE::iterator i=lst_mg_geometrie.find(num);
    if (i==lst_mg_geometrie.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_GEOMETRIE* MG_GESTIONNAIRE::get_mg_geometrie(unsigned int num)
{
    if (!(num<lst_mg_geometrie.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_GEOMETRIE::iterator i=lst_mg_geometrie.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}

MG_GEOMETRIE* MG_GESTIONNAIRE::get_premier_geometrie(LISTE_MG_GEOMETRIE::iterator &it)
{
    it = lst_mg_geometrie.begin();
    if (it == lst_mg_geometrie.end())
        return NULL;
    return it->second ;
}

MG_GEOMETRIE* MG_GESTIONNAIRE::get_suivant_geometrie(LISTE_MG_GEOMETRIE::iterator &it)
{
    it++;
    if (it==lst_mg_geometrie.end())
        return NULL;
    return it->second;
}

unsigned int MG_GESTIONNAIRE::get_nb_mg_geometrie(void)
{
    return lst_mg_geometrie.size();
}


int MG_GESTIONNAIRE::supprimer_mg_geometrieid(unsigned long num)
{
    MG_GEOMETRIE* mggeo=get_mg_geometrieid(num);
    if (mggeo==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mggeo;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_GEOMETRIE::iterator j=lst_mg_geometrie.find(num);
    lst_mg_geometrie.erase(j);
    delete mggeo;
    return OK;
}


int MG_GESTIONNAIRE::supprimer_mg_geometrie(unsigned int num)
{
    MG_GEOMETRIE* mggeo=get_mg_geometrie(num);
    if (mggeo==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mggeo;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_GEOMETRIE::iterator j=lst_mg_geometrie.find(id->get_id());
    lst_mg_geometrie.erase(j);
    delete mggeo;
    return OK;
}


void MG_GESTIONNAIRE::supprimer_tout_mg_geometrie(void)
{
    while (get_nb_mg_geometrie()!=0)
    {
        LISTE_MG_GEOMETRIE::iterator j=lst_mg_geometrie.begin();
        MG_GEOMETRIE* mggeo=(*j).second;
        MG_IDENTIFICATEUR* id=mggeo;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_geometrie.erase(j);
        delete mggeo;
    }
}

//ENTITE CONSTRUTION

int MG_GESTIONNAIRE::ajouter_mg_construction(MG_GEOMETRIE *construction)
{
    recherche_bonid(*construction);
    MG_IDENTIFICATEUR *id=construction;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second) return FAIL;
    std::pair<const unsigned long,MG_GEOMETRIE*> tmp(construction->get_id(),construction);
    lst_mg_construction.insert(tmp);
    construction->change_gestionnaire(this);
    return OK;
}


MG_GEOMETRIE* MG_GESTIONNAIRE::get_mg_constructionid(unsigned long num)
{
    LISTE_MG_CONSTRUCTION::iterator i=lst_mg_construction.find(num);
    if (i==lst_mg_construction.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_GEOMETRIE* MG_GESTIONNAIRE::get_mg_construction(unsigned int num)
{
    if (!(num<lst_mg_construction.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_CONSTRUCTION::iterator i=lst_mg_construction.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}

MG_GEOMETRIE* MG_GESTIONNAIRE::get_premier_construction(LISTE_MG_CONSTRUCTION::iterator &it)
{
    it = lst_mg_construction.begin();
    if (it == lst_mg_construction.end())
        return NULL;
    return it->second ;
}

MG_GEOMETRIE* MG_GESTIONNAIRE::get_suivant_construction(LISTE_MG_CONSTRUCTION::iterator &it)
{
    it++;
    if (it==lst_mg_construction.end())
        return NULL;
    return it->second;
}

unsigned int MG_GESTIONNAIRE::get_nb_mg_construction(void)
{
    return lst_mg_construction.size();
}


int MG_GESTIONNAIRE::supprimer_mg_constructionid(unsigned long num)
{
    MG_GEOMETRIE* construction=get_mg_constructionid(num);
    if (construction==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=construction;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_CONSTRUCTION::iterator j=lst_mg_construction.find(num);
    lst_mg_construction.erase(j);
    delete construction;
    return OK;
}


int MG_GESTIONNAIRE::supprimer_mg_construction(unsigned int num)
{
    MG_GEOMETRIE* construction=get_mg_construction(num);
    if (construction==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=construction;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_CONSTRUCTION::iterator j=lst_mg_construction.find(id->get_id());
    lst_mg_construction.erase(j);
    delete construction;
    return OK;
}


void MG_GESTIONNAIRE::supprimer_tout_mg_construction(void)
{
    while (get_nb_mg_construction()!=0)
    {
        LISTE_MG_CONSTRUCTION::iterator j=lst_mg_construction.begin();
        MG_GEOMETRIE* construction=(*j).second;
        MG_IDENTIFICATEUR* id=construction;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_construction.erase(j);
        delete construction;
    }
}

// ENTITE MG_MAILLAGE


int MG_GESTIONNAIRE::ajouter_mg_maillage(MG_MAILLAGE *mgmai)
{
    recherche_bonid(*mgmai);
    MG_IDENTIFICATEUR *id=mgmai;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_MAILLAGE*> tmp(mgmai->get_id(),mgmai);
    lst_mg_maillage.insert(tmp);
    mgmai->change_gestionnaire(this);
    return OK;
}


MG_MAILLAGE* MG_GESTIONNAIRE::get_mg_maillageid(unsigned long num)
{
    LISTE_MG_MAILLAGE::iterator i=lst_mg_maillage.find(num);
    if (i==lst_mg_maillage.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_MAILLAGE* MG_GESTIONNAIRE::get_mg_maillage(unsigned int num)
{
    if (!(num<lst_mg_maillage.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_MAILLAGE::iterator i=lst_mg_maillage.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


MG_MAILLAGE* MG_GESTIONNAIRE::get_premier_mg_maillage(LISTE_MG_MAILLAGE::iterator &it)
{
    it = lst_mg_maillage.begin();
    if (it == lst_mg_maillage.end())
        return NULL;
    return it->second ;
}

MG_MAILLAGE* MG_GESTIONNAIRE::get_suivant_mg_maillage(LISTE_MG_MAILLAGE::iterator &it)
{
    it++;
    if (it==lst_mg_maillage.end())
        return NULL;
    return it->second;
}


unsigned int MG_GESTIONNAIRE::get_nb_mg_maillage(void)
{
    return lst_mg_maillage.size();
}


int MG_GESTIONNAIRE::supprimer_mg_maillageid(unsigned long num)
{
    MG_MAILLAGE* mgmai=get_mg_maillageid(num);
    if (mgmai==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgmai;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_MAILLAGE::iterator j=lst_mg_maillage.find(num);
    lst_mg_maillage.erase(j);
    delete mgmai;
    return OK;
}


int MG_GESTIONNAIRE::supprimer_mg_maillage(unsigned int num)
{
    MG_MAILLAGE* mgmai=get_mg_maillage(num);
    if (mgmai==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgmai;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_MAILLAGE::iterator j=lst_mg_maillage.find(id->get_id());
    lst_mg_maillage.erase(j);
    delete mgmai;
    return OK;
}


void MG_GESTIONNAIRE::supprimer_tout_mg_maillage(void)
{
    while (get_nb_mg_maillage()!=0)
    {
        LISTE_MG_MAILLAGE::iterator j=lst_mg_maillage.begin();
        MG_MAILLAGE* mgmai=(*j).second;
        MG_IDENTIFICATEUR* id=mgmai;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_maillage.erase(j);
        delete mgmai;
    }

}


// ENTITE FEM_MAILLAGE


int MG_GESTIONNAIRE::ajouter_fem_maillage(FEM_MAILLAGE *femmai)
{
    recherche_bonid(*femmai);
    MG_IDENTIFICATEUR *id=femmai;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,FEM_MAILLAGE*> tmp(femmai->get_id(),femmai);
    lst_fem_maillage.insert(tmp);
    femmai->change_gestionnaire(this);
    return OK;
}


FEM_MAILLAGE* MG_GESTIONNAIRE::get_fem_maillageid(unsigned long num)
{
    LISTE_FEM_MAILLAGE::iterator i=lst_fem_maillage.find(num);
    if (i==lst_fem_maillage.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


FEM_MAILLAGE* MG_GESTIONNAIRE::get_fem_maillage(unsigned int num)
{
    if (!(num<lst_fem_maillage.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_FEM_MAILLAGE::iterator i=lst_fem_maillage.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


unsigned int MG_GESTIONNAIRE::get_nb_fem_maillage(void)
{
    return lst_fem_maillage.size();
}


int MG_GESTIONNAIRE::supprimer_fem_maillageid(unsigned long num)
{
    FEM_MAILLAGE* femmai=get_fem_maillageid(num);
    if (femmai==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=femmai;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_FEM_MAILLAGE::iterator j=lst_fem_maillage.find(num);
    lst_fem_maillage.erase(j);
    delete femmai;
    return OK;
}


int MG_GESTIONNAIRE::supprimer_fem_maillage(unsigned int num)
{
    FEM_MAILLAGE* femmai=get_fem_maillage(num);
    if (femmai==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=femmai;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_FEM_MAILLAGE::iterator j=lst_fem_maillage.find(id->get_id());
    lst_fem_maillage.erase(j);
    delete femmai;
    return OK;
}


void MG_GESTIONNAIRE::supprimer_tout_fem_maillage(void)
{
    while (get_nb_fem_maillage()!=0)
    {
        LISTE_FEM_MAILLAGE::iterator j=lst_fem_maillage.begin();
        FEM_MAILLAGE* femmai=(*j).second;
        MG_IDENTIFICATEUR* id=femmai;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_fem_maillage.erase(j);
        delete femmai;
    }

}

FEM_MAILLAGE* MG_GESTIONNAIRE::get_premier_fem_maillage(LISTE_FEM_MAILLAGE::iterator &it)
{
    it = lst_fem_maillage.begin();
    if (it == lst_fem_maillage.end())
        return NULL;
    return it->second ;
}

FEM_MAILLAGE* MG_GESTIONNAIRE::get_suivant_fem_maillage(LISTE_FEM_MAILLAGE::iterator &it)
{
    it++;
    if (it==lst_fem_maillage.end())
        return NULL;
    return it->second;
}


// ENTITE MG_SOLUTION


int MG_GESTIONNAIRE::ajouter_mg_solution(MG_SOLUTION *mgsol)
{
    recherche_bonid(*mgsol);
    MG_IDENTIFICATEUR *id=mgsol;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
        return FAIL;
    }

    std::pair<const unsigned long,MG_SOLUTION*> tmp(mgsol->get_id(),mgsol);
    lst_mg_solution.insert(tmp);
    return OK;
}


MG_SOLUTION* MG_GESTIONNAIRE::get_mg_solutionid(unsigned long num)
{
    LISTE_MG_SOLUTION::iterator i=lst_mg_solution.find(num);
    if (i==lst_mg_solution.end())
    {
        return NULL;
    }
    return ((*i).second);
}


MG_SOLUTION* MG_GESTIONNAIRE::get_mg_solution(unsigned int num)
{
    if (!(num<lst_mg_solution.size()))
    {
        return NULL;
    }
    LISTE_MG_SOLUTION::iterator i=lst_mg_solution.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}

MG_SOLUTION* MG_GESTIONNAIRE::get_mg_solution(MG_MAILLAGE* mg,int nb_champs,char *nomfichier,char *nomsolution)
{
 LISTE_MG_SOLUTION::iterator j=lst_mg_solution.begin();
 while (j!=lst_mg_solution.end())
    {
        
        MG_SOLUTION* mgsol=(*j).second;
        if (mgsol->get_maillage()==mg)
          if (mgsol->get_nb_champ()==nb_champs)
            if (strcmp(mgsol->get_nom().c_str(),nomsolution)==0)
              if (strcmp(mgsol->get_nom_fichier().c_str(),nomfichier)==0)
                return mgsol;
        j++;
    }
    return NULL;
}

MG_SOLUTION* MG_GESTIONNAIRE::get_premier_mg_solution(LISTE_MG_SOLUTION::iterator &it)
{
    it = lst_mg_solution.begin();
    if (it == lst_mg_solution.end())
        return NULL;
    return it->second ;
}

MG_SOLUTION* MG_GESTIONNAIRE::get_suivant_mg_solution(LISTE_MG_SOLUTION::iterator &it)
{
    it++;
    if (it==lst_mg_solution.end())
        return NULL;
    return it->second;
}


unsigned int MG_GESTIONNAIRE::get_nb_mg_solution(void)
{
    return lst_mg_solution.size();
}


int MG_GESTIONNAIRE::supprimer_mg_solutionid(unsigned long num)
{
    MG_SOLUTION* mgsol=get_mg_solutionid(num);
    if (mgsol==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsol;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_SOLUTION::iterator j=lst_mg_solution.find(num);
    lst_mg_solution.erase(j);
    mgsol->efface();
    delete mgsol;
    return OK;
}


int MG_GESTIONNAIRE::supprimer_mg_solution(unsigned int num)
{
    MG_SOLUTION* mgsol=get_mg_solution(num);
    if (mgsol==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsol;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_SOLUTION::iterator j=lst_mg_solution.find(id->get_id());
    lst_mg_solution.erase(j);
    mgsol->efface();
    delete mgsol;
    return OK;
}


void MG_GESTIONNAIRE::supprimer_tout_mg_solution(void)
{
    while (get_nb_mg_solution()!=0)
    {
        LISTE_MG_SOLUTION::iterator j=lst_mg_solution.begin();
        MG_SOLUTION* mgsol=(*j).second;
        MG_IDENTIFICATEUR* id=mgsol;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_solution.erase(j);
        delete mgsol;
    }

}


// ENTITE FEM_SOLUTION


int MG_GESTIONNAIRE::ajouter_fem_solution(FEM_SOLUTION *mgsol)
{
    recherche_bonid(*mgsol);
    MG_IDENTIFICATEUR *id=mgsol;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
        return FAIL;
    }

    std::pair<const unsigned long,FEM_SOLUTION*> tmp(mgsol->get_id(),mgsol);
    lst_fem_solution.insert(tmp);
    return OK;
}


FEM_SOLUTION* MG_GESTIONNAIRE::get_fem_solutionid(unsigned long num)
{
    LISTE_FEM_SOLUTION::iterator i=lst_fem_solution.find(num);
    if (i==lst_fem_solution.end())
    {
        return NULL;
    }
    return ((*i).second);
}


FEM_SOLUTION* MG_GESTIONNAIRE::get_fem_solution(unsigned int num)
{
    if (!(num<lst_fem_solution.size()))
    {
        return NULL;
    }
    LISTE_FEM_SOLUTION::iterator i=lst_fem_solution.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


FEM_SOLUTION* MG_GESTIONNAIRE::get_fem_solution(FEM_MAILLAGE* fem,int nb_champs,char *nomfichier,char *nomsolution)
{
 LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.begin();
 while (j!=lst_fem_solution.end())
    {
        
        FEM_SOLUTION* mgsol=(*j).second;
        if (mgsol->get_maillage()==fem)
          if (mgsol->get_nb_champ()==nb_champs)
            if (strcmp(mgsol->get_nom().c_str(),nomsolution)==0)
              if (strcmp(mgsol->get_nom_fichier().c_str(),nomfichier)==0)
                return mgsol;
        j++;
    }
    return NULL;
}


unsigned int MG_GESTIONNAIRE::get_nb_fem_solution(void)
{
    return lst_fem_solution.size();
}


int MG_GESTIONNAIRE::supprimer_fem_solutionid(unsigned long num)
{
    FEM_SOLUTION* mgsol=get_fem_solutionid(num);
    if (mgsol==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsol;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.find(num);
    lst_fem_solution.erase(j);
    mgsol->efface();
    delete mgsol;
    return OK;
}


int MG_GESTIONNAIRE::supprimer_fem_solution(unsigned int num)
{
    FEM_SOLUTION* mgsol=get_fem_solution(num);
    if (mgsol==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsol;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.find(id->get_id());
    lst_fem_solution.erase(j);
    mgsol->efface();
    delete mgsol;
    return OK;
}

int MG_GESTIONNAIRE::supprimer_fem_solution_du_gestionnaire(unsigned int num)
{
    FEM_SOLUTION* mgsol=get_fem_solution(num);
    if (mgsol==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsol;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.find(id->get_id());
    lst_fem_solution.erase(j);
    return OK;
}


void MG_GESTIONNAIRE::supprimer_tout_fem_solution(void)
{
    while (get_nb_fem_solution()!=0)
    {
        LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.begin();
        FEM_SOLUTION* mgsol=(*j).second;
        MG_IDENTIFICATEUR* id=mgsol;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_fem_solution.erase(j);
        delete mgsol;
    }

}


FEM_SOLUTION* MG_GESTIONNAIRE::get_premier_fem_solution(LISTE_FEM_SOLUTION::iterator &it)
{
    it = lst_fem_solution.begin();
    if (it == lst_fem_solution.end())
        return NULL;
    return it->second ;
}

FEM_SOLUTION* MG_GESTIONNAIRE::get_suivant_fem_solution(LISTE_FEM_SOLUTION::iterator &it)
{
    it++;
    if (it==lst_fem_solution.end())
        return NULL;
    return it->second;
}


// FIN DE GESTION DES ENTITES


void MG_GESTIONNAIRE::enregistrer(char* chemin)
{
    std::ofstream o(chemin,std::ios::out|std::ios::trunc);
    o.precision(16);
    o.setf(std::ios::showpoint);
    o <<(*this) << std::endl;
}

void MG_GESTIONNAIRE::enregistrer(const char* chemin)
{
    std::ofstream o(chemin,std::ios::out|std::ios::trunc);
    o.precision(16);
    o.setf(std::ios::showpoint);
    o <<  (*this) << std::endl;
}

void MG_GESTIONNAIRE::enregistrer(std::ostream& o,double version)
{
    version_fichier=version;
    LISTE_ENTITE::const_iterator i;
    o << "// Fichier MAGIC - UQTR;" << std::endl;
    o << "//*i:" << entiteidmax << ";" << std::endl;
    o << "//*v:" << version_fichier << ";" << std::endl;
    for (i=lst_entite.begin();i!=lst_entite.end();i++)
        (*i)->enregistrer(o,version_fichier);
    o << "FIN;" << std::endl;
}


void MG_GESTIONNAIRE::get_fichier_dependant(std::vector<std::string> &liste_fichier)
{
    LISTE_ENTITE::const_iterator i;
    for (i=lst_entite.begin();i!=lst_entite.end();i++)
        (*i)->get_fichier_dependant(liste_fichier);
}

double MG_GESTIONNAIRE::get_version_fichier(void)
{
return version_fichier;  
}


std::ostream& operator << (std::ostream& o,MG_GESTIONNAIRE& gest)
{
    gest.enregistrer(o,VERSIONFICHIER);
    return o;
}

Revision:	944
Committed:	Tue Jun 12 15:51:19 2018 UTC (6 years, 11 months ago) by couturad
File size:	27409 byte(s)
Log Message:	Correction des bugs detectes par Cppcheck