Improve Structure Rrverse Lookup

Author: bingzheung

CoreIME/Sources/CoreIME/Candidate.swift

@@ -191,8 +191,8 @@ extension Array where Element == Candidate {
         /// Returns a new Candidate by concatenating this Candidate sequence.
         /// - Returns: Single, concatenated Candidate.
         public func joined() -> Candidate? {
-                let isNotAllCantonese: Bool = self.contains(where: \.isNotCantonese)
-                guard !isNotAllCantonese else { return nil }
+                let isAllCantonese: Bool = !(contains(where: \.isNotCantonese))
+                guard isAllCantonese else { return nil }
                 let text: String = map(\.text).joined()
                 let lexiconText: String = map(\.lexiconText).joined()
                 let romanization: String = map(\.romanization).joined(separator: " ")

CoreIME/Sources/CoreIME/Structure.swift

@@ -12,7 +12,7 @@ extension Engine {
         public static func structureReverseLookup(text: String, input: String, segmentation: Segmentation) -> [Candidate] {
                 let markFreeText = text.removedSpacesTonesSeparators()
                 let matched = process(text: markFreeText, segmentation: segmentation).uniqued()
-                guard !matched.isEmpty else { return [] }
+                guard matched.isNotEmpty else { return [] }
                 switch (text.hasSeparators, text.hasTones) {
                 case (true, true):
                         let isOneToneOnly: Bool = (text.count - markFreeText.count) == 2
@@ -44,31 +44,28 @@ extension Engine {
         }
 
         private static func process(text: String, segmentation: Segmentation) -> [Candidate] {
+                let matched = match(text: text)
                 let textCount = text.count
-                let segmentation = segmentation.filter({ $0.length == textCount })
-                guard segmentation.maxLength > 0 else {
-                        return match(text: text)
-                }
-                let matches = segmentation.map({ scheme -> [Candidate] in
+                let schemes = segmentation.filter({ $0.length == textCount })
+                guard schemes.maxLength > 0 else { return matched }
+                let matches = schemes.map({ scheme -> [Candidate] in
                         let pingText = scheme.map(\.origin).joined()
                         return match(text: pingText)
                 })
-                return match(text: text) + matches.flatMap({ $0 })
+                return matched + matches.flatMap({ $0 })
         }
-
         private static func match(text: String) -> [Candidate] {
                 var candidates: [Candidate] = []
-                let query: String = "SELECT word, romanization FROM composetable WHERE ping = \(text.hash);"
+                let command: String = "SELECT word, romanization FROM structuretable WHERE ping = \(text.hash);"
                 var statement: OpaquePointer? = nil
-                if sqlite3_prepare_v2(Engine.database, query, -1, &statement, nil) == SQLITE_OK {
-                        while sqlite3_step(statement) == SQLITE_ROW {
-                                let word: String = String(cString: sqlite3_column_text(statement, 0))
-                                let romanization: String = String(cString: sqlite3_column_text(statement, 1))
-                                let instance = Candidate(text: word, romanization: romanization, input: text)
-                                candidates.append(instance)
-                        }
+                defer { sqlite3_finalize(statement) }
+                guard sqlite3_prepare_v2(Engine.database, command, -1, &statement, nil) == SQLITE_OK else { return [] }
+                while sqlite3_step(statement) == SQLITE_ROW {
+                        let word: String = String(cString: sqlite3_column_text(statement, 0))
+                        let romanization: String = String(cString: sqlite3_column_text(statement, 1))
+                        let instance = Candidate(text: word, romanization: romanization, input: text)
+                        candidates.append(instance)
                 }
-                sqlite3_finalize(statement)
                 return candidates
         }
 }

Preparing/Sources/Preparing/DatabasePreparer.swift

@@ -13,7 +13,7 @@ struct DatabasePreparer {
                 createQuickTable()
                 createStrokeTable()
                 createT2STable()
-                createComposeTable()
+                createStructureTable()
                 createPinyinTable()
                 createSymbolTable()
                 createOtherIndies()
@@ -94,7 +94,7 @@ struct DatabasePreparer {
                         "CREATE INDEX strokestrokeindex ON stroketable(stroke);",
                         "CREATE INDEX strokecodeindex ON stroketable(code);",
 
-                        "CREATE INDEX composepingindex ON composetable(ping);",
+                        "CREATE INDEX structurepingindex ON structuretable(ping);",
 
                         "CREATE INDEX pinyinshortcutindex ON pinyintable(shortcut);",
                         "CREATE INDEX pinyinpingindex ON pinyintable(ping);",
@@ -232,13 +232,13 @@ struct DatabasePreparer {
                 guard sqlite3_prepare_v2(database, insert, -1, &insertStatement, nil) == SQLITE_OK else { return }
                 guard sqlite3_step(insertStatement) == SQLITE_DONE else { return }
         }
-        private static func createComposeTable() {
-                let createTable: String = "CREATE TABLE composetable(word TEXT NOT NULL, romanization TEXT NOT NULL, ping INTEGER NOT NULL);"
+        private static func createStructureTable() {
+                let createTable: String = "CREATE TABLE structuretable(word TEXT NOT NULL, romanization TEXT NOT NULL, ping INTEGER NOT NULL);"
                 var createStatement: OpaquePointer? = nil
                 guard sqlite3_prepare_v2(database, createTable, -1, &createStatement, nil) == SQLITE_OK else { sqlite3_finalize(createStatement); return }
                 guard sqlite3_step(createStatement) == SQLITE_DONE else { sqlite3_finalize(createStatement); return }
                 sqlite3_finalize(createStatement)
-                guard let url = Bundle.module.url(forResource: "compose", withExtension: "txt") else { return }
+                guard let url = Bundle.module.url(forResource: "structure", withExtension: "txt") else { return }
                 guard let content = try? String(contentsOf: url) else { return }
                 let sourceLines: [String] = content.trimmingCharacters(in: .whitespacesAndNewlines).components(separatedBy: .newlines)
                 let entries = sourceLines.map { sourceLine -> String? in
@@ -250,7 +250,7 @@ struct DatabasePreparer {
                         return "('\(word)', '\(romanization)', \(ping))"
                 }
                 let values: String = entries.compactMap({ $0 }).joined(separator: ", ")
-                let insert: String = "INSERT INTO composetable (word, romanization, ping) VALUES \(values);"
+                let insert: String = "INSERT INTO structuretable (word, romanization, ping) VALUES \(values);"
                 var insertStatement: OpaquePointer? = nil
                 defer { sqlite3_finalize(insertStatement) }
                 guard sqlite3_prepare_v2(database, insert, -1, &insertStatement, nil) == SQLITE_OK else { return }