Changeset 11071 for code/trunk/src/orxonox/interfaces

Timestamp:

Jan 17, 2016, 10:29:21 PM (8 years ago)

Author:

landauf

Message:

merged branch cpp11_v3 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/orxonox/interfaces/NotificationListener.cc (modified) (4 diffs)
• src/orxonox/interfaces/NotificationListener.h (modified) (6 diffs)
• src/orxonox/interfaces/PickupCarrier.cc (modified) (2 diffs)
• src/orxonox/interfaces/PickupCarrier.h (modified) (2 diffs)
• src/orxonox/interfaces/PickupListener.cc (modified) (2 diffs)
• src/orxonox/interfaces/Pickupable.cc (modified) (7 diffs)
• src/orxonox/interfaces/Pickupable.h (modified) (2 diffs)
• src/orxonox/interfaces/RadarViewable.cc (modified) (1 diff)
• src/orxonox/interfaces/RadarViewable.h (modified) (2 diffs)

code/trunk/src/orxonox/interfaces/NotificationListener.cc

@@ -74 +74 @@
         The type of the notification, can be either 'info' or 'important'.
     */
-    /*static*/ void NotificationListener::sendNetworkHelper(const std::string& message, const std::string& sender, notificationSendMode::Value sendMode, unsigned int clientId, bool isCommand, notificationMessageType::Value messageType)
+    /*static*/ void NotificationListener::sendNetworkHelper(const std::string& message, const std::string& sender, NotificationSendMode sendMode, unsigned int clientId, bool isCommand, NotificationMessageType messageType)
     {
         // If we're in standalone mode or we're already no the right client we create and send the notification/command.
-        if(GameMode::isStandalone() || sendMode == notificationSendMode::local || (sendMode ==  notificationSendMode::network && Host::getPlayerID() == clientId))
+        if(GameMode::isStandalone() || sendMode == NotificationSendMode::local || (sendMode ==  NotificationSendMode::network && Host::getPlayerID() == clientId))
         {
             sendHelper(message, sender, isCommand, messageType);
         }
         // If we're on the server (and the server is not the intended recipient of the notification/command) we send it over the network.
-        else if(GameMode::isServer() && sendMode == notificationSendMode::network && Host::getPlayerID() != clientId)
+        else if(GameMode::isServer() && sendMode == NotificationSendMode::network && Host::getPlayerID() != clientId)
         {
-            callStaticNetworkFunction(&NotificationListener::sendHelper, clientId, message, sender, isCommand, (unsigned int)messageType);
+            callStaticNetworkFunction(&NotificationListener::sendHelper, clientId, message, sender, isCommand, messageType);
         }
-        else if(GameMode::isServer() && sendMode == notificationSendMode::broadcast)
+        else if(GameMode::isServer() && sendMode == NotificationSendMode::broadcast)
         {
             // TODO: Works as intended?
-            callStaticNetworkFunction(&NotificationListener::sendHelper, NETWORK_PEER_ID_BROADCAST, message, sender, isCommand, (unsigned int)messageType);
+            callStaticNetworkFunction(&NotificationListener::sendHelper, NETWORK_PEER_ID_BROADCAST, message, sender, isCommand, messageType);
         }
     }
@@ -105 +105 @@
         The type of the notification.
     */
-    /*static*/ void NotificationListener::sendHelper(const std::string& message, const std::string& sender, bool isCommand, unsigned int messageType)
+    /*static*/ void NotificationListener::sendHelper(const std::string& message, const std::string& sender, bool isCommand, NotificationMessageType type)
     {
         // Iterate through all NotificationListeners and notify them by calling the method they overloaded.
-        for(ObjectList<NotificationListener>::iterator it = ObjectList<NotificationListener>::begin(); it != ObjectList<NotificationListener>::end(); ++it)
+        for(NotificationListener* listener : ObjectList<NotificationListener>())
         {
             // If the notification is a message.
             if(!isCommand)
-                it->registerNotification(message, sender, notificationMessageType::Value(messageType));
+                listener->registerNotification(message, sender, type);
 
             // If the notification is a command.
             if(isCommand)
             {
-                notificationCommand::Value command = str2Command(message);
-                if(command != notificationCommand::none)
-                    it->executeCommand(command, sender);
+                NotificationCommand command = str2Command(message);
+                if(command != NotificationCommand::none)
+                    listener->executeCommand(command, sender);
             }
         }
@@ -130 +130 @@
         The string to be converted.
     @return
-        Returns the corresponding enum, notificationCommand::none if the command doesn't exist.
+        Returns the corresponding enum, NotificationCommand::none if the command doesn't exist.
     */
-    /*static*/ notificationCommand::Value NotificationListener::str2Command(const std::string& string)
+    /*static*/ NotificationCommand NotificationListener::str2Command(const std::string& string)
     {
-        notificationCommand::Value command = notificationCommand::none;
+        NotificationCommand command = NotificationCommand::none;
 
         if(string == NotificationListener::COMMAND_CLEAR)
-            command = notificationCommand::clear;
+            command = NotificationCommand::clear;
 
         return command;
@@ -150 +150 @@
         Returns the corresponding string.
     */
-    /*static*/ const std::string& NotificationListener::command2Str(notificationCommand::Value command)
+    /*static*/ const std::string& NotificationListener::command2Str(NotificationCommand command)
     {
         switch(command)
         {
-            case notificationCommand::clear:
+            case NotificationCommand::clear:
                 return NotificationListener::COMMAND_CLEAR;
             default:

code/trunk/src/orxonox/interfaces/NotificationListener.h

@@ -49 +49 @@
 {
     // TODO: Document.
-    namespace notificationMessageType
-    {
-        enum Value {
-            info,
-            important
-        };
-    }
+    enum class NotificationMessageType {
+        info,
+        important
+    };
     
-    namespace notificationSendMode
-    {
-        enum Value {
-            local,
-            network,
-            broadcast
-        };
-    }
+    enum class NotificationSendMode {
+        local,
+        network,
+        broadcast
+    };
     
-    namespace notificationCommand
-    {
-        enum Value {
-            none,
-            clear
-        };
-    }
+    enum class NotificationCommand {
+        none,
+        clear
+    };
 
     // TODO: Update doc.
@@ -101 +92 @@
             @param sender The sender that sent the notification. Default is 'none'.
             @param messageType The type of the message, can be either 'info' or 'important'. Default is 'info'.
-            @param sendMode The mode in which the notification is sent, can be 'local' to send the notification to the client where this function is executed, 'network' if the notification is to be sent to the client with the specified clientID, or 'broadcast' if the notification should be sent to all hosts. Default is notificationSendMode::local.
+            @param sendMode The mode in which the notification is sent, can be 'local' to send the notification to the client where this function is executed, 'network' if the notification is to be sent to the client with the specified clientID, or 'broadcast' if the notification should be sent to all hosts. Default is NotificationSendMode::local.
             @param clientId The id of the client the notification should be sent to. Default is 0.
             */
-            static void sendNotification(const std::string& message, const std::string& sender = NotificationListener::NONE, notificationMessageType::Value messageType = notificationMessageType::info, notificationSendMode::Value sendMode = notificationSendMode::local, unsigned int clientId = 0)
+            static void sendNotification(const std::string& message, const std::string& sender = NotificationListener::NONE, NotificationMessageType messageType = NotificationMessageType::info, NotificationSendMode sendMode = NotificationSendMode::local, unsigned int clientId = 0)
                 { NotificationListener::sendNetworkHelper(message, sender, sendMode, clientId, false, messageType); }
             /**
@@ -110 +101 @@
             @param command The command that should be sent (and later executed).
             @param sender The sender that sent the notification. Default is 'none'.
-            @param sendMode The mode in which the command is sent, can be 'local' to send the command to the client where this function is executed, 'network' if the command is to be sent to the client with the specified clientID, or 'broadcast' if the command should be sent to all hosts. Default is notificationSendMode::local.
+            @param sendMode The mode in which the command is sent, can be 'local' to send the command to the client where this function is executed, 'network' if the command is to be sent to the client with the specified clientID, or 'broadcast' if the command should be sent to all hosts. Default is NotificationSendMode::local.
             @param clientId The id of the client the command should be sent to. Default is 0.
             */
-            static void sendCommand(const std::string& command, const std::string& sender = NotificationListener::NONE, notificationSendMode::Value sendMode = notificationSendMode::local, unsigned int clientId = 0)
+            static void sendCommand(const std::string& command, const std::string& sender = NotificationListener::NONE, NotificationSendMode sendMode = NotificationSendMode::local, unsigned int clientId = 0)
                 { NotificationListener::sendNetworkHelper(command, sender, sendMode, clientId, true); }
 
-            static void sendHelper(const std::string& message, const std::string& sender, bool isCommand = false, unsigned int messageMode = 0); // Helper method to register a notification/execute a command with all NotificationListeners after it has been sent over the network.
+            static void sendHelper(const std::string& message, const std::string& sender, bool isCommand, NotificationMessageType type); // Helper method to register a notification/execute a command with all NotificationListeners after it has been sent over the network.
 
             //TODO: Make protected?
@@ -128 +119 @@
             @return Returns true if the notification was successfully registered, false if not.
             */
-            virtual bool registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type)
+            virtual bool registerNotification(const std::string& message, const std::string& sender, NotificationMessageType type)
                 { return false; }
             /**
@@ -137 +128 @@
             @return Returns true if the command was successfully executed, false if not.
             */
-            virtual bool executeCommand(notificationCommand::Value command, const std::string& sender) { return false; }
+            virtual bool executeCommand(NotificationCommand command, const std::string& sender) { return false; }
 
         public:
@@ -149 +140 @@
             
         protected:
-            static void sendNetworkHelper(const std::string& message, const std::string& sender, notificationSendMode::Value sendMode, unsigned int clientId, bool isCommand = false, notificationMessageType::Value messageType = notificationMessageType::info); // Helper method to send both notifications and commands over the network.
+            static void sendNetworkHelper(const std::string& message, const std::string& sender, NotificationSendMode sendMode, unsigned int clientId, bool isCommand = false, NotificationMessageType messageType = NotificationMessageType::info); // Helper method to send both notifications and commands over the network.
 
-            static notificationCommand::Value str2Command(const std::string& string); // Helper method. Converts a string into the enum for a command.
-            static const std::string& command2Str(notificationCommand::Value command); // Helper method. Converts a command enum into its corresponding string.
+            static NotificationCommand str2Command(const std::string& string); // Helper method. Converts a string into the enum for a command.
+            static const std::string& command2Str(NotificationCommand command); // Helper method. Converts a command enum into its corresponding string.
     };
 }

code/trunk/src/orxonox/interfaces/PickupCarrier.cc

@@ -101 +101 @@
         // Go recursively through all children to check whether they are a target.
         std::vector<PickupCarrier*>* children = this->getCarrierChildren();
-        for(std::vector<PickupCarrier*>::const_iterator it = children->begin(); it != children->end(); it++)
+        for(PickupCarrier* carrier : *children)
         {
-            if((*it)->isTarget(pickup))
+            if(carrier->isTarget(pickup))
             {
                 isTarget = true;
@@ -127 +127 @@
     {
         if(!this->isTarget(pickup))
-            return NULL;
+            return nullptr;
 
         if(pickup->isTarget(this)) // If the PickupCarrier itself is a target.
             return this;
 
-        PickupCarrier* target = NULL;
+        PickupCarrier* target = nullptr;
         // Go recursively through all children to check whether they are the target.
         std::vector<PickupCarrier*>* children = this->getCarrierChildren();
-        for(std::vector<PickupCarrier*>::iterator it = children->begin(); it != children->end(); it++)
+        for(PickupCarrier* child : *children)
         {
-            if(pickup->isTarget(*it))
+            if(pickup->isTarget(child))
             {
-                target = *it;
+                target = child;
                 break;
             }

code/trunk/src/orxonox/interfaces/PickupCarrier.h

@@ -59 +59 @@
         But this structure has to be established first.
         - <b>getCarrierChildren()</b> To this end a PickupCarrier needs to implement getCarrierChildren() which returns a list of its direct PickupCarrier children. If you need an example, have a look at @ref orxonox::Pawn "Pawn" and @ref orxonox::Engine "Engine".
-        - <b>getCarrierParent()</b> This is the method in the other direction. It returns the parent of this PickupCarrier, or NULL if the PickupCarrier is a root node in this hierarchy.
+        - <b>getCarrierParent()</b> This is the method in the other direction. It returns the parent of this PickupCarrier, or nullptr if the PickupCarrier is a root node in this hierarchy.
 
     @author
@@ -77 +77 @@
             PickupCarrier(); //!< Constructor.
             virtual ~PickupCarrier(); //!< Destructor.
-            void preDestroy(void); //!< Is called before the PickupCarrier is effectively destroyed.
+            virtual void preDestroy(void) override; //!< Is called before the PickupCarrier is effectively destroyed.
 
             bool isTarget(const Pickupable* pickup) const; //!< Can be used to check whether the PickupCarrier or a child of his is a target ot the input Pickupable.

code/trunk/src/orxonox/interfaces/PickupListener.cc

@@ -74 +74 @@
 
         // Iterate through all PickupListeners and notify them by calling the method they overloaded.
-        for(ObjectList<PickupListener>::iterator it = ObjectList<PickupListener>::begin(); it != ObjectList<PickupListener>::end(); ++it)
-            it->pickupChangedUsed(pickup, used);
+        for(PickupListener* listener : ObjectList<PickupListener>())
+            listener->pickupChangedUsed(pickup, used);
     }
 
@@ -92 +92 @@
 
         // Iterate through all PickupListeners and notify them by calling the method they overloaded.
-        for(ObjectList<PickupListener>::iterator it = ObjectList<PickupListener>::begin(); it != ObjectList<PickupListener>::end(); ++it)
-            it->pickupChangedPickedUp(pickup, pickedUp);
+        for(PickupListener* listener : ObjectList<PickupListener>())
+            listener->pickupChangedPickedUp(pickup, pickedUp);
     }
 

code/trunk/src/orxonox/interfaces/Pickupable.cc

@@ -56 +56 @@
         RegisterObject(Pickupable);
 
-        this->carrier_ = NULL;
+        this->carrier_ = nullptr;
 
         this->beingDestroyed_ = false;
@@ -143 +143 @@
     bool Pickupable::isTarget(const PickupCarrier* carrier) const
     {
-        if(carrier == NULL)
+        if(carrier == nullptr)
             return false;
 
@@ -160 +160 @@
     {
         // Iterate through all targets of this Pickupable.
-        for(std::list<Identifier*>::const_iterator it = this->targets_.begin(); it != this->targets_.end(); it++)
+        for(Identifier* target : this->targets_)
         {
-            if(identifier->isA(*it))
+            if(identifier->isA(target))
                 return true;
         }
@@ -210 +210 @@
     bool Pickupable::pickup(PickupCarrier* carrier)
     {
-        if(carrier == NULL || this->isPickedUp()) // If carrier is NULL or the Pickupable is already picked up.
+        if(carrier == nullptr || this->isPickedUp()) // If carrier is nullptr or the Pickupable is already picked up.
             return false;
 
@@ -237 +237 @@
             return false;
 
-        assert(this->getCarrier()); // The Carrier cannot be NULL at this point.
+        assert(this->getCarrier()); // The Carrier cannot be nullptr at this point.
         if(!this->getCarrier()->removePickup(this)) //TODO Shouldn't this be a little later?
             orxout(internal_warning, context::pickups) << "Pickupable (&" << this << ", " << this->getIdentifier()->getName() << ") is being dropped, but it was not present in the PickupCarriers list of pickups." << endl;
@@ -249 +249 @@
             created = this->createSpawner();
 
-        this->setCarrier(NULL);
+        this->setCarrier(nullptr);
 
         if(!created && createSpawner) // If a PickupSpawner should have been created but wasn't.
@@ -301 +301 @@
         orxout(verbose, context::pickups) << "Pickupable (&" << this << ") changed Carrier (& " << carrier << ")." << endl;
 
-        if(carrier != NULL && tell)
+        if(carrier != nullptr && tell)
         {
             if(!carrier->addPickup(this))

code/trunk/src/orxonox/interfaces/Pickupable.h

@@ -144 +144 @@
 
         protected:
-            virtual void preDestroy(void); //!< A method that is called by Destroyable::destroy() before the object is actually destroyed.
+            virtual void preDestroy(void) override; //!< A method that is called by Destroyable::destroy() before the object is actually destroyed.
             virtual void destroyPickup(void); //!< Destroys a Pickupable.
             virtual void carrierDestroyed(void); //!< Is called by the PickupCarrier when it is being destroyed.
@@ -182 +182 @@
         // For implementing the Rewardable interface:
         public:
-            virtual bool reward(PlayerInfo* player); //!< Method to transcribe a Pickupable as a Rewardable to the player.
+            virtual bool reward(PlayerInfo* player) override; //!< Method to transcribe a Pickupable as a Rewardable to the player.
 
     };

code/trunk/src/orxonox/interfaces/RadarViewable.cc

@@ -49 +49 @@
         , wePtr_(wePtr)
         , radarObjectCamouflage_(0.0f)
-        , radarObjectShape_(Dot)
+        , radarObjectShape_(Shape::Dot)
         , radarObjectDescription_("staticObject")
         , scale_(1.0f)

code/trunk/src/orxonox/interfaces/RadarViewable.h

@@ -49 +49 @@
     {
     public:
-        enum Shape
+        enum class Shape
         {
             Square,
@@ -66 +66 @@
                 if (name == "HIDDEN")
                 {
-                    this->bVisibility_ = 0;
+                    this->bVisibility_ = false;
                     this->settingsChanged();
                 }