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

package it.unimi.dsi.fastutil.booleans;

import it.unimi.dsi.fastutil.objects.Reference2CharFunction;
import it.unimi.dsi.fastutil.objects.Reference2BooleanFunction;
import it.unimi.dsi.fastutil.chars.Char2ReferenceFunction;
import it.unimi.dsi.fastutil.objects.Object2CharFunction;
import it.unimi.dsi.fastutil.objects.Object2BooleanFunction;
import it.unimi.dsi.fastutil.chars.Char2ObjectFunction;
import it.unimi.dsi.fastutil.doubles.Double2CharFunction;
import it.unimi.dsi.fastutil.doubles.Double2BooleanFunction;
import it.unimi.dsi.fastutil.chars.Char2DoubleFunction;
import it.unimi.dsi.fastutil.floats.Float2CharFunction;
import it.unimi.dsi.fastutil.floats.Float2BooleanFunction;
import it.unimi.dsi.fastutil.chars.Char2FloatFunction;
import it.unimi.dsi.fastutil.chars.Char2BooleanFunction;
import it.unimi.dsi.fastutil.chars.Char2CharFunction;
import it.unimi.dsi.fastutil.longs.Long2CharFunction;
import it.unimi.dsi.fastutil.longs.Long2BooleanFunction;
import it.unimi.dsi.fastutil.chars.Char2LongFunction;
import it.unimi.dsi.fastutil.ints.Int2CharFunction;
import it.unimi.dsi.fastutil.ints.Int2BooleanFunction;
import it.unimi.dsi.fastutil.chars.Char2IntFunction;
import it.unimi.dsi.fastutil.shorts.Short2CharFunction;
import it.unimi.dsi.fastutil.shorts.Short2BooleanFunction;
import it.unimi.dsi.fastutil.chars.Char2ShortFunction;
import it.unimi.dsi.fastutil.bytes.Byte2CharFunction;
import it.unimi.dsi.fastutil.bytes.Byte2BooleanFunction;
import it.unimi.dsi.fastutil.chars.Char2ByteFunction;
import it.unimi.dsi.fastutil.Function;

@FunctionalInterface
public interface Boolean2CharFunction extends Function<Boolean, Character>
{
    default char put(final boolean key, final char value) {
        throw new UnsupportedOperationException();
    }
    
    char get(final boolean p0);
    
    default char getOrDefault(final boolean key, final char defaultValue) {
        final char v;
        return ((v = this.get(key)) != this.defaultReturnValue() || this.containsKey(key)) ? v : defaultValue;
    }
    
    default char remove(final boolean key) {
        throw new UnsupportedOperationException();
    }
    
    @Deprecated
    default Character put(final Boolean key, final Character value) {
        final boolean k = key;
        final boolean containsKey = this.containsKey(k);
        final char v = this.put(k, (char)value);
        return containsKey ? Character.valueOf(v) : null;
    }
    
    @Deprecated
    default Character get(final Object key) {
        if (key == null) {
            return null;
        }
        final boolean k = (boolean)key;
        final char v;
        return ((v = this.get(k)) != this.defaultReturnValue() || this.containsKey(k)) ? Character.valueOf(v) : null;
    }
    
    @Deprecated
    default Character getOrDefault(final Object key, final Character defaultValue) {
        if (key == null) {
            return defaultValue;
        }
        final boolean k = (boolean)key;
        final char v = this.get(k);
        return (v != this.defaultReturnValue() || this.containsKey(k)) ? Character.valueOf(v) : defaultValue;
    }
    
    @Deprecated
    default Character remove(final Object key) {
        if (key == null) {
            return null;
        }
        final boolean k = (boolean)key;
        return this.containsKey(k) ? Character.valueOf(this.remove(k)) : null;
    }
    
    default boolean containsKey(final boolean key) {
        return true;
    }
    
    @Deprecated
    default boolean containsKey(final Object key) {
        return key != null && this.containsKey((boolean)key);
    }
    
    default void defaultReturnValue(final char rv) {
        throw new UnsupportedOperationException();
    }
    
    default char defaultReturnValue() {
        return '\0';
    }
    
    @Deprecated
    default <T> java.util.function.Function<T, Character> compose(final java.util.function.Function<? super T, ? extends Boolean> before) {
        return super.compose((java.util.function.Function<? super T, ?>)before);
    }
    
    @Deprecated
    default <T> java.util.function.Function<Boolean, T> andThen(final java.util.function.Function<? super Character, ? extends T> after) {
        return super.andThen((java.util.function.Function<? super Object, ? extends T>)after);
    }
    
    default Boolean2ByteFunction andThenByte(final Char2ByteFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Byte2CharFunction composeByte(final Byte2BooleanFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Boolean2ShortFunction andThenShort(final Char2ShortFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Short2CharFunction composeShort(final Short2BooleanFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Boolean2IntFunction andThenInt(final Char2IntFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Int2CharFunction composeInt(final Int2BooleanFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Boolean2LongFunction andThenLong(final Char2LongFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Long2CharFunction composeLong(final Long2BooleanFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Boolean2CharFunction andThenChar(final Char2CharFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Char2CharFunction composeChar(final Char2BooleanFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Boolean2FloatFunction andThenFloat(final Char2FloatFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Float2CharFunction composeFloat(final Float2BooleanFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Boolean2DoubleFunction andThenDouble(final Char2DoubleFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Double2CharFunction composeDouble(final Double2BooleanFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default <T> Boolean2ObjectFunction<T> andThenObject(final Char2ObjectFunction<? extends T> after) {
        return (Boolean2ObjectFunction<T>)(k -> after.get(this.get(k)));
    }
    
    default <T> Object2CharFunction<T> composeObject(final Object2BooleanFunction<? super T> before) {
        return k -> this.get(before.getBoolean(k));
    }
    
    default <T> Boolean2ReferenceFunction<T> andThenReference(final Char2ReferenceFunction<? extends T> after) {
        return (Boolean2ReferenceFunction<T>)(k -> after.get(this.get(k)));
    }
    
    default <T> Reference2CharFunction<T> composeReference(final Reference2BooleanFunction<? super T> before) {
        return k -> this.get(before.getBoolean(k));
    }
}