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

package it.unimi.dsi.fastutil.ints;

import it.unimi.dsi.fastutil.objects.Reference2ShortFunction;
import it.unimi.dsi.fastutil.objects.Reference2IntFunction;
import it.unimi.dsi.fastutil.shorts.Short2ReferenceFunction;
import it.unimi.dsi.fastutil.objects.Object2ShortFunction;
import it.unimi.dsi.fastutil.objects.Object2IntFunction;
import it.unimi.dsi.fastutil.shorts.Short2ObjectFunction;
import it.unimi.dsi.fastutil.doubles.Double2ShortFunction;
import it.unimi.dsi.fastutil.doubles.Double2IntFunction;
import it.unimi.dsi.fastutil.shorts.Short2DoubleFunction;
import it.unimi.dsi.fastutil.floats.Float2ShortFunction;
import it.unimi.dsi.fastutil.floats.Float2IntFunction;
import it.unimi.dsi.fastutil.shorts.Short2FloatFunction;
import it.unimi.dsi.fastutil.chars.Char2ShortFunction;
import it.unimi.dsi.fastutil.chars.Char2IntFunction;
import it.unimi.dsi.fastutil.shorts.Short2CharFunction;
import it.unimi.dsi.fastutil.longs.Long2ShortFunction;
import it.unimi.dsi.fastutil.longs.Long2IntFunction;
import it.unimi.dsi.fastutil.shorts.Short2LongFunction;
import it.unimi.dsi.fastutil.shorts.Short2IntFunction;
import it.unimi.dsi.fastutil.shorts.Short2ShortFunction;
import it.unimi.dsi.fastutil.bytes.Byte2ShortFunction;
import it.unimi.dsi.fastutil.bytes.Byte2IntFunction;
import it.unimi.dsi.fastutil.shorts.Short2ByteFunction;
import java.util.function.IntUnaryOperator;
import it.unimi.dsi.fastutil.Function;

@FunctionalInterface
public interface Int2ShortFunction extends Function<Integer, Short>, IntUnaryOperator
{
    default int applyAsInt(final int operand) {
        return this.get(operand);
    }
    
    default short put(final int key, final short value) {
        throw new UnsupportedOperationException();
    }
    
    short get(final int p0);
    
    default short getOrDefault(final int key, final short defaultValue) {
        final short v;
        return ((v = this.get(key)) != this.defaultReturnValue() || this.containsKey(key)) ? v : defaultValue;
    }
    
    default short remove(final int key) {
        throw new UnsupportedOperationException();
    }
    
    @Deprecated
    default Short put(final Integer key, final Short value) {
        final int k = key;
        final boolean containsKey = this.containsKey(k);
        final short v = this.put(k, (short)value);
        return containsKey ? Short.valueOf(v) : null;
    }
    
    @Deprecated
    default Short get(final Object key) {
        if (key == null) {
            return null;
        }
        final int k = (int)key;
        final short v;
        return ((v = this.get(k)) != this.defaultReturnValue() || this.containsKey(k)) ? Short.valueOf(v) : null;
    }
    
    @Deprecated
    default Short getOrDefault(final Object key, final Short defaultValue) {
        if (key == null) {
            return defaultValue;
        }
        final int k = (int)key;
        final short v = this.get(k);
        return (v != this.defaultReturnValue() || this.containsKey(k)) ? Short.valueOf(v) : defaultValue;
    }
    
    @Deprecated
    default Short remove(final Object key) {
        if (key == null) {
            return null;
        }
        final int k = (int)key;
        return this.containsKey(k) ? Short.valueOf(this.remove(k)) : null;
    }
    
    default boolean containsKey(final int key) {
        return true;
    }
    
    @Deprecated
    default boolean containsKey(final Object key) {
        return key != null && this.containsKey((int)key);
    }
    
    default void defaultReturnValue(final short rv) {
        throw new UnsupportedOperationException();
    }
    
    default short defaultReturnValue() {
        return 0;
    }
    
    @Deprecated
    default <T> java.util.function.Function<T, Short> compose(final java.util.function.Function<? super T, ? extends Integer> before) {
        return super.compose((java.util.function.Function<? super T, ?>)before);
    }
    
    @Deprecated
    default <T> java.util.function.Function<Integer, T> andThen(final java.util.function.Function<? super Short, ? extends T> after) {
        return super.andThen((java.util.function.Function<? super Object, ? extends T>)after);
    }
    
    default Int2ByteFunction andThenByte(final Short2ByteFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Byte2ShortFunction composeByte(final Byte2IntFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Int2ShortFunction andThenShort(final Short2ShortFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Short2ShortFunction composeShort(final Short2IntFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Int2IntFunction andThenInt(final Short2IntFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Int2ShortFunction composeInt(final Int2IntFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Int2LongFunction andThenLong(final Short2LongFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Long2ShortFunction composeLong(final Long2IntFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Int2CharFunction andThenChar(final Short2CharFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Char2ShortFunction composeChar(final Char2IntFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Int2FloatFunction andThenFloat(final Short2FloatFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Float2ShortFunction composeFloat(final Float2IntFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Int2DoubleFunction andThenDouble(final Short2DoubleFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Double2ShortFunction composeDouble(final Double2IntFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default <T> Int2ObjectFunction<T> andThenObject(final Short2ObjectFunction<? extends T> after) {
        return (Int2ObjectFunction<T>)(k -> after.get(this.get(k)));
    }
    
    default <T> Object2ShortFunction<T> composeObject(final Object2IntFunction<? super T> before) {
        return k -> this.get(before.getInt(k));
    }
    
    default <T> Int2ReferenceFunction<T> andThenReference(final Short2ReferenceFunction<? extends T> after) {
        return (Int2ReferenceFunction<T>)(k -> after.get(this.get(k)));
    }
    
    default <T> Reference2ShortFunction<T> composeReference(final Reference2IntFunction<? super T> before) {
        return k -> this.get(before.getInt(k));
    }
}