org.rx.bean.FlagsEnum Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of rxlib Show documentation
A set of utilities for Java
There is a newer version: 3.0.0
package org.rx.bean;

import lombok.SneakyThrows;
import org.rx.core.Arrays;
import org.rx.core.NQuery;
import org.rx.core.Strings;
import org.rx.util.function.BiFunc;

import java.util.EnumMap;
import java.util.EnumSet;

import static org.rx.core.App.NON_WARNING;
import static org.rx.core.App.require;

public final class FlagsEnum & NEnum> implements NEnum {
    @SuppressWarnings(NON_WARNING)
    public static  & NEnum> FlagsEnum valueOf(Class type, int flags) {
        require(type);

        FlagsEnum flagsEnum = null;
        for (T constant : type.getEnumConstants()) {
            if ((flags & constant.getValue()) != constant.getValue()) {
                continue;
            }
            if (flagsEnum == null) {
                flagsEnum = new FlagsEnum<>(constant);
                continue;
            }
            flagsEnum.add(constant);
        }
        return flagsEnum;
    }

    public static  & NEnum> FlagsEnum valueOf(Class type, EnumSet enumSet) {
        require(type, enumSet);

        int flags = 0;
        for (T t : enumSet) {
            flags |= t.getValue();
        }
        return FlagsEnum.valueOf(type, flags);
    }

    public static  & NEnum> FlagsEnum valueOf(Class type, String names) {
        require(type, names);

        return valueOf(type, EnumSet.copyOf(NQuery.of(Strings.split(names, ", "))
                .join(Arrays.toList(type.getEnumConstants()), (p1, p2) -> p1.equals(p2.name()), (p1, p2) -> p2)
                .toList()));
    }

    private final Class type;
    private int flags;

    public String name() {
        return String.join(", ", NQuery.of(toSet()).select(Enum::name));
    }

    @Override
    public int getValue() {
        return flags;
    }

    @Override
    public String description() {
        return String.join(", ", NQuery.of(toSet()).select(NEnum::description));
    }

    @SuppressWarnings(NON_WARNING)
    FlagsEnum(NEnum nEnum) {
        type = (Class) nEnum.getClass();
        flags = nEnum.getValue();
    }

    @SuppressWarnings(NON_WARNING)
    public FlagsEnum add(T... nEnum) {
        require(nEnum);

        for (T t : nEnum) {
            flags |= t.getValue();
        }
        return this;
    }

    @SuppressWarnings(NON_WARNING)
    public FlagsEnum remove(T... nEnum) {
        require(nEnum);

        for (T t : nEnum) {
            flags &= ~t.getValue();
        }
        return this;
    }

    @SuppressWarnings(NON_WARNING)
    public boolean has(T... nEnum) {
        require(nEnum);

        int val = 0;
        for (T t : nEnum) {
            val |= t.getValue();
        }
        return (flags & val) == val;
    }

    @SuppressWarnings(NON_WARNING)
    public EnumSet toSet() {
        EnumSet set = EnumSet.noneOf(type);
        for (T constant : type.getEnumConstants()) {
            if (has(constant)) {
                set.add(constant);
            }
        }
        return set;
    }

    @SuppressWarnings(NON_WARNING)
    @SneakyThrows
    public  EnumMap toMap(BiFunc compute) {
        EnumMap map = new EnumMap<>(type);
        for (T constant : type.getEnumConstants()) {
            if (has(constant)) {
                map.put(constant, compute.invoke(constant));
            }
        }
        return map;
    }
}