Changeset 11003

Timestamp:

Dec 30, 2015, 9:24:39 PM (8 years ago)

Author:

landauf

Message:

using strongly typed enum class in notifications.
NotificationListener::sendHelper (a network function) now uses the new enum instead of an unsigned int for the message-type. this is possible due to MultiType's new support for strongly typed enums.

Location:

code/branches/cpp11_v2/src

Files:

• modules/notifications/NotificationDispatcher.cc (modified) (2 diffs)
• modules/notifications/NotificationManager.cc (modified) (3 diffs)
• modules/notifications/NotificationManager.h (modified) (4 diffs)
• modules/questsystem/QuestDescription.cc (modified) (1 diff)
• orxonox/infos/GametypeInfo.cc (modified) (2 diffs)
• orxonox/interfaces/NotificationListener.cc (modified) (5 diffs)
• orxonox/interfaces/NotificationListener.h (modified) (6 diffs)

code/branches/cpp11_v2/src/modules/notifications/NotificationDispatcher.cc

@@ -113 +113 @@
         // TODO: Needed?
         const std::string message = this->createNotificationMessage();
-        NotificationListener::sendNotification(message, this->getSender(), notificationMessageType::info, notificationSendMode::local);
+        NotificationListener::sendNotification(message, this->getSender(), NotificationMessageType::info, NotificationSendMode::local);
 
         // Broadcast
@@ -144 +144 @@
             const std::string message = this->createNotificationMessage();
             // TODO: Make the type configurable.
-            NotificationListener::sendNotification(message, this->getSender(), notificationMessageType::info, notificationSendMode::network, clientId);
+            NotificationListener::sendNotification(message, this->getSender(), NotificationMessageType::info, NotificationSendMode::network, clientId);
         }
         else if(GameMode::isServer())

code/branches/cpp11_v2/src/modules/notifications/NotificationManager.cc

@@ -106 +106 @@
         Returns true if successful.
     */
-    bool NotificationManager::registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type)
+    bool NotificationManager::registerNotification(const std::string& message, const std::string& sender, NotificationMessageType type)
     {
         // TODO: Do something with the type.
@@ -124 +124 @@
         Returns true if the command was successfully executed.
     */
-    bool NotificationManager::executeCommand(notificationCommand::Value command, const std::string& sender)
+    bool NotificationManager::executeCommand(NotificationCommand command, const std::string& sender)
     {
         bool commandExecuted = false;
-        if(command == notificationCommand::clear)
+        if(command == NotificationCommand::clear)
         {
             if(this->commandClear(sender))
@@ -437 +437 @@
 
     */
-    Notification::Notification(const std::string& message, const std::string& sender, notificationMessageType::Value type)
+    Notification::Notification(const std::string& message, const std::string& sender, NotificationMessageType type)
     {
         this->initialize();

code/branches/cpp11_v2/src/modules/notifications/NotificationManager.h

@@ -62 +62 @@
     {
         public:
-            Notification(const std::string& message, const std::string& sender, notificationMessageType::Value type);
+            Notification(const std::string& message, const std::string& sender, NotificationMessageType type);
             virtual ~Notification();
 
@@ -89 +89 @@
             @return Returns an enum with the type of the Notification.
             */
-            inline notificationMessageType::Value getType(void) const
+            inline NotificationMessageType getType(void) const
                 { return this->type_; }
 
@@ -95 +95 @@
             std::string message_; //!< The Notification message.
             std::string sender_; //!< The sender of the notification.
-            notificationMessageType::Value type_; //!< The type of the notification.
+            NotificationMessageType type_; //!< The type of the notification.
 
             void initialize(void); //!< Registers the object and sets some default values.
@@ -128 +128 @@
             static NotificationManager& getInstance() { return Singleton<NotificationManager>::getInstance(); } // tolua_export
 
-            virtual bool registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type) override;
-            virtual bool executeCommand(notificationCommand::Value command, const std::string& sender) override;
+            virtual bool registerNotification(const std::string& message, const std::string& sender, NotificationMessageType type) override;
+            virtual bool executeCommand(NotificationCommand command, const std::string& sender) override;
 
             bool registerNotification(Notification* notification); // Registers a Notification within the NotificationManager.

code/branches/cpp11_v2/src/modules/questsystem/QuestDescription.cc

@@ -119 +119 @@
         }
 
-        NotificationListener::sendNotification(message, QuestDescription::SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
+        NotificationListener::sendNotification(message, QuestDescription::SENDER, NotificationMessageType::info, NotificationSendMode::network, player->getClientID());
         return true;
     }

code/branches/cpp11_v2/src/orxonox/infos/GametypeInfo.cc

@@ -291 +291 @@
         if(GameMode::isMaster())
         {
-            NotificationListener::sendNotification("Press [Fire] to respawn", GametypeInfo::NOTIFICATION_SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
+            NotificationListener::sendNotification("Press [Fire] to respawn", GametypeInfo::NOTIFICATION_SENDER, NotificationMessageType::info, NotificationSendMode::network, player->getClientID());
             // Remove the player from the list of players that have spawned, since it currently is not.
             this->spawnedPlayers_.erase(player);
@@ -346 +346 @@
                 // Display "Press [Fire] to start the match" if the game has not yet ended.
                 if(!this->hasEnded())
-                    NotificationListener::sendNotification("Press [Fire] to start the match", GametypeInfo::NOTIFICATION_SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
+                    NotificationListener::sendNotification("Press [Fire] to start the match", GametypeInfo::NOTIFICATION_SENDER, NotificationMessageType::info, NotificationSendMode::network, player->getClientID());
                 // Else display "Game has ended".
                 else
-                    NotificationListener::sendNotification("Game has ended", GametypeInfo::NOTIFICATION_SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
+                    NotificationListener::sendNotification("Game has ended", GametypeInfo::NOTIFICATION_SENDER, NotificationMessageType::info, NotificationSendMode::network, player->getClientID());
             }
         }

code/branches/cpp11_v2/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.
@@ -112 +112 @@
             // If the notification is a message.
             if(!isCommand)
-                listener->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)
+                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/branches/cpp11_v2/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.
     };
 }