Changeset 9312 for code/branches/presentation2012merge/src

Timestamp:

Jul 8, 2012, 5:26:04 PM (12 years ago)

Author:

landauf

Message:

renamed some functions where enums are converted to/from strings for XMLPort to make it more obvious where the value is actually set and where it is only converted

Location:

code/branches/presentation2012merge/src/modules/pickup/items

Files:

• DronePickup.cc (modified) (1 diff)
• DronePickup.h (modified) (1 diff)
• HealthPickup.cc (modified) (7 diffs)
• HealthPickup.h (modified) (2 diffs)
• MetaPickup.cc (modified) (6 diffs)
• MetaPickup.h (modified) (3 diffs)

code/branches/presentation2012merge/src/modules/pickup/items/DronePickup.cc

@@ -106 +106 @@
         The name of the Template to e set.
     */
-    void DronePickup::setDroneTemplate(std::string templatename){
+    void DronePickup::setDroneTemplate(const std::string& templatename){
         droneTemplate_ = templatename;
     }

code/branches/presentation2012merge/src/modules/pickup/items/DronePickup.h

@@ -77 +77 @@
             void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
 
-            void setDroneTemplate(std::string templatename); //!< Set the droneTemplate.
+            void setDroneTemplate(const std::string& templatename); //!< Set the droneTemplate.
 
         private:

code/branches/presentation2012merge/src/modules/pickup/items/HealthPickup.cc

@@ -106 +106 @@
         XMLPortParam(HealthPickup, "health", setHealth, getHealth, xmlelement, mode);
         XMLPortParam(HealthPickup, "healthRate", setHealthRate, getHealthRate, xmlelement, mode);
-        XMLPortParam(HealthPickup, "healthType", setHealthType, getHealthType, xmlelement, mode);
+        XMLPortParam(HealthPickup, "healthType", setHealthTypeAsString, getHealthTypeAsString, xmlelement, mode);
 
         if(!this->isContinuous())
-            this->healthRate_ = 0.0f;
+            this->setHealthRate(0.0f); // TODO: this logic should be inside tick(), not in XMLPort
 
         this->initializeIdentifier();
@@ -139 +139 @@
             this->setHealth(this->getHealth()-health);
 
-            switch(this->getHealthTypeDirect())
+            switch(this->getHealthType())
             {
                 case pickupHealthType::permanent:
@@ -186 +186 @@
 
                 float health = 0.0f;
-                switch(this->getHealthTypeDirect())
+                switch(this->getHealthType())
                 {
                     case pickupHealthType::permanent:
@@ -215 +215 @@
         else
         {
-            if(this->getHealthTypeDirect() == pickupHealthType::temporary)
+            if(this->getHealthType() == pickupHealthType::temporary)
             {
                 PickupCarrier* carrier = this->getCarrier();
@@ -276 +276 @@
         pickup->setHealth(this->getHealth());
         pickup->setHealthRate(this->getHealthRate());
-        pickup->setHealthTypeDirect(this->getHealthTypeDirect());
+        pickup->setHealthType(this->getHealthType());
 
         pickup->initializeIdentifier();
@@ -287 +287 @@
         Returns the health type as a string.
     */
-    const std::string& HealthPickup::getHealthType(void) const
-    {
-        switch(this->getHealthTypeDirect())
+    const std::string& HealthPickup::getHealthTypeAsString(void) const
+    {
+        switch(this->getHealthType())
         {
             case pickupHealthType::limited:
@@ -340 +340 @@
         The type as a string.
     */
-    void HealthPickup::setHealthType(std::string type)
+    void HealthPickup::setHealthTypeAsString(const std::string& type)
     {
         if(type == HealthPickup::healthTypeLimited_s)
-            this->setHealthTypeDirect(pickupHealthType::limited);
+            this->setHealthType(pickupHealthType::limited);
         else if(type == HealthPickup::healthTypeTemporary_s)
-            this->setHealthTypeDirect(pickupHealthType::temporary);
+            this->setHealthType(pickupHealthType::temporary);
         else if(type == HealthPickup::healthTypePermanent_s)
-            this->setHealthTypeDirect(pickupHealthType::permanent);
+            this->setHealthType(pickupHealthType::permanent);
         else
             orxout(internal_error, context::pickups) << "Invalid healthType '" << type << "' in HealthPickup." << endl;

code/branches/presentation2012merge/src/modules/pickup/items/HealthPickup.h

@@ -116 +116 @@
             @return Returns the health type as an enum.
             */
-            inline pickupHealthType::Value getHealthTypeDirect(void) const
+            inline pickupHealthType::Value getHealthType(void) const
                 { return this->healthType_; }
-            const std::string& getHealthType(void) const; //!< Get the health type of this pickup.
+            const std::string& getHealthTypeAsString(void) const; //!< Get the health type of this pickup.
 
         protected:
@@ -130 +130 @@
             @param type The type of this pickup as an enum.
             */
-            inline void setHealthTypeDirect(pickupHealthType::Value type)
+            inline void setHealthType(pickupHealthType::Value type)
                 { this->healthType_ = type; }
-            void setHealthType(std::string type); //!< Set the type of the HealthPickup.
+            void setHealthTypeAsString(const std::string& type); //!< Set the type of the HealthPickup.
 
         private:

code/branches/presentation2012merge/src/modules/pickup/items/MetaPickup.cc

@@ -101 +101 @@
         SUPER(MetaPickup, XMLPort, xmlelement, mode);
 
-        XMLPortParam(MetaPickup, "metaType", setMetaType, getMetaType, xmlelement, mode);
+        XMLPortParam(MetaPickup, "metaType", setMetaTypeAsString, getMetaTypeAsString, xmlelement, mode);
 
         this->initializeIdentifier();
@@ -119 +119 @@
         {
             PickupCarrier* carrier = this->getCarrier();
-            if(this->getMetaTypeDirect() != pickupMetaType::none && carrier != NULL)
+            if(this->getMetaType() != pickupMetaType::none && carrier != NULL)
             {
                 // If the metaType is destroyCarrier, then the PickupCarrier is destroyed.
-                if(this->getMetaTypeDirect() == pickupMetaType::destroyCarrier)
+                if(this->getMetaType() == pickupMetaType::destroyCarrier)
                 {
                     Pawn* pawn = orxonox_cast<Pawn*>(carrier);
@@ -137 +137 @@
 
                     // If the metaType is use, then the Pickupable is set to used.
-                    if(this->getMetaTypeDirect() == pickupMetaType::use && !pickup->isUsed())
+                    if(this->getMetaType() == pickupMetaType::use && !pickup->isUsed())
                     {
                         pickup->setUsed(true);
                     }
                     // If the metaType is drop, then the Pickupable is dropped.
-                    else if(this->getMetaTypeDirect() == pickupMetaType::drop)
+                    else if(this->getMetaType() == pickupMetaType::drop)
                     {
                         pickup->drop();
                     }
                     // If the metaType is destroy, then the Pickupable is destroyed.
-                    else if(this->getMetaTypeDirect() == pickupMetaType::destroy)
+                    else if(this->getMetaType() == pickupMetaType::destroy)
                     {
                         pickup->Pickupable::destroy();
@@ -171 +171 @@
 
         MetaPickup* pickup = orxonox_cast<MetaPickup*>(item);
-        pickup->setMetaTypeDirect(this->getMetaTypeDirect());
+        pickup->setMetaType(this->getMetaType());
 
         pickup->initializeIdentifier();
@@ -182 +182 @@
         Returns a string with the meta type of the MetaPickup.
     */
-    const std::string& MetaPickup::getMetaType(void) const
-    {
-        switch(this->getMetaTypeDirect())
+    const std::string& MetaPickup::getMetaTypeAsString(void) const
+    {
+        switch(this->getMetaType())
         {
             case pickupMetaType::none:
@@ -207 +207 @@
         A string with the type to be set.
     */
-    void MetaPickup::setMetaType(const std::string& type)
+    void MetaPickup::setMetaTypeAsString(const std::string& type)
     {
         if(type == MetaPickup::metaTypeNone_s)
         {
-            this->setMetaTypeDirect(pickupMetaType::none);
+            this->setMetaType(pickupMetaType::none);
         }
         else if(type == MetaPickup::metaTypeUse_s)
         {
-            this->setMetaTypeDirect(pickupMetaType::use);
+            this->setMetaType(pickupMetaType::use);
         }
         else if(type == MetaPickup::metaTypeDrop_s)
         {
-            this->setMetaTypeDirect(pickupMetaType::drop);
+            this->setMetaType(pickupMetaType::drop);
         }
         else if(type == MetaPickup::metaTypeDestroy_s)
         {
-            this->setMetaTypeDirect(pickupMetaType::destroy);
+            this->setMetaType(pickupMetaType::destroy);
         }
         else if(type == MetaPickup::metaTypeDestroyCarrier_s)
         {
-            this->setMetaTypeDirect(pickupMetaType::destroyCarrier);
+            this->setMetaType(pickupMetaType::destroyCarrier);
         }
         else

code/branches/presentation2012merge/src/modules/pickup/items/MetaPickup.h

@@ -69 +69 @@
 
         The default value is <em>none</em>, which basically does nothing.
-        
+
         The parameter <b>activation type</b> can be used to specify, whether the MetaPickup is used upon pickup (<em>immediate</em>) or not (<em>onUse</em>). With <em>immediate</em> being the default.
 
@@ -101 +101 @@
             @return Returns an enum with the meta type of the MetaPickup.
             */
-            inline pickupMetaType::Value getMetaTypeDirect(void) const
+            inline pickupMetaType::Value getMetaType(void) const
                 { return this->metaType_; }
-            const std::string& getMetaType(void) const; //!< Get the meta type of this MetaPickup.
+            const std::string& getMetaTypeAsString(void) const; //!< Get the meta type of this MetaPickup.
 
         protected:
@@ -112 +112 @@
             @param type The meta type as an enum.
             */
-            inline void setMetaTypeDirect(pickupMetaType::Value type)
+            inline void setMetaType(pickupMetaType::Value type)
                 { this->metaType_ =  type; }
-            void setMetaType(const std::string& type); //!< Set the meta type of this MetaPickup.
+            void setMetaTypeAsString(const std::string& type); //!< Set the meta type of this MetaPickup.
 
         private: