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

package it.unimi.dsi.fastutil.doubles;

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.Objects;
import java.util.function.DoublePredicate;
import java.util.function.Predicate;
import it.unimi.dsi.fastutil.Size64;
import java.util.Collection;

public interface DoubleCollection extends Collection<Double>, DoubleIterable
{
    DoubleIterator iterator();
    
    default DoubleIterator doubleIterator() {
        return this.iterator();
    }
    
    default DoubleSpliterator spliterator() {
        return DoubleSpliterators.asSpliterator(this.iterator(), Size64.sizeOf(this), 320);
    }
    
    default DoubleSpliterator doubleSpliterator() {
        return this.spliterator();
    }
    
    boolean add(final double p0);
    
    boolean contains(final double p0);
    
    boolean rem(final double p0);
    
    @Deprecated
    default boolean add(final Double key) {
        return this.add((double)key);
    }
    
    @Deprecated
    default boolean contains(final Object key) {
        return key != null && this.contains((double)key);
    }
    
    @Deprecated
    default boolean remove(final Object key) {
        return key != null && this.rem((double)key);
    }
    
    double[] toDoubleArray();
    
    @Deprecated
    default double[] toDoubleArray(final double[] a) {
        return this.toArray(a);
    }
    
    double[] toArray(final double[] p0);
    
    boolean addAll(final DoubleCollection p0);
    
    boolean containsAll(final DoubleCollection p0);
    
    boolean removeAll(final DoubleCollection p0);
    
    @Deprecated
    default boolean removeIf(final Predicate<? super Double> filter) {
        return this.removeIf((filter instanceof DoublePredicate) ? ((DoublePredicate)filter) : (key -> filter.test(key)));
    }
    
    default boolean removeIf(final DoublePredicate filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final DoubleIterator each = this.iterator();
        while (each.hasNext()) {
            if (filter.test(each.nextDouble())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }
    
    default boolean removeIf(final it.unimi.dsi.fastutil.doubles.DoublePredicate filter) {
        return this.removeIf((DoublePredicate)filter);
    }
    
    boolean retainAll(final DoubleCollection p0);
    
    @Deprecated
    default Stream<Double> stream() {
        return super.stream();
    }
    
    default DoubleStream doubleStream() {
        return StreamSupport.doubleStream(this.doubleSpliterator(), false);
    }
    
    @Deprecated
    default Stream<Double> parallelStream() {
        return super.parallelStream();
    }
    
    default DoubleStream doubleParallelStream() {
        return StreamSupport.doubleStream(this.doubleSpliterator(), true);
    }
}