← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/contrib/icu/src/java/org/apache/lucene/analysis/icu/segmentation/DefaultICUTokenizerConfig.java

  • Committer: Sebastian Meyer
  • Date: 2012-08-03 09:12:40 UTC
  • Revision ID: sebastian.meyer@slub-dresden.de-20120803091240-x6861b0vabq1xror
https://launchpad.net/bugs/985487
Remove Lucene and Solr source code and add patches instead
Fix Bug #985487: Auto-suggestion for the search interface

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene/contrib/icu/src/java/org/apache/lucene/analysis/icu/segmentation/DefaultICUTokenizerConfig.java
1
 
package org.apache.lucene.analysis.icu.segmentation;
2
 
 
3
 
/**
4
 
 * Licensed to the Apache Software Foundation (ASF) under one or more
5
 
 * contributor license agreements.  See the NOTICE file distributed with
6
 
 * this work for additional information regarding copyright ownership.
7
 
 * The ASF licenses this file to You under the Apache License, Version 2.0
8
 
 * (the "License"); you may not use this file except in compliance with
9
 
 * the License.  You may obtain a copy of the License at
10
 
 *
11
 
 *     http://www.apache.org/licenses/LICENSE-2.0
12
 
 *
13
 
 * Unless required by applicable law or agreed to in writing, software
14
 
 * distributed under the License is distributed on an "AS IS" BASIS,
15
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16
 
 * See the License for the specific language governing permissions and
17
 
 * limitations under the License.
18
 
 */
19
 
 
20
 
import java.io.IOException;
21
 
import java.io.InputStream;
22
 
 
23
 
import org.apache.lucene.analysis.standard.StandardTokenizer;
24
 
 
25
 
import com.ibm.icu.lang.UScript;
26
 
import com.ibm.icu.text.BreakIterator;
27
 
import com.ibm.icu.text.RuleBasedBreakIterator;
28
 
import com.ibm.icu.util.ULocale;
29
 
 
30
 
/**
31
 
 * Default {@link ICUTokenizerConfig} that is generally applicable
32
 
 * to many languages.
33
 
 * <p>
34
 
 * Generally tokenizes Unicode text according to UAX#29 
35
 
 * ({@link BreakIterator#getWordInstance(ULocale) BreakIterator.getWordInstance(ULocale.ROOT)}), 
36
 
 * but with the following tailorings:
37
 
 * <ul>
38
 
 *   <li>Thai text is broken into words with a 
39
 
 *   {@link com.ibm.icu.text.DictionaryBasedBreakIterator}
40
 
 *   <li>Lao, Myanmar, and Khmer text is broken into syllables
41
 
 *   based on custom BreakIterator rules.
42
 
 *   <li>Hebrew text has custom tailorings to handle special cases
43
 
 *   involving punctuation.
44
 
 * </ul>
45
 
 * @lucene.experimental
46
 
 */
47
 
public class DefaultICUTokenizerConfig extends ICUTokenizerConfig {
48
 
  /** Token type for words containing ideographic characters */
49
 
  public static final String WORD_IDEO = StandardTokenizer.TOKEN_TYPES[StandardTokenizer.IDEOGRAPHIC];
50
 
  /** Token type for words containing Japanese hiragana */
51
 
  public static final String WORD_HIRAGANA = StandardTokenizer.TOKEN_TYPES[StandardTokenizer.HIRAGANA];
52
 
  /** Token type for words containing Japanese katakana */
53
 
  public static final String WORD_KATAKANA = StandardTokenizer.TOKEN_TYPES[StandardTokenizer.KATAKANA];
54
 
  /** Token type for words containing Korean hangul  */
55
 
  public static final String WORD_HANGUL = StandardTokenizer.TOKEN_TYPES[StandardTokenizer.HANGUL];
56
 
  /** Token type for words that contain letters */
57
 
  public static final String WORD_LETTER = StandardTokenizer.TOKEN_TYPES[StandardTokenizer.ALPHANUM];
58
 
  /** Token type for words that appear to be numbers */
59
 
  public static final String WORD_NUMBER = StandardTokenizer.TOKEN_TYPES[StandardTokenizer.NUM];
60
 
  
61
 
  /*
62
 
   * the default breakiterators in use. these can be expensive to
63
 
   * instantiate, cheap to clone.
64
 
   */  
65
 
  private static final BreakIterator rootBreakIterator = 
66
 
    readBreakIterator("Default.brk");
67
 
  private static final BreakIterator thaiBreakIterator = 
68
 
    BreakIterator.getWordInstance(new ULocale("th_TH"));
69
 
  private static final BreakIterator hebrewBreakIterator = 
70
 
    readBreakIterator("Hebrew.brk");
71
 
  private static final BreakIterator khmerBreakIterator = 
72
 
    readBreakIterator("Khmer.brk");
73
 
  private static final BreakIterator laoBreakIterator = 
74
 
    new LaoBreakIterator(readBreakIterator("Lao.brk"));
75
 
  private static final BreakIterator myanmarBreakIterator = 
76
 
    readBreakIterator("Myanmar.brk");
77
 
  
78
 
  @Override
79
 
  public BreakIterator getBreakIterator(int script) {
80
 
    switch(script) {
81
 
      case UScript.THAI: return (BreakIterator)thaiBreakIterator.clone();
82
 
      case UScript.HEBREW: return (BreakIterator)hebrewBreakIterator.clone();
83
 
      case UScript.KHMER: return (BreakIterator)khmerBreakIterator.clone();
84
 
      case UScript.LAO: return (BreakIterator)laoBreakIterator.clone();
85
 
      case UScript.MYANMAR: return (BreakIterator)myanmarBreakIterator.clone();
86
 
      default: return (BreakIterator)rootBreakIterator.clone();
87
 
    }
88
 
  }
89
 
 
90
 
  @Override
91
 
  public String getType(int script, int ruleStatus) {
92
 
    switch (ruleStatus) {
93
 
      case RuleBasedBreakIterator.WORD_IDEO:
94
 
        return WORD_IDEO;
95
 
      case RuleBasedBreakIterator.WORD_KANA:
96
 
        return script == UScript.HIRAGANA ? WORD_HIRAGANA : WORD_KATAKANA;
97
 
      case RuleBasedBreakIterator.WORD_LETTER:
98
 
        return script == UScript.HANGUL ? WORD_HANGUL : WORD_LETTER;
99
 
      case RuleBasedBreakIterator.WORD_NUMBER:
100
 
        return WORD_NUMBER;
101
 
      default: /* some other custom code */
102
 
        return "<OTHER>";
103
 
    }
104
 
  }
105
 
 
106
 
  private static RuleBasedBreakIterator readBreakIterator(String filename) {
107
 
    InputStream is = 
108
 
      DefaultICUTokenizerConfig.class.getResourceAsStream(filename);
109
 
    try {
110
 
      RuleBasedBreakIterator bi = 
111
 
        RuleBasedBreakIterator.getInstanceFromCompiledRules(is);
112
 
      is.close();
113
 
      return bi;
114
 
    } catch (IOException e) {
115
 
      throw new RuntimeException(e);
116
 
    }
117
 
  }
118
 
}