SHOGUN  3.2.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
List.h
Go to the documentation of this file.
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License as published by
4  * the Free Software Foundation; either version 3 of the License, or
5  * (at your option) any later version.
6  *
7  * Written (W) 1999-2009 Soeren Sonnenburg
8  * Written (W) 1999-2008 Gunnar Raetsch
9  * Written (W) 2012 Heiko Strathmann
10  * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
11  */
12 
13 #ifndef _LIST_H_
14 #define _LIST_H_
15 
16 #include <shogun/lib/config.h>
17 
18 #include <shogun/lib/common.h>
19 #include <shogun/base/SGObject.h>
20 #include <shogun/base/Parameter.h>
21 
22 namespace shogun
23 {
25 class CListElement :public CSGObject
26 {
27  public:
30  : next(NULL), prev(NULL), data(NULL)
31  {
32  init();
33  }
34 
42  CListElement* p_prev = NULL,
43  CListElement* p_next = NULL)
44  {
45  init();
46 
47  this->data = p_data;
48  this->next = p_next;
49  this->prev = p_prev;
50  }
51 
53  virtual ~CListElement() { data = NULL; }
54 
56  virtual const char* get_name() const { return "ListElement"; }
57 
58  private:
59  void init()
60  {
61  m_parameters->add(&data, "data", "Data of this element.");
62  m_parameters->add((CSGObject**) &next, "next",
63  "Next element in list.");
65  "Next element in list.");
66  m_model_selection_parameters->add(&data, "data", "Data of this element.");
67  }
68 
69  public:
76 
77 };
78 
84 class CList : public CSGObject
85 {
86  public:
91  CList(bool p_delete_data=false) : CSGObject()
92  {
93  m_parameters->add(&delete_data, "delete_data",
94  "Delete data on destruction?");
95  m_parameters->add(&num_elements, "num_elements",
96  "Number of elements.");
97  m_parameters->add((CSGObject**) &first, "first",
98  "First element in list.");
99  m_model_selection_parameters->add((CSGObject**) &first, "first",
100  "First element in list.");
101 
102  first = NULL;
103  current = NULL;
104  last = NULL;
105 
106  num_elements = 0;
107  this->delete_data=p_delete_data;
108  }
109 
110  virtual ~CList()
111  {
112  SG_DEBUG("Destroying List %p\n", this)
113 
115  }
116 
118  inline void delete_all_elements()
119  {
120  while (get_num_elements())
121  {
123 
124  if (delete_data)
125  {
126  SG_DEBUG("SG_UNREF List Element %p\n", d)
127  SG_UNREF(d);
128  }
129  }
130 
131  first=NULL;
132  current=NULL;
133  last=NULL;
134  }
135 
140  inline int32_t get_num_elements() { return num_elements; }
141 
147  {
148  if (first != NULL)
149  {
150  current = first;
151  if (delete_data)
152  SG_REF(current->data);
153  return current->data;
154  }
155  else
156  return NULL;
157  }
158 
164  {
165  if (last != NULL)
166  {
167  current = last;
168  if (delete_data)
169  SG_REF(current->data);
170  return current->data;
171  }
172  else
173  return NULL;
174  }
175 
181  {
182  if ((current != NULL) && (current->next != NULL))
183  {
184  current = current->next;
185  if (delete_data)
186  SG_REF(current->data);
187  return current->data;
188  }
189  else
190  return NULL;
191  }
192 
198  {
199  if ((current != NULL) && (current->prev != NULL))
200  {
201  current = current->prev;
202  if (delete_data)
203  SG_REF(current->data);
204  return current->data;
205  }
206  else
207  return NULL;
208  }
209 
215  {
216  if (current != NULL)
217  {
218  if (delete_data)
219  SG_REF(current->data);
220  return current->data;
221  }
222  else
223  return NULL;
224  }
225 
226 
229 
236  {
237  if (first != NULL)
238  {
239  p_current = first;
240  if (delete_data)
241  SG_REF(p_current->data);
242  return p_current->data;
243  }
244  else
245  return NULL;
246  }
247 
254  {
255  if (last != NULL)
256  {
257  p_current = last;
258  if (delete_data)
259  SG_REF(p_current->data);
260  return p_current->data;
261  }
262  else
263  return NULL;
264  }
265 
272  {
273  if ((p_current != NULL) && (p_current->next != NULL))
274  {
275  p_current = p_current->next;
276  if (delete_data)
277  SG_REF(p_current->data);
278  return p_current->data;
279  }
280  else
281  return NULL;
282  }
283 
290  {
291  if ((p_current != NULL) && (p_current->prev != NULL))
292  {
293  p_current = p_current->prev;
294  if (delete_data)
295  SG_REF(p_current->data);
296  return p_current->data;
297  }
298  else
299  return NULL;
300  }
301 
308  {
309  if (p_current != NULL)
310  {
311  if (delete_data)
312  SG_REF(p_current->data);
313  return p_current->data;
314  }
315  else
316  return NULL;
317  }
319 
325  inline bool append_element(CSGObject* data)
326  {
327  if (current != NULL) // none available, case is shattered in insert_element()
328  {
330  if (e)
331  {
332  if (delete_data)
333  SG_UNREF(e);
334  // if successor exists use insert_element()
335  return insert_element(data);
336  }
337  else
338  {
339  // case with no successor but nonempty
340  CListElement* element;
341 
342  if ((element = new CListElement(data, current)) != NULL)
343  {
344  current->next = element;
345  current = element;
346  last = element;
347 
348  num_elements++;
349 
350  if (delete_data)
351  SG_REF(data);
352 
353  return true;
354  }
355  else
356  return false;
357  }
358  }
359  else
360  return insert_element(data);
361  }
362 
369  {
371  if (delete_data)
372  SG_UNREF(p);
373 
374  return append_element(data);
375  }
376 
382  inline bool push(CSGObject* data)
383  {
384  return append_element_at_listend(data);
385  }
386 
391  inline bool pop()
392  {
393  if (last)
394  {
395  if (first==last)
396  first=NULL;
397 
398  if (current==last)
399  {
400  if (first==last)
401  current=NULL;
402  else
403  current=current->prev;
404  }
405 
406  if (delete_data)
407  SG_UNREF(last->data);
408 
409  CListElement* temp=last;
410  last=last->prev;
411  SG_UNREF(temp);
412  if (last)
413  last->next=NULL;
414 
415  num_elements--;
416 
417  return true;
418  }
419  else
420  return false;
421  }
422 
428  inline bool insert_element(CSGObject* data)
429  {
430  CListElement* element;
431 
432  if (delete_data)
433  SG_REF(data);
434 
435  if (current == NULL)
436  {
437  if ((element = new CListElement(data)) != NULL)
438  {
439  current = element;
440  first = element;
441  last = element;
442 
443  num_elements++;
444 
445  return true;
446  }
447  else
448  return false;
449  }
450  else
451  {
452  if ((element = new CListElement(data, current->prev, current)) != NULL)
453  {
454  if (current->prev != NULL)
455  current->prev->next = element;
456  else
457  first = element;
458 
459  current->prev = element;
460  current = element;
461 
462  num_elements++;
463 
464  return true;
465  }
466  else
467  return false;
468  }
469  }
470 
478  {
479  CSGObject* data = get_current_element();
480 
481  if (num_elements>0)
482  num_elements--;
483 
484  if (data)
485  {
486  if (delete_data)
487  SG_UNREF(data);
488 
489  CListElement *element = current;
490 
491  if (element->prev)
492  element->prev->next = element->next;
493 
494  if (element->next)
495  element->next->prev = element->prev;
496 
497  if (element->next)
498  current = element->next;
499  else
500  current = element->prev;
501 
502  if (element == first)
503  first = element->next;
504 
505  if (element == last)
506  last = element->prev;
507 
508  delete element;
509 
510  return data;
511  }
512 
513  return NULL;
514  }
515 
517  {
519 
520  current = first;
521  CListElement* prev = NULL;
522  for (CListElement* cur=first; cur!=NULL; cur=cur->next)
523  {
524  cur->prev = prev;
525  prev = cur;
526  }
527  last = prev;
528  }
529 
531  void print_list()
532  {
533  CListElement* c=first;
534 
535  while (c)
536  {
537  SG_PRINT("\"%s\" at %p\n", c->data ? c->data->get_name() : "", c->data)
538  c=c->next;
539  }
540  }
541 
543  inline bool get_delete_data() { return delete_data; }
544 
546  virtual const char* get_name() const { return "List"; }
547 
548  private:
550  bool delete_data;
552  CListElement* first;
554  CListElement* current;
556  CListElement* last;
558  int32_t num_elements;
559 };
560 }
561 #endif

SHOGUN Machine Learning Toolbox - Documentation