1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.commons.codec.language.bm;
19
20 import java.util.ArrayList;
21 import java.util.Arrays;
22 import java.util.Collections;
23 import java.util.EnumMap;
24 import java.util.HashSet;
25 import java.util.LinkedHashSet;
26 import java.util.List;
27 import java.util.Locale;
28 import java.util.Map;
29 import java.util.Objects;
30 import java.util.Set;
31 import java.util.TreeMap;
32 import java.util.stream.Collectors;
33
34 import org.apache.commons.codec.language.bm.Languages.LanguageSet;
35 import org.apache.commons.codec.language.bm.Rule.Phoneme;
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56 public class PhoneticEngine {
57
58
59
60
61
62
63
64 static final class PhonemeBuilder {
65
66
67
68
69
70
71
72
73
74 public static PhonemeBuilder empty(final Languages.LanguageSet languages) {
75 return new PhonemeBuilder(new Rule.Phoneme("", languages));
76 }
77
78 private final Set<Rule.Phoneme> phonemes;
79
80 private PhonemeBuilder(final Rule.Phoneme phoneme) {
81 this.phonemes = new LinkedHashSet<>();
82 this.phonemes.add(phoneme);
83 }
84
85 private PhonemeBuilder(final Set<Rule.Phoneme> phonemes) {
86 this.phonemes = phonemes;
87 }
88
89
90
91
92
93
94 public void append(final CharSequence str) {
95 phonemes.forEach(ph -> ph.append(str));
96 }
97
98
99
100
101
102
103
104
105
106
107
108 public void apply(final Rule.PhonemeExpr phonemeExpr, final int maxPhonemes) {
109 final Set<Rule.Phoneme> newPhonemes = new LinkedHashSet<>(maxPhonemes);
110
111 EXPR: for (final Rule.Phoneme left : this.phonemes) {
112 for (final Rule.Phoneme right : phonemeExpr.getPhonemes()) {
113 final LanguageSet languages = left.getLanguages().restrictTo(right.getLanguages());
114 if (!languages.isEmpty()) {
115 final Rule.Phoneme join = new Phoneme(left, right, languages);
116 if (newPhonemes.size() < maxPhonemes) {
117 newPhonemes.add(join);
118 if (newPhonemes.size() >= maxPhonemes) {
119 break EXPR;
120 }
121 }
122 }
123 }
124 }
125
126 this.phonemes.clear();
127 this.phonemes.addAll(newPhonemes);
128 }
129
130
131
132
133
134
135 public Set<Rule.Phoneme> getPhonemes() {
136 return this.phonemes;
137 }
138
139
140
141
142
143
144
145
146 public String makeString() {
147 return phonemes.stream().map(Rule.Phoneme::getPhonemeText).collect(Collectors.joining("|"));
148 }
149 }
150
151
152
153
154
155
156
157
158
159
160
161
162
163 private static final class RulesApplication {
164 private final Map<String, List<Rule>> finalRules;
165 private final CharSequence input;
166
167 private final PhonemeBuilder phonemeBuilder;
168 private int i;
169 private final int maxPhonemes;
170 private boolean found;
171
172 public RulesApplication(final Map<String, List<Rule>> finalRules, final CharSequence input,
173 final PhonemeBuilder phonemeBuilder, final int i, final int maxPhonemes) {
174 Objects.requireNonNull(finalRules, "finalRules");
175 this.finalRules = finalRules;
176 this.phonemeBuilder = phonemeBuilder;
177 this.input = input;
178 this.i = i;
179 this.maxPhonemes = maxPhonemes;
180 }
181
182 public int getI() {
183 return this.i;
184 }
185
186 public PhonemeBuilder getPhonemeBuilder() {
187 return this.phonemeBuilder;
188 }
189
190
191
192
193
194
195
196
197 public RulesApplication invoke() {
198 this.found = false;
199 int patternLength = 1;
200 final List<Rule> rules = this.finalRules.get(input.subSequence(i, i+patternLength));
201 if (rules != null) {
202 for (final Rule rule : rules) {
203 final String pattern = rule.getPattern();
204 patternLength = pattern.length();
205 if (rule.patternAndContextMatches(this.input, this.i)) {
206 this.phonemeBuilder.apply(rule.getPhoneme(), maxPhonemes);
207 this.found = true;
208 break;
209 }
210 }
211 }
212
213 if (!this.found) {
214 patternLength = 1;
215 }
216
217 this.i += patternLength;
218 return this;
219 }
220
221 public boolean isFound() {
222 return this.found;
223 }
224 }
225
226 private static final int DEFAULT_MAX_PHONEMES = 20;
227
228 private static final Map<NameType, Set<String>> NAME_PREFIXES = new EnumMap<>(NameType.class);
229
230 static {
231 NAME_PREFIXES.put(NameType.ASHKENAZI,
232 Collections.unmodifiableSet(
233 new HashSet<>(Arrays.asList("bar", "ben", "da", "de", "van", "von"))));
234 NAME_PREFIXES.put(NameType.SEPHARDIC,
235 Collections.unmodifiableSet(
236 new HashSet<>(Arrays.asList("al", "el", "da", "dal", "de", "del", "dela", "de la",
237 "della", "des", "di", "do", "dos", "du", "van", "von"))));
238 NAME_PREFIXES.put(NameType.GENERIC,
239 Collections.unmodifiableSet(
240 new HashSet<>(Arrays.asList("da", "dal", "de", "del", "dela", "de la", "della",
241 "des", "di", "do", "dos", "du", "van", "von"))));
242 }
243
244
245
246
247
248
249
250
251 private static String join(final List<String> strings, final String sep) {
252 return strings.stream().collect(Collectors.joining(sep));
253 }
254
255 private final Lang lang;
256
257 private final NameType nameType;
258
259 private final RuleType ruleType;
260
261 private final boolean concat;
262
263 private final int maxPhonemes;
264
265
266
267
268
269
270
271
272
273
274
275 public PhoneticEngine(final NameType nameType, final RuleType ruleType, final boolean concat) {
276 this(nameType, ruleType, concat, DEFAULT_MAX_PHONEMES);
277 }
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292 public PhoneticEngine(final NameType nameType, final RuleType ruleType, final boolean concat,
293 final int maxPhonemes) {
294 if (ruleType == RuleType.RULES) {
295 throw new IllegalArgumentException("ruleType must not be " + RuleType.RULES);
296 }
297 this.nameType = nameType;
298 this.ruleType = ruleType;
299 this.concat = concat;
300 this.lang = Lang.instance(nameType);
301 this.maxPhonemes = maxPhonemes;
302 }
303
304
305
306
307
308
309
310
311
312 private PhonemeBuilder applyFinalRules(final PhonemeBuilder phonemeBuilder,
313 final Map<String, List<Rule>> finalRules) {
314 Objects.requireNonNull(finalRules, "finalRules");
315 if (finalRules.isEmpty()) {
316 return phonemeBuilder;
317 }
318
319 final Map<Rule.Phoneme, Rule.Phoneme> phonemes = new TreeMap<>(Rule.Phoneme.COMPARATOR);
320
321 phonemeBuilder.getPhonemes().forEach(phoneme -> {
322 PhonemeBuilder subBuilder = PhonemeBuilder.empty(phoneme.getLanguages());
323 final String phonemeText = phoneme.getPhonemeText().toString();
324
325 for (int i = 0; i < phonemeText.length();) {
326 final RulesApplication rulesApplication = new RulesApplication(finalRules, phonemeText, subBuilder, i, maxPhonemes).invoke();
327 final boolean found = rulesApplication.isFound();
328 subBuilder = rulesApplication.getPhonemeBuilder();
329
330 if (!found) {
331
332 subBuilder.append(phonemeText.subSequence(i, i + 1));
333 }
334
335 i = rulesApplication.getI();
336 }
337
338
339
340
341 subBuilder.getPhonemes().forEach(newPhoneme -> {
342 if (phonemes.containsKey(newPhoneme)) {
343 final Rule.Phoneme oldPhoneme = phonemes.remove(newPhoneme);
344 final Rule.Phoneme mergedPhoneme = oldPhoneme.mergeWithLanguage(newPhoneme.getLanguages());
345 phonemes.put(mergedPhoneme, mergedPhoneme);
346 } else {
347 phonemes.put(newPhoneme, newPhoneme);
348 }
349 });
350 });
351
352 return new PhonemeBuilder(phonemes.keySet());
353 }
354
355
356
357
358
359
360
361
362 public String encode(final String input) {
363 final Languages.LanguageSet languageSet = this.lang.guessLanguages(input);
364 return encode(input, languageSet);
365 }
366
367
368
369
370
371
372
373
374
375
376
377 public String encode(String input, final Languages.LanguageSet languageSet) {
378 final Map<String, List<Rule>> rules = Rule.getInstanceMap(this.nameType, RuleType.RULES, languageSet);
379
380 final Map<String, List<Rule>> finalRules1 = Rule.getInstanceMap(this.nameType, this.ruleType, "common");
381
382 final Map<String, List<Rule>> finalRules2 = Rule.getInstanceMap(this.nameType, this.ruleType, languageSet);
383
384
385
386 input = input.toLowerCase(Locale.ENGLISH).replace('-', ' ').trim();
387
388 if (this.nameType == NameType.GENERIC) {
389 if (input.startsWith("d'")) {
390 final String remainder = input.substring(2);
391 final String combined = "d" + remainder;
392 return "(" + encode(remainder) + ")-(" + encode(combined) + ")";
393 }
394 for (final String l : NAME_PREFIXES.get(this.nameType)) {
395
396 if (input.startsWith(l + " ")) {
397
398 final String remainder = input.substring(l.length() + 1);
399 final String combined = l + remainder;
400 return "(" + encode(remainder) + ")-(" + encode(combined) + ")";
401 }
402 }
403 }
404
405 final List<String> words = Arrays.asList(input.split("\\s+"));
406 final List<String> words2 = new ArrayList<>();
407
408
409 switch (this.nameType) {
410 case SEPHARDIC:
411 words.forEach(aWord -> {
412 final String[] parts = aWord.split("'", -1);
413 words2.add(parts[parts.length - 1]);
414 });
415 words2.removeAll(NAME_PREFIXES.get(this.nameType));
416 break;
417 case ASHKENAZI:
418 words2.addAll(words);
419 words2.removeAll(NAME_PREFIXES.get(this.nameType));
420 break;
421 case GENERIC:
422 words2.addAll(words);
423 break;
424 default:
425 throw new IllegalStateException("Unreachable case: " + this.nameType);
426 }
427
428 if (this.concat) {
429
430 input = join(words2, " ");
431 } else if (words2.size() == 1) {
432
433 input = words.iterator().next();
434 } else if (!words2.isEmpty()) {
435
436 final StringBuilder result = new StringBuilder();
437 words2.forEach(word -> result.append("-").append(encode(word)));
438
439 return result.substring(1);
440 }
441
442 PhonemeBuilder phonemeBuilder = PhonemeBuilder.empty(languageSet);
443
444
445 for (int i = 0; i < input.length();) {
446 final RulesApplication rulesApplication =
447 new RulesApplication(rules, input, phonemeBuilder, i, maxPhonemes).invoke();
448 i = rulesApplication.getI();
449 phonemeBuilder = rulesApplication.getPhonemeBuilder();
450 }
451
452
453 phonemeBuilder = applyFinalRules(phonemeBuilder, finalRules1);
454
455 phonemeBuilder = applyFinalRules(phonemeBuilder, finalRules2);
456
457 return phonemeBuilder.makeString();
458 }
459
460
461
462
463
464
465 public Lang getLang() {
466 return this.lang;
467 }
468
469
470
471
472
473
474
475 public int getMaxPhonemes() {
476 return this.maxPhonemes;
477 }
478
479
480
481
482
483
484 public NameType getNameType() {
485 return this.nameType;
486 }
487
488
489
490
491
492
493 public RuleType getRuleType() {
494 return this.ruleType;
495 }
496
497
498
499
500
501
502 public boolean isConcat() {
503 return this.concat;
504 }
505 }