Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/branches/resources/src/lib/lang/class_list.cc @ 8874

Last change on this file since 8874 was 7221, checked in by bensch, 19 years ago

orxonox/trunk: merged the std-branche back, it runs on windows and Linux

svn merge https://svn.orxonox.net/orxonox/branches/std . -r7202:HEAD

File size: 11.3 KB
Line 
1/*
2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   ### File Specific:
12   main-programmer: Benjamin Grauer
13   co-programmer: ...
14*/
15
16//#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_
17
18#include "class_list.h"
19#include "base_object.h"
20
21#include "compiler.h"
22#include "debug.h"
23#include <string.h>
24#include <math.h>
25#include <algorithm>
26#include "shell_command.h"
27
28using namespace std;
29
30#ifndef NO_SHELL_COMMAND
31SHELL_COMMAND_STATIC(debug, ClassList, ClassList::debugS)
32    ->describe("Shows all registered classes, if param1: is a valid ClassName only values of this class are shown. param2: how much output")
33    ->defaultValues(MT_NULL, 1);
34#endif
35
36/**
37 *  Creates a new ClassList
38*/
39ClassList::ClassList(ClassID classID, unsigned long classIDFull, const std::string& className)
40  : className(className)
41{
42  this->classID = classID;
43  this->classIDFull = classIDFull;
44}
45
46/**
47 *  standard deconstructor
48*/
49ClassList::~ClassList ()
50{
51//   ClassList::classList->clear());
52}
53
54//! a List of all known Classes.
55std::list<ClassList>* ClassList::classList = NULL;
56
57//! a List of all strings of all classes, that have registered so far.
58std::list<std::string> ClassList::classNames;
59
60/**
61 * @brief Adds a new Object to the ClassList (and if necessary a new Class)
62 * @param objectPointer Pointer to the Object at hand
63 * @param classID ID of the Given ObjectType \see ClassID
64 * @param className name of the Class to add
65 *
66 * !! FIRST YOU HAVE TO CALL THIS FUNCTION ONCE
67 * !! Before unsing the ClassList, as it creates the ClassLits
68 */
69ClassList* ClassList::addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const std::string& className)
70{
71  if (unlikely(classList == NULL))
72    ClassList::classList = new list<ClassList>();
73
74  PRINTF(5)("subscribe a '%s'\n", className.c_str() );
75
76  ClassList* regClass = ClassList::getClassList(classID);
77  if (regClass != NULL)
78  {
79    regClass->objectList.push_back(objectPointer);
80    return regClass;
81  }
82  else
83  {
84    ClassList::classList->push_back(ClassList(classID, classIDFull, className));
85    ClassList::classList->back().objectList.push_back(objectPointer);
86    return &ClassList::classList->back();
87  }
88}
89
90/**
91 * removes an Object from a the ClassList
92 * @param objectPointer the Object to delete from the List
93 */
94void ClassList::removeFromClassList(BaseObject* objectPointer)
95{
96  list<ClassList>::iterator cl;
97  for(cl = ClassList::classList->begin(); cl != ClassList::classList->end(); cl++)
98  {
99    if (objectPointer->isA((*cl).classID))
100    {
101      std::list<BaseObject*>::iterator bo = std::find ((*cl).objectList.begin(), (*cl).objectList.end(), objectPointer);
102      if (bo != (*cl).objectList.end())
103          (*cl).objectList.erase(bo);
104    }
105  }
106}
107
108/**
109 * grabs the names of all Classes, and injects it into a List of const chars
110 * @return the generated List
111 *
112 * This function first looks, if the List has been changed (by the ListSize)
113 * befor it changes anything.
114 */
115const std::list<std::string>* ClassList::getClassNames()
116{
117  if (ClassList::classNames.size() != ClassList::classList->size())
118  {
119      ClassList::classNames.clear();
120
121      list<ClassList>::const_iterator cl;
122      for (cl = ClassList::classList->begin(); cl != ClassList::classList->end(); cl++)
123        ClassList::classNames.push_back((*cl).className);
124  }
125
126  return &ClassList::classNames;
127}
128
129/**
130 * searches for classID and returns the list of Entities
131 * @param classID the ID of the class to get the list from
132 * @return the List accessed by classID, or NULL if not found
133 */
134const std::list<BaseObject*>* ClassList::getList(ClassID classID)
135{
136  ClassList* fl;
137  return ((fl = ClassList::getClassList(classID)) != NULL)?
138       &(fl->objectList) : NULL;
139
140/*
141  std::list<ClassList>::iterator classIT = find (classList->begin(), classList->end(), classID);
142  return (likely(classIT != classList->end()))? &(*classIT).objectList : NULL;*/
143
144/*  for (classIT = ClassList::classList->begin(); classIT != ClassList::classList->end(); classIT++)
145  {
146    if ((*classIT) == classID )
147      return &(*classIT).objectList;
148  }
149  return NULL;*/
150}
151
152/**
153 * searches for className and returns the list of Entities
154 * @param className the name of the class to get the list from
155 * @return the List accessed by classID, or NULL if not found
156 */
157const std::list<BaseObject*>* ClassList::getList(const std::string& className)
158{
159  ClassList* fl;
160  return ((fl = ClassList::getClassList(className)) != NULL)?
161      &(fl->objectList) : NULL;
162
163  /*
164  std::list<ClassList>::iterator classIT = find (classList->begin(), classList->end(), className);
165  return (likely(classIT != classList->end()))? &(*classIT).objectList : NULL;*/
166
167
168/*  for (classIT = ClassList::classList->begin(); classIT != ClassList::classList->end(); classIT++)
169  {
170    if ((*classIT) == className )
171      return &(*classIT).objectList;
172  }
173  return NULL;*/
174}
175
176/**
177 * !!PRIVATE!!
178 * @param classID the ClassID to search for
179 * @returns the ClassList with classID as specifyer, or NULL if not
180 */
181ClassList* ClassList::getClassList(ClassID classID)
182{
183  std::list<ClassList>::iterator classIT = find (ClassList::classList->begin(), ClassList::classList->end(), classID);
184  return (likely(classIT != classList->end()))? &(*classIT) : NULL;
185}
186
187
188/**
189 * !!PRIVATE!!
190 * @param className the ClassName to search for
191 * @returns the ClassList with className as specifyer, or NULL if not
192 */
193ClassList* ClassList::getClassList(const std::string& className)
194{
195  if (className.empty())
196    return NULL;
197  std::list<ClassList>::iterator classIT = find (classList->begin(), classList->end(), className);
198  return (likely(classIT != classList->end()))? &(*classIT) : NULL;
199}
200
201
202/**
203 * checks if the BaseObject* object exists.
204 * @param objectName the name of the BaseObject to look for
205 * @param classID if not CL_NULL it will only search through a specific type of Objects. Otherwise it will be searched everywhere.
206 * @return true, if the Object Exists in the specified ClassID, false otherwise
207 * @todo: speed this up!!
208 */
209BaseObject* ClassList::getObject(const std::string& objectName, ClassID classID)
210{
211  if (classID != CL_NULL)
212  {
213    ClassList* cl = ClassList::getClassList(classID);
214    if (cl != NULL)
215    {
216      std::list<BaseObject*>::iterator bo;
217      for (bo = cl->objectList.begin(); bo != cl->objectList.end(); bo++)
218        if ((*bo)->getName() != NULL && objectName == (*bo)->getName())
219          return (*bo);
220    }
221  }
222  else
223  {
224    list<ClassList>::iterator cl;
225    for (cl = ClassList::classList->begin(); cl != ClassList::classList->end(); cl++)
226    {
227      std::list<BaseObject*>::iterator bo;
228      for (bo = (*cl).objectList.begin(); bo != (*cl).objectList.end(); bo++)
229        if ((*bo)->getName() != NULL && objectName == (*bo)->getName())
230          return (*bo);
231    }
232  }
233  return NULL;
234}
235
236
237/**
238 * checks if the BaseObject* object exists.
239 * @param object the Pointer to a BaseObject to check if it exists
240 * @param classID if not CL_NULL it will only search through a specific type of Objects. Otherwise it will be searched everywhere.
241 * @return true, if the Object Exists in the specified ClassID, false otherwise
242 * @todo: speed this up!!
243 */
244bool ClassList::exists(const BaseObject* object, ClassID classID)
245{
246  if (classID != CL_NULL)
247  {
248    ClassList* cl = ClassList::getClassList(classID);
249    if (cl != NULL)
250    {
251      std::list<BaseObject*>::const_iterator bo = find (cl->objectList.begin(), cl->objectList.end(), object);
252      return (bo != cl->objectList.end());
253    }
254  }
255  else
256  {
257    list<ClassList>::iterator cl;
258    for (cl = ClassList::classList->begin(); cl != ClassList::classList->end(); cl++)
259    {
260      std::list<BaseObject*>::const_iterator bo = find ((*cl).objectList.begin(), (*cl).objectList.end(), object);
261      if (bo != (*cl).objectList.end())
262        return true;
263    }
264  }
265  return false;
266}
267
268/**
269 * prints out a string of all the types this Object matches
270 * @param object a Pointer to the object to analyze
271 */
272void ClassList::whatIs(const BaseObject* object)
273{
274  list<ClassList>::iterator cl;
275  for (cl = ClassList::classList->begin(); cl != ClassList::classList->end(); cl++)
276    if (object->isA((*cl).classID))
277  {
278    PRINT(0)("=%s::0x%.8X=-", (*cl).className.c_str(), (*cl).classID);
279  }
280}
281
282/**
283 * converts a ClassID into a string
284 * @param classID the ClassID to search for
285 * @return a String containing the name of the Class, NULL if the Class was not found
286 */
287const std::string& ClassList::IDToString(ClassID classID)
288{
289  static const std::string empty("");
290
291  ClassList* cl = ClassList::getClassList(classID);
292  return (cl != NULL) ? cl->className : empty;
293}
294
295/**
296 * converts a String into a ClassID
297 * @param className the name of the class to search for
298 * @return the ClassID. CL_NULL, if the class was not found.
299 */
300ClassID ClassList::StringToID(const std::string& className)
301{
302  ClassList* cl = ClassList::getClassList(className);
303  return (cl != NULL) ? cl->classID : CL_NULL;
304}
305
306/**
307 * checks if this ClassList is named className
308 * @param className the Name to check this ClassList's ClassName against
309 * @returns true on match, false otherwise
310 */
311bool ClassList::operator==(const std::string& className)
312{
313  return (this->className == className);
314}
315
316
317
318/**
319 * Print out some very nice debug information
320 * @param debugLevel the level of verbosity
321 * @param classID the class that should be displayed (if CL_NULL (default) all classes will be displayed)
322 */
323void ClassList::debug(unsigned int debugLevel, ClassID classID)
324{
325  if (debugLevel > 3)
326    debugLevel = 3;
327  PRINT(0)("==========================\n");
328  PRINT(0)("=  CLASS_LIST (level %d)  =\n", debugLevel);
329  PRINT(0)("==========================\n");
330  PRINT(0)("| knows %d Classes\n|\n", ClassList::classList->size());
331  char niceString[100];
332  unsigned int lenCount = 0;
333
334  list<ClassList>::iterator cl;
335  for (cl = ClassList::classList->begin(); cl != ClassList::classList->end(); cl++)
336  {
337    if ((debugLevel >= 1 || (*cl).objectList.size() > 0 ) &&
338         (classID == CL_NULL || unlikely (classID == (*cl).classID)))
339    {
340      lenCount = 1;
341      while (pow(10, lenCount) <= (*cl).objectList.size())
342        ++lenCount;
343      for (int i=0; i < 30-(*cl).className.size() - lenCount; i++)
344        (niceString[i]) = ' ';
345      niceString[30-(*cl).className.size() - lenCount] = '\0';
346
347      PRINT(0)("| CLASS %s::%s %d\n", (*cl).className.c_str(), niceString, (*cl).objectList.size());
348
349      if (debugLevel >=2 && (*cl).objectList.size() > 0)
350      {
351        PRINT(0)("|  Listing Instances:\n");
352        list<BaseObject*>::const_iterator bo;
353        for (bo = (*cl).objectList.begin(); bo != (*cl).objectList.end(); bo++)
354        {
355          PRINT(0)("|   %s::%s::(0x%.8X->%p ", (*bo)->getClassName(), (*bo)->getName(), (*bo)->getClassID(), (*bo));
356          if (debugLevel == 3)
357            ClassList::whatIs(*bo);
358          PRINT(0)("\n");
359        }
360      }
361    }
362  }
363  PRINT(0)("=======================CL=\n");
364}
365
366/**
367 * Print out some very nice debug information
368 * @param debugLevel the level of verbosity
369 * @param className the class that should be displayed.
370 * @see ClassList::debug
371 */
372void ClassList::debugS(const std::string& className, unsigned int debugLevel)
373{
374  ClassList::debug(debugLevel, ClassList::StringToID(className));
375}
Note: See TracBrowser for help on using the repository browser.