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


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


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