org.rx.core.Extends Maven / Gradle / Ivy

Go to download
package org.rx.core;

import lombok.NonNull;
import lombok.SneakyThrows;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.apache.commons.lang3.reflect.TypeUtils;
import org.rx.annotation.Description;
import org.rx.annotation.ErrorCode;
import org.rx.exception.ApplicationException;
import org.rx.exception.ExceptionHandler;
import org.rx.io.Serializer;
import org.rx.util.function.Action;
import org.rx.util.function.BiAction;
import org.rx.util.function.Func;

import java.io.Serializable;
import java.lang.reflect.AnnotatedElement;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Supplier;

@SuppressWarnings(Constants.NON_UNCHECKED)
public interface Extends extends Serializable {
    //region extend
    static  List newConcurrentList(boolean readMore) {
        return readMore ? new CopyOnWriteArrayList<>() : new Vector<>();
    }

    static  List newConcurrentList(int initialCapacity) {
        return newConcurrentList(initialCapacity, false);
    }

    static  List newConcurrentList(int initialCapacity, boolean readMore) {
        //CopyOnWriteArrayList 写性能差
        return readMore ? new CopyOnWriteArrayList<>() : new Vector<>(initialCapacity);
    }

    //todo checkerframework
    @ErrorCode("test")
    static void require(Object arg, boolean testResult) {
        if (!testResult) {
            throw new ApplicationException("test", values(arg));
        }
    }

    static String description(@NonNull AnnotatedElement annotatedElement) {
        Description desc = annotatedElement.getAnnotation(Description.class);
        if (desc == null) {
            return null;
        }
        return desc.value();
    }

    static boolean sneakyInvoke(Action action) {
        return sneakyInvoke(action, 1);
    }

    static boolean sneakyInvoke(@NonNull Action action, int retryCount) {
        Throwable last = null;
        for (int i = 0; i < retryCount; i++) {
            try {
                action.invoke();
                return true;
            } catch (Throwable e) {
                if (last != null) {
                    ExceptionHandler.INSTANCE.log("sneakyInvoke retry={}", i, e);
                }
                last = e;
            }
        }
        if (last != null) {
            ExceptionUtils.rethrow(last);
        }
        return false;
    }

    static  T sneakyInvoke(Func action) {
        return sneakyInvoke(action, 1);
    }

    static  T sneakyInvoke(@NonNull Func action, int retryCount) {
        Throwable last = null;
        for (int i = 0; i < retryCount; i++) {
            try {
                return action.invoke();
            } catch (Throwable e) {
                if (last != null) {
                    ExceptionHandler.INSTANCE.log("sneakyInvoke retry={}", i, e);
                }
                last = e;
            }
        }
        if (last != null) {
            ExceptionUtils.rethrow(last);
        }
        return null;
    }

    static  void eachQuietly(Iterable iterable, BiAction fn) {
        if (iterable == null) {
            return;
        }

        asyncEach(iterable, t -> {
            try {
                fn.invoke(t);
            } catch (Throwable e) {
                ExceptionHandler.INSTANCE.log("eachQuietly", e);
            }
        });
    }

    static boolean quietly(@NonNull Action action) {
        try {
            action.invoke();
            return true;
        } catch (Throwable e) {
            ExceptionHandler.INSTANCE.log("quietly", e);
        }
        return false;
    }

    static  T quietly(Func action) {
        return quietly(action, null);
    }

    static  T quietly(@NonNull Func action, Func defaultValue) {
        try {
            return action.invoke();
        } catch (Throwable e) {
            ExceptionHandler.INSTANCE.log("quietly", e);
        }
        if (defaultValue != null) {
            try {
                return defaultValue.invoke();
            } catch (Throwable e) {
                ExceptionUtils.rethrow(e);
            }
        }
        return null;
    }

    static boolean tryClose(Object obj) {
        return tryAs(obj, AutoCloseable.class, p -> quietly(p::close));
    }

    static boolean tryClose(AutoCloseable obj) {
        if (obj == null) {
            return false;
        }
        quietly(obj::close);
        return true;
    }

    static  boolean tryAs(Object obj, Class type) {
        return tryAs(obj, type, null);
    }

    @SneakyThrows
    static  boolean tryAs(Object obj, Class type, BiAction action) {
        T t = as(obj, type);
        if (t == null) {
            return false;
        }
        if (action != null) {
            action.invoke(t);
        }
        return true;
    }

    @SneakyThrows
    static  void asyncEach(Iterable iterable, BiAction fn) {
        if (iterable == null) {
            return;
        }

        for (T t : iterable) {
            fn.invoke(t);
            if (!ThreadPool.asyncContinueFlag(true)) {
                break;
            }
        }
    }

    static void asyncContinue(boolean flag) {
        ThreadPool.ASYNC_CONTINUE.set(flag);
    }

//    static CircuitBreakingException asyncBreak() {
//        throw new CircuitBreakingException();
//    }

    static  T as(Object obj, Class type) {
        if (!TypeUtils.isInstance(obj, type)) {
            return null;
        }
        return (T) obj;
    }

    static  T ifNull(T value, T defaultVal) {
        return value != null ? value : defaultVal;
    }

    static  T ifNull(T value, Supplier supplier) {
        if (value == null) {
            if (supplier != null) {
                value = supplier.get();
            }
        }
        return value;
    }

    static  boolean eq(T a, T b) {
        //Objects.equals() 有坑
        return a == b || (a != null && a.equals(b));
    }

    static Object[] values(Object... args) {
        return args;
    }

    @SneakyThrows
    static void sleep(long millis) {
        Thread.sleep(millis);
    }
    //endregion

    static  Map weakMap(Object ref) {
        return Container.>weakMap().computeIfAbsent(ref, k -> new ConcurrentHashMap<>(8));
    }

    default  TV attr(TK key) {
        Map attrMap = Container.>weakMap().get(this);
        if (attrMap == null) {
            return null;
        }
        return attrMap.get(key);
    }

    default  void attr(TK key, TV value) {
        weakMap(this).put(key, value);
    }

    default  T deepClone() {
        return Serializer.DEFAULT.deserialize(Serializer.DEFAULT.serialize(this));
    }
}