poly_occ/src/tpl_map_entite.h

//------------------------------------------------------------
//------------------------------------------------------------
//  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)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       tpl_map_entite.h
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 � 11H24
//------------------------------------------------------------
//------------------------------------------------------------
#ifndef _TPLMAPENTITE_
#define _TPLMAPENTITE_

#include <stdio.h>


   #ifdef BORLANDCPP
      #include <map.h>
   #else
      #include <map>
   #endif

template <class X>
class TPL_MAP_ENTITE
{
public:
typedef typename std::map<unsigned long,X,std::less<unsigned long> >::iterator ITERATEUR;

TPL_MAP_ENTITE() {};
virtual ~TPL_MAP_ENTITE() {};

/*
syntaxe :
TPL_MAP_ENTITE<MG_ELEMENT_MAILLAGE*> liste;
TPL_MAP_ENTITE<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
MG_ELEMENT_MAILLAGE* element;
for (element = liste.get_premier(it); element; element = liste.get_suivant(it) )
{
        printf("element id = %d", element->get_id());
}         
*/


virtual void ajouter(X x)
{
typename std::pair<const unsigned long,X> tmp(x->get_id(),x);
lst_X.insert(tmp);
};

virtual int existe(X x)
{
typename std::map<unsigned long,X,std::less<unsigned long> >::iterator j=lst_X.find(x->get_id());
if (j!=lst_X.end()) return 1;
return 0;
};


virtual void supprimer(X x)
{
typename std::map<unsigned long,X,std::less<unsigned long> >::iterator j=lst_X.find(x->get_id());
if (j==lst_X.end())
{
        ITERATEUR it;
            return;
}
lst_X.erase(j);
};


virtual int get_nb(void)
{
return lst_X.size();
};


virtual X get(int num)
{
typename std::map<unsigned long,X,std::less<unsigned long> >::iterator j=lst_X.begin();
for (int i=0;i<num;i++) j++;
return ((*j).second);
};

virtual X getid(unsigned long num)
{
typename std::map<unsigned long,X,std::less<unsigned long> >::iterator j=lst_X.find(num);
if (j==lst_X.end())
   {
      return NULL;
   }
return ((*j).second);
};

virtual void vide(void)
{
lst_X.clear();
};


virtual X get_premier(ITERATEUR &it)
{
it = lst_X.begin();
if (it == lst_X.end())
    return NULL;
return it->second ;
};

virtual X get_suivant(ITERATEUR &it)
{
it++;
if(it==lst_X.end())
{
            return NULL;
}
return it->second;
}
                 
virtual X get(ITERATEUR & it)
{
        if (it == lst_X.end())
                return NULL;

        return it->second;
}


virtual X premier_commun(TPL_MAP_ENTITE<X> &lst2,ITERATEUR & it1,ITERATEUR & it2)
{
X suiv2;
it1=lst_X.begin();
suiv2=lst2.get_premier(it2);
int ok=0;
X rep=NULL;
if (it1==lst_X.end())  ok=1;
if (suiv2==NULL)  ok=1;
while (ok==0)  
  {
  unsigned long id1=it1->first;
  unsigned long id2=it2->first;
  if (id2==id1) 
      {
      rep=it1->second;
      ok=1;
      }
  else if (id2<id1) suiv2=get_suivant(it2);
  else if (id2>id1) it1++;
  if (it1==lst_X.end())  ok=1;
  if (suiv2==NULL)  ok=1;
  }
return rep;  
}

virtual X suivant_commun(TPL_MAP_ENTITE<X> &lst2,ITERATEUR & it1,ITERATEUR & it2)
{
X suiv2;
it1++;
suiv2=lst2.get_suivant(it2);
int ok=0;
X rep=NULL;
if (it1==lst_X.end())  ok=1;
if (suiv2==NULL)  ok=1;
while (ok==0)  
  {
  unsigned long id1=it1->first;
  unsigned long id2=it2->first;
  if (id2==id1) 
      {
      rep=it1->second;
      ok=1;
      }
  else if (id2<id1) suiv2=get_suivant(it2);
  else if (id2>id1) it1++;
  if (it1==lst_X.end())  ok=1;
  if (suiv2==NULL)  ok=1;
  }
return rep;  
}


private:
typename std::map<unsigned long,X,std::less<unsigned long> > lst_X;


};


#endif
Revision:	1009
Committed:	Mon Mar 25 16:40:06 2019 UTC (6 years, 1 month ago) by francois
Content type:	text/plain
File size:	4332 byte(s)
Log Message:	ajout de fichier pour les polycristaux (ajout temporaire)
#	User	Rev	Content
1	francois	1009	//------------------------------------------------------------
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			// tpl_map_entite.h
16			//
17			//------------------------------------------------------------
18			//------------------------------------------------------------
19			// COPYRIGHT 2000
20			// Version du 02/03/2006 � 11H24
21			//------------------------------------------------------------
22			//------------------------------------------------------------
23			#ifndef _TPLMAPENTITE_
24			#define _TPLMAPENTITE_
25
26			#include <stdio.h>
27
28
29			#ifdef BORLANDCPP
30			#include <map.h>
31			#else
32			#include <map>
33			#endif
34
35			template <class X>
36			class TPL_MAP_ENTITE
37			{
38			public:
39			typedef typename std::map<unsigned long,X,std::less<unsigned long> >::iterator ITERATEUR;
40
41			TPL_MAP_ENTITE() {};
42			virtual ~TPL_MAP_ENTITE() {};
43
44			/*
45			syntaxe :
46			TPL_MAP_ENTITE<MG_ELEMENT_MAILLAGE*> liste;
47			TPL_MAP_ENTITE<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
48			MG_ELEMENT_MAILLAGE* element;
49			for (element = liste.get_premier(it); element; element = liste.get_suivant(it) )
50			{
51			printf("element id = %d", element->get_id());
52			}
53			*/
54
55
56			virtual void ajouter(X x)
57			{
58			typename std::pair<const unsigned long,X> tmp(x->get_id(),x);
59			lst_X.insert(tmp);
60			};
61
62			virtual int existe(X x)
63			{
64			typename std::map<unsigned long,X,std::less<unsigned long> >::iterator j=lst_X.find(x->get_id());
65			if (j!=lst_X.end()) return 1;
66			return 0;
67			};
68
69
70			virtual void supprimer(X x)
71			{
72			typename std::map<unsigned long,X,std::less<unsigned long> >::iterator j=lst_X.find(x->get_id());
73			if (j==lst_X.end())
74			{
75			ITERATEUR it;
76			return;
77			}
78			lst_X.erase(j);
79			};
80
81
82
83
84			virtual int get_nb(void)
85			{
86			return lst_X.size();
87			};
88
89
90			virtual X get(int num)
91			{
92			typename std::map<unsigned long,X,std::less<unsigned long> >::iterator j=lst_X.begin();
93			for (int i=0;i<num;i++) j++;
94			return ((*j).second);
95			};
96
97			virtual X getid(unsigned long num)
98			{
99			typename std::map<unsigned long,X,std::less<unsigned long> >::iterator j=lst_X.find(num);
100			if (j==lst_X.end())
101			{
102			return NULL;
103			}
104			return ((*j).second);
105			};
106
107			virtual void vide(void)
108			{
109			lst_X.clear();
110			};
111
112
113			virtual X get_premier(ITERATEUR &it)
114			{
115			it = lst_X.begin();
116			if (it == lst_X.end())
117			return NULL;
118			return it->second ;
119			};
120
121			virtual X get_suivant(ITERATEUR &it)
122			{
123			it++;
124			if(it==lst_X.end())
125			{
126			return NULL;
127			}
128			return it->second;
129			}
130
131			virtual X get(ITERATEUR & it)
132			{
133			if (it == lst_X.end())
134			return NULL;
135
136			return it->second;
137			}
138
139
140			virtual X premier_commun(TPL_MAP_ENTITE<X> &lst2,ITERATEUR & it1,ITERATEUR & it2)
141			{
142			X suiv2;
143			it1=lst_X.begin();
144			suiv2=lst2.get_premier(it2);
145			int ok=0;
146			X rep=NULL;
147			if (it1==lst_X.end()) ok=1;
148			if (suiv2==NULL) ok=1;
149			while (ok==0)
150			{
151			unsigned long id1=it1->first;
152			unsigned long id2=it2->first;
153			if (id2==id1)
154			{
155			rep=it1->second;
156			ok=1;
157			}
158			else if (id2<id1) suiv2=get_suivant(it2);
159			else if (id2>id1) it1++;
160			if (it1==lst_X.end()) ok=1;
161			if (suiv2==NULL) ok=1;
162			}
163			return rep;
164			}
165
166			virtual X suivant_commun(TPL_MAP_ENTITE<X> &lst2,ITERATEUR & it1,ITERATEUR & it2)
167			{
168			X suiv2;
169			it1++;
170			suiv2=lst2.get_suivant(it2);
171			int ok=0;
172			X rep=NULL;
173			if (it1==lst_X.end()) ok=1;
174			if (suiv2==NULL) ok=1;
175			while (ok==0)
176			{
177			unsigned long id1=it1->first;
178			unsigned long id2=it2->first;
179			if (id2==id1)
180			{
181			rep=it1->second;
182			ok=1;
183			}
184			else if (id2<id1) suiv2=get_suivant(it2);
185			else if (id2>id1) it1++;
186			if (it1==lst_X.end()) ok=1;
187			if (suiv2==NULL) ok=1;
188			}
189			return rep;
190			}
191
192
193
194			private:
195			typename std::map<unsigned long,X,std::less<unsigned long> > lst_X;
196
197
198			};
199
200
201
202
203
204
205
206
207			#endif