mupplet_core.h

// mupplet_core.h - muwerk mupplet core library
 
#pragma once
 
#include "scheduler.h"
 
namespace ustd {
 
int8_t parseBoolean(String arg) {
    arg.trim();
    arg.toLowerCase();
    if (arg == "on" || arg == "true") {
        return 1;
    } else if (arg == "0" || arg == "off" || arg == "false") {
        return 0;
    } else if (atoi(arg.c_str())) {
        return 1;
    } else {
        return -1;
    }
}
 
int16_t parseToken(String arg, const char **tokenList, int16_t defaultVal = -1) {
    arg.trim();
    arg.toLowerCase();
    for (const char **pToken = tokenList; *pToken; pToken++) {
        if (!strcmp(arg.c_str(), *pToken)) {
            return pToken - tokenList;
        }
    }
    return defaultVal;
}
 
long parseLong(String arg, long defaultVal) {
    arg.trim();
    if (arg.length() == 0) {
        return defaultVal;
    }
    for (const char *pPtr = arg.c_str(); *pPtr; pPtr++) {
        if (*pPtr < '0' || *pPtr > '9') {
            if (pPtr == arg.c_str() && *pPtr != '-') {
                return defaultVal;
            }
        }
    }
    return atol(arg.c_str());
}
 
long parseRangedLong(String arg, long minVal, long maxVal, long minDefaultVal, long maxDefaultVal) {
    long val = parseLong(arg, minDefaultVal);
    if (val == minDefaultVal) {
        // maybe not a number?
        return minDefaultVal;
    } else if (val < minVal) {
        return minDefaultVal;
    } else if (val > maxVal) {
        return maxDefaultVal;
    } else {
        return val;
    }
}
 
double parseUnitLevel(String arg) {
    double val = 0.0;
    arg.trim();
    arg.toLowerCase();
 
    if (arg == "on" || arg == "true") {
        return 1.0;
    } else if (arg == "off" || arg == "false") {
        return 0.0;
    } else if (arg == "pct") {
        arg = shift(arg);
        val = atoi(arg.c_str()) / 100.0;
    } else if (arg.endsWith("%")) {
        arg.remove(arg.length() - 1);
        val = atoi(arg.c_str()) / 100.0;
    } else if (arg.indexOf('.') == -1) {
        val = atoi(arg.c_str()) / 100.0;
    } else {
        val = atof(arg.c_str());
    }
    return val < 0.0 ? 0.0 : val > 1.0 ? 1.0
                                       : val;
}
 
uint16_t countChars(String txt, char c) {
    uint16_t n = 0;
    for (uint16_t i = 0; i < txt.length(); i++) {
        if (txt[i] == c) ++n;
    }
    return n;
}
 
bool getNthHexbyte(String hex, uint8_t ind, uint8_t *pVal) {
    if (hex.length() < (uint16_t)((ind + 1) * 2)) return false;
    if (pVal) {
        *pVal = (uint8_t)strtol(hex.substring(ind * 2, ind * 2 + 2).c_str(), 0, 16);
        return true;
    } else
        return false;
}
 
bool getNthInt(String arg, uint8_t ind, uint8_t *pVal) {
    if (countChars(arg, ',') < ind) return false;
    uint8_t i = 0, n = 0, p1 = 0, p2 = 0;
    String carg = "," + arg + ",";
    while (true) {
        if (carg[i] == ',') {
            if (n == ind + 1) {
                p2 = i;
                if (pVal) {
                    *pVal = strtol(carg.substring(p1, p2).c_str(), 0, 10);
                    return true;
                } else
                    return false;
            } else if (n == ind) {
                p1 = i + 1;
            }
            ++n;
        }
        ++i;
        if (i == carg.length()) return false;
    }
}
 
bool parseColor(String arg, uint8_t *pr, uint8_t *pg, uint8_t *pb, uint8_t *pw = nullptr, uint8_t *pww = nullptr) {
    String hex;
    if (arg.startsWith("#")) {
        hex = arg.substring(1);
    } else if (arg.startsWith("0x")) {
        hex = arg.substring(2);
    } else if (arg.indexOf(',') != -1) {
        uint16_t n = countChars(arg, ',');
        if (n == 2) {  // RGB
            if (pr)
                if (!getNthInt(arg, 0, pr)) return false;
            if (pg)
                if (!getNthInt(arg, 1, pg)) return false;
            if (pb)
                if (!getNthInt(arg, 2, pb)) return false;
        } else if (n == 3) {  // RGBW
            if (pw)
                if (!getNthInt(arg, 0, pw)) return false;
            if (pr)
                if (!getNthInt(arg, 1, pr)) return false;
            if (pg)
                if (!getNthInt(arg, 2, pg)) return false;
            if (pb)
                if (!getNthInt(arg, 3, pb)) return false;
        } else if (n == 4) {  // RGBWW
            if (pww)
                if (!getNthInt(arg, 0, pww)) return false;
            if (pw)
                if (!getNthInt(arg, 1, pw)) return false;
            if (pr)
                if (!getNthInt(arg, 2, pr)) return false;
            if (pg)
                if (!getNthInt(arg, 3, pg)) return false;
            if (pb)
                if (!getNthInt(arg, 4, pb)) return false;
        } else
            return false;
        return true;
    }
    if (hex.length() == 6) {
        if (pr)
            if (!getNthHexbyte(hex, 0, pr)) return false;
        if (pg)
            if (!getNthHexbyte(hex, 1, pg)) return false;
        if (pb)
            if (!getNthHexbyte(hex, 2, pb)) return false;
    } else if (hex.length() == 8) {
        if (pw)
            if (!getNthHexbyte(hex, 0, pw)) return false;
        if (pr)
            if (!getNthHexbyte(hex, 1, pr)) return false;
        if (pg)
            if (!getNthHexbyte(hex, 2, pg)) return false;
        if (pb)
            if (!getNthHexbyte(hex, 3, pb)) return false;
    } else if (hex.length() == 10) {
        if (pww)
            if (!getNthHexbyte(hex, 0, pww)) return false;
        if (pw)
            if (!getNthHexbyte(hex, 1, pw)) return false;
        if (pr)
            if (!getNthHexbyte(hex, 2, pr)) return false;
        if (pg)
            if (!getNthHexbyte(hex, 3, pg)) return false;
        if (pb)
            if (!getNthHexbyte(hex, 4, pb)) return false;
    } else
        return false;
    return true;
}
 
// clang-format off
// clang-format on
 
bool isAscii(String utf8string) {
    for (unsigned int i = 0; i < utf8string.length(); i++) {
        unsigned char c = utf8string[i];
        if ((c & 0x80) != 0)
            return false;
    }
    return true;
}
 
bool isNumber(String string, bool integer = false) {
    return isNumber(string.c_str(), integer);
}
 
bool isNumber(const char *value, bool integer = false) {
    if (!value) {
        return false;
    }
    if (*value == '-') {
        value++;
    }
    bool decimalpoint = false;
    while (*value) {
        if (*value < '0' || *value > '9') {
            if (integer || decimalpoint || *value != '.') {
                return false;
            } else {
                decimalpoint = true;
            }
        }
        value++;
    }
    return true;
}
 
String utf8ToLatin(String utf8string, char invalid_char = '_') {
    String latin = "";
    unsigned char c, nc;
    for (unsigned int i = 0; i < utf8string.length(); i++) {
        c = utf8string[i];
        if ((c & 0x80) == 0) {  // 1 byte utf8
            latin += (char)c;
            continue;
        } else {
            if ((c & 0b11100000) == 0b11000000) {  // 2 byte utf8
                if (i < utf8string.length() - 1) {
                    nc = utf8string[i + 1];
                    switch (c) {
                    case 0xc2:
                        latin += (char)nc;
                        break;
                    case 0xc3:
                        nc += 0x40;
                        latin += (char)nc;
                        break;
                    default:
                        latin += (char)invalid_char;
                        break;
                    }
                    i += 1;
                    continue;
                } else {  // damaged utf8
                    latin += (char)invalid_char;
                    return latin;
                }
            } else {
                if ((c & 0b11110000) == 0b11100000) {  // 3 byte utf8
                    i += 2;
                    latin += (char)invalid_char;
                    continue;
                } else {
                    if ((c & 0b11111000) == 0b11110000) {  // 4 byte utf8
                        i += 3;
                        latin += (char)invalid_char;
                        continue;
                    } else {  // damaged utf8
                        latin += (char)invalid_char;
                        return latin;  // we can't continue parsing
                    }
                }
            }
        }
    }
    return latin;
}
 
String latinToUtf8(String latin) {
    String utf8str = "";
    unsigned char c;
    for (unsigned int i = 0; i < latin.length(); i++) {
        c = latin[i];
        if (c < 0x80)
            utf8str += (char)c;
        else {
            if (c < 0xc0) {
                utf8str += (char)0xc2;
                utf8str += (char)c;
            } else {
                utf8str += (char)0xc3;
                c -= 0x40;
                utf8str += (char)c;
            }
        }
    }
    return utf8str;
}
 
/*
const char *hdmap = "→←"
                    " 。「」、・ヲァィゥェォャュョッ"
                    "ーアイウエオカキクケコサシスセソ"
                    "タチツテトナニヌネノハヒフヘホマ"
                    "ミムメモヤユヨラリルレロワン゛゜"
                    "αäßεμσρg√⁻¹j˟₵₤ñö"
                    "pqΘ∞ΩüΣπx̅y不万円÷ █";
*/
class HD44780Charset {
  public:
    HD44780Charset(char *pLookupTable = nullptr) {
    }
 
    static String toHD_ASCII(String utf8string, char invalid_char = '_') {
        String hdstr = "";
        unsigned char c;
        for (unsigned int i = 0; i < utf8string.length(); i++) {
            c = utf8string[i];
            Serial.println(c);
            if ((c & 0x80) == 0) {  // 1 byte utf8
                if (c < 0x7e) {     // and not 0x7e or 0x7f
                    if (strchr("gjpqy", c) != nullptr)
                        c += 0x80;  // Use extended matrix for lowercase descenders.
                    hdstr += (char)c;
                } else {
                    hdstr += (char)invalid_char;
                }
                continue;
            } else {
                if ((c & 0b11100000) == 0b11000000) {  // 2 byte utf8
                    if (i < utf8string.length() - 1) {
                        hdstr += (char)invalid_char;
                        i += 1;
                        continue;
                    } else {  // damaged utf8
                        hdstr += (char)invalid_char;
                        return hdstr;
                    }
                } else {
                    if ((c & 0b11110000) == 0b11100000) {  // 3 byte utf8
                        i += 2;
                        hdstr += (char)invalid_char;
                        continue;
                    } else {
                        if ((c & 0b11111000) == 0b11110000) {  // 4 byte utf8
                            i += 3;
                            hdstr += (char)invalid_char;
                            continue;
                        } else {  // damaged utf8
                            hdstr += (char)invalid_char;
                            return hdstr;  // we can't continue parsing
                        }
                    }
                }
            }
        }
        return hdstr;
    }
 
    static String toUtf8(String hdstr, char invalid_char = '_') {
        String utf8str = "";
        unsigned char c;
        for (unsigned int i = 0; i < hdstr.length(); i++) {
            c = hdstr[i];
            if (c < 0x7e)
                utf8str += (char)c;
            else {
                char cf = (char)(c - 0x80);
                if (strchr("gjpqy", cf) != nullptr)
                    utf8str += cf;
                else
                    utf8str += (char)invalid_char;
            }
        }
        return utf8str;
    }
};
}  // namespace ustd