| /* |
| * 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.analysis; |
| |
| |
| import java.util.AbstractSet; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.Set; |
| |
| /** |
| * A simple class that stores Strings as char[]'s in a |
| * hash table. Note that this is not a general purpose |
| * class. For example, it cannot remove items from the |
| * set, nor does it resize its hash table to be smaller, |
| * etc. It is designed to be quick to test if a char[] |
| * is in the set without the necessity of converting it |
| * to a String first. |
| * |
| * <P> |
| * <em>Please note:</em> This class implements {@link java.util.Set Set} but |
| * does not behave like it should in all cases. The generic type is |
| * {@code Set<Object>}, because you can add any object to it, |
| * that has a string representation. The add methods will use |
| * {@link Object#toString} and store the result using a {@code char[]} |
| * buffer. The same behavior have the {@code contains()} methods. |
| * The {@link #iterator()} returns an {@code Iterator<char[]>}. |
| */ |
| public class CharArraySet extends AbstractSet<Object> { |
| |
| /** An empty {@code CharArraySet}. */ |
| public static final CharArraySet EMPTY_SET = new CharArraySet(CharArrayMap.<Object>emptyMap()); |
| |
| private static final Object PLACEHOLDER = new Object(); |
| |
| private final CharArrayMap<Object> map; |
| |
| /** |
| * Create set with enough capacity to hold startSize terms |
| * |
| * @param startSize |
| * the initial capacity |
| * @param ignoreCase |
| * <code>false</code> if and only if the set should be case sensitive |
| * otherwise <code>true</code>. |
| */ |
| public CharArraySet(int startSize, boolean ignoreCase) { |
| this(new CharArrayMap<>(startSize, ignoreCase)); |
| } |
| |
| /** |
| * Creates a set from a Collection of objects. |
| * |
| * @param c |
| * a collection whose elements to be placed into the set |
| * @param ignoreCase |
| * <code>false</code> if and only if the set should be case sensitive |
| * otherwise <code>true</code>. |
| */ |
| public CharArraySet(Collection<?> c, boolean ignoreCase) { |
| this(c.size(), ignoreCase); |
| addAll(c); |
| } |
| |
| /** Create set from the specified map (internal only), used also by {@link CharArrayMap#keySet()} */ |
| CharArraySet(final CharArrayMap<Object> map){ |
| this.map = map; |
| } |
| |
| /** Clears all entries in this set. This method is supported for reusing, but not {@link Set#remove}. */ |
| @Override |
| public void clear() { |
| map.clear(); |
| } |
| |
| /** true if the <code>len</code> chars of <code>text</code> starting at <code>off</code> |
| * are in the set */ |
| public boolean contains(char[] text, int off, int len) { |
| return map.containsKey(text, off, len); |
| } |
| |
| /** true if the <code>CharSequence</code> is in the set */ |
| public boolean contains(CharSequence cs) { |
| return map.containsKey(cs); |
| } |
| |
| @Override |
| public boolean contains(Object o) { |
| return map.containsKey(o); |
| } |
| |
| @Override |
| public boolean add(Object o) { |
| return map.put(o, PLACEHOLDER) == null; |
| } |
| |
| /** Add this CharSequence into the set */ |
| public boolean add(CharSequence text) { |
| return map.put(text, PLACEHOLDER) == null; |
| } |
| |
| /** Add this String into the set */ |
| public boolean add(String text) { |
| return map.put(text, PLACEHOLDER) == null; |
| } |
| |
| /** Add this char[] directly to the set. |
| * If ignoreCase is true for this Set, the text array will be directly modified. |
| * The user should never modify this text array after calling this method. |
| */ |
| public boolean add(char[] text) { |
| return map.put(text, PLACEHOLDER) == null; |
| } |
| |
| @Override |
| public int size() { |
| return map.size(); |
| } |
| |
| /** |
| * Returns an unmodifiable {@link CharArraySet}. This allows to provide |
| * unmodifiable views of internal sets for "read-only" use. |
| * |
| * @param set |
| * a set for which the unmodifiable set is returned. |
| * @return an new unmodifiable {@link CharArraySet}. |
| * @throws NullPointerException |
| * if the given set is <code>null</code>. |
| */ |
| public static CharArraySet unmodifiableSet(CharArraySet set) { |
| if (set == null) |
| throw new NullPointerException("Given set is null"); |
| if (set == EMPTY_SET) |
| return EMPTY_SET; |
| if (set.map instanceof CharArrayMap.UnmodifiableCharArrayMap) |
| return set; |
| return new CharArraySet(CharArrayMap.unmodifiableMap(set.map)); |
| } |
| |
| /** |
| * Returns a copy of the given set as a {@link CharArraySet}. If the given set |
| * is a {@link CharArraySet} the ignoreCase property will be preserved. |
| * |
| * @param set |
| * a set to copy |
| * @return a copy of the given set as a {@link CharArraySet}. If the given set |
| * is a {@link CharArraySet} the ignoreCase property as well as the |
| * matchVersion will be of the given set will be preserved. |
| */ |
| public static CharArraySet copy(final Set<?> set) { |
| if(set == EMPTY_SET) |
| return EMPTY_SET; |
| if(set instanceof CharArraySet) { |
| final CharArraySet source = (CharArraySet) set; |
| return new CharArraySet(CharArrayMap.copy(source.map)); |
| } |
| return new CharArraySet(set, false); |
| } |
| |
| /** |
| * Returns an {@link Iterator} for {@code char[]} instances in this set. |
| */ |
| @Override @SuppressWarnings("unchecked") |
| public Iterator<Object> iterator() { |
| // use the AbstractSet#keySet()'s iterator (to not produce endless recursion) |
| return map.originalKeySet().iterator(); |
| } |
| |
| @Override |
| public String toString() { |
| final StringBuilder sb = new StringBuilder("["); |
| for (Object item : this) { |
| if (sb.length()>1) sb.append(", "); |
| if (item instanceof char[]) { |
| sb.append((char[]) item); |
| } else { |
| sb.append(item); |
| } |
| } |
| return sb.append(']').toString(); |
| } |
| } |