Changeset 6475 for code/branches/pickup3/src/orxonox/pickup/PickupIdentifier.h

Timestamp:

Mar 5, 2010, 6:26:54 PM (14 years ago)

Author:

dafrick

Message:

Additional documentation, code niceifying and potential bug fixing. Also: Renamed DroppedItem to DroppedPickup.

File:

• code/branches/pickup3/src/orxonox/pickup/PickupIdentifier.h (modified) (1 diff)

code/branches/pickup3/src/orxonox/pickup/PickupIdentifier.h

@@ -32 +32 @@
 #include "OrxonoxPrereqs.h"
 
-#include "core/OrxonoxClass.h" 
-#include "core/Identifier.h"
 #include <map>
 #include <string>
+#include "core/Identifier.h"
+
+#include "core/OrxonoxClass.h" 
 
 namespace orxonox
 {
     
+    /**
+    @brief
+        The purpose of the PickupIdentifier class is to identify different types of pickups allthough they are of the same class.
+        This allows for more generic classes (or pickups in this case) that can be a number of different pickup types and can be identified as such without the need for a lot of different classes. An example is the HealthPickup class that encompasses a wide variety of different types of health pickups, e.g a HealthPickup that adds 10 health every second for 10 seconds or a HealthPickup that adds 100 health as soon as it is picked up, a.s.o.
+        To that purpose this class provides functionality to compare two PickupIdentifier (and since all Pickupables have an Identifier through that Pickupables can be compared). It als provides functionality to add parameters that distinguish between different types of pickups in the same pickup class.
+        Lastly a struct is provided that can be used in stl containers to establish a strictly lesser ordering between PickupIdentifiers (and thus Pickupables).
+    @author
+        Damian 'Mozork' Frick
+    */
     class _OrxonoxExport PickupIdentifier : virtual public OrxonoxClass
     {
         
         public:
-            PickupIdentifier(void);
-            ~PickupIdentifier();
+            PickupIdentifier(void); //!< Constructor.
+            ~PickupIdentifier(); //!< Destructor.
             
-            virtual int compare(const PickupIdentifier& identifier) const;
+            virtual int compare(const PickupIdentifier* identifier) const; //!< Compares two PickupIdentifiers and returns 0 if a == b, <0 if a < b and >0 if a > b for a.compare(b).
             
-            void addClass(Identifier* identifier);
-            bool addParameter(std::string & name, std::string & value);
+            void addClass(Identifier* identifier); //!< Add the class of the Pickupable to its PickupIdentifier.
+            bool addParameter(std::string & name, std::string & value); //!< Add a parameter to the PickupIdentifier.
             
         private:
-            Identifier* classIdentifier_;
-            std::map<std::string, std::string> parameters_;
-            
+            Identifier* classIdentifier_; //!< The Identifier of the class.
+            std::map<std::string, std::string> parameters_; //!< The parameters identifying the type of the pickup beyond the class.
             
     };
     
-    //TODO: Needed?
+    /**
+    @brief
+        Struct that overloads the compare operation between two PickupIdentifier pointers.
+    */
     struct PickupIdentifierCompare
     {
-        bool operator() (const PickupIdentifier& lhs, const PickupIdentifier& rhs) const
-            { return lhs.compare(rhs) < 0; }
-    };
-    
-    struct PickupIdentifierPtrCompare
-    {
         bool operator() (const PickupIdentifier* lhs, const PickupIdentifier* rhs) const
-            { return lhs->compare(*rhs) < 0; }
+            { return lhs->compare(rhs) < 0; }
     };