+++ /dev/null
-package org.apache.lucene.util;
-
-/**
- * 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.util.Comparator;
-import java.io.UnsupportedEncodingException;
-
-/** Represents byte[], as a slice (offset + length) into an
- * existing byte[].
- *
- * @lucene.experimental */
-public final class BytesRef implements Comparable<BytesRef> {
-
- static final int HASH_PRIME = 31;
- public static final byte[] EMPTY_BYTES = new byte[0];
-
- /** The contents of the BytesRef. Should never be {@code null}. */
- public byte[] bytes;
-
- /** Offset of first valid byte. */
- public int offset;
-
- /** Length of used bytes. */
- public int length;
-
- public BytesRef() {
- bytes = EMPTY_BYTES;
- }
-
- /** This instance will directly reference bytes w/o making a copy.
- * bytes should not be null.
- */
- public BytesRef(byte[] bytes, int offset, int length) {
- assert bytes != null;
- this.bytes = bytes;
- this.offset = offset;
- this.length = length;
- }
-
- /** This instance will directly reference bytes w/o making a copy.
- * bytes should not be null */
- public BytesRef(byte[] bytes) {
- assert bytes != null;
- this.bytes = bytes;
- this.offset = 0;
- this.length = bytes.length;
- }
-
- public BytesRef(int capacity) {
- this.bytes = new byte[capacity];
- }
-
- /**
- * @param text Initialize the byte[] from the UTF8 bytes
- * for the provided Sring. This must be well-formed
- * unicode text, with no unpaired surrogates or U+FFFF.
- */
- public BytesRef(CharSequence text) {
- this();
- copy(text);
- }
-
- /**
- * @param text Initialize the byte[] from the UTF8 bytes
- * for the provided array. This must be well-formed
- * unicode text, with no unpaired surrogates or U+FFFF.
- */
- public BytesRef(char text[], int offset, int length) {
- this(length * 4);
- copy(text, offset, length);
- }
-
- public BytesRef(BytesRef other) {
- this();
- copy(other);
- }
-
- /* // maybe?
- public BytesRef(BytesRef other, boolean shallow) {
- this();
- if (shallow) {
- offset = other.offset;
- length = other.length;
- bytes = other.bytes;
- } else {
- copy(other);
- }
- }
- */
-
- /**
- * Copies the UTF8 bytes for this string.
- *
- * @param text Must be well-formed unicode text, with no
- * unpaired surrogates or invalid UTF16 code units.
- */
- public void copy(CharSequence text) {
- UnicodeUtil.UTF16toUTF8(text, 0, text.length(), this);
- }
-
- /**
- * Copies the UTF8 bytes for this string.
- *
- * @param text Must be well-formed unicode text, with no
- * unpaired surrogates or invalid UTF16 code units.
- */
- public void copy(char text[], int offset, int length) {
- UnicodeUtil.UTF16toUTF8(text, offset, length, this);
- }
-
- public boolean bytesEquals(BytesRef other) {
- if (length == other.length) {
- int otherUpto = other.offset;
- final byte[] otherBytes = other.bytes;
- final int end = offset + length;
- for(int upto=offset;upto<end;upto++,otherUpto++) {
- if (bytes[upto] != otherBytes[otherUpto]) {
- return false;
- }
- }
- return true;
- } else {
- return false;
- }
- }
-
- @Override
- public Object clone() {
- return new BytesRef(this);
- }
-
- private boolean sliceEquals(BytesRef other, int pos) {
- if (pos < 0 || length - pos < other.length) {
- return false;
- }
- int i = offset + pos;
- int j = other.offset;
- final int k = other.offset + other.length;
-
- while (j < k) {
- if (bytes[i++] != other.bytes[j++]) {
- return false;
- }
- }
-
- return true;
- }
-
- public boolean startsWith(BytesRef other) {
- return sliceEquals(other, 0);
- }
-
- public boolean endsWith(BytesRef other) {
- return sliceEquals(other, length - other.length);
- }
-
- /** Calculates the hash code as required by TermsHash during indexing.
- * <p>It is defined as:
- * <pre>
- * int hash = 0;
- * for (int i = offset; i < offset + length; i++) {
- * hash = 31*hash + bytes[i];
- * }
- * </pre>
- */
- @Override
- public int hashCode() {
- int result = 0;
- final int end = offset + length;
- for(int i=offset;i<end;i++) {
- result = HASH_PRIME * result + bytes[i];
- }
- return result;
- }
-
- @Override
- public boolean equals(Object other) {
- if (other == null) {
- return false;
- }
- return this.bytesEquals((BytesRef) other);
- }
-
- /** Interprets stored bytes as UTF8 bytes, returning the
- * resulting string */
- public String utf8ToString() {
- try {
- return new String(bytes, offset, length, "UTF-8");
- } catch (UnsupportedEncodingException uee) {
- // should not happen -- UTF8 is presumably supported
- // by all JREs
- throw new RuntimeException(uee);
- }
- }
-
- /** Returns hex encoded bytes, eg [0x6c 0x75 0x63 0x65 0x6e 0x65] */
- @Override
- public String toString() {
- StringBuilder sb = new StringBuilder();
- sb.append('[');
- final int end = offset + length;
- for(int i=offset;i<end;i++) {
- if (i > offset) {
- sb.append(' ');
- }
- sb.append(Integer.toHexString(bytes[i]&0xff));
- }
- sb.append(']');
- return sb.toString();
- }
-
- public void copy(BytesRef other) {
- if (bytes.length < other.length) {
- bytes = new byte[other.length];
- }
- System.arraycopy(other.bytes, other.offset, bytes, 0, other.length);
- length = other.length;
- offset = 0;
- }
-
- public void append(BytesRef other) {
- int newLen = length + other.length;
- if (bytes.length < newLen) {
- byte[] newBytes = new byte[newLen];
- System.arraycopy(bytes, offset, newBytes, 0, length);
- offset = 0;
- bytes = newBytes;
- }
- System.arraycopy(other.bytes, other.offset, bytes, length+offset, other.length);
- length = newLen;
- }
-
- public void grow(int newLength) {
- bytes = ArrayUtil.grow(bytes, newLength);
- }
-
- /** Unsigned byte order comparison */
- public int compareTo(BytesRef other) {
- if (this == other) return 0;
-
- final byte[] aBytes = this.bytes;
- int aUpto = this.offset;
- final byte[] bBytes = other.bytes;
- int bUpto = other.offset;
-
- final int aStop = aUpto + Math.min(this.length, other.length);
-
- while(aUpto < aStop) {
- int aByte = aBytes[aUpto++] & 0xff;
- int bByte = bBytes[bUpto++] & 0xff;
- int diff = aByte - bByte;
- if (diff != 0) return diff;
- }
-
- // One is a prefix of the other, or, they are equal:
- return this.length - other.length;
- }
-
- private final static Comparator<BytesRef> utf8SortedAsUnicodeSortOrder = new UTF8SortedAsUnicodeComparator();
-
- public static Comparator<BytesRef> getUTF8SortedAsUnicodeComparator() {
- return utf8SortedAsUnicodeSortOrder;
- }
-
- private static class UTF8SortedAsUnicodeComparator implements Comparator<BytesRef> {
- // Only singleton
- private UTF8SortedAsUnicodeComparator() {};
-
- public int compare(BytesRef a, BytesRef b) {
- final byte[] aBytes = a.bytes;
- int aUpto = a.offset;
- final byte[] bBytes = b.bytes;
- int bUpto = b.offset;
-
- final int aStop;
- if (a.length < b.length) {
- aStop = aUpto + a.length;
- } else {
- aStop = aUpto + b.length;
- }
-
- while(aUpto < aStop) {
- int aByte = aBytes[aUpto++] & 0xff;
- int bByte = bBytes[bUpto++] & 0xff;
-
- int diff = aByte - bByte;
- if (diff != 0) {
- return diff;
- }
- }
-
- // One is a prefix of the other, or, they are equal:
- return a.length - b.length;
- }
- }
-
- private final static Comparator<BytesRef> utf8SortedAsUTF16SortOrder = new UTF8SortedAsUTF16Comparator();
-
- public static Comparator<BytesRef> getUTF8SortedAsUTF16Comparator() {
- return utf8SortedAsUTF16SortOrder;
- }
-
- private static class UTF8SortedAsUTF16Comparator implements Comparator<BytesRef> {
- // Only singleton
- private UTF8SortedAsUTF16Comparator() {};
-
- public int compare(BytesRef a, BytesRef b) {
-
- final byte[] aBytes = a.bytes;
- int aUpto = a.offset;
- final byte[] bBytes = b.bytes;
- int bUpto = b.offset;
-
- final int aStop;
- if (a.length < b.length) {
- aStop = aUpto + a.length;
- } else {
- aStop = aUpto + b.length;
- }
-
- while(aUpto < aStop) {
- int aByte = aBytes[aUpto++] & 0xff;
- int bByte = bBytes[bUpto++] & 0xff;
-
- if (aByte != bByte) {
-
- // See http://icu-project.org/docs/papers/utf16_code_point_order.html#utf-8-in-utf-16-order
-
- // We know the terms are not equal, but, we may
- // have to carefully fixup the bytes at the
- // difference to match UTF16's sort order:
-
- // NOTE: instead of moving supplementary code points (0xee and 0xef) to the unused 0xfe and 0xff,
- // we move them to the unused 0xfc and 0xfd [reserved for future 6-byte character sequences]
- // this reserves 0xff for preflex's term reordering (surrogate dance), and if unicode grows such
- // that 6-byte sequences are needed we have much bigger problems anyway.
- if (aByte >= 0xee && bByte >= 0xee) {
- if ((aByte & 0xfe) == 0xee) {
- aByte += 0xe;
- }
- if ((bByte&0xfe) == 0xee) {
- bByte += 0xe;
- }
- }
- return aByte - bByte;
- }
- }
-
- // One is a prefix of the other, or, they are equal:
- return a.length - b.length;
- }
- }
-}
fnp / pylucene.git / blobdiff