@react-native-ohos/react-native-svg 15.12.1-rc.10 → 15.12.1-rc.11

package/harmony/svg/build/default/cache/default/default@PackageHar/src/main/cpp/utils/StringUtils.h

@@ -1,644 +0,0 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
- * Use of this source code is governed by a MIT license that can be
- * found in the LICENSE file.
- *
- * This file incorporates from the OpenHarmony project, licensed under
- * the Apache License, Version 2.0. Specifically:
- * - [OpenHarmony/arkui_ace_engine] (https://gitee.com/openharmony/arkui_ace_engine)
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy
- * of the License at:
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- */
-
-// from ArkUI "frameworks/base/utils/string_utils.h"
-#pragma once
-
-#include <climits>
-#include <cmath>
-#include <codecvt>
-#include <cstring>
-#include <locale>
-#include <sstream>
-#include <string>
-#include <vector>
-#include "properties/Dimension.h"
-#include "utils/SvgUtils.h"
-#include "native_drawing/drawing_bitmap.h"
-
-namespace rnoh {
-namespace svg {
-
-namespace StringUtils {
-extern const char DEFAULT_STRING[];
-extern const std::wstring DEFAULT_WSTRING;
-extern const std::u16string DEFAULT_USTRING;
-extern const std::u32string DEFAULT_U32STRING;
-constexpr int32_t TEXT_CASE_LOWERCASE = 1;
-constexpr int32_t TEXT_CASE_UPPERCASE = 2;
-constexpr double PERCENT_VALUE = 100.0;
-constexpr double DEGREES_VALUE = 360.0;    // one turn means 360 deg
-constexpr double GRADIANS_VALUE = 400.0;   // one turn means 400 grad
-constexpr double RADIANS_VALUE = 2 * M_PI; // one turn means 2*pi rad
-const char ELLIPSIS[] = "...";
-
-
-inline bool NotInUtf16Bmp(char16_t c) { return (c & 0xF800) == 0xD800; }
-
-inline bool NotInBmp(wchar_t ch) { return ch >= 0xD800 && ch <= 0xDBFF; }
-
-inline bool IsNumber(const std::string &value) {
-    if (value.empty()) {
-        return false;
-    }
-    return std::all_of(value.begin(), value.end(), [](char i) { return isdigit(i); });
-}
-
-inline void ReplaceSpace(std::string &data) {
-    bool isFirstSpace = true;
-    auto iter = data.begin();
-    while (iter != data.end()) {
-        if (*iter == ' ') {
-            if (isFirstSpace) {
-                iter++;
-                isFirstSpace = false;
-            } else {
-                iter = data.erase(iter);
-            }
-        } else if (*iter == '\t') {
-            *iter = ' ';
-        } else {
-            isFirstSpace = true;
-            iter++;
-        }
-    }
-}
-
-inline void ReplaceTabAndNewLine(std::string &data) {
-    for (auto &i : data) {
-        if (i == '\r' || i == '\n') {
-            i = ' ';
-        }
-    }
-    ReplaceSpace(data);
-}
-
-inline std::string RestoreEscape(const std::string &src) {
-    std::string res;
-    for (auto &c : src) {
-        switch (c) {
-        case '\n':
-            res += "\\n";
-            break;
-        case '\r':
-            res += "\\r";
-            break;
-        case '\t':
-            res += "\\t";
-            break;
-        default:
-            res.push_back(c);
-            break;
-        }
-    }
-    return res;
-}
-
-inline int32_t StringToInt(const std::string &value) {
-    errno = 0;
-    char *pEnd = nullptr;
-    int64_t result = std::strtol(value.c_str(), &pEnd, 10);
-    if (pEnd == value.c_str() || (result < INT_MIN || result > INT_MAX) || errno == ERANGE) {
-        return 0;
-    } else {
-        return result;
-    }
-}
-
-inline int64_t StringToLongInt(const std::string &value, int64_t defaultErr = 0) {
-    errno = 0;
-    char *pEnd = nullptr;
-    int64_t result = std::strtoll(value.c_str(), &pEnd, 10);
-    if (pEnd == value.c_str() || errno == ERANGE) {
-        return defaultErr;
-    } else {
-        return result;
-    }
-}
-
-inline uint64_t StringToLongUint(const std::string &value, uint64_t defaultErr = 0) {
-    errno = 0;
-    char *pEnd = nullptr;
-    uint64_t result = std::strtoull(value.c_str(), &pEnd, 10);
-    if (pEnd == value.c_str() || errno == ERANGE) {
-        return defaultErr;
-    } else {
-        return result;
-    }
-}
-
-inline uint32_t StringToUintCheck(const std::string &value, uint32_t defaultErr = 0) {
-    errno = 0;
-    char *pEnd = nullptr;
-    uint64_t result = std::strtoull(value.c_str(), &pEnd, 10);
-    if ((pEnd == value.c_str()) || ((pEnd != nullptr) && (*pEnd != '\0')) || result > UINT32_MAX || errno == ERANGE) {
-        return defaultErr;
-    } else {
-        return result;
-    }
-}
-
-inline uint32_t StringToUint(const std::string &value, uint32_t defaultErr = 0) {
-    errno = 0;
-    char *pEnd = nullptr;
-    uint64_t result = std::strtoull(value.c_str(), &pEnd, 10);
-    if (pEnd == value.c_str() || result > UINT32_MAX || errno == ERANGE) {
-        return defaultErr;
-    } else {
-        return result;
-    }
-}
-
-// generic string to double value method without success check
-inline double StringToDouble(const std::string &value) {
-    char *pEnd = nullptr;
-    errno = 0;
-    double result = std::strtod(value.c_str(), &pEnd);
-    if (pEnd == value.c_str() || errno == ERANGE) {
-        return 0.0;
-    } else {
-        return result;
-    }
-}
-// string to double method with success check, and support for parsing number string with percentage case
-inline bool StringToDouble(const std::string &value, double &result) {
-    errno = 0;
-    char *pEnd = nullptr;
-    double res = std::strtod(value.c_str(), &pEnd);
-    if (pEnd == value.c_str() || errno == ERANGE) {
-        return false;
-    } else if (pEnd != nullptr) {
-        if (std::strcmp(pEnd, "%") == 0) {
-            result = res / PERCENT_VALUE;
-            return true;
-        } else if (std::strcmp(pEnd, "") == 0) {
-            result = res;
-            return true;
-        }
-    }
-    return false;
-}
-
-inline float StringToFloat(const std::string &value) {
-    errno = 0;
-    char *pEnd = nullptr;
-    float result = std::strtof(value.c_str(), &pEnd);
-    if (pEnd == value.c_str() || errno == ERANGE) {
-        return 0.0f;
-    } else {
-        return result;
-    }
-}
-
-static Dimension FromString(const std::string &str) {
-    static const int32_t percentUnit = 100;
-    static const std::unordered_map<std::string, DimensionUnit> uMap{
-        {"px", DimensionUnit::PX},     {"vp", DimensionUnit::VP},   {"fp", DimensionUnit::FP},
-        {"%", DimensionUnit::PERCENT}, {"lpx", DimensionUnit::LPX}, {"auto", DimensionUnit::AUTO},
-    };
-
-    double value = 0.0;
-    DimensionUnit unit = DimensionUnit::FP;
-
-    if (str.empty()) {
-        return Dimension(value, unit);
-    }
-
-    for (int32_t i = str.length() - 1; i >= 0; --i) {
-        if (str[i] >= '0' && str[i] <= '9') {
-            value = StringUtils::StringToDouble(str.substr(0, i + 1));
-            auto subStr = str.substr(i + 1);
-            unit = uMap.count(subStr) ? uMap.at(subStr) : unit;
-            value = unit == DimensionUnit::PERCENT ? value / percentUnit : value;
-            break;
-        }
-    }
-    return Dimension(value, unit);
-};
-
-static Dimension StringToDimensionWithUnit(const std::string &value, DimensionUnit defaultUnit = DimensionUnit::PX,
-                                           float defaultValue = 0.0f, bool isCalc = false) {
-    errno = 0;
-    if (std::strcmp(value.c_str(), "auto") == 0) {
-        return Dimension(defaultValue, DimensionUnit::AUTO);
-    }
-    char *pEnd = nullptr;
-    double result = std::strtod(value.c_str(), &pEnd);
-    if (pEnd == value.c_str() || errno == ERANGE) {
-        return Dimension(defaultValue, defaultUnit);
-    }
-    if (pEnd != nullptr) {
-        if (std::strcmp(pEnd, "%") == 0) {
-            // Parse percent, transfer from [0, 100] to [0, 1]
-            return Dimension(result / 100.0, DimensionUnit::PERCENT);
-        }
-        if (std::strcmp(pEnd, "px") == 0) {
-            return Dimension(result, DimensionUnit::PX);
-        }
-        if (std::strcmp(pEnd, "vp") == 0) {
-            return Dimension(result, DimensionUnit::VP);
-        }
-        if (std::strcmp(pEnd, "fp") == 0) {
-            return Dimension(result, DimensionUnit::FP);
-        }
-        if (std::strcmp(pEnd, "lpx") == 0) {
-            return Dimension(result, DimensionUnit::LPX);
-        }
-        if ((std::strcmp(pEnd, "\0") == 0) && isCalc) {
-            return Dimension(result, DimensionUnit::NONE);
-        }
-        if (isCalc) {
-            return Dimension(result, DimensionUnit::INVALID);
-        }
-    }
-    return Dimension(result, defaultUnit);
-}
-
-inline Dimension StringToDimension(const std::string &value, bool useVp = false) {
-    return StringToDimensionWithUnit(value, useVp ? DimensionUnit::VP : DimensionUnit::PX);
-}
-
-static bool StringToDimensionWithUnitNG(const std::string &value, Dimension &dimensionResult,
-                                        DimensionUnit defaultUnit = DimensionUnit::PX, float defaultValue = 0.0f,
-                                        bool isCalc = false) {
-    errno = 0;
-    if (std::strcmp(value.c_str(), "auto") == 0) {
-        dimensionResult = Dimension(defaultValue, DimensionUnit::AUTO);
-        return true;
-    }
-    char *pEnd = nullptr;
-    double result = std::strtod(value.c_str(), &pEnd);
-    if (pEnd == value.c_str() || errno == ERANGE) {
-        dimensionResult = Dimension(defaultValue, defaultUnit);
-        return false;
-    }
-    if (pEnd != nullptr) {
-        if (std::strcmp(pEnd, "%") == 0) {
-            // Parse percent, transfer from [0, 100] to [0, 1]
-            dimensionResult = Dimension(result / 100.0, DimensionUnit::PERCENT);
-            return true;
-        }
-        if (std::strcmp(pEnd, "px") == 0) {
-            dimensionResult = Dimension(result, DimensionUnit::PX);
-            return true;
-        }
-        if (std::strcmp(pEnd, "vp") == 0) {
-            dimensionResult = Dimension(result, DimensionUnit::VP);
-            return true;
-        }
-        if (std::strcmp(pEnd, "fp") == 0) {
-            dimensionResult = Dimension(result, DimensionUnit::FP);
-            return true;
-        }
-        if (std::strcmp(pEnd, "lpx") == 0) {
-            dimensionResult = Dimension(result, DimensionUnit::LPX);
-            return true;
-        }
-        if ((std::strcmp(pEnd, "\0") == 0) && isCalc) {
-            dimensionResult = Dimension(result, DimensionUnit::NONE);
-            return true;
-        }
-        if (isCalc) {
-            dimensionResult = Dimension(result, DimensionUnit::INVALID);
-            return true;
-        }
-        if ((std::strcmp(pEnd, "\0") != 0)) {
-            dimensionResult = Dimension(result, DimensionUnit::NONE);
-            return false;
-        }
-    }
-    dimensionResult = Dimension(result, defaultUnit);
-    return true;
-}
-
-inline std::string ReplaceChar(std::string str, char old_char, char new_char) {
-    for (char &it : str) {
-        if (it == old_char) {
-            it = new_char;
-        }
-    }
-    return str;
-}
-
-inline double StringToDegree(const std::string &value) {
-    // https://developer.mozilla.org/zh-CN/docs/Web/CSS/angle
-
-    errno = 0;
-    char *pEnd = nullptr;
-    double result = std::strtod(value.c_str(), &pEnd);
-    if (pEnd == value.c_str() || errno == ERANGE) {
-        return 0.0;
-    } else if (pEnd) {
-        if ((std::strcmp(pEnd, "deg")) == 0) {
-            return result;
-        } else if (std::strcmp(pEnd, "grad") == 0) {
-            return result / GRADIANS_VALUE * DEGREES_VALUE;
-        } else if (std::strcmp(pEnd, "rad") == 0) {
-            return result / RADIANS_VALUE * DEGREES_VALUE;
-        } else if (std::strcmp(pEnd, "turn") == 0) {
-            return result * DEGREES_VALUE;
-        }
-    }
-    return StringToDouble(value);
-}
-
-// StringToDegree with check. If the string is valid, change result and return true, otherwise return false.
-inline bool StringToDegree(const std::string &value, double &result) {
-    errno = 0;
-    char *pEnd = nullptr;
-    double temp = std::strtod(value.c_str(), &pEnd);
-    if (pEnd == value.c_str() || errno == ERANGE) {
-        return false;
-    } else if (pEnd) {
-        if (*pEnd == '\0') {
-            result = temp;
-            return true;
-        }
-        if (std::strcmp(pEnd, "deg") == 0) {
-            result = temp;
-            return true;
-        }
-        if (std::strcmp(pEnd, "grad") == 0) {
-            result = temp / GRADIANS_VALUE * DEGREES_VALUE;
-            return true;
-        }
-        if (std::strcmp(pEnd, "rad") == 0) {
-            result = temp / RADIANS_VALUE * DEGREES_VALUE;
-            return true;
-        }
-        if (std::strcmp(pEnd, "turn") == 0) {
-            result = temp * DEGREES_VALUE;
-            return true;
-        }
-    }
-    return false;
-}
-
-template <class T>
-inline void StringSplitter(const std::string &source, char delimiter, T (*func)(const std::string &),
-                           std::vector<T> &out) {
-    out.erase(out.begin(), out.end());
-
-    if (source.empty()) {
-        return;
-    }
-
-    std::size_t startIndex = 0;
-    for (std::size_t index = 0; index < source.size(); index++) {
-        if (source[index] != delimiter) {
-            continue;
-        }
-
-        if (index > startIndex) {
-            out.emplace_back(func(source.substr(startIndex, index - startIndex)));
-        }
-        startIndex = index + 1;
-    }
-
-    if (startIndex < source.size()) {
-        out.emplace_back(func(source.substr(startIndex)));
-    }
-}
-
-inline bool ParseStringToArray(const std::string &input, std::vector<float> &output) {
-    std::istringstream iss(StringUtils::ReplaceChar(input, ',', ' '));
-    std::string token;
-
-    while (iss >> token) {
-        double value;
-        if (!StringToDouble(token, value)) {
-            return false;
-        }
-        output.emplace_back(value);
-    }
-
-    return true;
-}
-
-inline void StringSplitter(const std::string &source, char delimiter, std::vector<std::string> &out) {
-    using Func = std::string (*)(const std::string &);
-    Func func = [](const std::string &value) { return value; };
-    StringSplitter(source, delimiter, func, out);
-}
-
-inline void StringSplitter(const std::string &source, char delimiter, std::vector<double> &out) {
-    using Func = double (*)(const std::string &);
-    Func func = [](const std::string &value) { return StringToDouble(value); };
-    StringSplitter(source, delimiter, func, out);
-}
-
-inline void StringSplitter(const std::string &source, char delimiter, std::vector<float> &out) {
-    using Func = float (*)(const std::string &);
-    Func func = [](const std::string &value) { return StringToFloat(value); };
-    StringSplitter(source, delimiter, func, out);
-}
-
-inline void StringSplitter(const std::string &source, char delimiter, std::vector<int> &out) {
-    using Func = int32_t (*)(const std::string &);
-    Func func = [](const std::string &value) { return StringToInt(value); };
-    StringSplitter(source, delimiter, func, out);
-}
-
-inline void StringSplitter(const std::string &source, char delimiter, std::vector<Dimension> &out) {
-    using Func = Dimension (*)(const std::string &);
-    Func func = [](const std::string &value) { return StringToDimension(value); };
-    StringSplitter(source, delimiter, func, out);
-}
-
-inline std::string DoubleToString(double value, int32_t precision = 2) {
-    std::ostringstream result;
-    result.precision(precision);
-    if (NearEqual(value, Infinity<double>())) {
-        result << "Infinity";
-    } else {
-        result << std::fixed << value;
-    }
-    return result.str();
-}
-
-inline void DeleteAllMark(std::string &str, const char mark) {
-    str.erase(std::remove(str.begin(), str.end(), mark), str.end());
-}
-
-inline std::string TrimStr(const std::string &str, char cTrim = ' ') {
-    auto firstPos = str.find_first_not_of(cTrim);
-    if (firstPos == std::string::npos) {
-        return str;
-    }
-    auto endPos = str.find_last_not_of(cTrim);
-    return str.substr(firstPos, endPos - firstPos + 1);
-}
-
-inline void TrimStrLeadingAndTrailing(std::string &str, char cTrim = ' ') {
-    auto firstIndexNotOfSpace = str.find_first_not_of(" ");
-    if (firstIndexNotOfSpace == std::string::npos) {
-        str = "";
-        return;
-    }
-    str.erase(0, firstIndexNotOfSpace);
-    auto lastIndexNotOfSpace = str.find_last_not_of(" ");
-    if (lastIndexNotOfSpace == std::string::npos) {
-        str = "";
-        return;
-    }
-    str.erase(lastIndexNotOfSpace + 1);
-}
-
-inline void SplitStr(const std::string &str, const std::string &sep, std::vector<std::string> &out,
-                     bool needTrim = true) {
-    out.erase(out.begin(), out.end());
-
-    if (str.empty() || sep.empty()) {
-        return;
-    }
-
-    std::string strPart;
-    std::string::size_type startPos = 0;
-    std::string::size_type pos = str.find_first_of(sep, startPos);
-    while (pos != std::string::npos) {
-        if (pos > startPos) {
-            strPart = needTrim ? TrimStr(str.substr(startPos, pos - startPos)) : str.substr(startPos, pos - startPos);
-            out.emplace_back(std::move(strPart));
-        }
-        startPos = pos + sep.size();
-        pos = str.find_first_of(sep, startPos);
-    }
-
-    if (startPos < str.size()) {
-        strPart = needTrim ? TrimStr(str.substr(startPos)) : str.substr(startPos);
-        out.emplace_back(std::move(strPart));
-    }
-}
-
-inline void SplitStr(const std::string &str, const std::string &sep, std::vector<Dimension> &out,
-                     bool needTrim = true) {
-    out.erase(out.begin(), out.end());
-    if (str.empty() || sep.empty()) {
-        return;
-    }
-    std::string strPart;
-    std::string::size_type startPos = 0;
-    std::string::size_type pos = str.find_first_of(sep, startPos);
-    while (pos != std::string::npos) {
-        if (pos > startPos) {
-            strPart = needTrim ? TrimStr(str.substr(startPos, pos - startPos)) : str.substr(startPos, pos - startPos);
-            if (!strPart.empty()) {
-                out.emplace_back(StringToDimension(std::move(strPart)));
-            }
-        }
-        startPos = pos + sep.size();
-        pos = str.find_first_of(sep, startPos);
-    }
-    if (startPos < str.size()) {
-        strPart = needTrim ? TrimStr(str.substr(startPos)) : str.substr(startPos);
-        if (!strPart.empty()) {
-            out.emplace_back(StringToDimension(std::move(strPart)));
-        }
-    }
-}
-
-inline bool StartWith(const std::string &dst, const std::string &prefix) {
-    return dst.compare(0, prefix.size(), prefix) == 0;
-}
-
-inline bool StartWith(const std::string &str, const char *prefix, size_t prefixLen) {
-    return ((str.length() >= prefixLen) && (str.compare(0, prefixLen, prefix) == 0));
-}
-
-inline bool EndWith(const std::string &dst, const std::string &suffix) {
-    return (dst.size() >= suffix.size()) && dst.compare(dst.size() - suffix.size(), suffix.size(), suffix) == 0;
-}
-
-inline bool EndWith(const std::string &str, const char *suffix, size_t suffixLen) {
-    size_t len = str.length();
-    return ((len >= suffixLen) && (str.compare(len - suffixLen, suffixLen, suffix) == 0));
-}
-
-inline void TransformStrCase(std::string &str, int32_t textCase) {
-    if (str.empty()) {
-        return;
-    }
-
-    switch (textCase) {
-    case TEXT_CASE_LOWERCASE:
-        transform(str.begin(), str.end(), str.begin(), ::tolower);
-        break;
-    case TEXT_CASE_UPPERCASE:
-        transform(str.begin(), str.end(), str.begin(), ::toupper);
-        break;
-    default:
-        break;
-    }
-}
-
-bool IsAscii(const std::string &str);
-
-inline std::vector<double> stringVectorToDoubleVector(const std::vector<std::string> &stringVec,
-                                                      const double pixelDensity) {
-    std::vector<double> doubleVec;
-    doubleVec.reserve(stringVec.size()); // 预分配内存以提高效率
-    for (const std::string &str : stringVec) {
-        auto value = StringToDouble(str);
-        doubleVec.push_back(pixelDensity * value);
-    }
-    return doubleVec;
-}
-
-inline std::string doubleVectorToString(const std::vector<double> &doubleVec) {
-    std::ostringstream oss;
-    for (const double &num : doubleVec) {
-        oss << num << ", "; // 将每个元素转换为字符串并拼接到流中
-    }
-    return oss.str(); // 将流中的内容转换为字符串并返回
-}
-
-std::string base64_encode(unsigned char const *bytes_to_encode, size_t in_len, bool url = false);
-std::string bitmapToBase64(OH_Drawing_Bitmap *bitmap);
-
-inline std::string getFileExtension(const std::string &uri) {
-    size_t pos = uri.rfind('.');
-    if (pos != std::string::npos) {
-        return uri.substr(pos); // 返回后缀名，包括点 ".jpg"
-    }
-    return ""; // 如果没有扩展名，返回空字符串
-}
-
-inline std::string generateHash(const std::string &url) {
-    std::hash<std::string> hash_fn;
-    size_t hash = hash_fn(url);
-    // 将哈希值转换为固定宽度的十六进制字符串（16位）
-    std::stringstream ss;
-    ss << std::hex << std::setw(16) << std::setfill('0') << hash;
-    return ss.str();
-}
-
-inline std::string generateHashedFileName(const std::string &uri) {
-    // 获取文件后缀名
-    std::string extension = StringUtils::getFileExtension(uri);
-    // 对URI进行哈希
-    std::string hash = StringUtils::generateHash(uri);
-    // 返回哈希值 + 文件后缀
-    return hash + extension;
-}
-
-} // namespace StringUtils
-} // namespace svg
-} // namespace rnoh