Changeset 7494 for code/trunk/src/orxonox/pickup

Timestamp:

Sep 28, 2010, 5:31:59 PM (14 years ago)

Author:

dafrick

Message:

Some documenting and cleaning up/re-organization in pickups module.

Location:

code/trunk/src/orxonox/pickup

Files:

• PickupIdentifier.cc (modified) (3 diffs)
• PickupIdentifier.h (modified) (3 diffs)

code/trunk/src/orxonox/pickup/PickupIdentifier.cc

@@ -35 +35 @@
 
 #include "core/CoreIncludes.h"
+#include "core/Identifier.h"
+
 #include "interfaces/Pickupable.h"
 
@@ -69 +71 @@
     int PickupIdentifier::compare(const PickupIdentifier* identifier) const
     {
-        if(identifier == NULL)
-        {
-            return 1;
-            COUT(1) << "Error in PickupIdentifier::compare: Input Identifier is NULL." << std::endl;
-        }
+        assert(identifier);
+        assert(identifier->pickup_);
+        assert(this->pickup_);
 
-        if(identifier->pickup_ == NULL && this->pickup_ == NULL)
-        {
-            return 0;
-            COUT(1) << "Error in PickupIdentifier::compare: Pickup stored by Identifier is NULL." << std::endl;
-        }
-
-        if(identifier->pickup_ == NULL)
-        {
-            return 1;
-            COUT(1) << "Error in PickupIdentifier::compare: Pickup stored by Identifier is NULL." << std::endl;
-        }
-
-        if(this->pickup_ == NULL)
-        {
-            return -1;
-            COUT(1) << "Error in PickupIdentifier::compare: Pickup stored by Identifier is NULL." << std::endl;
-        }
-
-        //! If the classIdentifiers are not the same (meaning the PickupIdentifiers identify different classes), the obviously the two Pickupables identified by the PickupIdentifiers cannot be the same. An ordering is established through the alphabetical ordering of the respective classnames.
+        // If the classIdentifiers are not the same (meaning the PickupIdentifiers identify different classes), the obviously the two Pickupables identified by the PickupIdentifiers cannot be the same. An ordering is established through the alphabetical ordering of the respective classnames.
         if(!identifier->pickup_->getIdentifier()->isExactlyA(this->pickup_->getIdentifier()))
             return this->pickup_->getIdentifier()->getName().compare(identifier->pickup_->getIdentifier()->getName());
 
-        //! If the class is the same for both PickupIdentifiers we go on to check the parameters of the class.
-        //! If the two have a different number of parameters then obviusly something is very wrong.
+        // If the class is the same for both PickupIdentifiers we go on to check the parameters of the class.
+        // If the two have a different number of parameters then obviously something is very wrong.
         if(!(this->parameters_.size() == identifier->parameters_.size()))
         {
@@ -105 +87 @@
         }
 
-        //! We iterate through all parameters and compare their values (which are strings). The first parameter is the most significant. The ordering is once again established by the alphabetical comparison of the two value strings.
+        // We iterate through all parameters and compare their values (which are strings). The first parameter is the most significant. The ordering is once again established by the alphabetical comparison of the two value strings.
         for(std::map<std::string, std::string>::const_iterator it = this->parameters_.begin(); it != this->parameters_.end(); it++)
         {
-            //!< If a parameter present in one of the identifiers is not found in the other, once again, something is very wrong.
+            // If a parameter present in one of the identifiers is not found in the other, once again, something is very wrong.
             if(identifier->parameters_.find(it->first) == identifier->parameters_.end())
             {

code/trunk/src/orxonox/pickup/PickupIdentifier.h

@@ -40 +40 @@
 #include <map>
 #include <string>
-#include "core/Identifier.h"
 
 #include "core/OrxonoxClass.h"
@@ -49 +48 @@
     /**
     @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).
+        The purpose of the PickupIdentifier class is to identify (or differentiate between) different types of pickups although 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 @ref orxonox::HealthPickup "HealthPickup" class that encompasses a wide variety of different types of health pickups, e.g a @ref orxonox::HealthPickup "HealthPickup" that adds 10 health every second for 10 seconds or a @ref orxonox::HealthPickup "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 @ref orxonox::PickupIdentifier "PickupIdentifiers" (and since all @ref orxonox::Pickupable "Pickupables" have an identifier, we can use it to compare pickups). It als provides functionality to add parameters that distinguish between different types of pickups in the same pickup class.
+
+        Lastly a struct (@ref orxonox::PickupIdentifierCompare "PickupIdentifierCompare") is provided that can be used in stl containers to establish a strictly lesser ordering between @ref orxonox::PickupIdentifier "PickupIdentifiers" (and thus @ref orxonox::Pickupable "Pickupables").
     @author
         Damian 'Mozork' Frick
@@ -75 +79 @@
     /**
     @brief
-        Struct that overloads the compare operation between two PickupIdentifier pointers.
+        Struct that overloads the compare operation between two @ref orxonox::PickupIdentifier "PickupIdentifier" pointers.
     */
     struct PickupIdentifierCompare