← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lucene/contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/ReadTokensTask.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/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/ReadTokensTask.java
1
 
package org.apache.lucene.benchmark.byTask.tasks;
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.Reader;
21
 
import java.util.List;
22
 
 
23
 
import org.apache.lucene.analysis.Analyzer;
24
 
import org.apache.lucene.analysis.TokenStream;
25
 
import org.apache.lucene.benchmark.byTask.PerfRunData;
26
 
import org.apache.lucene.benchmark.byTask.feeds.DocMaker;
27
 
import org.apache.lucene.document.Document;
28
 
import org.apache.lucene.document.Fieldable;
29
 
import org.apache.lucene.document.NumericField;
30
 
 
31
 
/**
32
 
 * Simple task to test performance of tokenizers.  It just
33
 
 * creates a token stream for each field of the document and
34
 
 * read all tokens out of that stream.
35
 
 */
36
 
public class ReadTokensTask extends PerfTask {
37
 
 
38
 
  public ReadTokensTask(PerfRunData runData) {
39
 
    super(runData);
40
 
  }
41
 
 
42
 
  private int totalTokenCount = 0;
43
 
  
44
 
  // volatile data passed between setup(), doLogic(), tearDown().
45
 
  private Document doc = null;
46
 
  
47
 
  @Override
48
 
  public void setup() throws Exception {
49
 
    super.setup();
50
 
    DocMaker docMaker = getRunData().getDocMaker();
51
 
    doc = docMaker.makeDocument();
52
 
  }
53
 
 
54
 
  @Override
55
 
  protected String getLogMessage(int recsCount) {
56
 
    return "read " + recsCount + " docs; " + totalTokenCount + " tokens";
57
 
  }
58
 
  
59
 
  @Override
60
 
  public void tearDown() throws Exception {
61
 
    doc = null;
62
 
    super.tearDown();
63
 
  }
64
 
 
65
 
  @Override
66
 
  public int doLogic() throws Exception {
67
 
    List<Fieldable> fields = doc.getFields();
68
 
    Analyzer analyzer = getRunData().getAnalyzer();
69
 
    int tokenCount = 0;
70
 
    for(final Fieldable field : fields) {
71
 
      if (!field.isTokenized() || field instanceof NumericField) continue;
72
 
      
73
 
      final TokenStream stream;
74
 
      final TokenStream streamValue = field.tokenStreamValue();
75
 
 
76
 
      if (streamValue != null) 
77
 
        stream = streamValue;
78
 
      else {
79
 
        // the field does not have a TokenStream,
80
 
        // so we have to obtain one from the analyzer
81
 
        final Reader reader;                      // find or make Reader
82
 
        final Reader readerValue = field.readerValue();
83
 
 
84
 
        if (readerValue != null)
85
 
          reader = readerValue;
86
 
        else {
87
 
          String stringValue = field.stringValue();
88
 
          if (stringValue == null)
89
 
            throw new IllegalArgumentException("field must have either TokenStream, String or Reader value");
90
 
          stringReader.init(stringValue);
91
 
          reader = stringReader;
92
 
        }
93
 
        
94
 
        // Tokenize field
95
 
        stream = analyzer.reusableTokenStream(field.name(), reader);
96
 
      }
97
 
 
98
 
      // reset the TokenStream to the first token
99
 
      stream.reset();
100
 
 
101
 
      while(stream.incrementToken())
102
 
        tokenCount++;
103
 
    }
104
 
    totalTokenCount += tokenCount;
105
 
    return tokenCount;
106
 
  }
107
 
 
108
 
  /* Simple StringReader that can be reset to a new string;
109
 
   * we use this when tokenizing the string value from a
110
 
   * Field. */
111
 
  ReusableStringReader stringReader = new ReusableStringReader();
112
 
 
113
 
  private final static class ReusableStringReader extends Reader {
114
 
    int upto;
115
 
    int left;
116
 
    String s;
117
 
    
118
 
    ReusableStringReader() {}
119
 
    void init(String s) {
120
 
      this.s = s;
121
 
      left = s.length();
122
 
      this.upto = 0;
123
 
    }
124
 
    @Override
125
 
    public int read(char[] c) {
126
 
      return read(c, 0, c.length);
127
 
    }
128
 
    @Override
129
 
    public int read(char[] c, int off, int len) {
130
 
      if (left > len) {
131
 
        s.getChars(upto, upto+len, c, off);
132
 
        upto += len;
133
 
        left -= len;
134
 
        return len;
135
 
      } else if (0 == left) {
136
 
        return -1;
137
 
      } else {
138
 
        s.getChars(upto, upto+left, c, off);
139
 
        int r = left;
140
 
        left = 0;
141
 
        upto = s.length();
142
 
        return r;
143
 
      }
144
 
    }
145
 
    @Override
146
 
    public void close() {}
147
 
  }
148
 
}