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

package it.unimi.dsi.fastutil.floats;

import it.unimi.dsi.fastutil.objects.Reference2IntFunction;
import it.unimi.dsi.fastutil.objects.Reference2FloatFunction;
import it.unimi.dsi.fastutil.ints.Int2ReferenceFunction;
import it.unimi.dsi.fastutil.objects.Object2IntFunction;
import it.unimi.dsi.fastutil.objects.Object2FloatFunction;
import it.unimi.dsi.fastutil.ints.Int2ObjectFunction;
import it.unimi.dsi.fastutil.doubles.Double2IntFunction;
import it.unimi.dsi.fastutil.doubles.Double2FloatFunction;
import it.unimi.dsi.fastutil.ints.Int2DoubleFunction;
import it.unimi.dsi.fastutil.chars.Char2IntFunction;
import it.unimi.dsi.fastutil.chars.Char2FloatFunction;
import it.unimi.dsi.fastutil.ints.Int2CharFunction;
import it.unimi.dsi.fastutil.longs.Long2IntFunction;
import it.unimi.dsi.fastutil.longs.Long2FloatFunction;
import it.unimi.dsi.fastutil.ints.Int2LongFunction;
import it.unimi.dsi.fastutil.ints.Int2FloatFunction;
import it.unimi.dsi.fastutil.ints.Int2IntFunction;
import it.unimi.dsi.fastutil.shorts.Short2IntFunction;
import it.unimi.dsi.fastutil.shorts.Short2FloatFunction;
import it.unimi.dsi.fastutil.ints.Int2ShortFunction;
import it.unimi.dsi.fastutil.bytes.Byte2IntFunction;
import it.unimi.dsi.fastutil.bytes.Byte2FloatFunction;
import it.unimi.dsi.fastutil.ints.Int2ByteFunction;
import it.unimi.dsi.fastutil.SafeMath;
import java.util.function.DoubleToIntFunction;
import it.unimi.dsi.fastutil.Function;

@FunctionalInterface
public interface Float2IntFunction extends Function<Float, Integer>, DoubleToIntFunction
{
    @Deprecated
    default int applyAsInt(final double operand) {
        return this.get(SafeMath.safeDoubleToFloat(operand));
    }
    
    default int put(final float key, final int value) {
        throw new UnsupportedOperationException();
    }
    
    int get(final float p0);
    
    default int getOrDefault(final float key, final int defaultValue) {
        final int v;
        return ((v = this.get(key)) != this.defaultReturnValue() || this.containsKey(key)) ? v : defaultValue;
    }
    
    default int remove(final float key) {
        throw new UnsupportedOperationException();
    }
    
    @Deprecated
    default Integer put(final Float key, final Integer value) {
        final float k = key;
        final boolean containsKey = this.containsKey(k);
        final int v = this.put(k, (int)value);
        return containsKey ? Integer.valueOf(v) : null;
    }
    
    @Deprecated
    default Integer get(final Object key) {
        if (key == null) {
            return null;
        }
        final float k = (float)key;
        final int v;
        return ((v = this.get(k)) != this.defaultReturnValue() || this.containsKey(k)) ? Integer.valueOf(v) : null;
    }
    
    @Deprecated
    default Integer getOrDefault(final Object key, final Integer defaultValue) {
        if (key == null) {
            return defaultValue;
        }
        final float k = (float)key;
        final int v = this.get(k);
        return (v != this.defaultReturnValue() || this.containsKey(k)) ? Integer.valueOf(v) : defaultValue;
    }
    
    @Deprecated
    default Integer remove(final Object key) {
        if (key == null) {
            return null;
        }
        final float k = (float)key;
        return this.containsKey(k) ? Integer.valueOf(this.remove(k)) : null;
    }
    
    default boolean containsKey(final float key) {
        return true;
    }
    
    @Deprecated
    default boolean containsKey(final Object key) {
        return key != null && this.containsKey((float)key);
    }
    
    default void defaultReturnValue(final int rv) {
        throw new UnsupportedOperationException();
    }
    
    default int defaultReturnValue() {
        return 0;
    }
    
    @Deprecated
    default <T> java.util.function.Function<T, Integer> compose(final java.util.function.Function<? super T, ? extends Float> before) {
        return super.compose((java.util.function.Function<? super T, ?>)before);
    }
    
    @Deprecated
    default <T> java.util.function.Function<Float, T> andThen(final java.util.function.Function<? super Integer, ? extends T> after) {
        return super.andThen((java.util.function.Function<? super Object, ? extends T>)after);
    }
    
    default Float2ByteFunction andThenByte(final Int2ByteFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Byte2IntFunction composeByte(final Byte2FloatFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Float2ShortFunction andThenShort(final Int2ShortFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Short2IntFunction composeShort(final Short2FloatFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Float2IntFunction andThenInt(final Int2IntFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Int2IntFunction composeInt(final Int2FloatFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Float2LongFunction andThenLong(final Int2LongFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Long2IntFunction composeLong(final Long2FloatFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Float2CharFunction andThenChar(final Int2CharFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Char2IntFunction composeChar(final Char2FloatFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Float2FloatFunction andThenFloat(final Int2FloatFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Float2IntFunction composeFloat(final Float2FloatFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Float2DoubleFunction andThenDouble(final Int2DoubleFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Double2IntFunction composeDouble(final Double2FloatFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default <T> Float2ObjectFunction<T> andThenObject(final Int2ObjectFunction<? extends T> after) {
        return (Float2ObjectFunction<T>)(k -> after.get(this.get(k)));
    }
    
    default <T> Object2IntFunction<T> composeObject(final Object2FloatFunction<? super T> before) {
        return k -> this.get(before.getFloat(k));
    }
    
    default <T> Float2ReferenceFunction<T> andThenReference(final Int2ReferenceFunction<? extends T> after) {
        return (Float2ReferenceFunction<T>)(k -> after.get(this.get(k)));
    }
    
    default <T> Reference2IntFunction<T> composeReference(final Reference2FloatFunction<? super T> before) {
        return k -> this.get(before.getFloat(k));
    }
}