CMSDK  2.0.1
MemoryMaps.tpl.h
1 #include "Utils.h"
2 
3 namespace cmlabs {
4 
5 template <typename T, typename ID>
6 T* GenericMemoryMap<T,ID>::CreateEntry(char* data, ID id, const char* name) {
7  T* entry = NULL;
8  if (data == NULL) {
9  fprintf(stderr, "CreateEntry %u no data provided\n", id);
10  return NULL;
11  }
12  GenericMapHeader* header = (GenericMapHeader*)data;
13 
14  if (id >= header->maxID) {
15  fprintf(stderr, "CreateEntry bit location %u out of range\n", id);
16  return NULL;
17  }
18 
19  //printf("{%X} {%X} {%X} {%X}\n",
20  // *(uint32*)((char*)header + sizeof(GenericMapHeader)),
21  // *(uint32*)((char*)header + sizeof(GenericMapHeader) + 4),
22  // *(uint32*)((char*)header + sizeof(GenericMapHeader) + 8),
23  // *(uint32*)((char*)header + sizeof(GenericMapHeader) + 12) ); fflush(stdout);
24 
25  bit check;
26  if (!utils::GetBit(id, ((char*)header + sizeof(GenericMapHeader)), header->bitFieldSize, check) || (check == BITOCCUPIED)) {
27  //fprintf(stderr, "CreateEntry bit location %u already in use\n", id);
28  // Already in use, let's check if it is the same one
29  entry = GetEntry(data, id);
30  if (entry && (strcmp(name, entry->name) == 0)) {
31  // Same entry name, return this existing one
32  return entry;
33  }
34  else
35  return NULL;
36  }
37 
38  // Reserve it
39  utils::SetBit(id, BITOCCUPIED, ((char*)header + sizeof(GenericMapHeader)), header->bitFieldSize);
40 
41  // Calc offset
42  uint32 offset = sizeof(GenericMapHeader) + header->bitFieldSize + id * sizeof(T);
43  if (offset > header->size) {
44  fprintf(stderr, "CreateEntry offset error in Memory Map\n");
45  return NULL;
46  }
47  entry = (T*) (data+offset);
48  if ((entry->id == id) || (entry->time == 0)) {
49  entry->id = id;
50  entry->status = 1; // only assigned, not ready
51  entry->time = GetTimeNow();
52  if (name != NULL)
53  utils::strcpyavail(entry->name, name, MAXKEYNAMELEN, true);
54  header->count++;
55  return entry;
56  }
57  else {
58  fprintf(stderr, "CreateEntry entry error in Memory Map\n");
59  return NULL;
60  }
61 }
62 
63 
64 template <typename T, typename ID>
65 T* GenericMemoryMap<T,ID>::CreateFirstFreeEntry(char* data, ID &id, const char* name) {
66  T* entry = NULL;
67  if (data == NULL)
68  return NULL;
69  GenericMapHeader* header = (GenericMapHeader*)data;
70 
71  //printf("{%X} {%X} {%X} {%X}\n",
72  // *(uint32*)((char*)header + sizeof(GenericMapHeader)),
73  // *(uint32*)((char*)header + sizeof(GenericMapHeader) + 4),
74  // *(uint32*)((char*)header + sizeof(GenericMapHeader) + 8),
75  // *(uint32*)((char*)header + sizeof(GenericMapHeader) + 12) ); fflush(stdout);
76 
77  uint32 loc;
78  if (!utils::GetFirstFreeBitLoc(((char*)header + sizeof(GenericMapHeader)), header->bitFieldSize, loc) || (loc >= header->maxID)) {
79  fprintf(stderr, "No more bit locations available\n");
80  return NULL;
81  }
82 
83  // Reserve it
84  id = (ID)loc;
85  utils::SetBit(id, BITOCCUPIED, ((char*)header + sizeof(GenericMapHeader)), header->bitFieldSize);
86 
87  // Calc offset
88  uint32 offset = sizeof(GenericMapHeader) + header->bitFieldSize + id * sizeof(T);
89  if (offset > header->size) {
90  fprintf(stderr, "Offset error in Memory Map\n");
91  return NULL;
92  }
93  entry = (T*) (data+offset);
94  if ((entry->id == id) || (entry->time == 0)) {
95  entry->id = id;
96  entry->status = 1; // only assigned, not ready
97  entry->time = GetTimeNow();
98  if (name != NULL)
99  utils::strcpyavail(entry->name, name, MAXKEYNAMELEN, true);
100  header->count++;
101  return entry;
102  }
103  else {
104  fprintf(stderr, "Entry error in Memory Map\n");
105  return NULL;
106  }
107 }
108 
109 template <typename T, typename ID>
110 bool GenericMemoryMap<T,ID>::DeleteEntry(char* data, ID id) {
111  T* entry = NULL;
112  if (data == NULL)
113  return false;
114  GenericMapHeader* header = (GenericMapHeader*)data;
115 
116  // Calc offset
117  uint32 offset = sizeof(GenericMapHeader) + header->bitFieldSize + id * sizeof(T);
118  if (offset > header->size)
119  return false;
120  entry = (T*) (data+offset);
121  if ((entry->id != id) || (entry->time == 0))
122  return false;
123 
124  // Free it
125  entry->time = 0;
126  header->count--;
127  utils::SetBit(id, BITFREE, ((char*)header + sizeof(GenericMapHeader)), header->bitFieldSize);
128  return true;
129 }
130 
131 
132 template <typename T, typename ID>
133 uint64 GenericMemoryMap<T,ID>::GetEntryTime(char* data, ID id) {
134  T* entry = GetEntry(data, id);
135  if (entry == NULL)
136  return 0;
137  return entry->time;
138 }
139 
140 template <typename T, typename ID>
141 T* GenericMemoryMap<T,ID>::GetEntry(char* data, ID id) {
142  T* entry = NULL;
143  if (data == NULL)
144  return NULL;
145  GenericMapHeader* header = (GenericMapHeader*)data;
146 
147  // Calc offset
148  uint32 offset = sizeof(GenericMapHeader) + header->bitFieldSize + id * sizeof(T);
149  if (offset > header->size)
150  return NULL;
151  entry = (T*) (data+offset);
152  if ((entry->id == id) && (entry->time != 0) && (entry->status > 1))
153  return entry;
154  else
155  return NULL;
156 }
157 
158 template <typename T, typename ID>
159 bool GenericMemoryMap<T,ID>::ConfirmEntry(char* data, ID id) {
160  T* entry = NULL;
161  if (data == NULL)
162  return false;
163  GenericMapHeader* header = (GenericMapHeader*)data;
164 
165  // Calc offset
166  uint32 offset = sizeof(GenericMapHeader) + header->bitFieldSize + id * sizeof(T);
167  if (offset > header->size)
168  return false;
169  entry = (T*) (data+offset);
170  if ((entry->id == id) && entry->time && (entry->status >= 1)) {
171  entry->status = 2;
172  return true;
173  }
174  else
175  return false;
176 }
177 
178 template <typename T, typename ID>
179 bool GenericMemoryMap<T,ID>::CancelEntry(char* data, ID id) {
180  T* entry = NULL;
181  if (data == NULL)
182  return false;
183  GenericMapHeader* header = (GenericMapHeader*)data;
184 
185  // Calc offset
186  uint32 offset = sizeof(GenericMapHeader) + header->bitFieldSize + id * sizeof(T);
187  if (offset > header->size)
188  return false;
189  entry = (T*) (data+offset);
190  if ((entry->id == id) && entry->time && (entry->status <= 1)) {
191  entry->status = 0;
192  entry->time = 0;
193  return true;
194  }
195  else if ((entry->id == 0) || (entry->status == 0))
196  return true;
197  else
198  return false;
199 }
200 
201 template <typename T, typename ID>
202 bool GenericMemoryMap<T,ID>::GetEntryName(char* data, ID id, char* name, uint32 maxSize) {
203  T* entry = GetEntry(data, id);
204  if (entry == NULL)
205  return NULL;
206  return (utils::strcpyavail(name, entry->name, maxSize, true) > 0);
207 }
208 
209 template <typename T, typename ID>
210 ID GenericMemoryMap<T,ID>::GetEntryID(char* data, const char* name, bool force) {
211  T* entry = NULL;
212  if (data == NULL)
213  return 0;
214  GenericMapHeader* header = (GenericMapHeader*)data;
215 
216  entry = (T*) (data + sizeof(GenericMapHeader) + header->bitFieldSize);
217  while ((uint32)((char*)entry - data) < header->size) {
218  if (stricmp(name, entry->name) == 0) {
219  if ((entry->status > 1) || force)
220  return entry->id;
221  else
222  return 0;
223  }
224  entry = entry + 1; //sizeof(TypeMapEntry);
225  }
226  return 0;
227 }
228 
229 template <typename T, typename ID>
230 uint8 GenericMemoryMap<T,ID>::LookupEntryID(char* data, const char* name, ID& id) {
231  T* entry = NULL;
232  if (data == NULL)
233  return 0;
234  GenericMapHeader* header = (GenericMapHeader*)data;
235 
236  uint32 n = 0;
237  entry = (T*) (data + sizeof(GenericMapHeader) + header->bitFieldSize);
238  while ((uint32)((char*)entry - data) < header->size) {
239  if (stricmp(name, entry->name) == 0) {
240  id = entry->id;
241  return entry->status;
242  }
243  n++;
244  entry = entry + 1; //sizeof(TypeMapEntry);
245  }
246  return 0;
247 }
248 
249 template <typename T, typename ID>
250 std::string GenericMemoryMap<T,ID>::PrintAllEntries(char* data) {
251  std::string str;
252  T* entry = NULL;
253  if (data == NULL)
254  return 0;
255  GenericMapHeader* header = (GenericMapHeader*)data;
256 
257  entry = (T*) (data + sizeof(GenericMapHeader) + header->bitFieldSize);
258  while ((uint32)((char*)entry - data) < header->size) {
259  if (entry->id) {
260  if (entry->status > 1)
261  str += utils::StringFormat("%u = %s (%s)\n", entry->id, entry->name, PrintTimeString(entry->time).c_str());
262  else
263  str += utils::StringFormat("*%u = %s (%s)\n", entry->id, entry->name, PrintTimeString(entry->time).c_str());
264  }
265  entry = entry + 1; //sizeof(TypeMapEntry);
266  }
267  return str;
268 }
269 
270 template <typename T, typename ID>
271 std::string GenericMemoryMap<T,ID>::PrintAllEntriesHTML(char* data) {
272  std::string str;
273  T* entry = NULL;
274  if (data == NULL)
275  return 0;
276  GenericMapHeader* header = (GenericMapHeader*)data;
277 
278  entry = (T*) (data + sizeof(GenericMapHeader) + header->bitFieldSize);
279  while ((uint32)((char*)entry - data) < header->size) {
280  if (entry->id) {
281  if (entry->status > 1)
282  str += utils::StringFormat("<tr><td>%u</td><td>%s</td><td>%s</td></tr>", entry->id, entry->name, PrintTimeString(entry->time).c_str());
283  else
284  str += utils::StringFormat("<tr><td>%**u</td><td>%s</td><td>%s</td></tr>\n", entry->id, entry->name, PrintTimeString(entry->time).c_str());
285  }
286  entry = entry + 1; //sizeof(TypeMapEntry);
287  }
288  return str;
289 }
290 
291 template <typename T, typename ID>
292 std::string GenericMemoryMap<T,ID>::ToXML(char* data) {
293  std::string str;
294  T* entry = NULL;
295  if (data == NULL)
296  return 0;
297  GenericMapHeader* header = (GenericMapHeader*)data;
298 
299  uint32 count = 0;
300  entry = (T*) (data + sizeof(GenericMapHeader) + header->bitFieldSize);
301  while ((uint32)((char*)entry - data) < header->size) {
302  if (entry->id) {
303  str += entry->toXML();
304  count++;
305  }
306  entry = entry + 1; //sizeof(TypeMapEntry);
307  }
308  std::string outerName = T::GetOuterXMLName();
309  if (!count)
310  return utils::StringFormat("<%s count=\"%u\" />\n", outerName.c_str(), count);
311  else
312  return utils::StringFormat("<%s count=\"%u\">\n%s</%s>\n", outerName.c_str(), count, str.c_str(), outerName.c_str());
313 }
314 
315 template <typename T, typename ID>
316 bool GenericMemoryMap<T, ID>::WriteAllIDsToMsg(const char* arrayname, char* data, DataMessage* msg) {
317  T* entry = NULL;
318  if (data == NULL)
319  return false;
320  GenericMapHeader* header = (GenericMapHeader*)data;
321 
322  uint32 n = 0;
323  entry = (T*)(data + sizeof(GenericMapHeader) + header->bitFieldSize);
324  while ((uint32)((char*)entry - data) < header->size) {
325  if (entry->id) {
326  if (!entry->writeIDToMsg(arrayname, n, msg))
327  return false;
328  n++;
329  }
330  entry = entry + 1; //sizeof(TypeMapEntry);
331  }
332  return true;
333 }
334 
335 
336 template <typename T, typename ID>
337 bool GenericMemoryMap<T, ID>::WriteAllEntriesToMsg(char* data, DataMessage* msg) {
338  T* entry = NULL;
339  if (data == NULL)
340  return false;
341  GenericMapHeader* header = (GenericMapHeader*)data;
342 
343  uint32 n = 0;
344  entry = (T*)(data + sizeof(GenericMapHeader) + header->bitFieldSize);
345  while ((uint32)((char*)entry - data) < header->size) {
346  if (entry->id) {
347  if (!entry->writeToMsg(n, msg))
348  return false;
349  n++;
350  }
351  entry = entry + 1; //sizeof(TypeMapEntry);
352  }
353  return true;
354 }
355 
356 
357 template <typename T, typename ID>
358 uint32 GenericMemoryMap<T,ID>::GetCount(char* data) {
359  if (data == NULL)
360  return false;
361  return ((GenericMapHeader*)data)->count;
362 }
363 
364 template <typename T, typename ID>
365 uint32 GenericMemoryMap<T,ID>::GetUsage(char* data) {
366  if (data == NULL)
367  return 0;
368  return ((GenericMapHeader*)data)->count * sizeof(T);
369 }
370 
371 } // namespace cmlabs
cmlabs
Definition: Bitmap.h:7
Generated by   doxygen 1.8.14