Java tutorial
/* * 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. */ package org.apache.lucene.facet.taxonomy; import static org.apache.lucene.util.ByteBlockPool.BYTE_BLOCK_SIZE; import java.util.Arrays; import org.apache.lucene.facet.taxonomy.writercache.LruTaxonomyWriterCache; // javadocs import org.apache.lucene.facet.taxonomy.writercache.NameHashIntCacheLRU; // javadocs /** * Holds a sequence of string components, specifying the hierarchical name of a * category. * * @lucene.internal */ public class FacetLabel implements Comparable<FacetLabel> { /* * copied from DocumentWriterPerThread -- if a FacetLabel is resolved to a * drill-down term which is encoded to a larger term than that length, it is * silently dropped! Therefore we limit the number of characters to MAX/4 to * be on the safe side. */ /** * The maximum number of characters a {@link FacetLabel} can have. */ public final static int MAX_CATEGORY_PATH_LENGTH = (BYTE_BLOCK_SIZE - 2) / 4; /** * The components of this {@link FacetLabel}. Note that this array may be * shared with other {@link FacetLabel} instances, e.g. as a result of * {@link #subpath(int)}, therefore you should traverse the array up to * {@link #length} for this path's components. */ public final String[] components; /** The number of components of this {@link FacetLabel}. */ public final int length; // Used by subpath private FacetLabel(final FacetLabel copyFrom, final int prefixLen) { // while the code which calls this method is safe, at some point a test // tripped on AIOOBE in toString, but we failed to reproduce. adding the // assert as a safety check. assert prefixLen >= 0 && prefixLen <= copyFrom.components.length : "prefixLen cannot be negative nor larger than the given components' length: prefixLen=" + prefixLen + " components.length=" + copyFrom.components.length; this.components = copyFrom.components; length = prefixLen; } /** Construct from the given path components. */ public FacetLabel(final String... components) { this.components = components; length = components.length; checkComponents(); } /** Construct from the dimension plus the given path components. */ public FacetLabel(String dim, String[] path) { components = new String[1 + path.length]; components[0] = dim; System.arraycopy(path, 0, components, 1, path.length); length = components.length; checkComponents(); } private void checkComponents() { long len = 0; for (String comp : components) { if (comp == null || comp.isEmpty()) { throw new IllegalArgumentException( "empty or null components not allowed: " + Arrays.toString(components)); } len += comp.length(); } len += components.length - 1; // add separators if (len > MAX_CATEGORY_PATH_LENGTH) { throw new IllegalArgumentException( "category path exceeds maximum allowed path length: max=" + MAX_CATEGORY_PATH_LENGTH + " len=" + len + " path=" + Arrays.toString(components).substring(0, 30) + "..."); } } /** * Compares this path with another {@link FacetLabel} for lexicographic * order. */ @Override public int compareTo(FacetLabel other) { final int len = length < other.length ? length : other.length; for (int i = 0, j = 0; i < len; i++, j++) { int cmp = components[i].compareTo(other.components[j]); if (cmp < 0) { return -1; // this is 'before' } if (cmp > 0) { return 1; // this is 'after' } } // one is a prefix of the other return length - other.length; } @Override public boolean equals(Object obj) { if (!(obj instanceof FacetLabel)) { return false; } FacetLabel other = (FacetLabel) obj; if (length != other.length) { return false; // not same length, cannot be equal } // CategoryPaths are more likely to differ at the last components, so start // from last-first for (int i = length - 1; i >= 0; i--) { if (!components[i].equals(other.components[i])) { return false; } } return true; } @Override public int hashCode() { if (length == 0) { return 0; } int hash = length; for (int i = 0; i < length; i++) { hash = hash * 31 + components[i].hashCode(); } return hash; } /** Calculate a 64-bit hash function for this path. This * is necessary for {@link NameHashIntCacheLRU} (the * default cache impl for {@link * LruTaxonomyWriterCache}) to reduce the chance of * "silent but deadly" collisions. */ public long longHashCode() { if (length == 0) { return 0; } long hash = length; for (int i = 0; i < length; i++) { hash = hash * 65599 + components[i].hashCode(); } return hash; } /** Returns a sub-path of this path up to {@code length} components. */ public FacetLabel subpath(final int length) { if (length >= this.length || length < 0) { return this; } else { return new FacetLabel(this, length); } } /** * Returns a string representation of the path. */ @Override public String toString() { if (length == 0) { return "FacetLabel: []"; } String[] parts = new String[length]; System.arraycopy(components, 0, parts, 0, length); return "FacetLabel: " + Arrays.toString(parts); } }