src.it.unimi.dsi.fastutil.objects.AbstractObjectCollection Maven / Gradle / Ivy
/* Generic definitions */
/* Assertions (useful to generate conditional code) */
/* Current type and class (and size, if applicable) */
/* Value methods */
/* Interfaces (keys) */
/* Interfaces (values) */
/* Abstract implementations (keys) */
/* Abstract implementations (values) */
/* Static containers (keys) */
/* Static containers (values) */
/* Implementations */
/* Synchronized wrappers */
/* Unmodifiable wrappers */
/* Other wrappers */
/* Methods (keys) */
/* Methods (values) */
/* Methods (keys/values) */
/* Methods that have special names depending on keys (but the special names depend on values) */
/* Equality */
/* Object/Reference-only definitions (keys) */
/* Object/Reference-only definitions (values) */
/*
* Copyright (C) 2002-2013 Sebastiano Vigna
*
* Licensed 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 it.unimi.dsi.fastutil.objects;
import java.util.AbstractCollection;
import java.util.Collection;
import java.util.Iterator;
/** An abstract class providing basic methods for collections implementing a type-specific interface.
*
* In particular, this class provide {@link #iterator()}, add(), {@link #remove(Object)} and
* {@link #contains(Object)} methods that just call the type-specific counterpart.
*/
public abstract class AbstractObjectCollection extends AbstractCollection implements ObjectCollection {
protected AbstractObjectCollection() {}
public Object[] toArray() {
final Object[] a = new Object[ size() ];
it.unimi.dsi.fastutil.objects.ObjectIterators.unwrap( iterator(), a );
return a;
}
@SuppressWarnings("unchecked")
public T[] toArray( T[] a ) {
if ( a.length < size() ) a = (T[])java.lang.reflect.Array.newInstance( a.getClass().getComponentType(), size() );
it.unimi.dsi.fastutil.objects.ObjectIterators.unwrap( iterator(), a );
return a;
}
/** Adds all elements of the given collection to this collection.
*
* @param c a collection.
* @return true if this collection changed as a result of the call.
*/
public boolean addAll( Collection c ) {
boolean retVal = false;
final Iterator i = c.iterator();
int n = c.size();
while( n-- != 0 ) if ( add( i.next() ) ) retVal = true;
return retVal;
}
public boolean add( K k ) {
throw new UnsupportedOperationException();
}
/** Delegates to the new covariantly stronger generic method. */
@Deprecated
public ObjectIterator objectIterator() {
return iterator();
}
public abstract ObjectIterator iterator();
/** Checks whether this collection contains all elements from the given collection.
*
* @param c a collection.
* @return true if this collection contains all elements of the argument.
*/
public boolean containsAll( Collection c ) {
int n = c.size();
final Iterator i = c.iterator();
while( n-- != 0 ) if ( ! contains( i.next() ) ) return false;
return true;
}
/** Retains in this collection only elements from the given collection.
*
* @param c a collection.
* @return true if this collection changed as a result of the call.
*/
public boolean retainAll( Collection c ) {
boolean retVal = false;
int n = size();
final Iterator i = iterator();
while( n-- != 0 ) {
if ( ! c.contains( i.next() ) ) {
i.remove();
retVal = true;
}
}
return retVal;
}
/** Remove from this collection all elements in the given collection.
* If the collection is an instance of this class, it uses faster iterators.
*
* @param c a collection.
* @return true if this collection changed as a result of the call.
*/
public boolean removeAll( Collection c ) {
boolean retVal = false;
int n = c.size();
final Iterator i = c.iterator();
while( n-- != 0 ) if ( remove( i.next() ) ) retVal = true;
return retVal;
}
public boolean isEmpty() {
return size() == 0;
}
public String toString() {
final StringBuilder s = new StringBuilder();
final ObjectIterator i = iterator();
int n = size();
Object k;
boolean first = true;
s.append("{");
while(n-- != 0) {
if (first) first = false;
else s.append(", ");
k = i.next();
if (this == k) s.append("(this collection)"); else
s.append(String.valueOf(k));
}
s.append("}");
return s.toString();
}
}