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

#ifdef BREP_OCC
fonction1=new OCC_FONCTION1;
#endif

}

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

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