← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lucene/contrib/facet/src/java/org/apache/lucene/facet/taxonomy/writercache/cl2o/CharBlockArray.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/facet/src/java/org/apache/lucene/facet/taxonomy/writercache/cl2o/CharBlockArray.java
1
 
package org.apache.lucene.facet.taxonomy.writercache.cl2o;
2
 
 
3
 
import java.io.IOException;
4
 
import java.io.InputStream;
5
 
import java.io.ObjectInputStream;
6
 
import java.io.ObjectOutputStream;
7
 
import java.io.OutputStream;
8
 
import java.io.Serializable;
9
 
import java.util.ArrayList;
10
 
import java.util.List;
11
 
 
12
 
/**
13
 
 * Licensed to the Apache Software Foundation (ASF) under one or more
14
 
 * contributor license agreements.  See the NOTICE file distributed with
15
 
 * this work for additional information regarding copyright ownership.
16
 
 * The ASF licenses this file to You under the Apache License, Version 2.0
17
 
 * (the "License"); you may not use this file except in compliance with
18
 
 * the License.  You may obtain a copy of the License at
19
 
 *
20
 
 *     http://www.apache.org/licenses/LICENSE-2.0
21
 
 *
22
 
 * Unless required by applicable law or agreed to in writing, software
23
 
 * distributed under the License is distributed on an "AS IS" BASIS,
24
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
25
 
 * See the License for the specific language governing permissions and
26
 
 * limitations under the License.
27
 
 */
28
 
 
29
 
/**
30
 
 * Similar to {@link StringBuilder}, but with a more efficient growing strategy.
31
 
 * This class uses char array blocks to grow.
32
 
 * 
33
 
 * @lucene.experimental
34
 
 */
35
 
class CharBlockArray implements Appendable, Serializable, CharSequence {
36
 
 
37
 
  private static final long serialVersionUID = 1L;
38
 
 
39
 
  private final static int DefaultBlockSize = 32 * 1024;  // 32 KB default size
40
 
 
41
 
  final static class Block implements Serializable, Cloneable {
42
 
    private static final long serialVersionUID = 1L;
43
 
 
44
 
    char[] chars;
45
 
    int length;
46
 
 
47
 
    Block(int size) {
48
 
      this.chars = new char[size];
49
 
      this.length = 0;
50
 
    }
51
 
  }
52
 
 
53
 
  List<Block> blocks;
54
 
  Block current;
55
 
  int blockSize;
56
 
  int length;
57
 
 
58
 
  CharBlockArray() {
59
 
    this(DefaultBlockSize);
60
 
  }
61
 
 
62
 
  CharBlockArray(int blockSize) {
63
 
    this.blocks = new ArrayList<Block>();
64
 
    this.blockSize = blockSize;
65
 
    addBlock();
66
 
  }
67
 
 
68
 
  private void addBlock() {
69
 
    this.current = new Block(this.blockSize);
70
 
    this.blocks.add(this.current);
71
 
  }
72
 
 
73
 
  int blockIndex(int index) {
74
 
    return index / blockSize;
75
 
  }
76
 
 
77
 
  int indexInBlock(int index) {
78
 
    return index % blockSize;
79
 
  }
80
 
 
81
 
  public CharBlockArray append(CharSequence chars) {
82
 
    return append(chars, 0, chars.length());
83
 
  }
84
 
 
85
 
  public CharBlockArray append(char c) {
86
 
    if (this.current.length == this.blockSize) {
87
 
      addBlock();
88
 
    }
89
 
    this.current.chars[this.current.length++] = c;
90
 
    this.length++;
91
 
 
92
 
    return this;
93
 
  }
94
 
 
95
 
  public CharBlockArray append(CharSequence chars, int start, int length) {
96
 
    int end = start + length;
97
 
    for (int i = start; i < end; i++) {
98
 
      append(chars.charAt(i));
99
 
    }
100
 
    return this;
101
 
  }
102
 
 
103
 
  public CharBlockArray append(char[] chars, int start, int length) {
104
 
    int offset = start;
105
 
    int remain = length;
106
 
    while (remain > 0) {
107
 
      if (this.current.length == this.blockSize) {
108
 
        addBlock();
109
 
      }
110
 
      int toCopy = remain;
111
 
      int remainingInBlock = this.blockSize - this.current.length;
112
 
      if (remainingInBlock < toCopy) {
113
 
        toCopy = remainingInBlock;
114
 
      }
115
 
      System.arraycopy(chars, offset, this.current.chars, this.current.length, toCopy);
116
 
      offset += toCopy;
117
 
      remain -= toCopy;
118
 
      this.current.length += toCopy;
119
 
    }
120
 
 
121
 
    this.length += length;
122
 
    return this;
123
 
  }
124
 
 
125
 
  public CharBlockArray append(String s) {
126
 
    int remain = s.length();
127
 
    int offset = 0;
128
 
    while (remain > 0) {
129
 
      if (this.current.length == this.blockSize) {
130
 
        addBlock();
131
 
      }
132
 
      int toCopy = remain;
133
 
      int remainingInBlock = this.blockSize - this.current.length;
134
 
      if (remainingInBlock < toCopy) {
135
 
        toCopy = remainingInBlock;
136
 
      }
137
 
      s.getChars(offset, offset + toCopy, this.current.chars, this.current.length);
138
 
      offset += toCopy;
139
 
      remain -= toCopy;
140
 
      this.current.length += toCopy;
141
 
    }
142
 
 
143
 
    this.length += s.length();
144
 
    return this;
145
 
  }
146
 
 
147
 
  public char charAt(int index) {
148
 
    Block b = this.blocks.get(blockIndex(index));
149
 
    return b.chars[indexInBlock(index)];
150
 
  }
151
 
 
152
 
  public int length() {
153
 
    return this.length;
154
 
  }
155
 
 
156
 
  public CharSequence subSequence(int start, int end) {
157
 
    throw new UnsupportedOperationException("subsequence not implemented yet");
158
 
  }
159
 
 
160
 
  @Override
161
 
  public String toString() {
162
 
    StringBuilder b = new StringBuilder(blockSize * this.blocks.size());
163
 
    for (int i = 0; i < this.blocks.size(); i++) {
164
 
      b.append(this.blocks.get(i).chars);
165
 
    }
166
 
    return b.toString();
167
 
  }
168
 
 
169
 
  void flush(OutputStream out) throws IOException {
170
 
    ObjectOutputStream oos = null;
171
 
    try {
172
 
      oos = new ObjectOutputStream(out);
173
 
      oos.writeObject(this);
174
 
      oos.flush();
175
 
    } finally {
176
 
      if (oos != null) {
177
 
        oos.close();
178
 
      }
179
 
    }
180
 
  }
181
 
 
182
 
  public static CharBlockArray open(InputStream in) throws IOException, ClassNotFoundException {
183
 
    ObjectInputStream ois = null;
184
 
    try {
185
 
      ois = new ObjectInputStream(in);
186
 
      CharBlockArray a = (CharBlockArray) ois.readObject();
187
 
      return a;
188
 
    } finally {
189
 
      if (ois != null) {
190
 
        ois.close();
191
 
      }
192
 
    }
193
 
  }
194
 
 
195
 
}