← Back to branch summary

~ubuntu-branches/ubuntu/trusty/pylucene/trusty

« back to all changes in this revision

Viewing changes to lucene-java-3.5.0/lucene/src/java/org/apache/lucene/analysis/PerFieldAnalyzerWrapper.java

  • Committer: Package Import Robot
  • Author(s): Dmitry Nezhevenko
  • Date: 2012-04-23 16:43:55 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120423164355-grqtepnwtecdjfk2
Tags: 3.5.0-1
http://bugs.debian.org/670179
http://bugs.debian.org/581198
http://bugs.debian.org/632240
http://bugs.debian.org/581197
* New maintainer (closes: 670179)
* New upstream release
* Switch to dpkg-source 3.0 (quilt) format
* Switch to machine-readable debian/copyright
* Bump debian/compat to 8, drop debian/pycompat
* Switch from cdbs to dh
* Add watch file
* Build for all supported versions of python2 (closes: 581198, 632240)
* Rename binary package to python-lucene (closes: 581197)
* Add -dbg package

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene-java-3.5.0/lucene/src/java/org/apache/lucene/analysis/PerFieldAnalyzerWrapper.java
 
1
package org.apache.lucene.analysis;
 
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 org.apache.lucene.document.Fieldable;
 
21
 
 
22
import java.io.Reader;
 
23
import java.io.IOException;
 
24
import java.util.Map;
 
25
import java.util.HashMap;
 
26
 
 
27
/**
 
28
 * This analyzer is used to facilitate scenarios where different
 
29
 * fields require different analysis techniques.  Use the Map
 
30
 * argument in {@link #PerFieldAnalyzerWrapper(Analyzer, java.util.Map)}
 
31
 * to add non-default analyzers for fields.
 
32
 * 
 
33
 * <p>Example usage:
 
34
 * 
 
35
 * <pre>
 
36
 *   Map analyzerPerField = new HashMap();
 
37
 *   analyzerPerField.put("firstname", new KeywordAnalyzer());
 
38
 *   analyzerPerField.put("lastname", new KeywordAnalyzer());
 
39
 *
 
40
 *   PerFieldAnalyzerWrapper aWrapper =
 
41
 *      new PerFieldAnalyzerWrapper(new StandardAnalyzer(), analyzerPerField);
 
42
 * </pre>
 
43
 * 
 
44
 * <p>In this example, StandardAnalyzer will be used for all fields except "firstname"
 
45
 * and "lastname", for which KeywordAnalyzer will be used.
 
46
 * 
 
47
 * <p>A PerFieldAnalyzerWrapper can be used like any other analyzer, for both indexing
 
48
 * and query parsing.
 
49
 */
 
50
public final class PerFieldAnalyzerWrapper extends Analyzer {
 
51
  private final Analyzer defaultAnalyzer;
 
52
  private final Map<String,Analyzer> analyzerMap = new HashMap<String,Analyzer>();
 
53
 
 
54
 
 
55
  /**
 
56
   * Constructs with default analyzer.
 
57
   *
 
58
   * @param defaultAnalyzer Any fields not specifically
 
59
   * defined to use a different analyzer will use the one provided here.
 
60
   */
 
61
  public PerFieldAnalyzerWrapper(Analyzer defaultAnalyzer) {
 
62
    this(defaultAnalyzer, null);
 
63
  }
 
64
  
 
65
  /**
 
66
   * Constructs with default analyzer and a map of analyzers to use for 
 
67
   * specific fields.
 
68
   *
 
69
   * @param defaultAnalyzer Any fields not specifically
 
70
   * defined to use a different analyzer will use the one provided here.
 
71
   * @param fieldAnalyzers a Map (String field name to the Analyzer) to be 
 
72
   * used for those fields 
 
73
   */
 
74
  public PerFieldAnalyzerWrapper(Analyzer defaultAnalyzer, 
 
75
      Map<String,Analyzer> fieldAnalyzers) {
 
76
    this.defaultAnalyzer = defaultAnalyzer;
 
77
    if (fieldAnalyzers != null) {
 
78
      analyzerMap.putAll(fieldAnalyzers);
 
79
    }
 
80
  }
 
81
  
 
82
 
 
83
  /**
 
84
   * Defines an analyzer to use for the specified field.
 
85
   *
 
86
   * @param fieldName field name requiring a non-default analyzer
 
87
   * @param analyzer non-default analyzer to use for field
 
88
   * @deprecated Changing the Analyzer for a field after instantiation prevents
 
89
   *             reusability.  Analyzers for fields should be set during construction.
 
90
   */
 
91
  @Deprecated
 
92
  public void addAnalyzer(String fieldName, Analyzer analyzer) {
 
93
    analyzerMap.put(fieldName, analyzer);
 
94
  }
 
95
 
 
96
  @Override
 
97
  public TokenStream tokenStream(String fieldName, Reader reader) {
 
98
    Analyzer analyzer = analyzerMap.get(fieldName);
 
99
    if (analyzer == null) {
 
100
      analyzer = defaultAnalyzer;
 
101
    }
 
102
 
 
103
    return analyzer.tokenStream(fieldName, reader);
 
104
  }
 
105
  
 
106
  @Override
 
107
  public TokenStream reusableTokenStream(String fieldName, Reader reader) throws IOException {
 
108
    Analyzer analyzer = analyzerMap.get(fieldName);
 
109
    if (analyzer == null)
 
110
      analyzer = defaultAnalyzer;
 
111
 
 
112
    return analyzer.reusableTokenStream(fieldName, reader);
 
113
  }
 
114
  
 
115
  /** Return the positionIncrementGap from the analyzer assigned to fieldName */
 
116
  @Override
 
117
  public int getPositionIncrementGap(String fieldName) {
 
118
    Analyzer analyzer = analyzerMap.get(fieldName);
 
119
    if (analyzer == null)
 
120
      analyzer = defaultAnalyzer;
 
121
    return analyzer.getPositionIncrementGap(fieldName);
 
122
  }
 
123
 
 
124
  /** Return the offsetGap from the analyzer assigned to field */
 
125
  @Override
 
126
  public int getOffsetGap(Fieldable field) {
 
127
    Analyzer analyzer = analyzerMap.get(field.name());
 
128
    if (analyzer == null)
 
129
      analyzer = defaultAnalyzer;
 
130
    return analyzer.getOffsetGap(field);
 
131
  }
 
132
  
 
133
  @Override
 
134
  public String toString() {
 
135
    return "PerFieldAnalyzerWrapper(" + analyzerMap + ", default=" + defaultAnalyzer + ")";
 
136
  }
 
137
}