Util.java

/**
 * PermissionsEx
 * Copyright (C) zml and PermissionsEx contributors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package ninja.leaping.permissionsex.util;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import com.google.common.eventbus.Subscribe;
import ninja.leaping.permissionsex.PermissionsEx;
import ninja.leaping.permissionsex.util.command.args.GenericArguments;

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;

import static ninja.leaping.permissionsex.util.Translations.t;
import static ninja.leaping.permissionsex.util.command.args.GameArguments.context;
import static ninja.leaping.permissionsex.util.command.args.GenericArguments.flags;

public class Util {
    public static Map.Entry<String, String> subjectFromString(String input) {
        String[] entries = input.split(":", 2);
        if (entries.length == 1) {
            return Maps.immutableEntry(PermissionsEx.SUBJECTS_GROUP, entries[0]);
        } else {
            return Maps.immutableEntry(entries[0], entries[1]);
        }

    }

    public static String subjectToString(Map.Entry<String, String> input) {
        return input.getKey() + ":" + input.getValue();
    }

    public static GenericArguments.FlagCommandElementBuilder contextTransientFlags() {
        return flags()
                .flag("-transient")
                .valueFlag(context(t("context")), "-context", "-contexts", "c");
    }

    public static <T> CompletableFuture<T> failedFuture(Throwable error) {
        CompletableFuture<T> ret = new CompletableFuture<>();
        ret.completeExceptionally(error);
        return ret;
    }

    @SuppressWarnings("unchecked")
    private static final CompletableFuture<Object> EMPTY_FUTURE = new CompletableFuture<>();
    static {
        EMPTY_FUTURE.complete(null);
    }

    @SuppressWarnings("unchecked")
    public static <T> CompletableFuture<T> emptyFuture() {
        return (CompletableFuture) EMPTY_FUTURE;
    }

    public static <I, T> CompletableFuture<T> failableFuture(I value, ThrowingFunction<I, T, ?> func) {
        return failableFuture(() -> func.apply(value));
    }

    public static <T> CompletableFuture<T> failableFuture(ThrowingSupplier<T, ?> func) {
        CompletableFuture<T> ret = new CompletableFuture<>();
        try {
            ret.complete(func.supply());
        } catch (Exception e) {
            ret.completeExceptionally(e);
        }
        return ret;
    }

    public static <T> CompletableFuture<T> asyncFailableFuture(ThrowingSupplier<T, ?> supplier, Executor exec) {
        CompletableFuture<T> ret = new CompletableFuture<>();
        exec.execute(() -> {
            try {
                ret.complete(supplier.supply());
            } catch (Exception e) {
                ret.completeExceptionally(e);
            }

        });
        return ret;
    }

    public static <K, V> Map<K, V> updateImmutable(Map<K, V> input, K newKey, V newVal) {
        if (input == null) {
            return ImmutableMap.of(newKey, newVal);
        }
        Map<K, V> ret = new HashMap<>(input);
        if (newVal == null) {
            ret.remove(newKey);
        } else {
            ret.put(newKey, newVal);
        }
        return Collections.unmodifiableMap(ret);
    }

    public static <T> ImmutableList<T> appendImmutable(List<T> input, T entry) {
        if (input == null) {
            return ImmutableList.of(entry);
        }
        ImmutableList.Builder<T> ret = ImmutableList.builder();
        ret.addAll(input);
        ret.add(entry);
        return ret.build();
    }
}