Improve code quality in encoding module

include/ls-std/encoding/Base64.hpp

@@ -3,23 +3,22 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-01-03
- * Changed:         2023-05-15
+ * Changed:         2024-05-31
  *
  * */
 
 #ifndef LS_STD_BASE64_HPP
 #define LS_STD_BASE64_HPP
 
-#include <bitset>
+#include <ls-std/core/definition.hpp>
 #include <ls-std/core/interface/IEncoding.hpp>
-#include <ls-std/os/dynamic-goal.hpp>
 #include <string_view>
 #include <unordered_map>
 #include <vector>
 
 namespace ls::std::encoding
 {
-  class LS_STD_DYNAMIC_GOAL Base64 : public ls::std::core::interface_type::IEncoding
+  ls_std_class Base64 final : public core::interface_type::IEncoding
   {
     public:
 

source/ls-std/encoding/Base64.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-01-03
- * Changed:         2023-05-15
+ * Changed:         2024-05-31
  *
  * */
 
@@ -26,11 +26,11 @@ string Base64::encode(const string &_sequence)
 
   for (size_t index = 0; index < _sequence.size(); index += 3)
   {
-    string_view byteTriple = Base64::_getNextByteTriple(_sequence, index);
-    encodedString += Base64::_encodeByteTriple(byteTriple);
+    const string_view byteTriple = _getNextByteTriple(_sequence, index);
+    encodedString += _encodeByteTriple(byteTriple);
   }
 
-  return Base64::_applyEndingRule(encodedString, _sequence.size());
+  return _applyEndingRule(encodedString, _sequence.size());
 }
 
 string Base64::decode(const string &_sequence)
@@ -39,16 +39,16 @@ string Base64::decode(const string &_sequence)
 
   for (int index{}; index < _sequence.size(); index += 4)
   {
-    string_view quadruple = Base64::_getNextByteQuadruple(string_view{_sequence}, index);
-    decodedString += Base64::_decodeByteQuadruple(quadruple);
+    const string_view quadruple = _getNextByteQuadruple(string_view{_sequence}, index);
+    decodedString += _decodeByteQuadruple(quadruple);
   }
 
   return decodedString;
 }
 
-string Base64::_applyEndingRule(string _encodedString, size_t _sequenceSize)
+string Base64::_applyEndingRule(string _encodedString, const size_t _sequenceSize)
 {
-  size_t size = _encodedString.size();
+  const size_t size = _encodedString.size();
 
   if (_sequenceSize % 3 == 1)
   {
@@ -64,50 +64,50 @@ string Base64::_applyEndingRule(string _encodedString, size_t _sequenceSize)
   return _encodedString;
 }
 
-string Base64::_decodeByteQuadruple(string_view _quadruple)
+string Base64::_decodeByteQuadruple(const string_view _quadruple)
 {
   string decodedText{};
   uint8_t shiftValue = 16;
-  uint32_t bitStorage = Base64::_toDecodingBitStorage(_quadruple);
+  const uint32_t bitStorage = _toDecodingBitStorage(_quadruple);
 
-  for (uint8_t index = 0; index < ((uint8_t) _quadruple.size() - 1); index++)
+  for (uint8_t index = 0; index < static_cast<uint8_t>(_quadruple.size()) - 1; index++)
   {
-    uint32_t bitMask = Base64::_generateBitMask(255, shiftValue);
-    uint32_t bitSequence = Base64::_extractBitSequence(bitMask, bitStorage);
+    const uint32_t bitMask = _generateBitMask(255, shiftValue);
+    uint32_t bitSequence = _extractBitSequence(bitMask, bitStorage);
     bitSequence = bitSequence >> shiftValue;
 
-    decodedText += (char) bitSequence;
+    decodedText += static_cast<char>(bitSequence);
     shiftValue -= 8;
   }
 
   return decodedText;
 }
 
-string Base64::_encodeByteTriple(string_view _byteTriple)
+string Base64::_encodeByteTriple(const string_view _byteTriple)
 {
   string encodedText{};
-  uint32_t bitStorage = Base64::_toEncodingBitStorage(_byteTriple);
+  const uint32_t bitStorage = _toEncodingBitStorage(_byteTriple);
   static vector<uint32_t> bitMaskStorage = {16515072, 258048, 4032, 63};
-  static unordered_map<uint8_t, char> encodingMap = Base64::_getEncodingMap();
+  static unordered_map<uint8_t, char> encodingMap = _getEncodingMap();
   uint8_t shiftValue = 18;
 
   for (uint8_t bitMaskIndex = 0; bitMaskIndex < 4; bitMaskIndex++)
   {
-    uint32_t extractedBitSequence = Base64::_extractBitSequence(bitMaskStorage[bitMaskIndex], bitStorage);
+    uint32_t extractedBitSequence = _extractBitSequence(bitMaskStorage[bitMaskIndex], bitStorage);
     extractedBitSequence = extractedBitSequence >> shiftValue;
-    encodedText += encodingMap[(uint8_t) extractedBitSequence];
+    encodedText += encodingMap[static_cast<uint8_t>(extractedBitSequence)];
     shiftValue -= 6;
   }
 
   return encodedText;
 }
 
-uint32_t Base64::_extractBitSequence(uint32_t _bitMask, uint32_t _bitStorage)
+uint32_t Base64::_extractBitSequence(const uint32_t _bitMask, const uint32_t _bitStorage)
 {
   return _bitStorage & _bitMask;
 }
 
-uint32_t Base64::_generateBitMask(uint32_t _maskValue, uint8_t _shiftValue)
+uint32_t Base64::_generateBitMask(const uint32_t _maskValue, const uint8_t _shiftValue)
 {
   uint32_t bitmask = _maskValue << _shiftValue;
 
@@ -136,12 +136,12 @@ unordered_map<uint8_t, char> Base64::_getEncodingMap()
   return encodingMap;
 }
 
-string_view Base64::_getNextByteQuadruple(string_view _sequence, size_t _index)
+string_view Base64::_getNextByteQuadruple(const string_view _sequence, const size_t _index)
 {
   return _sequence.substr(_index, 4);
 }
 
-string_view Base64::_getNextByteTriple(string_view _sequence, size_t _index)
+string_view Base64::_getNextByteTriple(const string_view _sequence, const size_t _index)
 {
   return _sequence.substr(_index, 3);
 }
@@ -151,31 +151,31 @@ void Base64::_mergeBitSequence(uint32_t &_bitStorage, const uint32_t &_bitMask)
   _bitStorage = _bitStorage | _bitMask;
 }
 
-uint32_t Base64::_toDecodingBitStorage(string_view _quadruple)
+uint32_t Base64::_toDecodingBitStorage(const string_view _quadruple)
 {
   uint32_t bitStorage{};
   uint8_t letterCounter = 1;
-  unordered_map<char, uint8_t> decodingMap = Base64::_getDecodingMap();
+  unordered_map<char, uint8_t> decodingMap = _getDecodingMap();
 
   for (char letter : _quadruple)
   {
-    uint32_t bitMask = Base64::_generateBitMask(decodingMap[letter], (4 - letterCounter) * 6); // must be hardcoded - even in case of less than 4 characters, so that conversion is correct
-    Base64::_mergeBitSequence(bitStorage, bitMask);
+    uint32_t bitMask = _generateBitMask(decodingMap[letter], (4 - letterCounter) * 6); // must be hardcoded - even in case of less than 4 characters, so that conversion is correct
+    _mergeBitSequence(bitStorage, bitMask);
     ++letterCounter;
   }
 
   return bitStorage;
 }
 
-uint32_t Base64::_toEncodingBitStorage(string_view _triple)
+uint32_t Base64::_toEncodingBitStorage(const string_view _triple)
 {
   uint32_t bitStorage{};
   uint8_t shiftValue = 16;
 
-  for (char letter : _triple)
+  for (const char letter : _triple)
   {
-    uint32_t bitMask = Base64::_generateBitMask((uint8_t) letter, shiftValue);
-    Base64::_mergeBitSequence(bitStorage, bitMask);
+    uint32_t bitMask = _generateBitMask(static_cast<uint8_t>(letter), shiftValue);
+    _mergeBitSequence(bitStorage, bitMask);
     shiftValue -= 8;
   }
 

source/ls-std/encoding/cli/cli-base64-main.cpp

@@ -3,7 +3,7 @@
  * Company:         Lynar Studios
  * E-Mail:          webmaster@lynarstudios.com
  * Created:         2022-07-03
- * Changed:         2023-05-18
+ * Changed:         2024-05-31
  *
  * */
 
@@ -26,9 +26,9 @@ using CliCommand = vector<string>;
 void printHelp();
 bool isValidCommand(const CliCommand &_command);
 
-int main(int argc, char *argv[])
+int main(const int argc, char *argv[])
 {
-  if (CliCommand command(argv, argv + argc); isValidCommand(command))
+  if (const CliCommand command(argv, argv + argc); isValidCommand(command))
   {
     if (command[1] == "--encode")
     {