pylucene 3.5.0-3

[pylucene.git] / lucene-java-3.5.0 / lucene / src / java / org / apache / lucene / index / TermBuffer.java

diff --git a/lucene-java-3.5.0/lucene/src/java/org/apache/lucene/index/TermBuffer.java b/lucene-java-3.5.0/lucene/src/java/org/apache/lucene/index/TermBuffer.java
new file mode 100644 (file)
index 0000000..983b6d3
--- /dev/null
+++ b/lucene-java-3.5.0/lucene/src/java/org/apache/lucene/index/TermBuffer.java
@@ -0,0 +1,140 @@
+package org.apache.lucene.index;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.IOException;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.util.UnicodeUtil;
+
+final class TermBuffer implements Cloneable {
+
+  private String field;
+  private Term term;                            // cached
+  private boolean preUTF8Strings;                // true if strings are stored in modified UTF8 encoding (LUCENE-510)
+  private boolean dirty;                          // true if text was set externally (ie not read via UTF8 bytes)
+
+  private UnicodeUtil.UTF16Result text = new UnicodeUtil.UTF16Result();
+  private UnicodeUtil.UTF8Result bytes = new UnicodeUtil.UTF8Result();
+
+  public final int compareTo(TermBuffer other) {
+    if (field == other.field)    // fields are interned
+      return compareChars(text.result, text.length, other.text.result, other.text.length);
+    else
+      return field.compareTo(other.field);
+  }
+
+  private static final int compareChars(char[] chars1, int len1,
+                                        char[] chars2, int len2) {
+    final int end = len1 < len2 ? len1:len2;
+    for (int k = 0; k < end; k++) {
+      char c1 = chars1[k];
+      char c2 = chars2[k];
+      if (c1 != c2) {
+        return c1 - c2;
+      }
+    }
+    return len1 - len2;
+  }
+
+  /** Call this if the IndexInput passed to {@link #read}
+   *  stores terms in the "modified UTF8" (pre LUCENE-510)
+   *  format. */
+  void setPreUTF8Strings() {
+    preUTF8Strings = true;
+  }
+
+  public final void read(IndexInput input, FieldInfos fieldInfos)
+    throws IOException {
+    this.term = null;                           // invalidate cache
+    int start = input.readVInt();
+    int length = input.readVInt();
+    int totalLength = start + length;
+    if (preUTF8Strings) {
+      text.setLength(totalLength);
+      input.readChars(text.result, start, length);
+    } else {
+
+      if (dirty) {
+        // Fully convert all bytes since bytes is dirty
+        UnicodeUtil.UTF16toUTF8(text.result, 0, text.length, bytes);
+        bytes.setLength(totalLength);
+        input.readBytes(bytes.result, start, length);
+        UnicodeUtil.UTF8toUTF16(bytes.result, 0, totalLength, text);
+        dirty = false;
+      } else {
+        // Incrementally convert only the UTF8 bytes that are new:
+        bytes.setLength(totalLength);
+        input.readBytes(bytes.result, start, length);
+        UnicodeUtil.UTF8toUTF16(bytes.result, start, length, text);
+      }
+    }
+    this.field = fieldInfos.fieldName(input.readVInt());
+  }
+
+  public final void set(Term term) {
+    if (term == null) {
+      reset();
+      return;
+    }
+    final String termText = term.text();
+    final int termLen = termText.length();
+    text.setLength(termLen);
+    termText.getChars(0, termLen, text.result, 0);
+    dirty = true;
+    field = term.field();
+    this.term = term;
+  }
+
+  public final void set(TermBuffer other) {
+    text.copyText(other.text);
+    dirty = true;
+    field = other.field;
+    term = other.term;
+  }
+
+  public void reset() {
+    field = null;
+    text.setLength(0);
+    term = null;
+    dirty = true;
+  }
+
+  public Term toTerm() {
+    if (field == null)                            // unset
+      return null;
+
+    if (term == null)
+      term = new Term(field, new String(text.result, 0, text.length), false);
+
+    return term;
+  }
+
+  @Override
+  protected Object clone() {
+    TermBuffer clone = null;
+    try {
+      clone = (TermBuffer)super.clone();
+    } catch (CloneNotSupportedException e) {}
+
+    clone.dirty = true;
+    clone.bytes = new UnicodeUtil.UTF8Result();
+    clone.text = new UnicodeUtil.UTF16Result();
+    clone.text.copyText(text);
+    return clone;
+  }
+}