1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
| #ifndef _SimpleLink_h
#define _SimpleLink_h
#include <Pool.h>
#include <map>
// this template class is used for bidirectionnal linking.
// When 2 instances of two different classes link each other, each side have a SimpleLink class with both classes as template arguments (in this order : Src, Dst)
template <class T0, class T> void Nothing(T0* A,T* B) {};
template <class T0, class T>
class SimpleLink
{
protected:
T0* _Owner;
// Destination reference pool
Pool<T>* _ReferencePool;
// Main data structure : map class permit multiple links as well as simple ones
std::map<int,T*> _Data;
// Link callbacks declaration as static members
static void (*_LinkCallBack)(T0*,T*) ;
static void (*_UnlinkCallBack)(T0*,T*) ;
public:
SimpleLink(T0* Owner, Pool<T>* ReferencePool);
virtual ~SimpleLink();
void Set(int Id); // Set a link (remove former ones, add just one)
void Add(int Id); // Add a link (add one more, without coping with former ones)
void Delete(int Id=NULL); // Delete a specified link or all if NULL is passed
T* get(); // Returns the destination objet (works only for simple links)
T* operator->() { return get();}; // shortcut to get()
T* IterateValues(T* Element); // Iterators : see Pool.h for similar behaviours
int IterateKeys(int Element);
static void setLinkCallBack(void (*CallBack)(T0*,T*)) { _LinkCallBack = CallBack;};
static void setUnlinkCallBack(void (*CallBack)(T0*,T*)) { _UnlinkCallBack = CallBack;};
};
// Initialisation to default callbacks
template <class T0, class T> void (*SimpleLink<T0,T>::_LinkCallBack)(T0*,T*) = Nothing; //-> C'EST ICI QU'APPARAIT L'ERREUR
template <class T0, class T> void (*SimpleLink<T0,T>::_UnlinkCallBack)(T0*,T*) = Nothing; //-> ET ICI AUSSI
template <class T0, class T> SimpleLink<T0,T>::SimpleLink(T0* Owner, Pool<T>* ReferencePool)
{
_Owner = Owner;
_ReferencePool = ReferencePool;
}
template <class T0, class T> SimpleLink<T0,T>::~SimpleLink()
{
if (_Data.size())
{
// Should never be here, unlink macro must be called before deleting the object....
int foo=0;
}
}
template <class T0, class T> void SimpleLink<T0,T>::Set(int Id)
{
Delete();
Add(Id);
}
template <class T0, class T> void SimpleLink<T0,T>::Add(int Id)
{
T* temp = _ReferencePool->Find(Id);
_Data[Id] = temp;
(*_LinkCallBack)(_Owner,temp);
}
template <class T0, class T> void SimpleLink<T0,T>::Delete(int Id)
{
std::map<int,T*>::iterator temp;
if (Id)
{
temp = _Data.find(Id);
(*_UnlinkCallBack)(_Owner,temp->second);
_Data.erase(temp);
}
else
{
for (temp = _Data.begin(); temp != _Data.end(); temp++)
{
(*_UnlinkCallBack)(_Owner,temp->second);
}
_Data.clear();
}
}
template <class T0, class T> T* SimpleLink<T0,T>::get()
{
if (!(_Data.size()))
return NULL;
else
return _Data.begin()->second;
}
template <class T0, class T> T* SimpleLink<T0,T>::IterateValues(T* Element)
{
static std::map<int,T*>::iterator Cursor;
if (Element == NULL) // If null given, we start from the begining
{
Cursor = _Data.begin();
if (Cursor == end())
return NULL;
else
return Cursor->second;
}
else
{
if (Element == Cursor->second) // If it isn't given back next one, must find it first
{
Cursor = _Data.begin();
while ((Cursor != _Data.end()) && (Cursor->second != Element))
Cursor++;
if (Cursor == end())
return NULL;
}
if ((++Cursor) == _Data.end())
{
return NULL;
}
else
{
return Cursor->second;
}
}
}
template <class T0, class T> int SimpleLink<T0,T>::IterateKeys(int Element)
{
static std::map<int,T*>::iterator Cursor;
if (Element == 0) // If null given, we start from the begining
{
Cursor = _Data.begin();
if (Cursor == _Data.end())
return NULL;
else
return Cursor->first;
}
else
{
if (Element == Cursor->first) // If it isn't given back next one, must find it first
{
Cursor = _Data.find(Element);
if (Cursor == _Data.end())
return NULL;
}
if ((++Cursor) == _Data.end())
{
return NULL;
}
else
{
return Cursor->first;
}
}
}
#endif |
