Tiny refactoring

je-s · je-s · commit 1f3a3d23f4c6 · 2020-02-22T23:24:04.000+01:00
diff --git a/README.md b/README.md
@@ -106,11 +106,11 @@ The StreamCommander has several standard commands which implement basic function
 | activate | Activates the automatic publishing of new status-messages | |
 | deactivate | Deactivates the automatic publishing of new status-messages | |
 | isactive | Returns whether the device is set to active or not | | 
-| echo | Sets the echoing of incoming commands on or off | on / off |
+| setecho | Sets the echoing of incoming commands on or off | on / off |
 | setid | Sets the ID of the device | &lt;id&gt; |
 | getid | Returns the ID of the device | |
-| ping | Returns a "ping:response"-message | |
-| status | Returns the current status of the device | |
+| ping | Returns a ping response message (usually a "ping:reply" message) | |
+| getstatus | Returns the current status of the device | |
 | commands | Returns all registered commands of the device | |
 # Message format
 To make the communication more easy and consistent, a simple message format has been defined, which is used by the ArduinoStreamCommander.\
@@ -123,7 +123,7 @@ The StreamCommander uses several standard message types, which are defined in [A
 | response | Return responses after a command has been executed |
 | info | Inform about something like an internal event (e.g. for logging-purposes) |
 | error | Inform about an error/problem which occured during the runtime |
-| ping | Containts an ping response message |
+| ping | Contains a ping response message (usually containts "reply") |
 | status | Send the current/most recent status of the device (Especially used for status updates) |
 | id | Contains the id of the device |
 | active | Contains whether the device is set to active or not |
diff --git a/src/StreamCommander.cpp b/src/StreamCommander.cpp
@@ -16,14 +16,15 @@
 
 #include "StreamCommander.hpp"
 
+const String StreamCommander::PING_REPLY = "reply";
 const String StreamCommander::COMMAND_ACTIVATE = "activate";
 const String StreamCommander::COMMAND_DEACTIVATE = "deactivate";
 const String StreamCommander::COMMAND_ISACTIVE = "isactive";
-const String StreamCommander::COMMAND_SETECHO = "echo";
+const String StreamCommander::COMMAND_SETECHO = "setecho";
 const String StreamCommander::COMMAND_SETID = "setid";
 const String StreamCommander::COMMAND_GETID = "getid";
 const String StreamCommander::COMMAND_PING = "ping";
-const String StreamCommander::COMMAND_GETSTATUS = "status";
+const String StreamCommander::COMMAND_GETSTATUS = "getstatus";
 const String StreamCommander::COMMAND_LISTCOMMANDS = "commands";
 
 StreamCommander::StreamCommander( Stream * streamInstance )
@@ -38,7 +39,7 @@ StreamCommander::~StreamCommander()
 
 void StreamCommander::init( bool active, char commandDelimiter, char messageDelimiter, bool echoCommands, bool addStandardCommands, long streamBufferTimeout )
 {
-    loadIdFromEEPROM();
+    loadIdFromEeprom();
     setCommandDelimiter( commandDelimiter );
     setMessageDelimiter( messageDelimiter );
     setStreamBufferTimeout( streamBufferTimeout );
@@ -82,7 +83,8 @@ Stream * StreamCommander::getStreamInstance()
 
 void StreamCommander::setActive( bool active )
 {
-    if ( isActive() != active ) // Only set our active-status if it's differing
+    // Only set & send our active-status if it's differing
+    if ( isActive() != active )
     {
         this->active = active;
 
@@ -137,10 +139,10 @@ bool StreamCommander::shouldAddStandardCommands()
 
 void StreamCommander::setStreamBufferTimeout( long streamBufferTimeout )
 {
-    // Check for Input-Errors
+    // Check if the timeout is over or equal to 0
     if ( streamBufferTimeout < 0 )
     {
-        sendError( F("Timeout has to be >= 0.") );
+        sendError( F( "Timeout has to be >= 0." ) );
 
         return;
     }
@@ -154,7 +156,7 @@ long StreamCommander::getStreamBufferTimeout()
     return this->streamBufferTimeout;
 }
 
-void StreamCommander::saveIdToEEPROM( String id )
+void StreamCommander::saveIdToEeprom( String id )
 {
     // Since EEPROM.put can't handle strings, we have to convert it to a c_str
     char idBuffer[ID_MAX_LENGTH];
@@ -163,7 +165,7 @@ void StreamCommander::saveIdToEEPROM( String id )
     EEPROM.put( 0, idBuffer );
 }
 
-void StreamCommander::loadIdFromEEPROM()
+void StreamCommander::loadIdFromEeprom()
 {
     char id[ID_MAX_LENGTH];
     EEPROM.get( 0, id );
@@ -173,22 +175,24 @@ void StreamCommander::loadIdFromEEPROM()
 
 void StreamCommander::setId( String id )
 {
-    // Check for Errors
+    // Check if the ID is too long
     if ( id.length() > ID_MAX_LENGTH )
     {
         sendError( "ID '" + id + "' too long (ID_MAX_LENGTH = " + String( ID_MAX_LENGTH ) + ")." );
 
         return;
     }
 
+    // Check whether the ID differs or not
+    // Only proceed with the saving-process when it differs
     if ( id.equals( getId() ) )
     {
         sendResponse( "ID is already '" + id + "'." );
 
         return;
     }
 
-    saveIdToEEPROM( id );
+    saveIdToEeprom( id );
     this->id = id;
     sendId();
 }
@@ -210,7 +214,7 @@ void StreamCommander::updateStatus( String status )
     {
         setStatus( status );
 
-        // Only send a Status-Update if our device is set active
+        // Only send a status update if our device is set active
         if ( isActive() )
         {
             sendStatus();
@@ -225,50 +229,52 @@ String StreamCommander::getStatus()
 
 void StreamCommander::addCommand( String commandName, CommandCallbackFunction commandCallback )
 {
-    // Check for Input-Errors
+    // Check that the command name is not empty
     if ( commandName.length() == 0 )
     {
-        sendError( F("Command-Name must not be empty.") );
+        sendError( F( "Command name must not be empty." ) );
 
         return;
     }
 
+    // Check that the command callback function is not empty
     if ( commandCallback == nullptr )
     {
-        sendError( F("Command-Callbackfunction must not be empty.") );
+        sendError( F( "Command callback function must not be empty." ) );
 
         return;
     }
 
-    int currentCommandNum = getNumCommands();
-    bool commandFound = false;
-    CommandContainer * container = getCommandContainer( commandName );
+    // Sets the currentCommandIndex to -1 if this commandName has not been added yet, or to the array-index where it has been found
+    int currentCommandIndex = getCommandContainerIndex( commandName );
+    bool commandFound = true;
 
-    // Check if the command has already been added
-    if ( container != nullptr )
+    // Check if the command has already been added or not
+    // If not: sets the index to the next index where the new command will be added
+    if ( currentCommandIndex < 0 )
     {
-        commandFound = true;
-        currentCommandNum = getCommandContainerNum( commandName ); // Set the currentCommandNum to the array-position where it has been found
+        currentCommandIndex = getNumCommands();
+        commandFound = false;
     }
 
     // If the command has not been added yet, incease the array size and create a pointer to our commandName. Set the Callback in the next step.
     // If it has already been added, just replace the old callback with the new one in the next step.
-    if ( !commandFound ) 
+    if ( !commandFound )
     {
-        commands = (CommandContainer*) realloc( commands, ( currentCommandNum + 1 ) * sizeof( CommandContainer ) );
+        commands = (CommandContainer*) realloc( commands, ( currentCommandIndex + 1 ) * sizeof( CommandContainer ) );
         incrementNumCommands();
 
         // Create a pointer to our command-name. On destruction of the corresponding CommandContainer, it will get deleted.
         String * commandNamePointer = new String( commandName );
-        commands[currentCommandNum].command = commandNamePointer;
+        commands[currentCommandIndex].command = commandNamePointer;
     }
     else
     {
-        sendInfo( "Command '" + commandName + "' already found. Replacing with new command." );
+        sendInfo( "Command '" + commandName + "' already found. Replacing with new callback function." );
     }
 
     // Set the Callback-Function
-    commands[currentCommandNum].callbackFunction = commandCallback;
+    commands[currentCommandIndex].callbackFunction = commandCallback;
 }
 
 StreamCommander::CommandContainer * StreamCommander::getCommandContainer( String command )
@@ -284,7 +290,7 @@ StreamCommander::CommandContainer * StreamCommander::getCommandContainer( String
     return nullptr;
 }
 
-int StreamCommander::getCommandContainerNum( String command )
+int StreamCommander::getCommandContainerIndex( String command )
 {
     for ( int i = 0; i < getNumCommands(); i++ )
     {
@@ -328,7 +334,7 @@ String StreamCommander::getCommandList()
         commandList = commandList + *(commands[i].command) + commandSeparator;
     }
 
-    // Remove the last command separator
+    // Remove the last commandSeparator occurence
     unsigned int listLength = commandList.length();
     unsigned int separatorLength = commandSeparator.length();
 
@@ -342,10 +348,10 @@ String StreamCommander::getCommandList()
 
 void StreamCommander::setDefaultCallback( DefaultCallbackFunction defaultCallbackFunction )
 {
-    // Check for Input-Errors
+    // Check that the default callback function is not empty
     if ( defaultCallbackFunction == nullptr )
     {
-        sendError( F("Default-Callbackfunction must not be empty.") );
+        sendError( F( "Default callback function must not be empty." ) );
 
         return;
     }
@@ -390,18 +396,17 @@ void StreamCommander::fetchCommand()
     {
         stringEnd = nl;
     }
-    else // If there's no CR/NL at all or if it's the first character, return -> no valid command found
+    else // If there's no CR/NL at all, or if it's the first character, return -> no valid command found
     {
         return;
     }
 
     // Parse command from buffer
-
     int commandEnd = commandBuffer.indexOf( getCommandDelimiter() );
     String command = "";
     String arguments = "";
 
-    // If there is no command-delimiter, we can't parse any arguments
+    // If there is no command-delimiter, we can't parse any arguments (cause there probably are none)
     if ( commandEnd == -1 )
     {
         // Set commandEnd to stringEnd, since our command ends there if no arguments are given
@@ -427,28 +432,23 @@ void StreamCommander::fetchCommand()
         }
     }
 
-    bool commandFound = false;
-
-    // Try to find our Input-Command and execute it
+    // Try to find our input-command and execute it
     CommandContainer * container = getCommandContainer( command );
 
     // If a container for this command has been found, try to call the callback
     if ( container != nullptr )
     {
-        commandFound = true;
-
         if ( container->callbackFunction != nullptr )
         {
-            // Call our Callback-Function with the arguments and our object-instace
+            // Call our Callback-Function with the arguments and our object-instance
             container->callbackFunction( arguments, this );
         }
         else
         {
-            sendError( F("Command-Callbackfunction is empty.") );
+            sendError( "Command callback function for command '" + command + "' is empty." );
         }
     }
-
-    if ( !commandFound )
+    else
     {
         getDefaultCallback()( command, arguments, this );
     }
@@ -476,7 +476,7 @@ void StreamCommander::sendError( String error )
 
 void StreamCommander::sendPing()
 {
-    sendMessage( MessageType::PING, "reply" );
+    sendMessage( MessageType::PING, PING_REPLY );
 }
 
 void StreamCommander::sendStatus()
@@ -523,11 +523,11 @@ void StreamCommander::commandSetEcho( String arguments, StreamCommander * instan
 {
     arguments.trim();
 
-    if ( arguments.equals( F("on") ) )
+    if ( arguments.equals( "on" ) )
     {
         instance->setEchoCommands( true );
     }
-    else if ( arguments.equals( F("off") ) )
+    else if ( arguments.equals( "off" ) )
     {
         instance->setEchoCommands( false );
     }
diff --git a/src/StreamCommander.hpp b/src/StreamCommander.hpp
@@ -1,4 +1,4 @@
-/*  
+/*
     Copyright 2019 Jan-Eric Schober
 
     Licensed under the Apache License, Version 2.0 (the "License");
@@ -49,6 +49,7 @@ class StreamCommander
     static const char COMMAND_DELIMITER = ' ';
     static const char MESSAGE_DELIMITER = ':';
     static const int ID_MAX_LENGTH = 32;
+    static const String PING_REPLY;
 
     static const String COMMAND_ACTIVATE;
     static const String COMMAND_DEACTIVATE;
@@ -79,13 +80,13 @@ class StreamCommander
     Stream * getStreamInstance(); // Gets the current streamInstance of the StreamCommander.
     void setAddStandardCommands( bool addStandardCommands ); // Sets whether the standard commands should be added or not (true/false).
     bool shouldAddStandardCommands(); // Returns whether the standard commadns should be added or not.
-    void saveIdToEEPROM( String id ); // Saves and ID to the EEPROM if it differs from the old one.
-    void loadIdFromEEPROM(); // Loads the ID from the EEPROM.
+    void saveIdToEeprom( String id ); // Saves and ID to the EEPROM if it differs from the old one.
+    void loadIdFromEeprom(); // Loads the ID from the EEPROM.
     void deleteCommands(); // Deletes all registered commands.
     void setNumCommands( int numCommands ); // Sets the number of the currently registered commands.
     void incrementNumCommands(); // Increments the number of the currently registered commands.
     CommandContainer * getCommandContainer( String command ); // Gets the container containing all commands.
-    int getCommandContainerNum( String command ); // Returns the number (position) of a specific command in the command container.
+    int getCommandContainerIndex( String command ); // Returns the index (position) of a specific command in the command container by name.
 
     static void commandActivate( String arguments, StreamCommander * instance );// Definition of the command COMMAND_ACTIVATE.
     static void commandDeactivate( String arguments, StreamCommander * instance ); // Definition of the command COMMAND_DEACTIVATE.
@@ -102,7 +103,7 @@ class StreamCommander
 public:
     // Constructor
     StreamCommander( Stream * streamInstance = &Serial ); // Constructor, instance of a Stream object as argument.
-    
+
     // Destructor
     ~StreamCommander();
 
@@ -141,15 +142,15 @@ class StreamCommander
     void fetchCommand(); // Fetches and interprets incoming commands, and invokes the corresponding callbacks. This should be called in the loop or after an interrupt/event.
 
     void sendMessage( String type, String content ); // Sends a message with a specific type and content separated by our delimiter.
-    void sendResponse( String response ); // Sends a message of type MessageType::RESPONSE
-    void sendInfo( String info ); // Sends a message of type MessageType::INFO
-    void sendError( String error ); // Sends a message of type MessageType::ERROR
-    void sendPing(); // Sends a message of type MessageType::PING, contains a "reply"
-    void sendStatus(); // Sends a message of type MessageType::STATUS, contains the current status
-    void sendId(); // Sends a message of type MessageType::ID, contains the current ID
-    void sendIsActive(); // Sends a message of type MessageType::ACTIVE, contains the current active status
-    void sendEcho( String echo ); // Sends a message of type MessageType::ECHO
-    void sendCommands(); // Sends a message of type MessageType::COMMANDS, contains a list of currently registered commands
+    void sendResponse( String response ); // Sends a message of type MessageType::RESPONSE.
+    void sendInfo( String info ); // Sends a message of type MessageType::INFO.
+    void sendError( String error ); // Sends a message of type MessageType::ERROR.
+    void sendPing(); // Sends a message of type MessageType::PING, contains a "reply".
+    void sendStatus(); // Sends a message of type MessageType::STATUS, contains the current status.
+    void sendId(); // Sends a message of type MessageType::ID, contains the current ID.
+    void sendIsActive(); // Sends a message of type MessageType::ACTIVE, contains the current active status.
+    void sendEcho( String echo ); // Sends a message of type MessageType::ECHO.
+    void sendCommands(); // Sends a message of type MessageType::COMMANDS, contains a list of currently registered commands.
 };
 
 #endif // STREAMCOMMANDER_HPP

Original file line number	Diff line number	Diff line change
`@@ -16,14 +16,15 @@`
`16`	`16`
`17`	`17`	`#include "StreamCommander.hpp"`
`18`	`18`
	`19`	`+const String StreamCommander::PING_REPLY = "reply";`
`19`	`20`	`const String StreamCommander::COMMAND_ACTIVATE = "activate";`
`20`	`21`	`const String StreamCommander::COMMAND_DEACTIVATE = "deactivate";`
`21`	`22`	`const String StreamCommander::COMMAND_ISACTIVE = "isactive";`
`22`		`-const String StreamCommander::COMMAND_SETECHO = "echo";`
	`23`	`+const String StreamCommander::COMMAND_SETECHO = "setecho";`
`23`	`24`	`const String StreamCommander::COMMAND_SETID = "setid";`
`24`	`25`	`const String StreamCommander::COMMAND_GETID = "getid";`
`25`	`26`	`const String StreamCommander::COMMAND_PING = "ping";`
`26`		`-const String StreamCommander::COMMAND_GETSTATUS = "status";`
	`27`	`+const String StreamCommander::COMMAND_GETSTATUS = "getstatus";`
`27`	`28`	`const String StreamCommander::COMMAND_LISTCOMMANDS = "commands";`
`28`	`29`
`29`	`30`	`StreamCommander::StreamCommander( Stream * streamInstance )`
`@@ -38,7 +39,7 @@ StreamCommander::~StreamCommander()`
`38`	`39`
`39`	`40`	`void StreamCommander::init( bool active, char commandDelimiter, char messageDelimiter, bool echoCommands, bool addStandardCommands, long streamBufferTimeout )`
`40`	`41`	`{`
`41`		`- loadIdFromEEPROM();`
	`42`	`+ loadIdFromEeprom();`
`42`	`43`	`setCommandDelimiter( commandDelimiter );`
`43`	`44`	`setMessageDelimiter( messageDelimiter );`
`44`	`45`	`setStreamBufferTimeout( streamBufferTimeout );`
`@@ -82,7 +83,8 @@ Stream * StreamCommander::getStreamInstance()`
`82`	`83`
`83`	`84`	`void StreamCommander::setActive( bool active )`
`84`	`85`	`{`
`85`		`- if ( isActive() != active ) // Only set our active-status if it's differing`
	`86`	`+ // Only set & send our active-status if it's differing`
	`87`	`+ if ( isActive() != active )`
`86`	`88`	`{`
`87`	`89`	`this->active = active;`
`88`	`90`
`@@ -137,10 +139,10 @@ bool StreamCommander::shouldAddStandardCommands()`
`137`	`139`
`138`	`140`	`void StreamCommander::setStreamBufferTimeout( long streamBufferTimeout )`
`139`	`141`	`{`
`140`		`- // Check for Input-Errors`
	`142`	`+ // Check if the timeout is over or equal to 0`
`141`	`143`	`if ( streamBufferTimeout < 0 )`
`142`	`144`	`{`
`143`		`- sendError( F("Timeout has to be >= 0.") );`
	`145`	`+ sendError( F( "Timeout has to be >= 0." ) );`
`144`	`146`
`145`	`147`	`return;`
`146`	`148`	`}`
`@@ -154,7 +156,7 @@ long StreamCommander::getStreamBufferTimeout()`
`154`	`156`	`return this->streamBufferTimeout;`
`155`	`157`	`}`
`156`	`158`
`157`		`-void StreamCommander::saveIdToEEPROM( String id )`
	`159`	`+void StreamCommander::saveIdToEeprom( String id )`
`158`	`160`	`{`
`159`	`161`	`// Since EEPROM.put can't handle strings, we have to convert it to a c_str`
`160`	`162`	`char idBuffer[ID_MAX_LENGTH];`
`@@ -163,7 +165,7 @@ void StreamCommander::saveIdToEEPROM( String id )`
`163`	`165`	`EEPROM.put( 0, idBuffer );`
`164`	`166`	`}`
`165`	`167`
`166`		`-void StreamCommander::loadIdFromEEPROM()`
	`168`	`+void StreamCommander::loadIdFromEeprom()`
`167`	`169`	`{`
`168`	`170`	`char id[ID_MAX_LENGTH];`
`169`	`171`	`EEPROM.get( 0, id );`
`@@ -173,22 +175,24 @@ void StreamCommander::loadIdFromEEPROM()`
`173`	`175`
`174`	`176`	`void StreamCommander::setId( String id )`
`175`	`177`	`{`
`176`		`- // Check for Errors`
	`178`	`+ // Check if the ID is too long`
`177`	`179`	`if ( id.length() > ID_MAX_LENGTH )`
`178`	`180`	`{`
`179`	`181`	`sendError( "ID '" + id + "' too long (ID_MAX_LENGTH = " + String( ID_MAX_LENGTH ) + ")." );`
`180`	`182`
`181`	`183`	`return;`
`182`	`184`	`}`
`183`	`185`
	`186`	`+ // Check whether the ID differs or not`
	`187`	`+ // Only proceed with the saving-process when it differs`
`184`	`188`	`if ( id.equals( getId() ) )`
`185`	`189`	`{`
`186`	`190`	`sendResponse( "ID is already '" + id + "'." );`
`187`	`191`
`188`	`192`	`return;`
`189`	`193`	`}`
`190`	`194`
`191`		`- saveIdToEEPROM( id );`
	`195`	`+ saveIdToEeprom( id );`
`192`	`196`	`this->id = id;`
`193`	`197`	`sendId();`
`194`	`198`	`}`
`@@ -210,7 +214,7 @@ void StreamCommander::updateStatus( String status )`
`210`	`214`	`{`
`211`	`215`	`setStatus( status );`
`212`	`216`
`213`		`- // Only send a Status-Update if our device is set active`
	`217`	`+ // Only send a status update if our device is set active`
`214`	`218`	`if ( isActive() )`
`215`	`219`	`{`
`216`	`220`	`sendStatus();`
`@@ -225,50 +229,52 @@ String StreamCommander::getStatus()`
`225`	`229`
`226`	`230`	`void StreamCommander::addCommand( String commandName, CommandCallbackFunction commandCallback )`
`227`	`231`	`{`
`228`		`- // Check for Input-Errors`
	`232`	`+ // Check that the command name is not empty`
`229`	`233`	`if ( commandName.length() == 0 )`
`230`	`234`	`{`
`231`		`- sendError( F("Command-Name must not be empty.") );`
	`235`	`+ sendError( F( "Command name must not be empty." ) );`
`232`	`236`
`233`	`237`	`return;`
`234`	`238`	`}`
`235`	`239`
	`240`	`+ // Check that the command callback function is not empty`
`236`	`241`	`if ( commandCallback == nullptr )`
`237`	`242`	`{`
`238`		`- sendError( F("Command-Callbackfunction must not be empty.") );`
	`243`	`+ sendError( F( "Command callback function must not be empty." ) );`
`239`	`244`
`240`	`245`	`return;`
`241`	`246`	`}`
`242`	`247`
`243`		`- int currentCommandNum = getNumCommands();`
`244`		`- bool commandFound = false;`
`245`		`- CommandContainer * container = getCommandContainer( commandName );`
	`248`	`+ // Sets the currentCommandIndex to -1 if this commandName has not been added yet, or to the array-index where it has been found`
	`249`	`+ int currentCommandIndex = getCommandContainerIndex( commandName );`
	`250`	`+ bool commandFound = true;`
`246`	`251`
`247`		`- // Check if the command has already been added`
`248`		`- if ( container != nullptr )`
	`252`	`+ // Check if the command has already been added or not`
	`253`	`+ // If not: sets the index to the next index where the new command will be added`
	`254`	`+ if ( currentCommandIndex < 0 )`
`249`	`255`	`{`
`250`		`- commandFound = true;`
`251`		`- currentCommandNum = getCommandContainerNum( commandName ); // Set the currentCommandNum to the array-position where it has been found`
	`256`	`+ currentCommandIndex = getNumCommands();`
	`257`	`+ commandFound = false;`
`252`	`258`	`}`
`253`	`259`
`254`	`260`	`// If the command has not been added yet, incease the array size and create a pointer to our commandName. Set the Callback in the next step.`
`255`	`261`	`// If it has already been added, just replace the old callback with the new one in the next step.`
`256`		`- if ( !commandFound )`
	`262`	`+ if ( !commandFound )`
`257`	`263`	`{`
`258`		`- commands = (CommandContainer) realloc( commands, ( currentCommandNum + 1 ) sizeof( CommandContainer ) );`
	`264`	`+ commands = (CommandContainer) realloc( commands, ( currentCommandIndex + 1 ) sizeof( CommandContainer ) );`
`259`	`265`	`incrementNumCommands();`
`260`	`266`
`261`	`267`	`// Create a pointer to our command-name. On destruction of the corresponding CommandContainer, it will get deleted.`
`262`	`268`	`String * commandNamePointer = new String( commandName );`
`263`		`- commands[currentCommandNum].command = commandNamePointer;`
	`269`	`+ commands[currentCommandIndex].command = commandNamePointer;`
`264`	`270`	`}`
`265`	`271`	`else`
`266`	`272`	`{`
`267`		`- sendInfo( "Command '" + commandName + "' already found. Replacing with new command." );`
	`273`	`+ sendInfo( "Command '" + commandName + "' already found. Replacing with new callback function." );`
`268`	`274`	`}`
`269`	`275`
`270`	`276`	`// Set the Callback-Function`
`271`		`- commands[currentCommandNum].callbackFunction = commandCallback;`
	`277`	`+ commands[currentCommandIndex].callbackFunction = commandCallback;`
`272`	`278`	`}`
`273`	`279`
`274`	`280`	`StreamCommander::CommandContainer * StreamCommander::getCommandContainer( String command )`
`@@ -284,7 +290,7 @@ StreamCommander::CommandContainer * StreamCommander::getCommandContainer( String`
`284`	`290`	`return nullptr;`
`285`	`291`	`}`
`286`	`292`
`287`		`-int StreamCommander::getCommandContainerNum( String command )`
	`293`	`+int StreamCommander::getCommandContainerIndex( String command )`
`288`	`294`	`{`
`289`	`295`	`for ( int i = 0; i < getNumCommands(); i++ )`
`290`	`296`	`{`
`@@ -328,7 +334,7 @@ String StreamCommander::getCommandList()`
`328`	`334`	`commandList = commandList + *(commands[i].command) + commandSeparator;`
`329`	`335`	`}`
`330`	`336`
`331`		`- // Remove the last command separator`
	`337`	`+ // Remove the last commandSeparator occurence`
`332`	`338`	`unsigned int listLength = commandList.length();`
`333`	`339`	`unsigned int separatorLength = commandSeparator.length();`
`334`	`340`
`@@ -342,10 +348,10 @@ String StreamCommander::getCommandList()`
`342`	`348`
`343`	`349`	`void StreamCommander::setDefaultCallback( DefaultCallbackFunction defaultCallbackFunction )`
`344`	`350`	`{`
`345`		`- // Check for Input-Errors`
	`351`	`+ // Check that the default callback function is not empty`
`346`	`352`	`if ( defaultCallbackFunction == nullptr )`
`347`	`353`	`{`
`348`		`- sendError( F("Default-Callbackfunction must not be empty.") );`
	`354`	`+ sendError( F( "Default callback function must not be empty." ) );`
`349`	`355`
`350`	`356`	`return;`
`351`	`357`	`}`
`@@ -390,18 +396,17 @@ void StreamCommander::fetchCommand()`
`390`	`396`	`{`
`391`	`397`	`stringEnd = nl;`
`392`	`398`	`}`
`393`		`- else // If there's no CR/NL at all or if it's the first character, return -> no valid command found`
	`399`	`+ else // If there's no CR/NL at all, or if it's the first character, return -> no valid command found`
`394`	`400`	`{`
`395`	`401`	`return;`
`396`	`402`	`}`
`397`	`403`
`398`	`404`	`// Parse command from buffer`
`399`		`-`
`400`	`405`	`int commandEnd = commandBuffer.indexOf( getCommandDelimiter() );`
`401`	`406`	`String command = "";`
`402`	`407`	`String arguments = "";`
`403`	`408`
`404`		`- // If there is no command-delimiter, we can't parse any arguments`
	`409`	`+ // If there is no command-delimiter, we can't parse any arguments (cause there probably are none)`
`405`	`410`	`if ( commandEnd == -1 )`
`406`	`411`	`{`
`407`	`412`	`// Set commandEnd to stringEnd, since our command ends there if no arguments are given`
`@@ -427,28 +432,23 @@ void StreamCommander::fetchCommand()`
`427`	`432`	`}`
`428`	`433`	`}`
`429`	`434`
`430`		`- bool commandFound = false;`
`431`		`-`
`432`		`- // Try to find our Input-Command and execute it`
	`435`	`+ // Try to find our input-command and execute it`
`433`	`436`	`CommandContainer * container = getCommandContainer( command );`
`434`	`437`
`435`	`438`	`// If a container for this command has been found, try to call the callback`
`436`	`439`	`if ( container != nullptr )`
`437`	`440`	`{`
`438`		`- commandFound = true;`
`439`		`-`
`440`	`441`	`if ( container->callbackFunction != nullptr )`
`441`	`442`	`{`
`442`		`- // Call our Callback-Function with the arguments and our object-instace`
	`443`	`+ // Call our Callback-Function with the arguments and our object-instance`
`443`	`444`	`container->callbackFunction( arguments, this );`
`444`	`445`	`}`
`445`	`446`	`else`
`446`	`447`	`{`
`447`		`- sendError( F("Command-Callbackfunction is empty.") );`
	`448`	`+ sendError( "Command callback function for command '" + command + "' is empty." );`
`448`	`449`	`}`
`449`	`450`	`}`
`450`		`-`
`451`		`- if ( !commandFound )`
	`451`	`+ else`
`452`	`452`	`{`
`453`	`453`	`getDefaultCallback()( command, arguments, this );`
`454`	`454`	`}`
`@@ -476,7 +476,7 @@ void StreamCommander::sendError( String error )`
`476`	`476`
`477`	`477`	`void StreamCommander::sendPing()`
`478`	`478`	`{`
`479`		`- sendMessage( MessageType::PING, "reply" );`
	`479`	`+ sendMessage( MessageType::PING, PING_REPLY );`
`480`	`480`	`}`
`481`	`481`
`482`	`482`	`void StreamCommander::sendStatus()`
`@@ -523,11 +523,11 @@ void StreamCommander::commandSetEcho( String arguments, StreamCommander * instan`
`523`	`523`	`{`
`524`	`524`	`arguments.trim();`
`525`	`525`
`526`		`- if ( arguments.equals( F("on") ) )`
	`526`	`+ if ( arguments.equals( "on" ) )`
`527`	`527`	`{`
`528`	`528`	`instance->setEchoCommands( true );`
`529`	`529`	`}`
`530`		`- else if ( arguments.equals( F("off") ) )`
	`530`	`+ else if ( arguments.equals( "off" ) )`
`531`	`531`	`{`
`532`	`532`	`instance->setEchoCommands( false );`
`533`	`533`	`}`