/*******************************************************************************
* Copyright (c) 2007 Wind River Systems, Inc. and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Martin Oberhuber (Wind River) - initial API and implementation for [105554]
*******************************************************************************/
package org.eclipse.core.internal.localstore;
import java.util.Arrays;
/**
* A pool of Strings for doing prefix checks against multiple
* candidates.
* <p>
* Allows to enter a list of Strings, and then perform the
* following checks:
* <ul>
* <li>{@link #containsAsPrefix(String)} - check whether a given
* String s is a prefix of any String in the pool.</li>
* <li>{@link #hasPrefixOf(String)} - check whether any String
* in the pool is a prefix of the given String s.
* </ul>
* The prefix pool is always kept normalized, i.e. no element of
* the pool is a prefix of any other element in the pool. In order
* to maintain this constraint, there are two methods for adding
* Strings to the pool:
* <ul>
* <li>{@link #insertLonger(String)} - add a String s to the pool,
* and remove any existing prefix of s from the pool.</li>
* <li>{@link #insertShorter(String)} - add a String s to the pool,
* and remove any existing Strings sx from the pool which
* contain s as prefix.</li>
* </ul>
* The PrefixPool grows as needed when adding Strings. Typically,
* it is used for prefix checks on absolute paths of a tree.
* </p><p>
* This class is not thread-safe: no two threads may add or
* check items at the same time.
*
* @since 3.3
*/
public class PrefixPool {
private String[] pool;
private int size;
/**
* Constructor.
* @param initialCapacity the initial size of the
* internal array holding the String pool. Must
* be greater than 0.
*/
public PrefixPool(int initialCapacity) {
if (initialCapacity <= 0)
throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity); //$NON-NLS-1$
pool = new String[initialCapacity];
size = 0;
}
/**
* Clears the prefix pool, allowing all items to be
* garbage collected. Does not change the capacity
* of the pool.
*/
public/*synchronized*/void clear() {
Arrays.fill(pool, 0, size, null);
size = 0;
}
/**
* Return the current size of prefix pool.
* @return the number of elements in the pool.
*/
public/*synchronized*/int size() {
return size;
}
/**
* Ensure that there is room for at least one more element.
*/
private void checkCapacity() {
if (size + 1 >= pool.length) {
String[] newprefixList = new String[2 * pool.length];
System.arraycopy(pool, 0, newprefixList, 0, pool.length);
Arrays.fill(pool, null); //help the garbage collector
pool = newprefixList;
}
}
/**
* Insert a String s into the pool of known prefixes, removing
* any existing prefix of it.
* <p>
* If any existing prefix of this String is found in the pool,
* it is replaced by the new longer one in order to maintain
* the constraint of keeping the pool normalized.
* </p><p>
* If it turns out that s is actually a prefix or equal to
* an existing element in the pool (so it is essentially
* shorter), this method returns with no operation in order
* to maintain the constraint that the pool remains normalized.
* </p>
* @param s the String to insert.
*/
public/*synchronized*/void insertLonger(String s) {
//check in reverse order since we expect some locality
for (int i = size - 1; i >= 0; i--) {
if (pool[i].startsWith(s)) {
//prefix of an existing String --> no-op
return;
} else if (s.startsWith(pool[i])) {
//replace, since a longer s has more prefixes than a short one
pool[i] = s;
return;
}
}
checkCapacity();
pool[size] = s;
size++;
}
/**
* Insert a String s into the pool of known prefixes, removing
* any Strings that have s as prefix.
* <p>
* If this String is a prefix of any existing String in the pool,
* all elements that contain the new String as prefix are removed
* and return value <code>true</code> is returned.
* </p><p>
* Otherwise, the new String is added to the pool unless an
* equal String or e prefix of it exists there already (so
* it is essentially equal or longer than an existing prefix).
* In all these cases, <code>false</code> is returned since
* no prefixes were replaced.
* </p>
* @param s the String to insert.
* @return <code>true</code>if any longer elements have been
* removed.
*/
public/*synchronized*/boolean insertShorter(String s) {
boolean replaced = false;
//check in reverse order since we expect some locality
for (int i = size - 1; i >= 0; i--) {
if (s.startsWith(pool[i])) {
//longer or equal to an existing prefix - nothing to do
return false;
} else if (pool[i].startsWith(s)) {
if (replaced) {
//replaced before, so shrink the array.
//Safe since we are iterating in reverse order.
System.arraycopy(pool, i + 1, pool, i, size - i - 1);
size--;
pool[size] = null;
} else {
//replace, since this is a shorter s
pool[i] = s;
replaced = true;
}
}
}
if (!replaced) {
//append at the end
checkCapacity();
pool[size] = s;
size++;
}
return replaced;
}
/**
* Check if the given String s is a prefix of any of Strings
* in the pool.
* @param s a s to check for being a prefix
* @return <code>true</code> if the passed s is a prefix
* of any of the Strings contained in the pool.
*/
public/*synchronized*/boolean containsAsPrefix(String s) {
//check in reverse order since we expect some locality
for (int i = size - 1; i >= 0; i--) {
if (pool[i].startsWith(s)) {
return true;
}
}
return false;
}
/**
* Test if the String pool contains any one that is a prefix
* of the given String s.
* @param s the String to test
* @return <code>true</code> if the String pool contains a
* prefix of the given String.
*/
public/*synchronized*/boolean hasPrefixOf(String s) {
for (int i = size - 1; i >= 0; i--) {
if (s.startsWith(pool[i])) {
return true;
}
}
return false;
}
}