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 "sld_fonction.h"


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


//using namespace std;

MG_GESTIONNAIRE::MG_GESTIONNAIRE():entiteidmax(0),ouvertsld(0)
{
#ifdef BREP_SLD
fonction=new SLD_FONCTION;
#endif
}

MG_GESTIONNAIRE::~MG_GESTIONNAIRE()
{
supprimer_tout_mg_solution();
supprimer_tout_mg_maillage();
supprimer_tout_mg_geometrie();
#ifdef BREP_SLD
delete fonction;
#endif
}

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_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 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_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);
}


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;
}


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)
{
  LISTE_ENTITE::const_iterator i;
  o << "// Fichier MAGIC - UQTR;" << std::endl;
  o << "//*i:" << entiteidmax+1 << ";" << std::endl;
  for (i=lst_entite.begin();i!=lst_entite.end();i++)
     (*i)->enregistrer(o);
     o << "FIN;" << std::endl;
}


#ifdef BREP_SAT
SAT_GESTIONNAIRE&  MG_GESTIONNAIRE::get_gest_sat(void)
{
return fichsat;
}
#endif
#ifdef BREP_STEP
ST_GESTIONNAIRE& MG_GESTIONNAIRE::get_gest_step(void)
{
return fichstep;
}
#endif

#ifdef BREP_SLD
SLD_FONCTION& MG_GESTIONNAIRE::get_sld_fonction(void)
{
return *fonction;
}
#endif

#ifdef BREP_OCC
OCC_FONCTION1& MG_GESTIONNAIRE::get_occ_fonction1(void)
{
 return *fonction1;
}
#endif


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

Revision:	115
Committed:	Thu Jun 26 16:18:08 2008 UTC (16 years, 10 months ago) by souaissa
Original Path:	*magic/lib/geometrie/geometrie/src/mg_gestionnaire.cpp*
File size:	16731 byte(s)
Log Message:	mise a jour de mg_gestionnaire.h
#	User	Rev	Content
1		5	//------------------------------------------------------------
2			//------------------------------------------------------------
3			// MAGiC
4			// Jean Christophe Cuillière et Vincent FRANCOIS
5			// Département de Génie Mécanique - UQTR
6			//------------------------------------------------------------
7			// Le projet MAGIC est un projet de recherche du département
8			// de génie mécanique de l'Université du Québec à
9			// Trois Rivières
10			// Les librairies ne peuvent être utilisées sans l'accord
11			// des auteurs (contact : francois@uqtr.ca)
12			//------------------------------------------------------------
13			//------------------------------------------------------------
14			//
15			// mg_gestionnaire.cpp
16			//
17			//------------------------------------------------------------
18			//------------------------------------------------------------
19			// COPYRIGHT 2000
20			// Version du 02/03/2006 à 11H22
21			//------------------------------------------------------------
22			//------------------------------------------------------------
23
24
25			#include "gestionversion.h"
26
27
28			#include "mg_gestionnaire.h"
29
30
31			#include "sld_fonction.h"
32
33
34			#include <fstream>
35			//#include "affiche.h"
36			//#include "message.h"
37
38
39			//using namespace std;
40
41			MG_GESTIONNAIRE::MG_GESTIONNAIRE():entiteidmax(0),ouvertsld(0)
42			{
43			#ifdef BREP_SLD
44			fonction=new SLD_FONCTION;
45			#endif
46			}
47
48			MG_GESTIONNAIRE::~MG_GESTIONNAIRE()
49			{
50			supprimer_tout_mg_solution();
51			supprimer_tout_mg_maillage();
52			supprimer_tout_mg_geometrie();
53			#ifdef BREP_SLD
54			delete fonction;
55			#endif
56			}
57
58			void MG_GESTIONNAIRE::recherche_bonid(MG_IDENTIFICATEUR &ident)
59			{
60			if (ident.get_id()==0)
61			{
62			entiteidmax++;
63			ident.change_id(entiteidmax);
64			}
65			else
66			{
67			if (ident.get_id()>entiteidmax) entiteidmax=ident.get_id();
68			}
69			}
70
71			void MG_GESTIONNAIRE::recherche_bonidvisuel(MG_IDENTIFICATEUR &ident)
72			{
73			if (ident.get_id()==0)
74			{
75			entitevisuelidmax++;
76			ident.change_id(entitevisuelidmax);
77			}
78			else
79			{
80			if (ident.get_id()>entitevisuelidmax) entitevisuelidmax=ident.get_id();
81			}
82			}
83
84			// ENTITE MG_GEOMETRIE
85
86
87			int MG_GESTIONNAIRE::ajouter_mg_geometrie(MG_GEOMETRIE *mggeo)
88			{
89			recherche_bonid(*mggeo);
90			MG_IDENTIFICATEUR *id=mggeo;
91			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
92			if (!p.second) return FAIL;
93			std::pair<const unsigned long,MG_GEOMETRIE*> tmp(mggeo->get_id(),mggeo);
94			lst_mg_geometrie.insert(tmp);
95			mggeo->change_gestionnaire(this);
96			return OK;
97			}
98
99
100			MG_GEOMETRIE* MG_GESTIONNAIRE::get_mg_geometrieid(unsigned long num)
101			{
102			LISTE_MG_GEOMETRIE::iterator i=lst_mg_geometrie.find(num);
103			if (i==lst_mg_geometrie.end())
104			{
105			// afficheur << INEXISTE << enderr;
106			return NULL;
107			}
108			return ((*i).second);
109			}
110
111
112
113			MG_GEOMETRIE* MG_GESTIONNAIRE::get_mg_geometrie(unsigned int num)
114			{
115			if (!(num<lst_mg_geometrie.size()))
116			{
117			// afficheur << INEXISTE << enderr;
118			return NULL;
119			}
120			LISTE_MG_GEOMETRIE::iterator i=lst_mg_geometrie.begin();
121			for (unsigned long j=0;j<num;j++) i++;
122			return ((*i).second);
123			}
124
125			MG_GEOMETRIE* MG_GESTIONNAIRE::get_premier_geometrie(LISTE_MG_GEOMETRIE::iterator &it)
126			{
127			it = lst_mg_geometrie.begin();
128			if (it == lst_mg_geometrie.end())
129			return NULL;
130			return it->second ;
131			}
132
133			MG_GEOMETRIE* MG_GESTIONNAIRE::get_suivant_geometrie(LISTE_MG_GEOMETRIE::iterator &it)
134			{
135			it++;
136			if(it==lst_mg_geometrie.end())
137			return NULL;
138			return it->second;
139			}
140
141			unsigned int MG_GESTIONNAIRE::get_nb_mg_geometrie(void)
142			{
143			return lst_mg_geometrie.size();
144			}
145
146
147			int MG_GESTIONNAIRE::supprimer_mg_geometrieid(unsigned long num)
148			{
149			MG_GEOMETRIE* mggeo=get_mg_geometrieid(num);
150			if (mggeo==NULL)
151			{
152			// afficheur << INEXISTE2 << enderr;
153			return FAIL;
154			}
155			MG_IDENTIFICATEUR* id=mggeo;
156			LISTE_ENTITE::iterator i=lst_entite.find(id);
157			lst_entite.erase(i);
158			LISTE_MG_GEOMETRIE::iterator j=lst_mg_geometrie.find(num);
159			lst_mg_geometrie.erase(j);
160			delete mggeo;
161			return OK;
162			}
163
164
165			int MG_GESTIONNAIRE::supprimer_mg_geometrie(unsigned int num)
166			{
167			MG_GEOMETRIE* mggeo=get_mg_geometrie(num);
168			if (mggeo==NULL)
169			{
170			// afficheur << INEXISTE2 << enderr;
171			return FAIL;
172			}
173			MG_IDENTIFICATEUR* id=mggeo;
174			LISTE_ENTITE::iterator i=lst_entite.find(id);
175			lst_entite.erase(i);
176			LISTE_MG_GEOMETRIE::iterator j=lst_mg_geometrie.find(id->get_id());
177			lst_mg_geometrie.erase(j);
178			delete mggeo;
179			return OK;
180			}
181
182
183			void MG_GESTIONNAIRE::supprimer_tout_mg_geometrie(void)
184			{
185			while (get_nb_mg_geometrie()!=0)
186			{
187			LISTE_MG_GEOMETRIE::iterator j=lst_mg_geometrie.begin();
188			MG_GEOMETRIE* mggeo=(*j).second;
189			MG_IDENTIFICATEUR* id=mggeo;
190			LISTE_ENTITE::iterator i=lst_entite.find(id);
191			lst_entite.erase(i);
192			lst_mg_geometrie.erase(j);
193			delete mggeo;
194			}
195			}
196
197			// ENTITE MG_MAILLAGE
198
199
200			int MG_GESTIONNAIRE::ajouter_mg_maillage(MG_MAILLAGE *mgmai)
201			{
202			recherche_bonid(*mgmai);
203			MG_IDENTIFICATEUR *id=mgmai;
204			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
205			if (!p.second)
206			{
207			// afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
208			return FAIL;
209			}
210
211			std::pair<const unsigned long,MG_MAILLAGE*> tmp(mgmai->get_id(),mgmai);
212			lst_mg_maillage.insert(tmp);
213			mgmai->change_gestionnaire(this);
214			return OK;
215			}
216
217
218			MG_MAILLAGE* MG_GESTIONNAIRE::get_mg_maillageid(unsigned long num)
219			{
220			LISTE_MG_MAILLAGE::iterator i=lst_mg_maillage.find(num);
221			if (i==lst_mg_maillage.end())
222			{
223			// afficheur << INEXISTE << enderr;
224			return NULL;
225			}
226			return ((*i).second);
227			}
228
229
230
231			MG_MAILLAGE* MG_GESTIONNAIRE::get_mg_maillage(unsigned int num)
232			{
233			if (!(num<lst_mg_maillage.size()))
234			{
235			// afficheur << INEXISTE << enderr;
236			return NULL;
237			}
238			LISTE_MG_MAILLAGE::iterator i=lst_mg_maillage.begin();
239			for (unsigned long j=0;j<num;j++) i++;
240			return ((*i).second);
241			}
242
243
244			MG_MAILLAGE* MG_GESTIONNAIRE::get_premier_mg_maillage(LISTE_MG_MAILLAGE::iterator &it)
245			{
246			it = lst_mg_maillage.begin();
247			if (it == lst_mg_maillage.end())
248			return NULL;
249			return it->second ;
250			}
251
252			MG_MAILLAGE* MG_GESTIONNAIRE::get_suivant_mg_maillage(LISTE_MG_MAILLAGE::iterator &it)
253			{
254			it++;
255			if(it==lst_mg_maillage.end())
256			return NULL;
257			return it->second;
258			}
259
260
261			unsigned int MG_GESTIONNAIRE::get_nb_mg_maillage(void)
262			{
263			return lst_mg_maillage.size();
264			}
265
266
267			int MG_GESTIONNAIRE::supprimer_mg_maillageid(unsigned long num)
268			{
269			MG_MAILLAGE* mgmai=get_mg_maillageid(num);
270			if (mgmai==NULL)
271			{
272			// afficheur << INEXISTE2 << enderr;
273			return FAIL;
274			}
275			MG_IDENTIFICATEUR* id=mgmai;
276			LISTE_ENTITE::iterator i=lst_entite.find(id);
277			lst_entite.erase(i);
278			LISTE_MG_MAILLAGE::iterator j=lst_mg_maillage.find(num);
279			lst_mg_maillage.erase(j);
280			delete mgmai;
281			return OK;
282			}
283
284
285			int MG_GESTIONNAIRE::supprimer_mg_maillage(unsigned int num)
286			{
287			MG_MAILLAGE* mgmai=get_mg_maillage(num);
288			if (mgmai==NULL)
289			{
290			// afficheur << INEXISTE2 << enderr;
291			return FAIL;
292			}
293			MG_IDENTIFICATEUR* id=mgmai;
294			LISTE_ENTITE::iterator i=lst_entite.find(id);
295			lst_entite.erase(i);
296			LISTE_MG_MAILLAGE::iterator j=lst_mg_maillage.find(id->get_id());
297			lst_mg_maillage.erase(j);
298			delete mgmai;
299			return OK;
300			}
301
302
303			void MG_GESTIONNAIRE::supprimer_tout_mg_maillage(void)
304			{
305			while (get_nb_mg_maillage()!=0)
306			{
307			LISTE_MG_MAILLAGE::iterator j=lst_mg_maillage.begin();
308			MG_MAILLAGE* mgmai=(*j).second;
309			MG_IDENTIFICATEUR* id=mgmai;
310			LISTE_ENTITE::iterator i=lst_entite.find(id);
311			lst_entite.erase(i);
312			lst_mg_maillage.erase(j);
313			delete mgmai;
314			}
315
316			}
317
318
319
320
321			// ENTITE FEM_MAILLAGE
322
323
324
325
326			int MG_GESTIONNAIRE::ajouter_fem_maillage(FEM_MAILLAGE *femmai)
327			{
328			recherche_bonid(*femmai);
329			MG_IDENTIFICATEUR *id=femmai;
330			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
331			if (!p.second)
332			{
333			// afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
334			return FAIL;
335			}
336
337			std::pair<const unsigned long,FEM_MAILLAGE*> tmp(femmai->get_id(),femmai);
338			lst_fem_maillage.insert(tmp);
339			femmai->change_gestionnaire(this);
340			return OK;
341			}
342
343
344			FEM_MAILLAGE* MG_GESTIONNAIRE::get_fem_maillageid(unsigned long num)
345			{
346			LISTE_FEM_MAILLAGE::iterator i=lst_fem_maillage.find(num);
347			if (i==lst_fem_maillage.end())
348			{
349			// afficheur << INEXISTE << enderr;
350			return NULL;
351			}
352			return ((*i).second);
353			}
354
355
356
357			FEM_MAILLAGE* MG_GESTIONNAIRE::get_fem_maillage(unsigned int num)
358			{
359			if (!(num<lst_fem_maillage.size()))
360			{
361			// afficheur << INEXISTE << enderr;
362			return NULL;
363			}
364			LISTE_FEM_MAILLAGE::iterator i=lst_fem_maillage.begin();
365			for (unsigned long j=0;j<num;j++) i++;
366			return ((*i).second);
367			}
368
369
370
371			unsigned int MG_GESTIONNAIRE::get_nb_fem_maillage(void)
372			{
373			return lst_fem_maillage.size();
374			}
375
376
377			int MG_GESTIONNAIRE::supprimer_fem_maillageid(unsigned long num)
378			{
379			FEM_MAILLAGE* femmai=get_fem_maillageid(num);
380			if (femmai==NULL)
381			{
382			// afficheur << INEXISTE2 << enderr;
383			return FAIL;
384			}
385			MG_IDENTIFICATEUR* id=femmai;
386			LISTE_ENTITE::iterator i=lst_entite.find(id);
387			lst_entite.erase(i);
388			LISTE_FEM_MAILLAGE::iterator j=lst_fem_maillage.find(num);
389			lst_fem_maillage.erase(j);
390			delete femmai;
391			return OK;
392			}
393
394
395			int MG_GESTIONNAIRE::supprimer_fem_maillage(unsigned int num)
396			{
397			FEM_MAILLAGE* femmai=get_fem_maillage(num);
398			if (femmai==NULL)
399			{
400			// afficheur << INEXISTE2 << enderr;
401			return FAIL;
402			}
403			MG_IDENTIFICATEUR* id=femmai;
404			LISTE_ENTITE::iterator i=lst_entite.find(id);
405			lst_entite.erase(i);
406			LISTE_FEM_MAILLAGE::iterator j=lst_fem_maillage.find(id->get_id());
407			lst_fem_maillage.erase(j);
408			delete femmai;
409			return OK;
410			}
411
412
413			void MG_GESTIONNAIRE::supprimer_tout_fem_maillage(void)
414			{
415			while (get_nb_fem_maillage()!=0)
416			{
417			LISTE_FEM_MAILLAGE::iterator j=lst_fem_maillage.begin();
418			FEM_MAILLAGE* femmai=(*j).second;
419			MG_IDENTIFICATEUR* id=femmai;
420			LISTE_ENTITE::iterator i=lst_entite.find(id);
421			lst_entite.erase(i);
422			lst_fem_maillage.erase(j);
423			delete femmai;
424			}
425
426			}
427
428			FEM_MAILLAGE* MG_GESTIONNAIRE::get_premier_fem_maillage(LISTE_FEM_MAILLAGE::iterator &it)
429			{
430			it = lst_fem_maillage.begin();
431			if (it == lst_fem_maillage.end())
432			return NULL;
433			return it->second ;
434			}
435
436			FEM_MAILLAGE* MG_GESTIONNAIRE::get_suivant_fem_maillage(LISTE_FEM_MAILLAGE::iterator &it)
437			{
438			it++;
439			if(it==lst_fem_maillage.end())
440			return NULL;
441			return it->second;
442			}
443
444
445
446
447
448			// ENTITE MG_SOLUTION
449
450
451
452
453
454
455			int MG_GESTIONNAIRE::ajouter_mg_solution(MG_SOLUTION *mgsol)
456			{
457			recherche_bonid(*mgsol);
458			MG_IDENTIFICATEUR *id=mgsol;
459			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
460			if (!p.second)
461			{
462			return FAIL;
463			}
464
465			std::pair<const unsigned long,MG_SOLUTION*> tmp(mgsol->get_id(),mgsol);
466			lst_mg_solution.insert(tmp);
467			return OK;
468			}
469
470
471			MG_SOLUTION* MG_GESTIONNAIRE::get_mg_solutionid(unsigned long num)
472			{
473			LISTE_MG_SOLUTION::iterator i=lst_mg_solution.find(num);
474			if (i==lst_mg_solution.end())
475			{
476			return NULL;
477			}
478			return ((*i).second);
479			}
480
481
482
483			MG_SOLUTION* MG_GESTIONNAIRE::get_mg_solution(unsigned int num)
484			{
485			if (!(num<lst_mg_solution.size()))
486			{
487			return NULL;
488			}
489			LISTE_MG_SOLUTION::iterator i=lst_mg_solution.begin();
490			for (unsigned long j=0;j<num;j++) i++;
491			return ((*i).second);
492			}
493
494
495			MG_SOLUTION* MG_GESTIONNAIRE::get_premier_mg_solution(LISTE_MG_SOLUTION::iterator &it)
496			{
497			it = lst_mg_solution.begin();
498			if (it == lst_mg_solution.end())
499			return NULL;
500			return it->second ;
501			}
502
503			MG_SOLUTION* MG_GESTIONNAIRE::get_suivant_mg_solution(LISTE_MG_SOLUTION::iterator &it)
504			{
505			it++;
506			if(it==lst_mg_solution.end())
507			return NULL;
508			return it->second;
509			}
510
511
512			unsigned int MG_GESTIONNAIRE::get_nb_mg_solution(void)
513			{
514			return lst_mg_solution.size();
515			}
516
517
518			int MG_GESTIONNAIRE::supprimer_mg_solutionid(unsigned long num)
519			{
520			MG_SOLUTION* mgsol=get_mg_solutionid(num);
521			if (mgsol==NULL)
522			{
523			return FAIL;
524			}
525			MG_IDENTIFICATEUR* id=mgsol;
526			LISTE_ENTITE::iterator i=lst_entite.find(id);
527			lst_entite.erase(i);
528			LISTE_MG_SOLUTION::iterator j=lst_mg_solution.find(num);
529			lst_mg_solution.erase(j);
530			mgsol->efface();
531			delete mgsol;
532			return OK;
533			}
534
535
536			int MG_GESTIONNAIRE::supprimer_mg_solution(unsigned int num)
537			{
538			MG_SOLUTION* mgsol=get_mg_solution(num);
539			if (mgsol==NULL)
540			{
541			return FAIL;
542			}
543			MG_IDENTIFICATEUR* id=mgsol;
544			LISTE_ENTITE::iterator i=lst_entite.find(id);
545			lst_entite.erase(i);
546			LISTE_MG_SOLUTION::iterator j=lst_mg_solution.find(id->get_id());
547			lst_mg_solution.erase(j);
548			mgsol->efface();
549			delete mgsol;
550			return OK;
551			}
552
553
554			void MG_GESTIONNAIRE::supprimer_tout_mg_solution(void)
555			{
556			while (get_nb_mg_solution()!=0)
557			{
558			LISTE_MG_SOLUTION::iterator j=lst_mg_solution.begin();
559			MG_SOLUTION* mgsol=(*j).second;
560			MG_IDENTIFICATEUR* id=mgsol;
561			LISTE_ENTITE::iterator i=lst_entite.find(id);
562			lst_entite.erase(i);
563			lst_mg_solution.erase(j);
564			delete mgsol;
565			}
566
567			}
568
569
570
571
572			// ENTITE FEM_SOLUTION
573
574
575
576
577
578			int MG_GESTIONNAIRE::ajouter_fem_solution(FEM_SOLUTION *mgsol)
579			{
580			recherche_bonid(*mgsol);
581			MG_IDENTIFICATEUR *id=mgsol;
582			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
583			if (!p.second)
584			{
585			return FAIL;
586			}
587
588			std::pair<const unsigned long,FEM_SOLUTION*> tmp(mgsol->get_id(),mgsol);
589			lst_fem_solution.insert(tmp);
590			return OK;
591			}
592
593
594			FEM_SOLUTION* MG_GESTIONNAIRE::get_fem_solutionid(unsigned long num)
595			{
596			LISTE_FEM_SOLUTION::iterator i=lst_fem_solution.find(num);
597			if (i==lst_fem_solution.end())
598			{
599			return NULL;
600			}
601			return ((*i).second);
602			}
603
604
605
606			FEM_SOLUTION* MG_GESTIONNAIRE::get_fem_solution(unsigned int num)
607			{
608			if (!(num<lst_fem_solution.size()))
609			{
610			return NULL;
611			}
612			LISTE_FEM_SOLUTION::iterator i=lst_fem_solution.begin();
613			for (unsigned long j=0;j<num;j++) i++;
614			return ((*i).second);
615			}
616
617
618
619			unsigned int MG_GESTIONNAIRE::get_nb_fem_solution(void)
620			{
621			return lst_fem_solution.size();
622			}
623
624
625			int MG_GESTIONNAIRE::supprimer_fem_solutionid(unsigned long num)
626			{
627			FEM_SOLUTION* mgsol=get_fem_solutionid(num);
628			if (mgsol==NULL)
629			{
630			return FAIL;
631			}
632			MG_IDENTIFICATEUR* id=mgsol;
633			LISTE_ENTITE::iterator i=lst_entite.find(id);
634			lst_entite.erase(i);
635			LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.find(num);
636			lst_fem_solution.erase(j);
637			mgsol->efface();
638			delete mgsol;
639			return OK;
640			}
641
642
643			int MG_GESTIONNAIRE::supprimer_fem_solution(unsigned int num)
644			{
645			FEM_SOLUTION* mgsol=get_fem_solution(num);
646			if (mgsol==NULL)
647			{
648			return FAIL;
649			}
650			MG_IDENTIFICATEUR* id=mgsol;
651			LISTE_ENTITE::iterator i=lst_entite.find(id);
652			lst_entite.erase(i);
653			LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.find(id->get_id());
654			lst_fem_solution.erase(j);
655			mgsol->efface();
656			delete mgsol;
657			return OK;
658			}
659
660
661			void MG_GESTIONNAIRE::supprimer_tout_fem_solution(void)
662			{
663			while (get_nb_fem_solution()!=0)
664			{
665			LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.begin();
666			FEM_SOLUTION* mgsol=(*j).second;
667			MG_IDENTIFICATEUR* id=mgsol;
668			LISTE_ENTITE::iterator i=lst_entite.find(id);
669			lst_entite.erase(i);
670			lst_fem_solution.erase(j);
671			delete mgsol;
672			}
673
674			}
675
676
677			FEM_SOLUTION* MG_GESTIONNAIRE::get_premier_fem_solution(LISTE_FEM_SOLUTION::iterator &it)
678			{
679			it = lst_fem_solution.begin();
680			if (it == lst_fem_solution.end())
681			return NULL;
682			return it->second ;
683			}
684
685			FEM_SOLUTION* MG_GESTIONNAIRE::get_suivant_fem_solution(LISTE_FEM_SOLUTION::iterator &it)
686			{
687			it++;
688			if(it==lst_fem_solution.end())
689			return NULL;
690			return it->second;
691			}
692
693
694
695			// FIN DE GESTION DES ENTITES
696
697
698
699			void MG_GESTIONNAIRE::enregistrer(char* chemin)
700			{
701			std::ofstream o(chemin,std::ios::out\|std::ios::trunc);
702			o.precision(16);
703			o.setf(std::ios::showpoint);
704			o <<(*this) << std::endl;
705			}
706
707			void MG_GESTIONNAIRE::enregistrer(const char* chemin)
708			{
709			std::ofstream o(chemin,std::ios::out\|std::ios::trunc);
710			o.precision(16);
711			o.setf(std::ios::showpoint);
712			o << (*this) << std::endl;
713			}
714
715			void MG_GESTIONNAIRE::enregistrer(std::ostream& o)
716			{
717			LISTE_ENTITE::const_iterator i;
718			o << "// Fichier MAGIC - UQTR;" << std::endl;
719			o << "//*i:" << entiteidmax+1 << ";" << std::endl;
720			for (i=lst_entite.begin();i!=lst_entite.end();i++)
721			(*i)->enregistrer(o);
722			o << "FIN;" << std::endl;
723			}
724
725
726			#ifdef BREP_SAT
727			SAT_GESTIONNAIRE& MG_GESTIONNAIRE::get_gest_sat(void)
728			{
729			return fichsat;
730			}
731			#endif
732			#ifdef BREP_STEP
733			ST_GESTIONNAIRE& MG_GESTIONNAIRE::get_gest_step(void)
734			{
735			return fichstep;
736			}
737			#endif
738
739			#ifdef BREP_SLD
740			SLD_FONCTION& MG_GESTIONNAIRE::get_sld_fonction(void)
741			{
742			return *fonction;
743			}
744			#endif
745
746	souaissa	115	#ifdef BREP_OCC
747			OCC_FONCTION1& MG_GESTIONNAIRE::get_occ_fonction1(void)
748			{
749			return *fonction1;
750			}
751			#endif
752		5
753
754			std::ostream& operator << (std::ostream& o,MG_GESTIONNAIRE& gest)
755			{
756			gest.enregistrer(o);
757			return o;
758			}
759