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

package it.unimi.dsi.fastutil.objects;

import it.unimi.dsi.fastutil.doubles.Double2ReferenceFunction;
import it.unimi.dsi.fastutil.doubles.Double2ObjectFunction;
import it.unimi.dsi.fastutil.floats.Float2ReferenceFunction;
import it.unimi.dsi.fastutil.floats.Float2ObjectFunction;
import it.unimi.dsi.fastutil.chars.Char2ReferenceFunction;
import it.unimi.dsi.fastutil.chars.Char2ObjectFunction;
import it.unimi.dsi.fastutil.longs.Long2ReferenceFunction;
import it.unimi.dsi.fastutil.longs.Long2ObjectFunction;
import it.unimi.dsi.fastutil.ints.Int2ReferenceFunction;
import it.unimi.dsi.fastutil.ints.Int2ObjectFunction;
import it.unimi.dsi.fastutil.shorts.Short2ReferenceFunction;
import it.unimi.dsi.fastutil.shorts.Short2ObjectFunction;
import it.unimi.dsi.fastutil.bytes.Byte2ReferenceFunction;
import it.unimi.dsi.fastutil.bytes.Byte2ObjectFunction;
import it.unimi.dsi.fastutil.Function;

@FunctionalInterface
public interface Object2ReferenceFunction<K, V> extends Function<K, V>
{
    default V put(final K key, final V value) {
        throw new UnsupportedOperationException();
    }
    
    V get(final Object p0);
    
    default V getOrDefault(final Object key, final V defaultValue) {
        final V v;
        return ((v = this.get(key)) != this.defaultReturnValue() || this.containsKey(key)) ? v : defaultValue;
    }
    
    default V remove(final Object key) {
        throw new UnsupportedOperationException();
    }
    
    default void defaultReturnValue(final V rv) {
        throw new UnsupportedOperationException();
    }
    
    default V defaultReturnValue() {
        return null;
    }
    
    default Object2ByteFunction<K> andThenByte(final Reference2ByteFunction<V> after) {
        return k -> after.getByte(this.get(k));
    }
    
    default Byte2ReferenceFunction<V> composeByte(final Byte2ObjectFunction<K> before) {
        return (Byte2ReferenceFunction<V>)(k -> this.get(before.get(k)));
    }
    
    default Object2ShortFunction<K> andThenShort(final Reference2ShortFunction<V> after) {
        return k -> after.getShort(this.get(k));
    }
    
    default Short2ReferenceFunction<V> composeShort(final Short2ObjectFunction<K> before) {
        return (Short2ReferenceFunction<V>)(k -> this.get(before.get(k)));
    }
    
    default Object2IntFunction<K> andThenInt(final Reference2IntFunction<V> after) {
        return k -> after.getInt(this.get(k));
    }
    
    default Int2ReferenceFunction<V> composeInt(final Int2ObjectFunction<K> before) {
        return (Int2ReferenceFunction<V>)(k -> this.get(before.get(k)));
    }
    
    default Object2LongFunction<K> andThenLong(final Reference2LongFunction<V> after) {
        return k -> after.getLong(this.get(k));
    }
    
    default Long2ReferenceFunction<V> composeLong(final Long2ObjectFunction<K> before) {
        return (Long2ReferenceFunction<V>)(k -> this.get(before.get(k)));
    }
    
    default Object2CharFunction<K> andThenChar(final Reference2CharFunction<V> after) {
        return k -> after.getChar(this.get(k));
    }
    
    default Char2ReferenceFunction<V> composeChar(final Char2ObjectFunction<K> before) {
        return (Char2ReferenceFunction<V>)(k -> this.get(before.get(k)));
    }
    
    default Object2FloatFunction<K> andThenFloat(final Reference2FloatFunction<V> after) {
        return k -> after.getFloat(this.get(k));
    }
    
    default Float2ReferenceFunction<V> composeFloat(final Float2ObjectFunction<K> before) {
        return (Float2ReferenceFunction<V>)(k -> this.get(before.get(k)));
    }
    
    default Object2DoubleFunction<K> andThenDouble(final Reference2DoubleFunction<V> after) {
        return k -> after.getDouble(this.get(k));
    }
    
    default Double2ReferenceFunction<V> composeDouble(final Double2ObjectFunction<K> before) {
        return (Double2ReferenceFunction<V>)(k -> this.get(before.get(k)));
    }
    
    default <T> Object2ObjectFunction<K, T> andThenObject(final Reference2ObjectFunction<? super V, ? extends T> after) {
        return (Object2ObjectFunction<K, T>)(k -> after.get(this.get(k)));
    }
    
    default <T> Object2ReferenceFunction<T, V> composeObject(final Object2ObjectFunction<? super T, ? extends K> before) {
        return k -> this.get(before.get(k));
    }
    
    default <T> Object2ReferenceFunction<K, T> andThenReference(final Reference2ReferenceFunction<? super V, ? extends T> after) {
        return k -> after.get(this.get(k));
    }
    
    default <T> Reference2ReferenceFunction<T, V> composeReference(final Reference2ObjectFunction<? super T, ? extends K> before) {
        return (Reference2ReferenceFunction<T, V>)(k -> this.get(before.get(k)));
    }
}