Line data    Source code

       1              : #pragma once
       2              : 
       3              : #include <AH/STL/utility> // std::forward
       4              : #include <AH/STL/vector>  // std::vector
       5              : #include <Settings/NamespaceSettings.hpp>
       6              : #include <ctype.h> // isxdigit, tolower
       7              : 
       8              : BEGIN_CS_NAMESPACE
       9              : 
      10              : /**
      11              :  * @brief   Class that parses hexadecimal ASCII text to bytes.
      12              :  *
      13              :  * For example, parses the string `"7f A 123456"` to the bytes 
      14              :  * `{0x7F, 0x0A, 0x12, 0x34, 0x56}`.
      15              :  *
      16              :  * @tparam  CharPuller
      17              :  *          Class that supplies the ASCII characters to parse.
      18              :  *
      19              :  * @see     @ref BufferPuller
      20              :  * @see     @ref StreamPuller
      21              :  * 
      22              :  * @ingroup MIDIParsers
      23              :  */
      24              : template <class CharPuller>
      25              : class HexPuller {
      26              :   public:
      27           16 :     HexPuller(CharPuller &&puller) : puller(std::forward<CharPuller>(puller)) {}
      28              : 
      29              :     /// Pull out a new byte. Pulls characters from the `CharPuller` until a
      30              :     /// hexadecimal number was found, decodes it, and returns it.
      31              :     ///
      32              :     /// @param[out] output
      33              :     ///             A new byte (if available).
      34              :     /// @return True if a byte was available, false otherwise.
      35           21 :     bool pull(uint8_t &output) {
      36           21 :         uint8_t input;
      37           53 :         while (puller.pull(input)) {
      38              :             // If we receive a hexadecimal digit
      39           53 :             if (isxdigit(input)) {
      40           40 :                 (char1 ? char2 : char1) = tolower(input);
      41              :             }
      42              :             // If we received two hex characters
      43           53 :             if (char1 && char2) {
      44           19 :                 output = hex2int(char1) << 4 | hex2int(char2);
      45           19 :                 char1 = '\0';
      46           19 :                 char2 = '\0';
      47           19 :                 return true;
      48              :             }
      49              :             // If we received one hex character followed by whitespace/other
      50           34 :             else if (!isxdigit(input) && char1) {
      51            2 :                 output = hex2int(char1);
      52            2 :                 char1 = '\0';
      53            2 :                 return true;
      54              :             }
      55              :         }
      56            0 :         return false;
      57              :     }
      58              : 
      59              :   private:
      60              :     /// Convert a hexadecimal character to a 4-bit nibble.
      61           40 :     static uint8_t hex2int(char hex) {
      62           40 :         return hex < 'a' ? hex - '0' : hex - 'a' + 10;
      63              :     }
      64              : 
      65              :   public:
      66              :     CharPuller puller;
      67              : 
      68              :   private:
      69              :     char char1 = '\0';
      70              :     char char2 = '\0';
      71              : };
      72              : 
      73              : END_CS_NAMESPACE