Changeset 10998

Timestamp:

Dec 30, 2015, 1:59:38 PM (9 years ago)

Author:

landauf

Message:

using strongly typed enum class in pickups and triggers.

Location:

code/branches/cpp11_v2/src/modules

Files:

• objects/triggers/DistanceMultiTrigger.cc (modified) (8 diffs)
• objects/triggers/DistanceMultiTrigger.h (modified) (3 diffs)
• objects/triggers/DistanceTrigger.cc (modified) (8 diffs)
• objects/triggers/DistanceTrigger.h (modified) (4 diffs)
• objects/triggers/EventTrigger.cc (modified) (1 diff)
• objects/triggers/EventTrigger.h (modified) (1 diff)
• objects/triggers/Trigger.cc (modified) (1 diff)
• objects/triggers/Trigger.h (modified) (1 diff)
• objects/triggers/TriggerBase.h (modified) (4 diffs)
• pickup/Pickup.cc (modified) (5 diffs)
• pickup/Pickup.h (modified) (11 diffs)
• pickup/items/DronePickup.cc (modified) (1 diff)
• pickup/items/HealthPickup.cc (modified) (6 diffs)
• pickup/items/HealthPickup.h (modified) (4 diffs)
• pickup/items/MetaPickup.cc (modified) (5 diffs)
• pickup/items/MetaPickup.h (modified) (4 diffs)

code/branches/cpp11_v2/src/modules/objects/triggers/DistanceMultiTrigger.cc

@@ -58 +58 @@
 
         this->distance_ = 100.0f;
-        this->setBeaconModeDirect(distanceMultiTriggerBeaconMode::off);
+        this->setBeaconModeDirect(DistanceMultiTriggerBeaconMode::off);
         this->targetName_ = "";
         this->beaconMask_.exclude(Class(BaseObject));
@@ -136 +136 @@
         ClassTreeMask targetMask = this->getTargetMask();
         // If we are in identify-mode another target mask has to be applies to find the DistanceTriggerBeacons.
-        if(this->beaconMode_ == distanceMultiTriggerBeaconMode::identify)
+        if(this->beaconMode_ == DistanceMultiTriggerBeaconMode::identify)
             targetMask = this->beaconMask_;
 
@@ -145 +145 @@
 
             // If the DistanceMultiTrigger is in identify-mode and the DistanceTriggerBeacon attached to the object has the wrong name we ignore it.
-            if(this->beaconMode_ == distanceMultiTriggerBeaconMode::identify)
+            if(this->beaconMode_ == DistanceMultiTriggerBeaconMode::identify)
             {
                 if(entity->getName() != this->targetName_)
@@ -155 +155 @@
             
             // If the DistanceMultiTrigger is in exclude mode and the DistanceTriggerBeacon attached to the object has the right name, we ignore it.
-            if(this->beaconMode_ == distanceMultiTriggerBeaconMode::exclude)
+            if(this->beaconMode_ == DistanceMultiTriggerBeaconMode::exclude)
             {
                 
@@ -182 +182 @@
 
                 // Change the entity to the parent of the DistanceTriggerBeacon (if in identify-mode), which is the entity to which the beacon is attached.
-                if(this->beaconMode_ == distanceMultiTriggerBeaconMode::identify)
+                if(this->beaconMode_ == DistanceMultiTriggerBeaconMode::identify)
                     entity = entity->getParent();
 
@@ -206 +206 @@
         The mode as an enum.
     */
-    void DistanceMultiTrigger::setBeaconModeDirect(distanceMultiTriggerBeaconMode::Value mode)
+    void DistanceMultiTrigger::setBeaconModeDirect(DistanceMultiTriggerBeaconMode mode)
     {
         this->beaconMode_ = mode;
@@ -221 +221 @@
         switch(this->getBeaconModeDirect())
         {
-            case distanceMultiTriggerBeaconMode::off :
+            case DistanceMultiTriggerBeaconMode::off :
                 return DistanceMultiTrigger::beaconModeOff_s;
-            case distanceMultiTriggerBeaconMode::identify:
+            case DistanceMultiTriggerBeaconMode::identify:
                 return DistanceMultiTrigger::beaconModeIdentify_s;
-            case distanceMultiTriggerBeaconMode::exclude:
+            case DistanceMultiTriggerBeaconMode::exclude:
                 return DistanceMultiTrigger::beaconModeExlcude_s;
             default :
@@ -242 +242 @@
     {
         if(mode == DistanceMultiTrigger::beaconModeOff_s)
-            this->setBeaconModeDirect(distanceMultiTriggerBeaconMode::off);
+            this->setBeaconModeDirect(DistanceMultiTriggerBeaconMode::off);
         else if(mode == DistanceMultiTrigger::beaconModeIdentify_s)
-            this->setBeaconModeDirect(distanceMultiTriggerBeaconMode::identify);
+            this->setBeaconModeDirect(DistanceMultiTriggerBeaconMode::identify);
         else if(mode == DistanceMultiTrigger::beaconModeExlcude_s)
-            this->setBeaconModeDirect(distanceMultiTriggerBeaconMode::exclude);
+            this->setBeaconModeDirect(DistanceMultiTriggerBeaconMode::exclude);
         else
             orxout(internal_error, context::triggers) << "Invalid beacon mode in DistanceMultiTrigger." << endl;

code/branches/cpp11_v2/src/modules/objects/triggers/DistanceMultiTrigger.h

@@ -55 +55 @@
     @ingroup MultiTrigger
     */
-    namespace distanceMultiTriggerBeaconMode
-    {
-        enum Value {
-            off, //!< The DistanceMultiTrigger is not in <em>beacon-mode</em>.
-            identify, //!< The DistanceTrigger is in <em>identify-mode</em>.
-            exclude //!< The DistanceTrigger is in <em>exclude-mode</em>.
-        };
-    }
+    enum class DistanceMultiTriggerBeaconMode {
+        off, //!< The DistanceMultiTrigger is not in <em>beacon-mode</em>.
+        identify, //!< The DistanceTrigger is in <em>identify-mode</em>.
+        exclude //!< The DistanceTrigger is in <em>exclude-mode</em>.
+    };
 
     /**
@@ -113 +110 @@
                 { return this->distance_; }
             
-            void setBeaconModeDirect(distanceMultiTriggerBeaconMode::Value mode); // Set the beacon mode.
+            void setBeaconModeDirect(DistanceMultiTriggerBeaconMode mode); // Set the beacon mode.
             /**
             @brief Get the beacon mode.
             @return Returns the mode as an enum.
             */
-            inline distanceMultiTriggerBeaconMode::Value getBeaconModeDirect(void) const
+            inline DistanceMultiTriggerBeaconMode getBeaconModeDirect(void) const
                 { return this->beaconMode_; }
             void setBeaconMode(const std::string& mode); // Set the beacon mode.
@@ -149 +146 @@
             float distance_; //!< The distance at which the DistanceMultiTrigger triggers.
 
-            distanceMultiTriggerBeaconMode::Value beaconMode_; //!< The beacon mode, the DistanceMultiTrigger is in.
+            DistanceMultiTriggerBeaconMode beaconMode_; //!< The beacon mode, the DistanceMultiTrigger is in.
             std::string targetName_; //!< The target name, used in <em>single-target</em> mode.
             ClassTreeMask beaconMask_; //!< A mask, that only accepts DistanceTriggerBeacons.

code/branches/cpp11_v2/src/modules/objects/triggers/DistanceTrigger.cc

@@ -158 +158 @@
         ClassTreeMask targetMask = this->targetMask_;
         // If we are in identify-mode another target mask has to be applies to find the DistanceTriggerBeacons.
-        if(this->beaconMode_ == distanceTriggerBeaconMode::identify)
+        if(this->beaconMode_ == DistanceTriggerBeaconMode::identify)
             targetMask = this->beaconMask_;
 
@@ -167 +167 @@
 
             // If the DistanceTrigger is in identify-mode and the DistanceTriggerBeacon attached to the object has the wrong name we ignore it.
-            if(this->beaconMode_ == distanceTriggerBeaconMode::identify)
+            if(this->beaconMode_ == DistanceTriggerBeaconMode::identify)
             {
                 if(entity->getName() != this->targetName_)
@@ -177 +177 @@
 
             // If the DistanceTrigger is in exclude mode and the DistanceTriggerBeacon attached to the object has the right name, we ignore it.
-            if(this->beaconMode_ == distanceTriggerBeaconMode::exclude)
+            if(this->beaconMode_ == DistanceTriggerBeaconMode::exclude)
             {
 
@@ -202 +202 @@
                 {
                     // Change the entity to the parent of the DistanceTriggerBeacon (if in identify-mode), which is the entity to which the beacon is attached.
-                    if(this->beaconMode_ == distanceTriggerBeaconMode::identify)
+                    if(this->beaconMode_ == DistanceTriggerBeaconMode::identify)
                         entity = entity->getParent();
 
@@ -228 +228 @@
         The mode as an enum.
     */
-    void DistanceTrigger::setBeaconModeDirect(distanceTriggerBeaconMode::Value mode)
+    void DistanceTrigger::setBeaconModeDirect(DistanceTriggerBeaconMode mode)
     {
         this->beaconMode_ = mode;
@@ -243 +243 @@
         switch(this->getBeaconModeDirect())
         {
-            case distanceTriggerBeaconMode::off :
+            case DistanceTriggerBeaconMode::off :
                 return DistanceTrigger::beaconModeOff_s;
-            case distanceTriggerBeaconMode::identify:
+            case DistanceTriggerBeaconMode::identify:
                 return DistanceTrigger::beaconModeIdentify_s;
-            case distanceTriggerBeaconMode::exclude:
+            case DistanceTriggerBeaconMode::exclude:
                 return DistanceTrigger::beaconModeExlcude_s;
             default :
@@ -264 +264 @@
     {
         if(mode == DistanceTrigger::beaconModeOff_s)
-            this->setBeaconModeDirect(distanceTriggerBeaconMode::off);
+            this->setBeaconModeDirect(DistanceTriggerBeaconMode::off);
         else if(mode == DistanceTrigger::beaconModeIdentify_s)
-            this->setBeaconModeDirect(distanceTriggerBeaconMode::identify);
+            this->setBeaconModeDirect(DistanceTriggerBeaconMode::identify);
         else if(mode == DistanceTrigger::beaconModeExlcude_s)
-            this->setBeaconModeDirect(distanceTriggerBeaconMode::exclude);
+            this->setBeaconModeDirect(DistanceTriggerBeaconMode::exclude);
         else
             orxout(internal_error, context::triggers) << "Invalid beacon mode in DistanceTrigger." << endl;
@@ -282 +282 @@
         Returns true if it is triggered ,false if not.
     */
-    bool DistanceTrigger::isTriggered(TriggerMode::Value mode)
+    bool DistanceTrigger::isTriggered(TriggerMode mode)
     {
         if (Trigger::isTriggered(mode))

code/branches/cpp11_v2/src/modules/objects/triggers/DistanceTrigger.h

@@ -55 +55 @@
   @ingroup NormalTrigger
   */
-  namespace distanceTriggerBeaconMode
-  {
-      enum Value {
-          off,
-          identify,
-          exclude
-      };
-  }
+  enum class DistanceTriggerBeaconMode {
+      off,
+      identify,
+      exclude
+  };
 
     /**
@@ -118 +115 @@
                 { return this->distance_; }
 
-            void setBeaconModeDirect(distanceTriggerBeaconMode::Value mode); // Set the beacon mode.
+            void setBeaconModeDirect(DistanceTriggerBeaconMode mode); // Set the beacon mode.
             /**
             @brief Get the beacon mode.
             @return Returns the mode as an enum.
             */
-            inline distanceTriggerBeaconMode::Value getBeaconModeDirect(void) const
+            inline DistanceTriggerBeaconMode getBeaconModeDirect(void) const
             { return this->beaconMode_; }
             void setBeaconMode(const std::string& mode); // Set the beacon mode.
@@ -144 +141 @@
 
         protected:
-            virtual bool isTriggered(TriggerMode::Value mode); // Check whether the DistanceTrigger is triggered.
+            virtual bool isTriggered(TriggerMode mode) override; // Check whether the DistanceTrigger is triggered.
             /**
             @brief Notifies interested parties about a change of the DistanceTrigger's target mask.
@@ -160 +157 @@
             float distance_; //!< The range of the DistanceTrigger.
             
-            distanceTriggerBeaconMode::Value beaconMode_; //!< The beacon mode.
+            DistanceTriggerBeaconMode beaconMode_; //!< The beacon mode.
             std::string targetName_; //!< The name a DistanceTriggerBeacon needs to have to make the DistanceTrigger react to it if in beacon-mode.
             ClassTreeMask beaconMask_; //!< A mask, that only accepts DistanceTriggerBeacons.

code/branches/cpp11_v2/src/modules/objects/triggers/EventTrigger.cc

@@ -79 +79 @@
         It should be triggered if it is triggered according just to its sub-triggers and if the last event that came in was an event that changed from not triggered to triggered.
     */
-    bool EventTrigger::isTriggered(TriggerMode::Value mode)
+    bool EventTrigger::isTriggered(TriggerMode mode)
     {
         if (Trigger::isTriggered(mode))

code/branches/cpp11_v2/src/modules/objects/triggers/EventTrigger.h

@@ -84 +84 @@
 
         protected:
-            virtual bool isTriggered(TriggerMode::Value mode); // Check whether the EventTrigger should be triggered.
+            virtual bool isTriggered(TriggerMode mode) override; // Check whether the EventTrigger should be triggered.
 
         private:

code/branches/cpp11_v2/src/modules/objects/triggers/Trigger.cc

@@ -203 +203 @@
         Returns true if the Trigger should be triggered and false if not.
     */
-    bool Trigger::isTriggered(TriggerMode::Value mode)
+    bool Trigger::isTriggered(TriggerMode mode)
     {
         // If the trigger has sub-triggers.

code/branches/cpp11_v2/src/modules/objects/triggers/Trigger.h

@@ -105 +105 @@
             inline bool isTriggered()
                 { return this->isTriggered(this->mode_); }
-            virtual bool isTriggered(TriggerMode::Value mode); // Check whether the Trigger should be triggered, given only its sub-triggers, given a specific mode.
+            virtual bool isTriggered(TriggerMode mode); // Check whether the Trigger should be triggered, given only its sub-triggers, given a specific mode.
             virtual void triggered(bool bIsTriggered); // Fires an event with the input triggered state.
 

code/branches/cpp11_v2/src/modules/objects/triggers/TriggerBase.h

@@ -52 +52 @@
     @ingroup Triggers
     */
-    namespace TriggerMode
+    enum class TriggerMode
     {
-        enum Value
-        {
-            EventTriggerAND, //!< The <em>and</em> mode. The trigger can only trigger if all the children are active. 
-            EventTriggerOR, //!< The <em>or</em> mode. The trigger can only trigger if at least one child is active.
-            EventTriggerXOR, //!< The <em>xor</em> mode. The trigger can only trigger if exactly one child is active. 
-        };
-    }
+        EventTriggerAND, //!< The <em>and</em> mode. The trigger can only trigger if all the children are active.
+        EventTriggerOR, //!< The <em>or</em> mode. The trigger can only trigger if at least one child is active.
+        EventTriggerXOR, //!< The <em>xor</em> mode. The trigger can only trigger if exactly one child is active.
+    };
 
     /**
@@ -158 +155 @@
             @param mode The mode of the trigger.
             */
-            inline void setMode(TriggerMode::Value mode) //!< Get the mode of the trigger.
+            inline void setMode(TriggerMode mode) //!< Get the mode of the trigger.
                 { this->mode_ = mode; }
             const std::string& getModeString(void) const;
@@ -165 +162 @@
             @return Returns and Enum for the mode of the trigger.
             */
-            inline TriggerMode::Value getMode(void) const
+            inline TriggerMode getMode(void) const
                 { return mode_; }
 
@@ -211 +208 @@
 
             bool bInvertMode_; //!< Bool for the invert-mode, if true the trigger is inverted.
-            TriggerMode::Value mode_; //!< The mode of the trigger.
+            TriggerMode mode_; //!< The mode of the trigger.
 
             TriggerBase* parent_; //!< The parent of this trigger.

code/branches/cpp11_v2/src/modules/pickup/Pickup.cc

@@ -78 +78 @@
     void Pickup::initialize(void)
     {
-        this->activationType_ = pickupActivationType::immediate;
-        this->durationType_ = pickupDurationType::once;
+        this->activationType_ = PickupActivationType::immediate;
+        this->durationType_ = PickupDurationType::once;
     }
 
@@ -105 +105 @@
         switch(this->getActivationType())
         {
-            case pickupActivationType::immediate:
+            case PickupActivationType::immediate:
                 return activationTypeImmediate_s;
-            case pickupActivationType::onUse:
+            case PickupActivationType::onUse:
                 return activationTypeOnUse_s;
             default:
@@ -124 +124 @@
         switch(this->getDurationType())
         {
-            case pickupDurationType::once:
+            case PickupDurationType::once:
                 return durationTypeOnce_s;
-            case pickupDurationType::continuous:
+            case PickupDurationType::continuous:
                 return durationTypeContinuous_s;
             default:
@@ -142 +142 @@
     {
         if(type == Pickup::activationTypeImmediate_s)
-            this->setActivationType(pickupActivationType::immediate);
+            this->setActivationType(PickupActivationType::immediate);
         else if(type == Pickup::activationTypeOnUse_s)
-            this->setActivationType(pickupActivationType::onUse);
+            this->setActivationType(PickupActivationType::onUse);
         else
             orxout(internal_error, context::pickups) << "Invalid activationType '" << type << "' in " << this->getIdentifier()->getName() << "." << endl;
@@ -158 +158 @@
     {
         if(type == Pickup::durationTypeOnce_s)
-            this->setDurationType(pickupDurationType::once);
+            this->setDurationType(PickupDurationType::once);
         else if(type == Pickup::durationTypeContinuous_s)
-            this->setDurationType(pickupDurationType::continuous);
+            this->setDurationType(PickupDurationType::continuous);
         else
             orxout(internal_error, context::pickups) << "Invalid durationType '" << type << "' in " << this->getIdentifier()->getName() << "." << endl;

code/branches/cpp11_v2/src/modules/pickup/Pickup.h

@@ -53 +53 @@
     @ingroup Pickup
     */
-    namespace pickupActivationType
+    enum class PickupActivationType
     {
-        enum Value
-        {
-            immediate, //!< Means that the @ref orxonox::Pickup "Pickup" will be used immediately after pickup.
-            onUse, //!< Means that the @ref orxonox::Pickup "Pickup" will be used at a later point trough some external influence.
-        };
-    }
+        immediate, //!< Means that the @ref orxonox::Pickup "Pickup" will be used immediately after pickup.
+        onUse, //!< Means that the @ref orxonox::Pickup "Pickup" will be used at a later point trough some external influence.
+    };
 
     /**
@@ -68 +65 @@
     @ingroup Pickup
     */
-    namespace pickupDurationType
+    enum class PickupDurationType
     {
-        enum Value
-        {
-            once, //!< Means that the @ref orxonox::Pickup "Pickup" will be used only once at a singular time instant.
-            continuous, //!< Means that the @ref orxonox::Pickup "Pickup" will be used over a continuous timespan.
-        };
-    }
+        once, //!< Means that the @ref orxonox::Pickup "Pickup" will be used only once at a singular time instant.
+        continuous, //!< Means that the @ref orxonox::Pickup "Pickup" will be used over a continuous timespan.
+    };
 
     /**
@@ -112 +106 @@
             @return Returns the activation type of the Pickup.
             */
-            inline pickupActivationType::Value getActivationType(void) const
+            inline PickupActivationType getActivationType(void) const
                 { return this->activationType_; }
             /**
@@ -118 +112 @@
             @return Returns the duration type of the Pickup.
             */
-            inline pickupDurationType::Value getDurationType(void) const
+            inline PickupDurationType getDurationType(void) const
                 { return this->durationType_; }
 
@@ -129 +123 @@
             */
             inline bool isImmediate(void) const
-                { return this->getActivationType() == pickupActivationType::immediate; }
+                { return this->getActivationType() == PickupActivationType::immediate; }
             /**
             @brief Get whether the activation type is 'onUse'.
@@ -135 +129 @@
             */
             inline bool isOnUse(void) const
-                { return this->getActivationType() == pickupActivationType::onUse; }
+                { return this->getActivationType() == PickupActivationType::onUse; }
             /**
             @brief Get whether the duration type is 'once'.
@@ -141 +135 @@
             */
             inline bool isOnce(void) const
-                { return this->getDurationType() == pickupDurationType::once; }
+                { return this->getDurationType() == PickupDurationType::once; }
             /**
             @brief Get whether the duration type is 'continuous'.
@@ -147 +141 @@
             */
             inline bool isContinuous(void) const
-                { return this->getDurationType() == pickupDurationType::continuous; }
+                { return this->getDurationType() == PickupDurationType::continuous; }
 
             virtual void changedPickedUp(void) override; //!< Should be called when the pickup has transited from picked up to dropped or the other way around.
@@ -164 +158 @@
             @param type The activation type of the Pickup.
             */
-            inline void setActivationType(pickupActivationType::Value type)
+            inline void setActivationType(PickupActivationType type)
                 { this->activationType_ = type; }
             /**
@@ -170 +164 @@
             @param type The duration type of the Pickup.
             */
-            inline void setDurationType(pickupDurationType::Value type)
+            inline void setDurationType(PickupDurationType type)
                 { this->durationType_ = type; }
 
@@ -180 +174 @@
 
             std::string representationName_; //!< The name of the associated PickupRepresentation.
-            pickupActivationType::Value activationType_; //!< The activation type of the Pickup.
-            pickupDurationType::Value durationType_; //!< The duration type of the Pickup.
+            PickupActivationType activationType_; //!< The activation type of the Pickup.
+            PickupDurationType durationType_; //!< The duration type of the Pickup.
 
             //! Strings for the activation and duration types.

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

@@ -74 +74 @@
     {
         this->addTarget(ClassIdentifier<Pawn>::getIdentifier());
-        this->setDurationType(pickupDurationType::once);
+        this->setDurationType(PickupDurationType::once);
         this->droneTemplate_ = "";
     }

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

@@ -77 +77 @@
         this->health_ = 0.0f;
         this->healthRate_ = 0.0f;
-        this->healthType_ = pickupHealthType::limited;
+        this->healthType_ = PickupHealthType::limited;
         this->maxHealthSave_ = 0.0f;
         this->maxHealthOverwrite_ = 0.0f;
@@ -127 +127 @@
             switch(this->getHealthType())
             {
-                case pickupHealthType::permanent:
+                case PickupHealthType::permanent:
                     if(pawn->getMaxHealth() < fullHealth)
                         pawn->setMaxHealth(fullHealth);
-                case pickupHealthType::limited:
+                case PickupHealthType::limited:
                     pawn->addHealth(health);
                     break;
-                case pickupHealthType::temporary:
+                case PickupHealthType::temporary:
                     if(pawn->getMaxHealth() > fullHealth)
                     {
@@ -174 +174 @@
                 switch(this->getHealthType())
                 {
-                    case pickupHealthType::permanent:
+                    case PickupHealthType::permanent:
                         health = pawn->getHealth()+this->getHealth();
                         if(pawn->getMaxHealth() < health)
                             pawn->setMaxHealth(health);
-                    case pickupHealthType::limited:
+                    case PickupHealthType::limited:
                         pawn->addHealth(this->getHealth());
                         break;
-                    case pickupHealthType::temporary:
+                    case PickupHealthType::temporary:
                         health = pawn->getHealth()+this->getHealth();
                         if(pawn->getMaxHealth() < health)
@@ -201 +201 @@
         else
         {
-            if(this->getHealthType() == pickupHealthType::temporary)
+            if(this->getHealthType() == PickupHealthType::temporary)
             {
                 PickupCarrier* carrier = this->getCarrier();
@@ -256 +256 @@
         switch(this->getHealthType())
         {
-            case pickupHealthType::limited:
+            case PickupHealthType::limited:
                 return HealthPickup::healthTypeLimited_s;
-            case pickupHealthType::temporary:
+            case PickupHealthType::temporary:
                 return HealthPickup::healthTypeTemporary_s;
-            case pickupHealthType::permanent:
+            case PickupHealthType::permanent:
                 return HealthPickup::healthTypePermanent_s;
             default:
@@ -308 +308 @@
     {
         if(type == HealthPickup::healthTypeLimited_s)
-            this->setHealthType(pickupHealthType::limited);
+            this->setHealthType(PickupHealthType::limited);
         else if(type == HealthPickup::healthTypeTemporary_s)
-            this->setHealthType(pickupHealthType::temporary);
+            this->setHealthType(PickupHealthType::temporary);
         else if(type == HealthPickup::healthTypePermanent_s)
-            this->setHealthType(pickupHealthType::permanent);
+            this->setHealthType(PickupHealthType::permanent);
         else
             orxout(internal_error, context::pickups) << "Invalid healthType '" << type << "' in HealthPickup." << endl;

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

@@ -51 +51 @@
     @ingroup PickupItems
     */
-    namespace pickupHealthType
+    enum class PickupHealthType
     {
-        enum Value
-        {
-            limited, //!< Means that the @ref orxonox::HealthPickup "HealthPickup" only increases the users health to its maximum health.
-            temporary, //!< Means that the @ref orxonox::HealthPickup "HealthPickup" temporarily increases the users health even above its maximum health, but only as long as it is in use.
-            permanent //!< Means that the @ref orxonox::HealthPickup "HealthPickup" increases the users health even above its maximum health and increases the maximum health permanently such that it matches the new health.
-        };
-    }
+        limited, //!< Means that the @ref orxonox::HealthPickup "HealthPickup" only increases the users health to its maximum health.
+        temporary, //!< Means that the @ref orxonox::HealthPickup "HealthPickup" temporarily increases the users health even above its maximum health, but only as long as it is in use.
+        permanent //!< Means that the @ref orxonox::HealthPickup "HealthPickup" increases the users health even above its maximum health and increases the maximum health permanently such that it matches the new health.
+    };
 
     /**
@@ -115 +112 @@
             @return Returns the health type as an enum.
             */
-            inline pickupHealthType::Value getHealthType(void) const
+            inline PickupHealthType getHealthType(void) const
                 { return this->healthType_; }
             const std::string& getHealthTypeAsString(void) const; //!< Get the health type of this pickup.
@@ -127 +124 @@
             @param type The type of this pickup as an enum.
             */
-            inline void setHealthType(pickupHealthType::Value type)
+            inline void setHealthType(PickupHealthType type)
                 { this->healthType_ = type; }
             void setHealthTypeAsString(const std::string& type); //!< Set the type of the HealthPickup.
@@ -139 +136 @@
             float maxHealthSave_; //!< Helper to remember what the actual maxHealth of the Pawn was before we changed it.
             float maxHealthOverwrite_; //!< Helper to remember with which value we overwrote the maxHealh, to detect if someone else changed it as well.
-            pickupHealthType::Value healthType_; //!< The type of the HealthPickup.
+            PickupHealthType healthType_; //!< The type of the HealthPickup.
 
             //! Strings for the health types.

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

@@ -79 +79 @@
         this->addTarget(ClassIdentifier<PickupCarrier>::getIdentifier());
 
-        this->setDurationType(pickupDurationType::once);
-        this->metaType_ = pickupMetaType::none;
+        this->setDurationType(PickupDurationType::once);
+        this->metaType_ = PickupMetaType::none;
     }
 
@@ -104 +104 @@
 
         // If the MetaPickup transited to used, and the metaType is not none.
-        if(this->isUsed() && this->metaType_ != pickupMetaType::none)
+        if(this->isUsed() && this->metaType_ != PickupMetaType::none)
         {
             PickupCarrier* carrier = this->getCarrier();
-            if(this->getMetaType() != pickupMetaType::none && carrier != nullptr)
+            if(this->getMetaType() != PickupMetaType::none && carrier != nullptr)
             {
                 // If the metaType is destroyCarrier, then the PickupCarrier is destroyed.
-                if(this->getMetaType() == pickupMetaType::destroyCarrier)
+                if(this->getMetaType() == PickupMetaType::destroyCarrier)
                 {
                     Pawn* pawn = orxonox_cast<Pawn*>(carrier);
@@ -124 +124 @@
 
                     // If the metaType is use, then the Pickupable is set to used.
-                    if(this->getMetaType() == 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->getMetaType() == pickupMetaType::drop)
+                    else if(this->getMetaType() == PickupMetaType::drop)
                     {
                         pickup->drop();
                     }
                     // If the metaType is destroy, then the Pickupable is destroyed.
-                    else if(this->getMetaType() == pickupMetaType::destroy)
+                    else if(this->getMetaType() == PickupMetaType::destroy)
                     {
                         pickup->Pickupable::destroy();
@@ -154 +154 @@
         switch(this->getMetaType())
         {
-            case pickupMetaType::none:
+            case PickupMetaType::none:
                 return MetaPickup::metaTypeNone_s;
-            case pickupMetaType::use:
+            case PickupMetaType::use:
                 return MetaPickup::metaTypeUse_s;
-            case pickupMetaType::drop:
+            case PickupMetaType::drop:
                 return MetaPickup::metaTypeDrop_s;
-            case pickupMetaType::destroy:
+            case PickupMetaType::destroy:
                 return MetaPickup::metaTypeDestroy_s;
-            case pickupMetaType::destroyCarrier:
+            case PickupMetaType::destroyCarrier:
                 return MetaPickup::metaTypeDestroyCarrier_s;
             default:
@@ -179 +179 @@
         if(type == MetaPickup::metaTypeNone_s)
         {
-            this->setMetaType(pickupMetaType::none);
+            this->setMetaType(PickupMetaType::none);
         }
         else if(type == MetaPickup::metaTypeUse_s)
         {
-            this->setMetaType(pickupMetaType::use);
+            this->setMetaType(PickupMetaType::use);
         }
         else if(type == MetaPickup::metaTypeDrop_s)
         {
-            this->setMetaType(pickupMetaType::drop);
+            this->setMetaType(PickupMetaType::drop);
         }
         else if(type == MetaPickup::metaTypeDestroy_s)
         {
-            this->setMetaType(pickupMetaType::destroy);
+            this->setMetaType(PickupMetaType::destroy);
         }
         else if(type == MetaPickup::metaTypeDestroyCarrier_s)
         {
-            this->setMetaType(pickupMetaType::destroyCarrier);
+            this->setMetaType(PickupMetaType::destroyCarrier);
         }
         else

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

@@ -48 +48 @@
     @ingroup PickupItems
     */
-    namespace pickupMetaType
+    enum class PickupMetaType
     {
-        enum Value
-        {
-            none, //!< The @ref orxonox::MetaPickup "MetaPickup" does nothing.
-            use, //!< The @ref orxonox::MetaPickup "MetaPickup" uses all the @ref orxonox::PickupCarrier "PickupCarriers'" @ref orxonox::Pickupable "Pickupables".
-            drop, //!< The @ref orxonox::MetaPickup "MetaPickup" drops all the @ref orxonox::PickupCarrier "PickupCarriers'" @ref orxonox::Pickupable "Pickupables".
-            destroy, //!< The @ref orxonox::MetaPickup "MetaPickup" destroys all the @ref orxonox::PickupCarrier "PickupCarriers'" @ref orxonox::Pickupable "Pickupables".
-            destroyCarrier //!< The @ref orxonox::MetaPickup "MetaPickup" destroys the @ref orxonox::PickupCarrier "PickupCarrier".
-        };
-    }
+        none, //!< The @ref orxonox::MetaPickup "MetaPickup" does nothing.
+        use, //!< The @ref orxonox::MetaPickup "MetaPickup" uses all the @ref orxonox::PickupCarrier "PickupCarriers'" @ref orxonox::Pickupable "Pickupables".
+        drop, //!< The @ref orxonox::MetaPickup "MetaPickup" drops all the @ref orxonox::PickupCarrier "PickupCarriers'" @ref orxonox::Pickupable "Pickupables".
+        destroy, //!< The @ref orxonox::MetaPickup "MetaPickup" destroys all the @ref orxonox::PickupCarrier "PickupCarriers'" @ref orxonox::Pickupable "Pickupables".
+        destroyCarrier //!< The @ref orxonox::MetaPickup "MetaPickup" destroys the @ref orxonox::PickupCarrier "PickupCarrier".
+    };
 
     /**
@@ -100 +97 @@
             @return Returns an enum with the meta type of the MetaPickup.
             */
-            inline pickupMetaType::Value getMetaType(void) const
+            inline PickupMetaType getMetaType(void) const
                 { return this->metaType_; }
             const std::string& getMetaTypeAsString(void) const; //!< Get the meta type of this MetaPickup.
@@ -109 +106 @@
             @param type The meta type as an enum.
             */
-            inline void setMetaType(pickupMetaType::Value type)
+            inline void setMetaType(PickupMetaType type)
                 { this->metaType_ =  type; }
             void setMetaTypeAsString(const std::string& type); //!< Set the meta type of this MetaPickup.
@@ -116 +113 @@
             void initialize(void); //!< Initializes the member variables.
 
-            pickupMetaType::Value metaType_; //!< The meta type of the MetaPickup, determines which actions are taken.
+            PickupMetaType metaType_; //!< The meta type of the MetaPickup, determines which actions are taken.
 
             //! Static strings for the meta types.