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

package it.unimi.dsi.fastutil.floats;

import java.util.Iterator;
import java.util.Collection;
import java.util.Arrays;
import java.util.AbstractCollection;

public abstract class AbstractFloatCollection extends AbstractCollection<Float> implements FloatCollection
{
    protected AbstractFloatCollection() {
    }
    
    @Override
    public abstract FloatIterator iterator();
    
    @Override
    public boolean add(final float k) {
        throw new UnsupportedOperationException();
    }
    
    @Override
    public boolean contains(final float k) {
        final FloatIterator iterator = this.iterator();
        while (iterator.hasNext()) {
            if (k == iterator.nextFloat()) {
                return true;
            }
        }
        return false;
    }
    
    @Override
    public boolean rem(final float k) {
        final FloatIterator iterator = this.iterator();
        while (iterator.hasNext()) {
            if (k == iterator.nextFloat()) {
                iterator.remove();
                return true;
            }
        }
        return false;
    }
    
    @Deprecated
    @Override
    public boolean add(final Float key) {
        return super.add(key);
    }
    
    @Deprecated
    @Override
    public boolean contains(final Object key) {
        return super.contains(key);
    }
    
    @Deprecated
    @Override
    public boolean remove(final Object key) {
        return super.remove(key);
    }
    
    @Override
    public float[] toArray(float[] a) {
        final int size = this.size();
        if (a == null) {
            a = new float[size];
        }
        else if (a.length < size) {
            a = Arrays.copyOf(a, size);
        }
        FloatIterators.unwrap(this.iterator(), a);
        return a;
    }
    
    @Override
    public float[] toFloatArray() {
        final int size = this.size();
        if (size == 0) {
            return FloatArrays.EMPTY_ARRAY;
        }
        final float[] a = new float[size];
        FloatIterators.unwrap(this.iterator(), a);
        return a;
    }
    
    @Deprecated
    @Override
    public float[] toFloatArray(final float[] a) {
        return this.toArray(a);
    }
    
    @Override
    public boolean addAll(final FloatCollection c) {
        boolean retVal = false;
        final FloatIterator i = c.iterator();
        while (i.hasNext()) {
            if (this.add(i.nextFloat())) {
                retVal = true;
            }
        }
        return retVal;
    }
    
    @Override
    public boolean addAll(final Collection<? extends Float> c) {
        if (c instanceof FloatCollection) {
            return this.addAll((FloatCollection)c);
        }
        return super.addAll(c);
    }
    
    @Override
    public boolean containsAll(final FloatCollection c) {
        final FloatIterator i = c.iterator();
        while (i.hasNext()) {
            if (!this.contains(i.nextFloat())) {
                return false;
            }
        }
        return true;
    }
    
    @Override
    public boolean containsAll(final Collection<?> c) {
        if (c instanceof FloatCollection) {
            return this.containsAll((FloatCollection)c);
        }
        return super.containsAll(c);
    }
    
    @Override
    public boolean removeAll(final FloatCollection c) {
        boolean retVal = false;
        final FloatIterator i = c.iterator();
        while (i.hasNext()) {
            if (this.rem(i.nextFloat())) {
                retVal = true;
            }
        }
        return retVal;
    }
    
    @Override
    public boolean removeAll(final Collection<?> c) {
        if (c instanceof FloatCollection) {
            return this.removeAll((FloatCollection)c);
        }
        return super.removeAll(c);
    }
    
    @Override
    public boolean retainAll(final FloatCollection c) {
        boolean retVal = false;
        final FloatIterator i = this.iterator();
        while (i.hasNext()) {
            if (!c.contains(i.nextFloat())) {
                i.remove();
                retVal = true;
            }
        }
        return retVal;
    }
    
    @Override
    public boolean retainAll(final Collection<?> c) {
        if (c instanceof FloatCollection) {
            return this.retainAll((FloatCollection)c);
        }
        return super.retainAll(c);
    }
    
    @Override
    public String toString() {
        final StringBuilder s = new StringBuilder();
        final FloatIterator i = this.iterator();
        int n = this.size();
        boolean first = true;
        s.append("{");
        while (n-- != 0) {
            if (first) {
                first = false;
            }
            else {
                s.append(", ");
            }
            final float k = i.nextFloat();
            s.append(String.valueOf(k));
        }
        s.append("}");
        return s.toString();
    }
}