content: 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 readTiiQuick(IndexInput input, FieldInfos fieldInfos)
    throws IOException {
    this.term = null;                           // invalidate cache
    int start = 0;
    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;
    }
  }
  