geometrie/src/mg_arbre.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_maillage.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 � 11H22
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"
#include <fstream>
#include <iostream>


#include "mg_arbre.h"
#include "mg_primitive.h"
#include "mg_operateur_boolean.h"
#include "mg_gestionnaire.h"


MG_ARBRE::MG_ARBRE(std::string nm):MG_IDENTIFICATEUR(),nom(nm)
{
}


MG_ARBRE::MG_ARBRE(long unsigned int num,std::string nm): MG_IDENTIFICATEUR(num),nom(nm)
{
}


MG_ARBRE::MG_ARBRE(MG_ARBRE& mdd):MG_IDENTIFICATEUR(mdd),nom(mdd.nom)
{
}


MG_ARBRE::~MG_ARBRE()
{
supprimer_tout_mg_operateur_boolean();
supprimer_tout_mg_primitive();
}


void MG_ARBRE::change_gestionnaire(MG_GESTIONNAIRE* mggest)
{
    gest=mggest;
}

// ENTITE MG_PRIMITIVE
int MG_ARBRE::ajouter_mg_primitive(MG_PRIMITIVE* mgprim)
{
    gest->recherche_bonid(*mgprim);
    MG_IDENTIFICATEUR *id=mgprim;
    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_PRIMITIVE*> tmp(mgprim->get_id(),mgprim);
    lst_mg_primitive.insert(tmp);
    return OK;
}


MG_PRIMITIVE* MG_ARBRE::get_mg_primitiveid(unsigned long num)
{
    LISTE_MG_PRIMITIVE::iterator i=lst_mg_primitive.find(num);
    if (i==lst_mg_primitive.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


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


unsigned int MG_ARBRE::get_nb_mg_primitive(void)
{
    return lst_mg_primitive.size();
}


int MG_ARBRE::supprimer_mg_primitiveid(unsigned long num)
{
    MG_PRIMITIVE* mgprim=get_mg_primitiveid(num);
    if (mgprim==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgprim;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.find(num);
    lst_mg_primitive.erase(j);
    delete mgprim;
    return OK;
}


int MG_ARBRE::supprimer_mg_primitive(unsigned int num)
{
    MG_PRIMITIVE* mgprim=get_mg_primitive(num);
    if (mgprim==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgprim;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_primitive.erase(j);
    delete mgprim;
    return OK;
}


void MG_ARBRE::supprimer_tout_mg_primitive(void)
{
    while (get_nb_mg_primitive()!=0)
    {
        LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
        MG_PRIMITIVE* mgprim=(*j).second;
        MG_IDENTIFICATEUR* id=mgprim;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_primitive.erase(j);
        delete mgprim;
    }
}


MG_PRIMITIVE* MG_ARBRE::get_premier_primitive(LISTE_MG_PRIMITIVE::iterator & it)
{
    it = lst_mg_primitive.begin();
    if (it == lst_mg_primitive.end())
        return NULL;
    return it->second;
}

MG_PRIMITIVE* MG_ARBRE::get_suivant_primitive(LISTE_MG_PRIMITIVE::iterator & it)
{
    it++;
    if (it == lst_mg_primitive.end())
        return NULL;
    return it->second;
}

// ENTITE MG_OPERATEUR_BOOLEAN
int MG_ARBRE::ajouter_mg_operateur_boolean(MG_OPERATEUR_BOOLEAN* mgop)
{
    gest->recherche_bonid(*mgop);
    MG_IDENTIFICATEUR *id=mgop;
    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_OPERATEUR_BOOLEAN*> tmp(mgop->get_id(),mgop);
    lst_mg_operateur_boolean.insert(tmp);
    return OK;
}


MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_booleanid(unsigned long num)
{
    LISTE_MG_OPERATEUR_BOOLEAN::iterator i=lst_mg_operateur_boolean.find(num);
    if (i==lst_mg_operateur_boolean.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


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


unsigned int MG_ARBRE::get_nb_mg_operateur_boolean(void)
{
    return lst_mg_operateur_boolean.size();
}


int MG_ARBRE::supprimer_mg_operateur_booleanid(unsigned long num)
{
    MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_booleanid(num);
    if (mgop==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgop;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.find(num);
    lst_mg_operateur_boolean.erase(j);
    delete mgop;
    return OK;
}


int MG_ARBRE::supprimer_mg_operateur_boolean(unsigned int num)
{
    MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_boolean(num);
    if (mgop==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgop;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_operateur_boolean.erase(j);
    delete mgop;
    return OK;
}


void MG_ARBRE::supprimer_tout_mg_operateur_boolean(void)
{
    while (get_nb_mg_operateur_boolean()!=0)
    {
        LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
        MG_OPERATEUR_BOOLEAN* mgop=(*j).second;
        MG_IDENTIFICATEUR* id=mgop;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_operateur_boolean.erase(j);
        delete mgop;
    }
}


MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_premier_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
{
    it = lst_mg_operateur_boolean.begin();
    if (it == lst_mg_operateur_boolean.end())
        return NULL;
    return it->second;
}

MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_suivant_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
{
    it++;
    if (it == lst_mg_operateur_boolean.end())
        return NULL;
    return it->second;
}

void MG_ARBRE::evaluer_geometrie(void)
{
  
}
 

MG_GESTIONNAIRE* MG_ARBRE::get_gestionnaire(void)
{
    return gest;
}

void MG_ARBRE::enregistrer(std::ostream& o)
{
o << "%" << get_id() << "=ARBRE("<< nom.c_str() <<")" << std::endl;  
LISTE_ENTITE::const_iterator i;
for (i=lst_entite.begin();i!=lst_entite.end();i++)
    {
        MG_IDENTIFICATEUR* entite = *i;
        entite->enregistrer(o);
    }
 
}
Revision:	686
Committed:	Tue Jul 7 14:45:11 2015 UTC (9 years, 10 months ago) by francois
File size:	8047 byte(s)
Log Message:	ajout d'un arbre caracteristique dans MAGiC - Phase 1 - Uniquement la structure vide pour le moment.
#	User	Rev	Content
1	francois	686	//------------------------------------------------------------
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_maillage.cpp
16			//
17			//------------------------------------------------------------
18			//------------------------------------------------------------
19			// COPYRIGHT 2000
20			// Version du 02/03/2006 � 11H22
21			//------------------------------------------------------------
22			//------------------------------------------------------------
23
24
25			#include "gestionversion.h"
26			#include <fstream>
27			#include <iostream>
28
29
30			#include "mg_arbre.h"
31			#include "mg_primitive.h"
32			#include "mg_operateur_boolean.h"
33			#include "mg_gestionnaire.h"
34
35
36
37			MG_ARBRE::MG_ARBRE(std::string nm):MG_IDENTIFICATEUR(),nom(nm)
38			{
39			}
40
41
42
43			MG_ARBRE::MG_ARBRE(long unsigned int num,std::string nm): MG_IDENTIFICATEUR(num),nom(nm)
44			{
45			}
46
47
48
49			MG_ARBRE::MG_ARBRE(MG_ARBRE& mdd):MG_IDENTIFICATEUR(mdd),nom(mdd.nom)
50			{
51			}
52
53
54
55
56			MG_ARBRE::~MG_ARBRE()
57			{
58			supprimer_tout_mg_operateur_boolean();
59			supprimer_tout_mg_primitive();
60			}
61
62
63
64			void MG_ARBRE::change_gestionnaire(MG_GESTIONNAIRE* mggest)
65			{
66			gest=mggest;
67			}
68
69			// ENTITE MG_PRIMITIVE
70			int MG_ARBRE::ajouter_mg_primitive(MG_PRIMITIVE* mgprim)
71			{
72			gest->recherche_bonid(*mgprim);
73			MG_IDENTIFICATEUR *id=mgprim;
74			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
75			if (!p.second)
76			{
77			// afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
78			return FAIL;
79			}
80
81			std::pair<const unsigned long,MG_PRIMITIVE*> tmp(mgprim->get_id(),mgprim);
82			lst_mg_primitive.insert(tmp);
83			return OK;
84			}
85
86
87
88
89			MG_PRIMITIVE* MG_ARBRE::get_mg_primitiveid(unsigned long num)
90			{
91			LISTE_MG_PRIMITIVE::iterator i=lst_mg_primitive.find(num);
92			if (i==lst_mg_primitive.end())
93			{
94			// afficheur << INEXISTE << enderr;
95			return NULL;
96			}
97			return ((*i).second);
98			}
99
100
101
102			MG_PRIMITIVE* MG_ARBRE::get_mg_primitive(unsigned int num)
103			{
104			if (!(num<lst_mg_primitive.size()))
105			{
106			// afficheur << INEXISTE << enderr;
107			return NULL;
108			}
109			LISTE_MG_PRIMITIVE::iterator i=lst_mg_primitive.begin();
110			for (unsigned long j=0;j<num;j++) i++;
111			return ((*i).second);
112			}
113
114
115
116			unsigned int MG_ARBRE::get_nb_mg_primitive(void)
117			{
118			return lst_mg_primitive.size();
119			}
120
121
122			int MG_ARBRE::supprimer_mg_primitiveid(unsigned long num)
123			{
124			MG_PRIMITIVE* mgprim=get_mg_primitiveid(num);
125			if (mgprim==NULL)
126			{
127			// afficheur << INEXISTE2 << enderr;
128			return FAIL;
129			}
130			MG_IDENTIFICATEUR* id=mgprim;
131			LISTE_ENTITE::iterator i=lst_entite.find(id);
132			lst_entite.erase(i);
133			LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.find(num);
134			lst_mg_primitive.erase(j);
135			delete mgprim;
136			return OK;
137			}
138
139
140			int MG_ARBRE::supprimer_mg_primitive(unsigned int num)
141			{
142			MG_PRIMITIVE* mgprim=get_mg_primitive(num);
143			if (mgprim==NULL)
144			{
145			// afficheur << INEXISTE2 << enderr;
146			return FAIL;
147			}
148			MG_IDENTIFICATEUR* id=mgprim;
149			LISTE_ENTITE::iterator i=lst_entite.find(id);
150			lst_entite.erase(i);
151			LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
152			for (unsigned int k=0;k<num;k++) j++;
153			lst_mg_primitive.erase(j);
154			delete mgprim;
155			return OK;
156			}
157
158
159			void MG_ARBRE::supprimer_tout_mg_primitive(void)
160			{
161			while (get_nb_mg_primitive()!=0)
162			{
163			LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
164			MG_PRIMITIVE* mgprim=(*j).second;
165			MG_IDENTIFICATEUR* id=mgprim;
166			LISTE_ENTITE::iterator i=lst_entite.find(id);
167			lst_entite.erase(i);
168			lst_mg_primitive.erase(j);
169			delete mgprim;
170			}
171			}
172
173
174			MG_PRIMITIVE* MG_ARBRE::get_premier_primitive(LISTE_MG_PRIMITIVE::iterator & it)
175			{
176			it = lst_mg_primitive.begin();
177			if (it == lst_mg_primitive.end())
178			return NULL;
179			return it->second;
180			}
181
182			MG_PRIMITIVE* MG_ARBRE::get_suivant_primitive(LISTE_MG_PRIMITIVE::iterator & it)
183			{
184			it++;
185			if (it == lst_mg_primitive.end())
186			return NULL;
187			return it->second;
188			}
189
190			// ENTITE MG_OPERATEUR_BOOLEAN
191			int MG_ARBRE::ajouter_mg_operateur_boolean(MG_OPERATEUR_BOOLEAN* mgop)
192			{
193			gest->recherche_bonid(*mgop);
194			MG_IDENTIFICATEUR *id=mgop;
195			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
196			if (!p.second)
197			{
198			// afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
199			return FAIL;
200			}
201
202			std::pair<const unsigned long,MG_OPERATEUR_BOOLEAN*> tmp(mgop->get_id(),mgop);
203			lst_mg_operateur_boolean.insert(tmp);
204			return OK;
205			}
206
207
208
209
210			MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_booleanid(unsigned long num)
211			{
212			LISTE_MG_OPERATEUR_BOOLEAN::iterator i=lst_mg_operateur_boolean.find(num);
213			if (i==lst_mg_operateur_boolean.end())
214			{
215			// afficheur << INEXISTE << enderr;
216			return NULL;
217			}
218			return ((*i).second);
219			}
220
221
222
223			MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_boolean(unsigned int num)
224			{
225			if (!(num<lst_mg_operateur_boolean.size()))
226			{
227			// afficheur << INEXISTE << enderr;
228			return NULL;
229			}
230			LISTE_MG_OPERATEUR_BOOLEAN::iterator i=lst_mg_operateur_boolean.begin();
231			for (unsigned long j=0;j<num;j++) i++;
232			return ((*i).second);
233			}
234
235
236
237			unsigned int MG_ARBRE::get_nb_mg_operateur_boolean(void)
238			{
239			return lst_mg_operateur_boolean.size();
240			}
241
242
243			int MG_ARBRE::supprimer_mg_operateur_booleanid(unsigned long num)
244			{
245			MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_booleanid(num);
246			if (mgop==NULL)
247			{
248			// afficheur << INEXISTE2 << enderr;
249			return FAIL;
250			}
251			MG_IDENTIFICATEUR* id=mgop;
252			LISTE_ENTITE::iterator i=lst_entite.find(id);
253			lst_entite.erase(i);
254			LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.find(num);
255			lst_mg_operateur_boolean.erase(j);
256			delete mgop;
257			return OK;
258			}
259
260
261			int MG_ARBRE::supprimer_mg_operateur_boolean(unsigned int num)
262			{
263			MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_boolean(num);
264			if (mgop==NULL)
265			{
266			// afficheur << INEXISTE2 << enderr;
267			return FAIL;
268			}
269			MG_IDENTIFICATEUR* id=mgop;
270			LISTE_ENTITE::iterator i=lst_entite.find(id);
271			lst_entite.erase(i);
272			LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
273			for (unsigned int k=0;k<num;k++) j++;
274			lst_mg_operateur_boolean.erase(j);
275			delete mgop;
276			return OK;
277			}
278
279
280			void MG_ARBRE::supprimer_tout_mg_operateur_boolean(void)
281			{
282			while (get_nb_mg_operateur_boolean()!=0)
283			{
284			LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
285			MG_OPERATEUR_BOOLEAN* mgop=(*j).second;
286			MG_IDENTIFICATEUR* id=mgop;
287			LISTE_ENTITE::iterator i=lst_entite.find(id);
288			lst_entite.erase(i);
289			lst_mg_operateur_boolean.erase(j);
290			delete mgop;
291			}
292			}
293
294
295			MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_premier_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
296			{
297			it = lst_mg_operateur_boolean.begin();
298			if (it == lst_mg_operateur_boolean.end())
299			return NULL;
300			return it->second;
301			}
302
303			MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_suivant_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
304			{
305			it++;
306			if (it == lst_mg_operateur_boolean.end())
307			return NULL;
308			return it->second;
309			}
310
311			void MG_ARBRE::evaluer_geometrie(void)
312			{
313
314			}
315
316
317			MG_GESTIONNAIRE* MG_ARBRE::get_gestionnaire(void)
318			{
319			return gest;
320			}
321
322			void MG_ARBRE::enregistrer(std::ostream& o)
323			{
324			o << "%" << get_id() << "=ARBRE("<< nom.c_str() <<")" << std::endl;
325			LISTE_ENTITE::const_iterator i;
326			for (i=lst_entite.begin();i!=lst_entite.end();i++)
327			{
328			MG_IDENTIFICATEUR* entite = *i;
329			entite->enregistrer(o);
330			}
331
332			}