1 | /*! |
---|
2 | * @file base_object.h |
---|
3 | * @brief Definition of the BaseObject class. |
---|
4 | * |
---|
5 | * This is a global handler for all classes Object and Class names |
---|
6 | * |
---|
7 | * BaseObject is the class, that handles object registration and |
---|
8 | * is the only write-access member of ClassList, where the Objects |
---|
9 | * References are stored. |
---|
10 | */ |
---|
11 | |
---|
12 | |
---|
13 | #ifndef __BASE_OBJECT_H_ |
---|
14 | #define __BASE_OBJECT_H_ |
---|
15 | |
---|
16 | #include "object_list.h" |
---|
17 | #include "sigslot/slot.h" |
---|
18 | |
---|
19 | #include <string> |
---|
20 | |
---|
21 | class TiXmlNode; |
---|
22 | class TiXmlElement; |
---|
23 | class ClassList; |
---|
24 | |
---|
25 | //! A class all other classes are derived from |
---|
26 | class BaseObject : public sigslot::has_slots<> |
---|
27 | { |
---|
28 | ObjectListDeclaration(BaseObject); |
---|
29 | public: |
---|
30 | BaseObject (const std::string& objectName = ""); |
---|
31 | |
---|
32 | virtual ~BaseObject (); |
---|
33 | |
---|
34 | virtual void loadParams(const TiXmlElement* root); |
---|
35 | void setName (const std::string& newName); |
---|
36 | /** returns the Name of this Object */ |
---|
37 | inline const std::string& getName() const { return this->objectName; }; |
---|
38 | /** returns the Name of this Object as a C-compliant string (const char*) */ |
---|
39 | inline const char* getCName() const { return this->objectName.c_str(); }; |
---|
40 | /** @returns the XML-Element with whicht this Object was loaded */ |
---|
41 | inline TiXmlNode* getXmlElem() const { return this->xmlElem; }; |
---|
42 | |
---|
43 | // /** @returns the className of the corresponding Object */ |
---|
44 | //inline const std::string& getClassName() const { return this->className; } |
---|
45 | /** @returns the className of the corresponding Object as a C-compliant string (const char*) */ |
---|
46 | inline const char* getClassCName() const { return _classes.front()._objectList->name().c_str(); }; |
---|
47 | /** @returns the ClassName of the Topmost Object of the ClassStack */ |
---|
48 | inline const std::string& getClassName() const { return _classes.front()._objectList->name(); }; |
---|
49 | |
---|
50 | inline const ClassID& getClassID() const { return _classes.front()._objectList->identity(); } |
---|
51 | /** @returns the ID of the Topmost object of the ClassStack */ |
---|
52 | inline const int& getLeafClassID() const { return _classes.front()._objectList->identity().id(); } |
---|
53 | |
---|
54 | bool isA(const ObjectListBase& objectList) const; |
---|
55 | bool isA(const ClassID& classID) const; |
---|
56 | bool isA(int classID) const; |
---|
57 | bool isA(const std::string& className) const; |
---|
58 | |
---|
59 | void listInheritance() const; |
---|
60 | |
---|
61 | /** @param classID comparer for a ClassID @returns true on match, false otherwise */ |
---|
62 | bool operator==(int classID) const { return this->isA(classID); }; |
---|
63 | /** @param objectName: the name to check. * @returns true on match, false otherwise. */ |
---|
64 | bool operator==(const std::string& objectName) const { return this->objectName == objectName;}; |
---|
65 | |
---|
66 | protected: |
---|
67 | template<class T> void registerObject(T* object, ObjectList<T>& list); |
---|
68 | |
---|
69 | protected: |
---|
70 | std::string objectName; //!< The name of this object |
---|
71 | |
---|
72 | private: |
---|
73 | |
---|
74 | TiXmlNode* xmlElem; //!< The XML Element with wich this Object was loaded(saved). |
---|
75 | |
---|
76 | ////////////////////////////// |
---|
77 | //// Type Definition Part //// |
---|
78 | ////////////////////////////// |
---|
79 | //! A ClassEntry so we can store Classes inside of Objects |
---|
80 | struct ClassEntry |
---|
81 | { |
---|
82 | /** Simple Constuctor @param objectList the ObjectList, @param iterator the (intrusive) Iterator inside of the ObjectList */ |
---|
83 | inline ClassEntry (ObjectListBase* objectList, ObjectListBase::IteratorBase* iterator) : _objectList(objectList), _iterator(iterator) {} |
---|
84 | ObjectListBase* _objectList; //!< A ObjectList this Object is part of |
---|
85 | ObjectListBase::IteratorBase* _iterator; //!< An iterator pointing to the position of the Object inside of the List. |
---|
86 | }; |
---|
87 | typedef std::list<ClassEntry> ClassList; //!< Type definition for the List. |
---|
88 | |
---|
89 | std::string className; //!< the name of the class |
---|
90 | ClassList _classes; //!< All Classes this object is part of. |
---|
91 | }; |
---|
92 | |
---|
93 | |
---|
94 | /** |
---|
95 | * @brief Registeres an Object of Type T to objectList |
---|
96 | * @param object The Object to append to the objectList. |
---|
97 | * @param objectList The ObjectList to append the Object to. |
---|
98 | * |
---|
99 | * This function is essential to integrate objects into their designated ObjectList. |
---|
100 | * Remember if you do not want objects to be stored in Lists (less overhead), |
---|
101 | * do not attempt to call this function. |
---|
102 | */ |
---|
103 | template<class T> |
---|
104 | inline void BaseObject::registerObject(T* object, ObjectList<T>& objectList) |
---|
105 | { |
---|
106 | this->_classes.push_front(ClassEntry(&objectList, objectList.registerObject(object))); |
---|
107 | } |
---|
108 | |
---|
109 | #endif /* __BASE_OBJECT_H_ */ |
---|