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 "occ_fonction1.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;
}

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


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

}


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

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


// FIN DE GESTION DES ENTITES


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

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

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