@react-native-ohos/react-native-text-input-mask 3.1.6-rc.4 → 3.1.6-rc.6

package/harmony/text_input_mask/src/main/cpp/common/Compiler.h

@@ -3,7 +3,8 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef COMPILER_H
+#define COMPILER_H
 #pragma once
 #include <string>
 #include <vector>
@@ -23,86 +24,86 @@ private:
     std::vector<Notation> customNotations;
 
 public:
-    Compiler(const std::vector<Notation> &notations) : customNotations(notations) {}
+    explicit Compiler(const std::vector<Notation> &notations) : customNotations(notations) {}
 
-    std::shared_ptr<State> compile(const std::string &formatString) {
+    std::shared_ptr<State> compile(const std::string &formatString)
+    {
         FormatSanitizer sanitizer;
         std::string sanitizedString = sanitizer.sanitize(formatString);
         return compile(sanitizedString, false, false, '\0');
     }
 
-    std::shared_ptr<State> compile(const std::string &formatString, bool valuable, bool fixed, char lastCharacter) {
+    std::shared_ptr<State> compile(const std::string &formatString, bool valuable, bool fixed, char lastCharacter)
+    {
         if (formatString.empty()) {
             return std::make_shared<EOLState>();
         }
-
         char ch = formatString.front();
         switch (ch) {
-        case '[':
-            if (lastCharacter != '\\') {
-                return compile(formatString.substr(1), true, false, ch);
-            }
-            break;
-
-        case '{':
-            if (lastCharacter != '\\') {
-                return compile(formatString.substr(1), false, true, ch);
-            }
-            break;
+            case '[':
+                if (lastCharacter != '\\') {
+                    return compile(formatString.substr(1), true, false, ch);
+                }
+                break;
 
-        case ']':
-        case '}':
-            if (lastCharacter != '\\') {
-                return compile(formatString.substr(1), false, false, ch);
-            }
-            break;
+            case '{':
+                if (lastCharacter != '\\') {
+                    return compile(formatString.substr(1), false, true, ch);
+                }
+                break;
 
-        case '\\':
-            if (lastCharacter != '\\') {
-                return compile(formatString.substr(1), valuable, fixed, ch);
-            }
-            break;
+            case ']':
+            case '}':
+                if (lastCharacter != '\\') {
+                    return compile(formatString.substr(1), false, false, ch);
+                }
+                break;
 
-        default:
-            break;
+            case '\\':
+                if (lastCharacter != '\\') {
+                    return compile(formatString.substr(1), valuable, fixed, ch);
+                }
+                break;
+            default:
+                break;
         }
 
         if (valuable) {
             switch (ch) {
-            case '0':
-                return std::make_shared<ValueState>(
-                    this->compile(formatString.substr(1), true, false, ch),
-                    // std::static_pointer_cast<ValueState::StateType>( std::make_shared<ValueState::Numeric>())
-                    std::make_shared<ValueState::Numeric>());
+                case '0':
+                    return std::make_shared<ValueState>(
+                        this->compile(formatString.substr(1), true, false, ch),
+                        // std::static_pointer_cast<ValueState::StateType>( std::make_shared<ValueState::Numeric>())
+                        std::make_shared<ValueState::Numeric>());
 
-            case 'A':
-                return std::make_shared<ValueState>(this->compile(formatString.substr(1), true, false, ch),
-                                                    std::make_shared<ValueState::Literal>());
+                case 'A':
+                    return std::make_shared<ValueState>(this->compile(formatString.substr(1), true, false, ch),
+                                                        std::make_shared<ValueState::Literal>());
 
-            case '_':
-                return std::make_shared<ValueState>(this->compile(formatString.substr(1), true, false, ch),
-                                                    std::make_shared<ValueState::AlphaNumeric>());
+                case '_':
+                    return std::make_shared<ValueState>(this->compile(formatString.substr(1), true, false, ch),
+                                                        std::make_shared<ValueState::AlphaNumeric>());
 
-            case '...':
-                return std::make_unique<ValueState>(determineInheritedType(lastCharacter));
+                case '...':
+                    return std::make_unique<ValueState>(determineInheritedType(lastCharacter));
 
-            case '9':
-                return std::make_shared<OptionalValueState>(this->compile(formatString.substr(1), true, false, ch),
-                                                            std::make_shared<OptionalValueState::Numeric>()
+                case '9':
+                    return std::make_shared<OptionalValueState>(this->compile(formatString.substr(1), true, false, ch),
+                                                                std::make_shared<OptionalValueState::Numeric>()
 
-                );
+                    );
 
-            case 'a':
-                return std::make_shared<OptionalValueState>(this->compile(formatString.substr(1), true, false, ch),
-                                                            std::make_shared<OptionalValueState::Literal>());
+                case 'a':
+                    return std::make_shared<OptionalValueState>(this->compile(formatString.substr(1), true, false, ch),
+                                                                std::make_shared<OptionalValueState::Literal>());
 
-            case '-':
-                return std::make_shared<OptionalValueState>(this->compile(formatString.substr(1), true, false, ch),
-                                                            std::make_shared<OptionalValueState::AlphaNumeric>());
+                case '-':
+                    return std::make_shared<OptionalValueState>(this->compile(formatString.substr(1), true, false, ch),
+                                                                std::make_shared<OptionalValueState::AlphaNumeric>());
 
-            default:
-                return compileWithCustomNotations(ch, formatString);
-            }
+                default:
+                    return compileWithCustomNotations(ch, formatString);
+                }
         }
         if (fixed) {
             return std::make_shared<FixedState>(compile(formatString.substr(1), false, true, ch), ch);
@@ -110,18 +111,21 @@ public:
         return std::make_shared<FreeState>(compile(formatString.substr(1), false, false, ch), ch);
     }
 
-    std::unique_ptr<State> compileWithCustomNotations(char c, const std::string &str) {
-         DLOG(ERROR) << "====== compileWithCustomNotations  customNotations size: " << customNotations.size();
+    std::unique_ptr<State> compileWithCustomNotations(char c, const std::string &str)
+    {
+        DLOG(ERROR) << "====== compileWithCustomNotations  customNotations size: " << customNotations.size();
         for (const auto &customNotation : customNotations) {
             if (customNotation.character == c) {
                 std::shared_ptr<State> compiledState = compile(str.substr(1), true, false, c);
                 if (customNotation.isOptional) {
-                    DLOG(ERROR) << "====== compileWithCustomNotations  customNotations isOptional :" << customNotation.isOptional;
+                    DLOG(ERROR) << "====== compileWithCustomNotations  customNotations isOptional :"
+                    << customNotation.isOptional;
                     return std::make_unique<OptionalValueState>(
                         std::move(compiledState),
                         std::make_shared<OptionalValueState::Custom>(c, customNotation.characterSet));
                 } else {
-                     DLOG(ERROR) << "======= compileWithCustomNotations  customNotations isOptional :" << customNotation.isOptional;
+                    DLOG(ERROR) << "======= compileWithCustomNotations  customNotations isOptional :"
+                    << customNotation.isOptional;
                     return std::make_unique<ValueState>(
                         std::move(compiledState), std::make_shared<ValueState::Custom>(c, customNotation.characterSet));
                 }
@@ -130,46 +134,45 @@ public:
         DLOG(INFO) << "compileWithCustomNotations No Match Found ";
         throw FormatError("compileWithCustomNotations No Match Found");
     }
-    std::shared_ptr<ValueState::ValueStateType> determineInheritedType(std::optional<char> lastCharacter) {
+    std::shared_ptr<ValueState::ValueStateType> determineInheritedType(std::optional<char> lastCharacter)
+    {
         if (!lastCharacter.has_value()) {
             throw FormatError(); // 处理空字符情况，抛出异常
         }
         char character = lastCharacter.value();
         switch (character) {
-        case '0':
-        case '9':
-            return std::make_shared<ValueState::Numeric>();
-
-        case 'A':
-        case 'a':
-            return std::make_shared<ValueState::Literal>();
-
-        case '_':
-        case '-':
-        case '...':
-        case '[':
-            return std::make_shared<ValueState::AlphaNumeric>();
-
-        default:
-            return determineTypeWithCustomNotations(lastCharacter);
+            case '0':
+            case '9':
+                return std::make_shared<ValueState::Numeric>();
+            case 'A':
+            case 'a':
+                return std::make_shared<ValueState::Literal>();
+            case '_':
+            case '-':
+            case '...':
+            case '[':
+                return std::make_shared<ValueState::AlphaNumeric>();
+            default:
+                return determineTypeWithCustomNotations(lastCharacter);
         }
     }
-
-    std::shared_ptr<ValueState::ValueStateType> determineTypeWithCustomNotations(std::optional<char> lastCharacter) {
+    std::shared_ptr<ValueState::ValueStateType> determineTypeWithCustomNotations(std::optional<char> lastCharacter)
+    {
         if (!lastCharacter.has_value()) {
             throw FormatError(); // 处理空字符情况，抛出异常
         }
-         DLOG(INFO) << "======determineTypeWithCustomNotations customNotations size: "<<customNotations.size();
+        DLOG(INFO) << "======determineTypeWithCustomNotations customNotations size: "<<customNotations.size();
         char character = lastCharacter.value();
         for (const auto &customNotation : customNotations) {
             if (customNotation.character == character) {
                 // 返回 Custom 状态
                 return std::make_shared<ValueState::Custom>(lastCharacter.value(),
-                                                            customNotation.characterSet); // 可以根据需要调整返回内容
+                    customNotation.characterSet); // 可以根据需要调整返回内容
             }
         }
         DLOG(INFO) << "determineTypeWithCustomNotations No Match Found ";
         throw FormatError("determineTypeWithCustomNotations No Match Found"); // 未找到匹配项，抛出异常
     }
 };
-} // namespace TinpMask
+} // namespace TinpMask
+#endif

package/harmony/text_input_mask/src/main/cpp/common/FormatError.h

@@ -3,7 +3,8 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef FORMATERROR_H
+#define FORMATERROR_H
 #pragma once
 // 定义 FormatError 类
 #include <string>
@@ -13,11 +14,10 @@ class FormatError : public std::exception {
 public:
     // 构造函数接受错误消息
     explicit FormatError(const std::string &message = "An error occurred") : msg(message) {}
-
     // 重写 what() 方法，返回错误消息
-    const char *what() const noexcept { return msg.c_str(); }
-
+    const char *what() const noexcept override { return msg.c_str(); }
 private:
     std::string msg; // 存储错误消息
 };
-} // namespace TinpMask
+} // namespace TinpMask
+#endif

package/harmony/text_input_mask/src/main/cpp/common/FormatSanitizer.h

@@ -3,7 +3,8 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef FORMATSANITIZER_H
+#define FORMATSANITIZER_H
 #pragma once
 #include <iostream>
 #include <vector>
@@ -17,13 +18,15 @@ namespace TinpMask {
 class Compiler;
 class FormatSanitizer {
 public:
-    std::string sanitize(const std::string &formatString) {
+    std::string sanitize(const std::string &formatString)
+    {
         checkOpenBraces(formatString);
         std::vector<std::string> blocks = divideBlocksWithMixedCharacters(getFormatBlocks(formatString));
         return sortFormatBlocks(blocks);
     }
 
-    std::vector<std::string> getFormatBlocks(const std::string &formatString) {
+    std::vector<std::string> getFormatBlocks(const std::string &formatString)
+    {
         std::vector<std::string> blocks;
         std::string currentBlock;
         bool escape = false;
@@ -36,36 +39,30 @@ public:
                     continue;
                 }
             }
-
             if ((ch == '[' || ch == '{') && !escape) {
                 if (!currentBlock.empty()) {
                     blocks.push_back(currentBlock);
                 }
                 currentBlock.clear();
             }
-
             currentBlock += ch;
 
             if ((ch == ']' || ch == '}') && !escape) {
                 blocks.push_back(currentBlock);
                 currentBlock.clear();
             }
-
             escape = false;
         }
 
         if (!currentBlock.empty()) {
             blocks.push_back(currentBlock);
         }
-
         return blocks;
     }
-
-
 public:
-    std::vector<std::string> divideBlocksWithMixedCharacters(const std::vector<std::string> &blocks) {
+    std::vector<std::string> divideBlocksWithMixedCharacters(const std::vector<std::string> &blocks)
+    {
         std::vector<std::string> resultingBlocks;
-
         for (const auto &block : blocks) {
             if (!block.empty() && block.substr(0, 1) == "[") { // 使用 substr 来检查开头
                 std::string blockBuffer;
@@ -114,7 +111,6 @@ public:
                 resultingBlocks.push_back(block);
             }
         }
-
         return resultingBlocks;
     }
 
@@ -127,7 +123,8 @@ private:
 
     bool isSpecialCharacter(char ch) const { return ch == '-' || ch == '_'; }
 
-    bool containsAny(const std::string &str, const std::vector<char> &characters) const {
+    bool containsAny(const std::string &str, const std::vector<char> &characters) const
+    {
         for (char c : characters) {
             if (str.find(c) != std::string::npos) {
                 return true;
@@ -135,9 +132,9 @@ private:
         }
         return false;
     }
-
 public:
-    std::string sortFormatBlocks(const std::vector<std::string> &blocks) {
+    std::string sortFormatBlocks(const std::vector<std::string> &blocks)
+    {
         std::vector<std::string> sortedBlocks;
 
         for (const auto &block : blocks) {
@@ -162,12 +159,11 @@ public:
 
         return join(sortedBlocks); // Ensure this is returning std::vector<std::string>
     }
-
-    void checkOpenBraces(const std::string &inputString) {
+    void checkOpenBraces(const std::string &inputString)
+    {
         bool escape = false;
         bool squareBraceOpen = false;
         bool curlyBraceOpen = false;
-
         for (const char &ch : inputString) {
             if (ch == '\\') {
                 escape = !escape;
@@ -191,7 +187,6 @@ public:
                 }
                 curlyBraceOpen = !escape;
             }
-
             if (ch == '}' && !escape) {
                 curlyBraceOpen = false;
             }
@@ -200,27 +195,29 @@ public:
     }
 
 private:
-    bool startsWith(const std::string &str, const std::string &prefix) const { return str.rfind(prefix, 0) == 0; }
-
-    std::string sortString(std::string str) {
+    bool startsWith(const std::string &str,
+        const std::string &prefix) const { return str.rfind(prefix, 0) == 0; }
+    std::string sortString(std::string str)
+    {
         std::sort(str.begin(), str.end());
         return str;
     }
-
-    std::string replaceChars(const std::string &str) {
+    std::string replaceChars(const std::string &str)
+    {
         std::string newStr = str;
         std::replace(newStr.begin(), newStr.end(), '_', 'A');
         std::replace(newStr.begin(), newStr.end(), '-', 'a');
         return newStr;
     }
-
-    std::string replaceCharsBack(const std::string &str) {
+    std::string replaceCharsBack(const std::string &str)
+    {
         std::string newStr = str;
         std::replace(newStr.begin(), newStr.end(), 'A', '_');
         std::replace(newStr.begin(), newStr.end(), 'a', '-');
         return newStr;
     }
-    std::string join(const std::vector<std::string> &strings) {
+    std::string join(const std::vector<std::string> &strings)
+    {
         std::string result;
         for (const auto &str : strings) {
             result += str; // 将所有块连接成一个字符串
@@ -228,4 +225,5 @@ private:
         return result;
     }
 };
-} // namespace TinpMask
+} // namespace TinpMask
+#endif