// 
// Decompiled by Procyon v0.6.0
// 

package it.unimi.dsi.fastutil.floats;

import java.util.Iterator;
import java.util.Spliterator;
import java.util.stream.StreamSupport;
import java.util.stream.DoubleStream;
import java.util.stream.Stream;
import java.util.function.DoublePredicate;
import java.util.Objects;
import it.unimi.dsi.fastutil.SafeMath;
import java.util.function.Predicate;
import it.unimi.dsi.fastutil.doubles.DoubleSpliterator;
import it.unimi.dsi.fastutil.Size64;
import it.unimi.dsi.fastutil.doubles.DoubleIterator;
import java.util.Collection;

public interface FloatCollection extends Collection<Float>, FloatIterable
{
    FloatIterator iterator();
    
    default DoubleIterator doubleIterator() {
        return super.doubleIterator();
    }
    
    default FloatSpliterator spliterator() {
        return FloatSpliterators.asSpliterator(this.iterator(), Size64.sizeOf(this), 320);
    }
    
    default DoubleSpliterator doubleSpliterator() {
        return super.doubleSpliterator();
    }
    
    boolean add(final float p0);
    
    boolean contains(final float p0);
    
    boolean rem(final float p0);
    
    @Deprecated
    default boolean add(final Float key) {
        return this.add((float)key);
    }
    
    @Deprecated
    default boolean contains(final Object key) {
        return key != null && this.contains((float)key);
    }
    
    @Deprecated
    default boolean remove(final Object key) {
        return key != null && this.rem((float)key);
    }
    
    float[] toFloatArray();
    
    @Deprecated
    default float[] toFloatArray(final float[] a) {
        return this.toArray(a);
    }
    
    float[] toArray(final float[] p0);
    
    boolean addAll(final FloatCollection p0);
    
    boolean containsAll(final FloatCollection p0);
    
    boolean removeAll(final FloatCollection p0);
    
    @Deprecated
    default boolean removeIf(final Predicate<? super Float> filter) {
        return this.removeIf((filter instanceof FloatPredicate) ? ((FloatPredicate)filter) : (key -> filter.test(SafeMath.safeDoubleToFloat(key))));
    }
    
    default boolean removeIf(final FloatPredicate filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final FloatIterator each = this.iterator();
        while (each.hasNext()) {
            if (filter.test(each.nextFloat())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }
    
    default boolean removeIf(final DoublePredicate filter) {
        FloatPredicate filter2;
        if (filter instanceof FloatPredicate) {
            filter2 = (FloatPredicate)filter;
        }
        else {
            Objects.requireNonNull(filter);
            filter2 = filter::test;
        }
        return this.removeIf(filter2);
    }
    
    boolean retainAll(final FloatCollection p0);
    
    @Deprecated
    default Stream<Float> stream() {
        return super.stream();
    }
    
    default DoubleStream doubleStream() {
        return StreamSupport.doubleStream(this.doubleSpliterator(), false);
    }
    
    @Deprecated
    default Stream<Float> parallelStream() {
        return super.parallelStream();
    }
    
    default DoubleStream doubleParallelStream() {
        return StreamSupport.doubleStream(this.doubleSpliterator(), true);
    }
}