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

package it.unimi.dsi.fastutil.longs;

import it.unimi.dsi.fastutil.objects.Reference2DoubleFunction;
import it.unimi.dsi.fastutil.objects.Reference2LongFunction;
import it.unimi.dsi.fastutil.doubles.Double2ReferenceFunction;
import it.unimi.dsi.fastutil.objects.Object2DoubleFunction;
import it.unimi.dsi.fastutil.objects.Object2LongFunction;
import it.unimi.dsi.fastutil.doubles.Double2ObjectFunction;
import it.unimi.dsi.fastutil.doubles.Double2DoubleFunction;
import it.unimi.dsi.fastutil.floats.Float2DoubleFunction;
import it.unimi.dsi.fastutil.floats.Float2LongFunction;
import it.unimi.dsi.fastutil.doubles.Double2FloatFunction;
import it.unimi.dsi.fastutil.chars.Char2DoubleFunction;
import it.unimi.dsi.fastutil.chars.Char2LongFunction;
import it.unimi.dsi.fastutil.doubles.Double2CharFunction;
import it.unimi.dsi.fastutil.doubles.Double2LongFunction;
import it.unimi.dsi.fastutil.ints.Int2DoubleFunction;
import it.unimi.dsi.fastutil.ints.Int2LongFunction;
import it.unimi.dsi.fastutil.doubles.Double2IntFunction;
import it.unimi.dsi.fastutil.shorts.Short2DoubleFunction;
import it.unimi.dsi.fastutil.shorts.Short2LongFunction;
import it.unimi.dsi.fastutil.doubles.Double2ShortFunction;
import it.unimi.dsi.fastutil.bytes.Byte2DoubleFunction;
import it.unimi.dsi.fastutil.bytes.Byte2LongFunction;
import it.unimi.dsi.fastutil.doubles.Double2ByteFunction;
import java.util.function.LongToDoubleFunction;
import it.unimi.dsi.fastutil.Function;

@FunctionalInterface
public interface Long2DoubleFunction extends Function<Long, Double>, LongToDoubleFunction
{
    default double applyAsDouble(final long operand) {
        return this.get(operand);
    }
    
    default double put(final long key, final double value) {
        throw new UnsupportedOperationException();
    }
    
    double get(final long p0);
    
    default double getOrDefault(final long key, final double defaultValue) {
        final double v;
        return ((v = this.get(key)) != this.defaultReturnValue() || this.containsKey(key)) ? v : defaultValue;
    }
    
    default double remove(final long key) {
        throw new UnsupportedOperationException();
    }
    
    @Deprecated
    default Double put(final Long key, final Double value) {
        final long k = key;
        final boolean containsKey = this.containsKey(k);
        final double v = this.put(k, (double)value);
        return containsKey ? Double.valueOf(v) : null;
    }
    
    @Deprecated
    default Double get(final Object key) {
        if (key == null) {
            return null;
        }
        final long k = (long)key;
        final double v;
        return ((v = this.get(k)) != this.defaultReturnValue() || this.containsKey(k)) ? Double.valueOf(v) : null;
    }
    
    @Deprecated
    default Double getOrDefault(final Object key, final Double defaultValue) {
        if (key == null) {
            return defaultValue;
        }
        final long k = (long)key;
        final double v = this.get(k);
        return (v != this.defaultReturnValue() || this.containsKey(k)) ? Double.valueOf(v) : defaultValue;
    }
    
    @Deprecated
    default Double remove(final Object key) {
        if (key == null) {
            return null;
        }
        final long k = (long)key;
        return this.containsKey(k) ? Double.valueOf(this.remove(k)) : null;
    }
    
    default boolean containsKey(final long key) {
        return true;
    }
    
    @Deprecated
    default boolean containsKey(final Object key) {
        return key != null && this.containsKey((long)key);
    }
    
    default void defaultReturnValue(final double rv) {
        throw new UnsupportedOperationException();
    }
    
    default double defaultReturnValue() {
        return 0.0;
    }
    
    @Deprecated
    default <T> java.util.function.Function<T, Double> compose(final java.util.function.Function<? super T, ? extends Long> before) {
        return super.compose((java.util.function.Function<? super T, ?>)before);
    }
    
    @Deprecated
    default <T> java.util.function.Function<Long, T> andThen(final java.util.function.Function<? super Double, ? extends T> after) {
        return super.andThen((java.util.function.Function<? super Object, ? extends T>)after);
    }
    
    default Long2ByteFunction andThenByte(final Double2ByteFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Byte2DoubleFunction composeByte(final Byte2LongFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Long2ShortFunction andThenShort(final Double2ShortFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Short2DoubleFunction composeShort(final Short2LongFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Long2IntFunction andThenInt(final Double2IntFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Int2DoubleFunction composeInt(final Int2LongFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Long2LongFunction andThenLong(final Double2LongFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Long2DoubleFunction composeLong(final Long2LongFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Long2CharFunction andThenChar(final Double2CharFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Char2DoubleFunction composeChar(final Char2LongFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Long2FloatFunction andThenFloat(final Double2FloatFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Float2DoubleFunction composeFloat(final Float2LongFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Long2DoubleFunction andThenDouble(final Double2DoubleFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Double2DoubleFunction composeDouble(final Double2LongFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default <T> Long2ObjectFunction<T> andThenObject(final Double2ObjectFunction<? extends T> after) {
        return (Long2ObjectFunction<T>)(k -> after.get(this.get(k)));
    }
    
    default <T> Object2DoubleFunction<T> composeObject(final Object2LongFunction<? super T> before) {
        return k -> this.get(before.getLong(k));
    }
    
    default <T> Long2ReferenceFunction<T> andThenReference(final Double2ReferenceFunction<? extends T> after) {
        return (Long2ReferenceFunction<T>)(k -> after.get(this.get(k)));
    }
    
    default <T> Reference2DoubleFunction<T> composeReference(final Reference2LongFunction<? super T> before) {
        return k -> this.get(before.getLong(k));
    }
}