Line data    Source code

       1             : // ---------------------------------------------------------------------------
       2             : // USB EPROM/Flash Programmer
       3             : //
       4             : // Copyright (2022) Robson Martins
       5             : //
       6             : // This work is licensed under a Creative Commons Attribution-NonCommercial-
       7             : // ShareAlike 4.0 International License.
       8             : // ---------------------------------------------------------------------------
       9             : /**
      10             :  * @ingroup Firmware
      11             :  * @file hal/string.cpp
      12             :  * @brief Implementation of the String Handling Helper Class.
      13             :  *
      14             :  * @author Robson Martins (https://www.robsonmartins.com)
      15             :  */
      16             : // ---------------------------------------------------------------------------
      17             : 
      18             : #include <sstream>
      19             : #include <iostream>
      20             : #include <iomanip>
      21             : #include <vector>
      22             : #include <bitset>
      23             : #include <algorithm>
      24             : #include <cstring>
      25             : #include <cmath>
      26             : 
      27             : #include "hal/string.hpp"
      28             : 
      29             : // ---------------------------------------------------------------------------
      30             : 
      31           5 : std::string StringUtils::upper(const std::string &src) {
      32           5 :     std::string s = src;
      33           5 :     std::transform(s.begin(), s.end(), s.begin(),
      34          32 :                    [](unsigned char c) { return std::toupper(c); });
      35           5 :     return s;
      36             : }
      37             : 
      38           5 : std::string StringUtils::lower(const std::string &src) {
      39           5 :     std::string s = src;
      40           5 :     std::transform(s.begin(), s.end(), s.begin(),
      41          32 :                    [](unsigned char c) { return std::tolower(c); });
      42           5 :     return s;
      43             : }
      44             : 
      45          10 : std::string StringUtils::trim(const std::string &src) {
      46          10 :     std::string s = src;
      47          10 :     s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char c) {
      48          24 :                 return (!std::isspace(c));
      49             :             }));
      50          20 :     s.erase(std::find_if(s.rbegin(), s.rend(),
      51          16 :                          [](unsigned char c) { return (!std::isspace(c)); })
      52          10 :                 .base(),
      53          10 :             s.end());
      54          10 :     return s;
      55           0 : }
      56             : 
      57          10 : StringUtils::TStringVector StringUtils::split(const std::string &src,
      58             :                                               char separator, bool trim) {
      59          10 :     TStringVector s;
      60          10 :     std::istringstream iss(src);
      61          10 :     std::string buf;
      62          25 :     while (getline(iss, buf, separator)) {
      63          15 :         if (!buf.empty()) {
      64          14 :             if (trim) {
      65           2 :                 s.push_back(StringUtils::trim(buf));
      66             :             } else {
      67          12 :                 s.push_back(buf);
      68             :             }
      69             :         }
      70             :     }
      71          20 :     return s;
      72          10 : }
      73             : 
      74          13 : int StringUtils::toInt(const std::string &src, uint base) {
      75          13 :     return std::strtol(src.c_str(), nullptr, base);
      76             : }
      77             : 
      78          10 : float StringUtils::toFloat(const std::string &src) {
      79          10 :     return std::strtof(src.c_str(), nullptr);
      80             : }
      81             : 
      82          30 : std::string StringUtils::fromInt(int src, uint base, uint digits, char fill) {
      83          30 :     std::ostringstream oss;
      84          30 :     std::string tmp;
      85             :     size_t pos;
      86          30 :     switch (base) {
      87           6 :         case 16:
      88           6 :             oss << std::setfill(fill) << std::setw(digits) << std::hex
      89           6 :                 << std::uppercase << src;
      90           6 :             break;
      91           6 :         case 8:
      92           6 :             oss << std::setfill(fill) << std::setw(digits) << std::oct << src;
      93           6 :             break;
      94           6 :         case 2:
      95           6 :             tmp = std::bitset<32>(src).to_string();
      96           6 :             pos = tmp.find_first_not_of("0");
      97           6 :             if (pos != std::string::npos) {
      98           3 :                 tmp = tmp.substr(pos);
      99             :             } else {
     100           3 :                 tmp = "0";
     101             :             }
     102          20 :             for (size_t i = tmp.length(); i < digits; i++) {
     103          14 :                 tmp = fill + tmp;
     104             :             }
     105           6 :             oss << tmp;
     106           6 :             break;
     107          11 :         case 10:
     108          11 :             oss << std::setfill(fill) << std::setw(digits) << std::dec << src;
     109          11 :             break;
     110           1 :         default:
     111           1 :             oss << src;
     112           1 :             break;
     113             :     }
     114          60 :     return oss.str();
     115          30 : }
     116             : 
     117          17 : std::string StringUtils::fromFloat(float src, uint precision) {
     118          17 :     std::ostringstream oss;
     119          17 :     oss.precision(precision);
     120          17 :     oss << std::fixed << src;
     121          34 :     return oss.str();
     122          17 : }