com.jn.langx.util.enums.Enums Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of langx-java Show documentation
Java lang extensions for java6+, a supplement to , replacement of a Guava, commons-lang. Core utilities, Collection utilities, IO utilities, Cache, Configuration library ...
There is a newer version: 4.8.2
Show newest version
package com.jn.langx.util.enums;

import com.jn.langx.Named;
import com.jn.langx.annotation.NonNull;
import com.jn.langx.text.StringTemplates;
import com.jn.langx.util.Objects;
import com.jn.langx.util.Preconditions;
import com.jn.langx.util.collection.Collects;
import com.jn.langx.util.enums.base.CommonEnum;
import com.jn.langx.util.function.Predicate;
import com.jn.langx.util.function.Supplier0;
import com.jn.langx.util.reflect.Reflects;

import java.util.EnumSet;
import java.util.List;
import java.util.Set;

public class Enums {
    private Enums(){}

    /**
     * 基于 ordinal
     *
     * @param value
     * @param targetClass
     * @param 
     * @return
     */
    public static > T ofValue(final int value, Class targetClass) {
        Preconditions.checkTrue(targetClass.isEnum(), targetClass.getName() + " not an enum class");
        return Collects.findFirst(EnumSet.allOf(targetClass), new Predicate() {
            @Override
            public boolean test(T e) {
                return e.ordinal() == value;
            }
        });
    }

    /**
     * 基于 code属性，或者 ordinal
     *
     * @param tClass
     * @param code
     * @param 
     * @return
     */
    public static > T ofCode(@NonNull final Class tClass, final int code) {
        Preconditions.checkNotNull(tClass);
        T t = null;
        if (Reflects.isSubClass(CommonEnum.class, tClass)) {
            t = Collects.findFirst(EnumSet.allOf(tClass), new Predicate() {
                @Override
                public boolean test(T e) {
                    CommonEnum y = (CommonEnum) e;
                    return y.getCode() == code;
                }
            });
        }
        if (t == null) {
            t = Collects.findFirst(EnumSet.allOf(tClass), new Predicate() {
                @Override
                public boolean test(T e) {
                    return e.ordinal() == code;
                }
            });
        }
        return t;
    }

    /**
     * 基于name
     *
     * @param tClass
     * @param name
     * @param 
     * @return
     */
    public static > T ofName(@NonNull final Class tClass, final String name) {
        Preconditions.checkNotNull(tClass);
        T t = null;
        if (Reflects.isSubClass(CommonEnum.class, tClass)) {
            t = Collects.findFirst(EnumSet.allOf(tClass), new Predicate() {
                @Override
                public boolean test(T e) {
                    CommonEnum y = (CommonEnum) e;
                    return y.getName().equals(name);
                }
            });
        }
        if (t == null && Reflects.isSubClass(Named.class, tClass)) {
            t = Collects.findFirst(EnumSet.allOf(tClass), new Predicate() {
                @Override
                public boolean test(T e) {
                    Named y = (Named) e;
                    return y.getName().equals(name);
                }
            });
        }
        if (t == null) {
            t = Collects.findFirst(EnumSet.allOf(tClass), new Predicate() {
                @Override
                public boolean test(T e) {
                    return e.name().equals(name);
                }
            });
        }

        return t;
    }

    public static > T ofToString(@NonNull final Class tClass, final String value) {
        Preconditions.checkNotNull(tClass);
        T t = null;
        if (Reflects.isSubClass(CommonEnum.class, tClass)) {
            t = Collects.findFirst(EnumSet.allOf(tClass), new Predicate() {
                @Override
                public boolean test(T e) {
                    CommonEnum y = (CommonEnum) e;
                    return y.toString().equals(value);
                }
            });
        }
        if (t == null) {
            t = Collects.findFirst(EnumSet.allOf(tClass), new Predicate() {
                @Override
                public boolean test(T e) {
                    return e.toString().equals(value);
                }
            });
        }

        return t;
    }

    public static > T ofDisplayText(@NonNull final Class tClass, final String displayText) {
        Preconditions.checkNotNull(tClass);
        T t = null;
        if (Reflects.isSubClass(CommonEnum.class, tClass)) {
            t = Collects.findFirst(EnumSet.allOf(tClass), new Predicate() {
                @Override
                public boolean test(T e) {
                    CommonEnum y = (CommonEnum) e;
                    return y.getDisplayText().equals(displayText);
                }
            });
        }
        if (t == null) {
            t = Collects.findFirst(EnumSet.allOf(tClass), new Predicate() {
                @Override
                public boolean test(T e) {
                    return e.name().equals(displayText);
                }
            });
        }
        return t;
    }

    public static > T inferEnum(Class targetClass, String text) {
        if (targetClass.isEnum() && Reflects.isSubClassOrEquals(Enum.class, targetClass)) {
            T v = ofDisplayText(targetClass, text);
            if (v == null) {
                return ofName(targetClass, text);
            }
        }
        return null;
    }

    public static > T ofField(Class targetClass, final String field, final Object value) {
        return ofField(targetClass, field, value, null);
    }

    public static > T ofField(Class targetClass, final String field, final Supplier0