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

package it.unimi.dsi.fastutil.shorts;

import java.util.stream.IntStream;
import java.util.stream.Stream;
import java.util.Spliterator;
import it.unimi.dsi.fastutil.ints.IntSpliterators;
import it.unimi.dsi.fastutil.ints.IntSpliterator;
import it.unimi.dsi.fastutil.ints.IntIterators;
import it.unimi.dsi.fastutil.ints.IntIterator;
import java.util.function.Predicate;
import java.util.Collection;
import java.util.function.Consumer;
import java.util.Set;
import java.io.Serializable;
import java.util.Iterator;

public final class ShortSets
{
    static final int ARRAY_SET_CUTOFF = 4;
    public static final EmptySet EMPTY_SET;
    static final ShortSet UNMODIFIABLE_EMPTY_SET;
    
    private ShortSets() {
    }
    
    public static ShortSet emptySet() {
        return ShortSets.EMPTY_SET;
    }
    
    public static ShortSet singleton(final short element) {
        return new Singleton(element);
    }
    
    public static ShortSet singleton(final Short element) {
        return new Singleton(element);
    }
    
    public static ShortSet synchronize(final ShortSet s) {
        return new SynchronizedSet(s);
    }
    
    public static ShortSet synchronize(final ShortSet s, final Object sync) {
        return new SynchronizedSet(s, sync);
    }
    
    public static ShortSet unmodifiable(final ShortSet s) {
        return new UnmodifiableSet(s);
    }
    
    public static ShortSet fromTo(final short from, final short to) {
        return new AbstractShortSet() {
            @Override
            public boolean contains(final short x) {
                return x >= from && x < to;
            }
            
            @Override
            public ShortIterator iterator() {
                return ShortIterators.fromTo(from, to);
            }
            
            @Override
            public int size() {
                final long size = to - (long)from;
                return (size >= 0L && size <= 2147483647L) ? ((int)size) : Integer.MAX_VALUE;
            }
        };
    }
    
    public static ShortSet from(final short from) {
        return new AbstractShortSet() {
            @Override
            public boolean contains(final short x) {
                return x >= from;
            }
            
            @Override
            public ShortIterator iterator() {
                return ShortIterators.concat(ShortIterators.fromTo(from, (short)32767), ShortSets.singleton((short)32767).iterator());
            }
            
            @Override
            public int size() {
                final long size = 32767L - from + 1L;
                return (size >= 0L && size <= 2147483647L) ? ((int)size) : Integer.MAX_VALUE;
            }
        };
    }
    
    public static ShortSet to(final short to) {
        return new AbstractShortSet() {
            @Override
            public boolean contains(final short x) {
                return x < to;
            }
            
            @Override
            public ShortIterator iterator() {
                return ShortIterators.fromTo((short)(-32768), to);
            }
            
            @Override
            public int size() {
                final long size = to + 32768L;
                return (size >= 0L && size <= 2147483647L) ? ((int)size) : Integer.MAX_VALUE;
            }
        };
    }
    
    static {
        EMPTY_SET = new EmptySet();
        UNMODIFIABLE_EMPTY_SET = unmodifiable(new ShortArraySet(ShortArrays.EMPTY_ARRAY));
    }
    
    public static class EmptySet extends ShortCollections.EmptyCollection implements ShortSet, Serializable, Cloneable
    {
        private static final long serialVersionUID = -7046029254386353129L;
        
        protected EmptySet() {
        }
        
        @Override
        public boolean remove(final short ok) {
            throw new UnsupportedOperationException();
        }
        
        public Object clone() {
            return ShortSets.EMPTY_SET;
        }
        
        @Override
        public boolean equals(final Object o) {
            return o instanceof Set && ((Set)o).isEmpty();
        }
        
        @Deprecated
        @Override
        public boolean rem(final short k) {
            return super.rem(k);
        }
        
        private Object readResolve() {
            return ShortSets.EMPTY_SET;
        }
    }
    
    public static class Singleton extends AbstractShortSet implements Serializable, Cloneable
    {
        private static final long serialVersionUID = -7046029254386353129L;
        protected final short element;
        
        protected Singleton(final short element) {
            this.element = element;
        }
        
        @Override
        public boolean contains(final short k) {
            return k == this.element;
        }
        
        @Override
        public boolean remove(final short k) {
            throw new UnsupportedOperationException();
        }
        
        @Override
        public ShortListIterator iterator() {
            return ShortIterators.singleton(this.element);
        }
        
        @Override
        public ShortSpliterator spliterator() {
            return ShortSpliterators.singleton(this.element);
        }
        
        @Override
        public int size() {
            return 1;
        }
        
        @Override
        public short[] toShortArray() {
            return new short[] { this.element };
        }
        
        @Deprecated
        @Override
        public void forEach(final Consumer<? super Short> action) {
            action.accept(this.element);
        }
        
        @Override
        public boolean addAll(final Collection<? extends Short> c) {
            throw new UnsupportedOperationException();
        }
        
        @Override
        public boolean removeAll(final Collection<?> c) {
            throw new UnsupportedOperationException();
        }
        
        @Override
        public boolean retainAll(final Collection<?> c) {
            throw new UnsupportedOperationException();
        }
        
        @Deprecated
        @Override
        public boolean removeIf(final Predicate<? super Short> filter) {
            throw new UnsupportedOperationException();
        }
        
        @Override
        public void forEach(final ShortConsumer action) {
            action.accept(this.element);
        }
        
        @Override
        public boolean addAll(final ShortCollection c) {
            throw new UnsupportedOperationException();
        }
        
        @Override
        public boolean removeAll(final ShortCollection c) {
            throw new UnsupportedOperationException();
        }
        
        @Override
        public boolean retainAll(final ShortCollection c) {
            throw new UnsupportedOperationException();
        }
        
        @Override
        public boolean removeIf(final ShortPredicate filter) {
            throw new UnsupportedOperationException();
        }
        
        @Override
        public IntIterator intIterator() {
            return IntIterators.singleton(this.element);
        }
        
        @Override
        public IntSpliterator intSpliterator() {
            return IntSpliterators.singleton(this.element);
        }
        
        @Deprecated
        @Override
        public Object[] toArray() {
            return new Object[] { this.element };
        }
        
        public Object clone() {
            return this;
        }
    }
    
    public static class SynchronizedSet extends ShortCollections.SynchronizedCollection implements ShortSet, Serializable
    {
        private static final long serialVersionUID = -7046029254386353129L;
        
        protected SynchronizedSet(final ShortSet s, final Object sync) {
            super(s, sync);
        }
        
        protected SynchronizedSet(final ShortSet s) {
            super(s);
        }
        
        @Override
        public boolean remove(final short k) {
            synchronized (this.sync) {
                return this.collection.rem(k);
            }
        }
        
        @Deprecated
        @Override
        public boolean rem(final short k) {
            return super.rem(k);
        }
    }
    
    public static class UnmodifiableSet extends ShortCollections.UnmodifiableCollection implements ShortSet, Serializable
    {
        private static final long serialVersionUID = -7046029254386353129L;
        
        protected UnmodifiableSet(final ShortSet s) {
            super(s);
        }
        
        @Override
        public boolean remove(final short k) {
            throw new UnsupportedOperationException();
        }
        
        @Override
        public boolean equals(final Object o) {
            return o == this || this.collection.equals(o);
        }
        
        @Override
        public int hashCode() {
            return this.collection.hashCode();
        }
        
        @Deprecated
        @Override
        public boolean rem(final short k) {
            return super.rem(k);
        }
    }
}