wording fixes

einspunktnull · einspunktnull · commit 9c604fb26f1f · 2024-05-22T16:19:40.000+02:00
diff --git a/src/SimpleSerialProtocol.cpp b/src/SimpleSerialProtocol.cpp
@@ -88,15 +88,15 @@ SimpleSerialProtocol::SimpleSerialProtocol(
     Serial_& usbapiSerialRef,
     const unsigned long baudrate,
     const unsigned long waitForByteTimeout,
-    const ErrorCallbackPointer _standaloneErrorCallbackPointer,
+    const ErrorCallbackPointer _errorCallbackPointer,
     const byte _commandCallbackRangeFrom,
     const byte _commandCallbackRangeTo) :
     SimpleSerialProtocol{
         static_cast<Stream&>(usbapiSerialRef),
         false,
         baudrate,
         waitForByteTimeout,
-        _standaloneErrorCallbackPointer,
+        _errorCallbackPointer,
         _commandCallbackRangeFrom,
         _commandCallbackRangeTo
     }
@@ -107,15 +107,15 @@ SimpleSerialProtocol::SimpleSerialProtocol(
     Serial_* usbapiSerialPtr,
     const unsigned long baudrate,
     const unsigned long waitForByteTimeout,
-    const ErrorCallbackPointer _standaloneErrorCallbackPointer,
+    const ErrorCallbackPointer _errorCallbackPointer,
     const byte _commandCallbackRangeFrom,
     const byte _commandCallbackRangeTo) :
     SimpleSerialProtocol{
         static_cast<Stream*>(usbapiSerialPtr),
         false,
         baudrate,
         waitForByteTimeout,
-        _standaloneErrorCallbackPointer,
+        _errorCallbackPointer,
         _commandCallbackRangeFrom,
         _commandCallbackRangeTo
     }
@@ -141,7 +141,7 @@ SimpleSerialProtocol::SimpleSerialProtocol(
     },
     _commandCallbackRangeFrom{commandCallbackRangeFrom},
     _commandCallbackRangeTo{commandCallbackRangeTo},
-    _standaloneErrorCallbackPointer{errorCallbackPointer}
+    _errorCallbackPointer{errorCallbackPointer}
 {
     _afterConstructor();
 }
@@ -163,24 +163,24 @@ SimpleSerialProtocol::SimpleSerialProtocol(
     },
     _commandCallbackRangeFrom{commandCallbackRangeFrom},
     _commandCallbackRangeTo{commandCallbackRangeTo},
-    _standaloneErrorCallbackPointer{errorCallbackPointer}
+    _errorCallbackPointer{errorCallbackPointer}
 {
     _afterConstructor();
 }
 
 SimpleSerialProtocol::~SimpleSerialProtocol()
 {
-    delete[] this->_standaloneCommandCallbackPointers;
+    delete[] this->_commandCallbackPointers;
 }
 
 void SimpleSerialProtocol::_afterConstructor()
 {
     const byte commandCallbackPointerBufferMaxIndex = abs(_commandCallbackRangeTo - _commandCallbackRangeFrom);
     const uint16_t commandCallbackPointerBufferSize = static_cast<uint16_t>(commandCallbackPointerBufferMaxIndex) + 1;
-    this->_standaloneCommandCallbackPointers = new CallbackPointer[commandCallbackPointerBufferSize];
+    this->_commandCallbackPointers = new CallbackPointer[commandCallbackPointerBufferSize];
     for (uint16_t i = 0; i <= commandCallbackPointerBufferMaxIndex; i++)
     {
-        this->_standaloneCommandCallbackPointers[i] = nullptr;
+        this->_commandCallbackPointers[i] = nullptr;
     }
 }
 
@@ -256,12 +256,12 @@ void SimpleSerialProtocol::writeEot() const
     this->writeByte(CHAR_EOT);
 }
 
-void SimpleSerialProtocol::setDieInstantlyOnNotRegisteredCommand(const bool die)
+void SimpleSerialProtocol::setDieImmediatelyOnNotRegisteredCommand(const bool die)
 {
     this->_dieImmediatelyOnNotRegisteredCommand = die;
 }
 
-void SimpleSerialProtocol::registerCommand(const byte command, const CallbackPointer callbackPointer)
+void SimpleSerialProtocol::registerCommand(const byte command, const CallbackPointer commandCallbackPointer)
 {
     //	Serial.println(F("SimpleSerialProtocol::registerCommand"));
 
@@ -283,7 +283,7 @@ void SimpleSerialProtocol::registerCommand(const byte command, const CallbackPoi
         return;
     }
 
-    this->_registerCommandCallback(command, callbackPointer);
+    this->_registerCommandCallback(command, commandCallbackPointer);
 }
 
 void SimpleSerialProtocol::unregisterCommand(const byte command)
@@ -357,13 +357,13 @@ void SimpleSerialProtocol::_registerCommandCallback(
 ) const
 {
     const uint8_t commandIndex = this->_getCommandIndex(command);
-    this->_standaloneCommandCallbackPointers[commandIndex] = commandCallbackPointer;
+    this->_commandCallbackPointers[commandIndex] = commandCallbackPointer;
 }
 
 void SimpleSerialProtocol::_unregisterCommandCallback(const byte command) const
 {
     const uint8_t commandIndex = this->_getCommandIndex(command);
-    this->_standaloneCommandCallbackPointers[commandIndex] = nullptr;
+    this->_commandCallbackPointers[commandIndex] = nullptr;
 }
 
 bool SimpleSerialProtocol::_isCommandRangeValid() const
@@ -384,7 +384,7 @@ bool SimpleSerialProtocol::_isCommandInReservedRange(const byte command) const
 bool SimpleSerialProtocol::_isCommandRegistered(const byte command) const
 {
     const uint8_t commandIndex = this->_getCommandIndex(command);
-    return this->_standaloneCommandCallbackPointers[commandIndex] != nullptr;
+    return this->_commandCallbackPointers[commandIndex] != nullptr;
 }
 
 uint8_t SimpleSerialProtocol::_getCommandIndex(const byte command) const
@@ -395,13 +395,13 @@ uint8_t SimpleSerialProtocol::_getCommandIndex(const byte command) const
 void SimpleSerialProtocol::_callCommandCallback(const byte command) const
 {
     const uint8_t commandIndex = this->_getCommandIndex(command);
-    const CallbackPointer commandCallbackPointer = this->_standaloneCommandCallbackPointers[commandIndex];
+    const CallbackPointer commandCallbackPointer = this->_commandCallbackPointers[commandIndex];
     commandCallbackPointer();
 }
 
 void SimpleSerialProtocol::_error(const uint8_t errorNum, const bool dieImmediately)
 {
-    this->_standaloneErrorCallbackPointer(errorNum);
+    this->_errorCallbackPointer(errorNum);
     if (dieImmediately) this->_die();
 }
 
@@ -435,5 +435,5 @@ void SimpleSerialProtocol::_flushCommand()
 void SimpleSerialProtocol::_die()
 {
     this->_isDead = true;
-    this->_standaloneErrorCallbackPointer(ERROR_IS_DEAD);
+    this->_errorCallbackPointer(ERROR_IS_DEAD);
 }
diff --git a/src/SimpleSerialProtocol.h b/src/SimpleSerialProtocol.h
@@ -33,12 +33,8 @@ constexpr uint8_t ERROR_END_OF_STRING_BYTE_NOT_IN_CHAR_ARRAY = 6;
 class SimpleSerialProtocol final : public Core
 {
 public:
-    using StandaloneCallbackPointer = void (*)();
-    using StandaloneErrorCallbackPointer = void (*)(uint8_t errorNum);
-    template <typename T>
-    using MemberCallbackPointer = void (T::*)();
-    template <typename T>
-    using MemberErrorCallbackPointer = void (T::*)(uint8_t errorNum);
+    using CallbackPointer = void (*)();
+    using ErrorCallbackPointer = void (*)(uint8_t errorNum);
 
 
 #ifdef SOFTWARESERIAL_SUPPORTED
@@ -47,26 +43,27 @@ class SimpleSerialProtocol final : public Core
         SoftwareSerial& softwareSerialRef,
         unsigned long baudrate,
         unsigned long waitForByteTimeout,
-        StandaloneErrorCallbackPointer errorCallbackPointer = nullptr,
+        ErrorCallbackPointer errorCallbackPointer = nullptr,
         byte commandCallbackRangeFrom = COMMAND_CALLBACK_RANGE_FROM,
         byte commandCallbackRangeTo = COMMAND_CALLBACK_RANGE_TO);
 
     SimpleSerialProtocol(
         SoftwareSerial* softwareSerialPtr,
         unsigned long baudrate,
         unsigned long waitForByteTimeout,
-        StandaloneErrorCallbackPointer errorCallbackPointer = nullptr,
+        ErrorCallbackPointer errorCallbackPointer = nullptr,
         byte commandCallbackRangeFrom = COMMAND_CALLBACK_RANGE_FROM,
         byte commandCallbackRangeTo = COMMAND_CALLBACK_RANGE_TO);
 
 #endif
 
 #ifdef HARDWARESERIAL
+
     SimpleSerialProtocol(
         HardwareSerial& hardwareSerialRef,
         unsigned long baudrate,
         unsigned long waitForByteTimeout,
-        StandaloneErrorCallbackPointer errorCallbackPointer = nullptr,
+        ErrorCallbackPointer errorCallbackPointer = nullptr,
         byte commandCallbackRangeFrom = COMMAND_CALLBACK_RANGE_FROM,
         byte commandCallbackRangeTo = COMMAND_CALLBACK_RANGE_TO
     );
@@ -75,7 +72,7 @@ class SimpleSerialProtocol final : public Core
         HardwareSerial* hardwareSerialPtr,
         unsigned long baudrate,
         unsigned long waitForByteTimeout,
-        StandaloneErrorCallbackPointer errorCallbackPointer = nullptr,
+        ErrorCallbackPointer errorCallbackPointer = nullptr,
         byte commandCallbackRangeFrom = COMMAND_CALLBACK_RANGE_FROM,
         byte commandCallbackRangeTo = COMMAND_CALLBACK_RANGE_TO
     );
@@ -106,8 +103,8 @@ class SimpleSerialProtocol final : public Core
     SimpleSerialProtocol& operator=(const SimpleSerialProtocol&) = delete; // verbiete Copy-Asssignment
 
     void init() override;
-    void setDieInstantlyOnNotRegisteredCommand(bool die);
-    void registerCommand(byte command, StandaloneCallbackPointer commandCallbackPointer);
+    void setDieImmediatelyOnNotRegisteredCommand(bool die);
+    void registerCommand(byte command, CallbackPointer commandCallbackPointer);
     void unregisterCommand(byte command);
     bool loop();
     byte readCommand();
@@ -126,7 +123,7 @@ class SimpleSerialProtocol final : public Core
     bool _isCommandRegistered(byte command) const;
     void _onWaitForByteTimeout() override;
     void _onGotCommandByte(byte command);
-    void _registerCommandCallback(byte command, StandaloneCallbackPointer commandCallbackPointer) const;
+    void _registerCommandCallback(byte command, CallbackPointer commandCallbackPointer) const;
     void _unregisterCommandCallback(byte command) const;
     uint8_t _getCommandIndex(byte command) const;
     void _callCommandCallback(byte command) const;
@@ -139,7 +136,7 @@ class SimpleSerialProtocol final : public Core
         bool isSoftwareSerial,
         unsigned long baudrate,
         unsigned long waitForByteTimeout,
-        StandaloneErrorCallbackPointer errorCallbackPointer,
+        ErrorCallbackPointer errorCallbackPointer,
         byte commandCallbackRangeFrom,
         byte commandCallbackRangeTo
     );
@@ -148,15 +145,13 @@ class SimpleSerialProtocol final : public Core
         bool isSoftwareSerial,
         unsigned long baudrate,
         unsigned long waitForByteTimeout,
-        StandaloneErrorCallbackPointer errorCallbackPointer,
+        ErrorCallbackPointer errorCallbackPointer,
         byte commandCallbackRangeFrom,
         byte commandCallbackRangeTo
     );
 
-    StandaloneErrorCallbackPointer _standaloneErrorCallbackPointer = nullptr;
-    StandaloneCallbackPointer* _standaloneCommandCallbackPointers = nullptr;
-    // MemberErrorCallbackPointer* commandCallbackPointers = nullptr;
-    // MemberCallbackPointer* commandCallbackPointers = nullptr;
+    ErrorCallbackPointer _errorCallbackPointer = nullptr;
+    CallbackPointer* _commandCallbackPointers = nullptr;
 
     bool _dieImmediatelyOnNotRegisteredCommand = true;
     bool _isWaitingForReadEot = false;

Original file line number	Diff line number	Diff line change
`@@ -88,15 +88,15 @@ SimpleSerialProtocol::SimpleSerialProtocol(`
`88`	`88`	`Serial_& usbapiSerialRef,`
`89`	`89`	`const unsigned long baudrate,`
`90`	`90`	`const unsigned long waitForByteTimeout,`
`91`		`- const ErrorCallbackPointer _standaloneErrorCallbackPointer,`
	`91`	`+ const ErrorCallbackPointer _errorCallbackPointer,`
`92`	`92`	`const byte _commandCallbackRangeFrom,`
`93`	`93`	`const byte _commandCallbackRangeTo) :`
`94`	`94`	`SimpleSerialProtocol{`
`95`	`95`	`static_cast<Stream&>(usbapiSerialRef),`
`96`	`96`	`false,`
`97`	`97`	`baudrate,`
`98`	`98`	`waitForByteTimeout,`
`99`		`- _standaloneErrorCallbackPointer,`
	`99`	`+ _errorCallbackPointer,`
`100`	`100`	`_commandCallbackRangeFrom,`
`101`	`101`	`_commandCallbackRangeTo`
`102`	`102`	`}`
`@@ -107,15 +107,15 @@ SimpleSerialProtocol::SimpleSerialProtocol(`
`107`	`107`	`Serial_* usbapiSerialPtr,`
`108`	`108`	`const unsigned long baudrate,`
`109`	`109`	`const unsigned long waitForByteTimeout,`
`110`		`- const ErrorCallbackPointer _standaloneErrorCallbackPointer,`
	`110`	`+ const ErrorCallbackPointer _errorCallbackPointer,`
`111`	`111`	`const byte _commandCallbackRangeFrom,`
`112`	`112`	`const byte _commandCallbackRangeTo) :`
`113`	`113`	`SimpleSerialProtocol{`
`114`	`114`	`static_cast<Stream*>(usbapiSerialPtr),`
`115`	`115`	`false,`
`116`	`116`	`baudrate,`
`117`	`117`	`waitForByteTimeout,`
`118`		`- _standaloneErrorCallbackPointer,`
	`118`	`+ _errorCallbackPointer,`
`119`	`119`	`_commandCallbackRangeFrom,`
`120`	`120`	`_commandCallbackRangeTo`
`121`	`121`	`}`
`@@ -141,7 +141,7 @@ SimpleSerialProtocol::SimpleSerialProtocol(`
`141`	`141`	`},`
`142`	`142`	`_commandCallbackRangeFrom{commandCallbackRangeFrom},`
`143`	`143`	`_commandCallbackRangeTo{commandCallbackRangeTo},`
`144`		`- _standaloneErrorCallbackPointer{errorCallbackPointer}`
	`144`	`+ _errorCallbackPointer{errorCallbackPointer}`
`145`	`145`	`{`
`146`	`146`	`_afterConstructor();`
`147`	`147`	`}`
`@@ -163,24 +163,24 @@ SimpleSerialProtocol::SimpleSerialProtocol(`
`163`	`163`	`},`
`164`	`164`	`_commandCallbackRangeFrom{commandCallbackRangeFrom},`
`165`	`165`	`_commandCallbackRangeTo{commandCallbackRangeTo},`
`166`		`- _standaloneErrorCallbackPointer{errorCallbackPointer}`
	`166`	`+ _errorCallbackPointer{errorCallbackPointer}`
`167`	`167`	`{`
`168`	`168`	`_afterConstructor();`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`SimpleSerialProtocol::~SimpleSerialProtocol()`
`172`	`172`	`{`
`173`		`- delete[] this->_standaloneCommandCallbackPointers;`
	`173`	`+ delete[] this->_commandCallbackPointers;`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`void SimpleSerialProtocol::_afterConstructor()`
`177`	`177`	`{`
`178`	`178`	`const byte commandCallbackPointerBufferMaxIndex = abs(_commandCallbackRangeTo - _commandCallbackRangeFrom);`
`179`	`179`	`const uint16_t commandCallbackPointerBufferSize = static_cast<uint16_t>(commandCallbackPointerBufferMaxIndex) + 1;`
`180`		`- this->_standaloneCommandCallbackPointers = new CallbackPointer[commandCallbackPointerBufferSize];`
	`180`	`+ this->_commandCallbackPointers = new CallbackPointer[commandCallbackPointerBufferSize];`
`181`	`181`	`for (uint16_t i = 0; i <= commandCallbackPointerBufferMaxIndex; i++)`
`182`	`182`	`{`
`183`		`- this->_standaloneCommandCallbackPointers[i] = nullptr;`
	`183`	`+ this->_commandCallbackPointers[i] = nullptr;`
`184`	`184`	`}`
`185`	`185`	`}`
`186`	`186`
`@@ -256,12 +256,12 @@ void SimpleSerialProtocol::writeEot() const`
`256`	`256`	`this->writeByte(CHAR_EOT);`
`257`	`257`	`}`
`258`	`258`
`259`		`-void SimpleSerialProtocol::setDieInstantlyOnNotRegisteredCommand(const bool die)`
	`259`	`+void SimpleSerialProtocol::setDieImmediatelyOnNotRegisteredCommand(const bool die)`
`260`	`260`	`{`
`261`	`261`	`this->_dieImmediatelyOnNotRegisteredCommand = die;`
`262`	`262`	`}`
`263`	`263`
`264`		`-void SimpleSerialProtocol::registerCommand(const byte command, const CallbackPointer callbackPointer)`
	`264`	`+void SimpleSerialProtocol::registerCommand(const byte command, const CallbackPointer commandCallbackPointer)`
`265`	`265`	`{`
`266`	`266`	`// Serial.println(F("SimpleSerialProtocol::registerCommand"));`
`267`	`267`
`@@ -283,7 +283,7 @@ void SimpleSerialProtocol::registerCommand(const byte command, const CallbackPoi`
`283`	`283`	`return;`
`284`	`284`	`}`
`285`	`285`
`286`		`- this->_registerCommandCallback(command, callbackPointer);`
	`286`	`+ this->_registerCommandCallback(command, commandCallbackPointer);`
`287`	`287`	`}`
`288`	`288`
`289`	`289`	`void SimpleSerialProtocol::unregisterCommand(const byte command)`
`@@ -357,13 +357,13 @@ void SimpleSerialProtocol::_registerCommandCallback(`
`357`	`357`	`) const`
`358`	`358`	`{`
`359`	`359`	`const uint8_t commandIndex = this->_getCommandIndex(command);`
`360`		`- this->_standaloneCommandCallbackPointers[commandIndex] = commandCallbackPointer;`
	`360`	`+ this->_commandCallbackPointers[commandIndex] = commandCallbackPointer;`
`361`	`361`	`}`
`362`	`362`
`363`	`363`	`void SimpleSerialProtocol::_unregisterCommandCallback(const byte command) const`
`364`	`364`	`{`
`365`	`365`	`const uint8_t commandIndex = this->_getCommandIndex(command);`
`366`		`- this->_standaloneCommandCallbackPointers[commandIndex] = nullptr;`
	`366`	`+ this->_commandCallbackPointers[commandIndex] = nullptr;`
`367`	`367`	`}`
`368`	`368`
`369`	`369`	`bool SimpleSerialProtocol::_isCommandRangeValid() const`
`@@ -384,7 +384,7 @@ bool SimpleSerialProtocol::_isCommandInReservedRange(const byte command) const`
`384`	`384`	`bool SimpleSerialProtocol::_isCommandRegistered(const byte command) const`
`385`	`385`	`{`
`386`	`386`	`const uint8_t commandIndex = this->_getCommandIndex(command);`
`387`		`- return this->_standaloneCommandCallbackPointers[commandIndex] != nullptr;`
	`387`	`+ return this->_commandCallbackPointers[commandIndex] != nullptr;`
`388`	`388`	`}`
`389`	`389`
`390`	`390`	`uint8_t SimpleSerialProtocol::_getCommandIndex(const byte command) const`
`@@ -395,13 +395,13 @@ uint8_t SimpleSerialProtocol::_getCommandIndex(const byte command) const`
`395`	`395`	`void SimpleSerialProtocol::_callCommandCallback(const byte command) const`
`396`	`396`	`{`
`397`	`397`	`const uint8_t commandIndex = this->_getCommandIndex(command);`
`398`		`- const CallbackPointer commandCallbackPointer = this->_standaloneCommandCallbackPointers[commandIndex];`
	`398`	`+ const CallbackPointer commandCallbackPointer = this->_commandCallbackPointers[commandIndex];`
`399`	`399`	`commandCallbackPointer();`
`400`	`400`	`}`
`401`	`401`
`402`	`402`	`void SimpleSerialProtocol::_error(const uint8_t errorNum, const bool dieImmediately)`
`403`	`403`	`{`
`404`		`- this->_standaloneErrorCallbackPointer(errorNum);`
	`404`	`+ this->_errorCallbackPointer(errorNum);`
`405`	`405`	`if (dieImmediately) this->_die();`
`406`	`406`	`}`
`407`	`407`
`@@ -435,5 +435,5 @@ void SimpleSerialProtocol::_flushCommand()`
`435`	`435`	`void SimpleSerialProtocol::_die()`
`436`	`436`	`{`
`437`	`437`	`this->_isDead = true;`
`438`		`- this->_standaloneErrorCallbackPointer(ERROR_IS_DEAD);`
	`438`	`+ this->_errorCallbackPointer(ERROR_IS_DEAD);`
`439`	`439`	`}`