spelling: recieve -> receive

rwengine/src/core/Logger.cpp

@@ -8,18 +8,18 @@ void Logger::log(const std::string& component, Logger::MessageSeverity severity,
                  const std::string& message) {
     LogMessage m{component, severity, message};
 
-    for (MessageReciever* r : recievers) {
-        r->messageRecieved(m);
+    for (MessageReceiver* r : receivers) {
+        r->messageReceived(m);
     }
 }
 
-void Logger::addReciever(Logger::MessageReciever* out) {
-    recievers.push_back(out);
+void Logger::addReceiver(Logger::MessageReceiver* out) {
+    receivers.push_back(out);
 }
 
-void Logger::removeReciever(Logger::MessageReciever* out) {
-    recievers.erase(std::remove(recievers.begin(), recievers.end(), out),
-                    recievers.end());
+void Logger::removeReceiver(Logger::MessageReceiver* out) {
+    receivers.erase(std::remove(receivers.begin(), receivers.end(), out),
+                    receivers.end());
 }
 
 void Logger::error(const std::string& component, const std::string& message) {
@@ -43,7 +43,7 @@ std::map<Logger::MessageSeverity, char> severityStr{{Logger::Error, 'E'},
                                                     {Logger::Info, 'I'},
                                                     {Logger::Verbose, 'V'}};
 
-void StdOutReciever::messageRecieved(const Logger::LogMessage& message) {
+void StdOutReceiver::messageReceived(const Logger::LogMessage& message) {
     std::cout << severityStr[message.severity] << " [" << message.component
               << "] " << message.message << std::endl;
 }

rwengine/src/core/Logger.hpp

@@ -6,7 +6,7 @@
 /**
  * Handles and stores messages from different components
  *
- * Dispatches recieved messages to logger outputs.
+ * Dispatches received messages to logger outputs.
  */
 class Logger {
 public:
@@ -29,18 +29,18 @@ class Logger {
     /**
      * Interface for handling logged messages.
      *
-     * The Logger class will not clean up allocated MessageRecievers.
+     * The Logger class will not clean up allocated MessageReceivers.
      */
-    struct MessageReciever {
-        virtual void messageRecieved(const LogMessage&) = 0;
+    struct MessageReceiver {
+        virtual void messageReceived(const LogMessage&) = 0;
     };
 
-    Logger(std::initializer_list<MessageReciever*> initial = {})
-        : recievers(initial) {
+    Logger(std::initializer_list<MessageReceiver*> initial = {})
+        : receivers(initial) {
     }
 
-    void addReciever(MessageReciever* out);
-    void removeReciever(MessageReciever* out);
+    void addReceiver(MessageReceiver* out);
+    void removeReceiver(MessageReceiver* out);
 
     void log(const std::string& component, Logger::MessageSeverity severity,
              const std::string& message);
@@ -51,9 +51,9 @@ class Logger {
     void error(const std::string& component, const std::string& message);
 
 private:
-    std::vector<MessageReciever*> recievers;
+    std::vector<MessageReceiver*> receivers;
 };
 
-class StdOutReciever : public Logger::MessageReciever {
-    virtual void messageRecieved(const Logger::LogMessage&);
+class StdOutReceiver : public Logger::MessageReceiver {
+    virtual void messageReceived(const Logger::LogMessage&);
 };

rwengine/src/render/OpenGLRenderer.hpp

@@ -41,7 +41,7 @@ class Renderer {
      * @brief The DrawParameters struct stores drawing state
      *
      * The state for texture units, blending and material properties
-     * are recieved for drawing through this structure.
+     * are received for drawing through this structure.
      *
      * Since not all draws use the same shaders, material properties
      * should be controlled via a different mechanism.

rwgame/main.cpp

@@ -6,7 +6,7 @@
 
 int main(int argc, char* argv[]) {
     // Initialise Logging before anything else happens
-    StdOutReciever logstdout;
+    StdOutReceiver logstdout;
     Logger logger({ &logstdout });
 
     try {

tests/test_Logger.cpp

@@ -2,30 +2,30 @@
 #include <core/Logger.hpp>
 #include <test_globals.hpp>
 
-class CallbackReceiver : public Logger::MessageReciever {
+class CallbackReceiver : public Logger::MessageReceiver {
 public:
     std::function<void(const Logger::LogMessage&)> func;
 
     CallbackReceiver(std::function<void(const Logger::LogMessage&)> func)
         : func(func) {
     }
 
-    virtual void messageRecieved(const Logger::LogMessage& message) {
+    virtual void messageReceived(const Logger::LogMessage& message) {
         func(message);
     }
 };
 
 BOOST_AUTO_TEST_SUITE(LoggerTests)
 
-BOOST_AUTO_TEST_CASE(test_reciever) {
+BOOST_AUTO_TEST_CASE(test_receiver) {
     Logger log;
 
     Logger::LogMessage lastMessage("", Logger::Error, "");
 
-    CallbackReceiver reciever(
+    CallbackReceiver receiver(
         [&](const Logger::LogMessage& m) { lastMessage = m; });
 
-    log.addReciever(&reciever);
+    log.addReceiver(&receiver);
 
     log.info("Tests", "Test");
 
@@ -34,4 +34,4 @@ BOOST_AUTO_TEST_CASE(test_reciever) {
     BOOST_CHECK_EQUAL(lastMessage.message, "Test");
 }
 
-BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()