trydofor / professional-mirana / #68

Committed 31 Aug 2024 02:56AM UTC coverage: 84.4% (+1.0%) from 83.382%

Build # #68

Build Type

push

Committed by

Commit Message

Merge pull request #45 from trydofor/develop

v2.7.3 with minor change

Run Details

474 of 568 new or added lines in 27 files covered. (83.45%)

8 existing lines in 6 files now uncovered.

5237 of 6205 relevant lines covered (84.4%)

0.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.2

/src/main/java/pro/fessional/mirana/cond/StaticFlag.java

package pro.fessional.mirana.cond;

import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Pattern;

/**
 * global static Flag of Enum
 *
 * @author trydofor
 * @since 2022-01-26
 */
public class StaticFlag {

    private static final Map<Enum<?>, Boolean> JvmFlags = new ConcurrentHashMap<>();

    public static void setFlag(@NotNull Enum<?> flag) {
        JvmFlags.put(flag, Boolean.TRUE);
    }

    public static void delFlag(@NotNull Enum<?> flag) {
        JvmFlags.remove(flag);
    }

    public static boolean hasFlag(@NotNull Enum<?> flag) {
        final Boolean bol = JvmFlags.get(flag);
        return bol != null;
    }

    public static boolean anyFlag(@NotNull Enum<?>... flags) {
        for (Enum<?> flag : flags) {
            if (hasFlag(flag)) {
                return true;
            }
        }
        return false;
    }

    public static boolean notFlag(@NotNull Enum<?> flag) {
        final Boolean bol = JvmFlags.get(flag);
        return bol == null;
    }

    private static final Map<Object, Map<Enum<?>, Boolean>> KeyFlags = new ConcurrentHashMap<>();

    public static void setFlag(@NotNull Object key, @NotNull Enum<?> flag) {
        KeyFlags.computeIfAbsent(key, k -> {
            Map<Enum<?>, Boolean> map = new ConcurrentHashMap<>();
            map.put(flag, Boolean.TRUE);
            return map;
        });
    }

    public static void delFlag(@NotNull Object key, @NotNull Enum<?> flag) {
        final Map<Enum<?>, Boolean> map = KeyFlags.get(key);
        if (map != null) {
            map.remove(flag);
        }
    }

    public static boolean hasFlag(@NotNull Object key, @NotNull Enum<?> flag) {
        final Map<Enum<?>, Boolean> map = KeyFlags.get(key);
        return map != null && map.get(flag) != null;
    }

    public static boolean anyFlag(@NotNull Object key, @NotNull Enum<?>... flags) {
        final Map<Enum<?>, Boolean> map = KeyFlags.get(key);
        if (map == null) return false;
        for (Enum<?> flag : flags) {
            if (map.get(flag) != null) {
                return true;
            }
        }
        return false;
    }

    public static boolean notFlag(@NotNull Object key, @NotNull Enum<?> flag) {
        final Map<Enum<?>, Boolean> map = KeyFlags.get(key);
        return map == null || map.get(flag) == null;
    }

    private static final Pattern ListSplit = Pattern.compile("[\r\n\t ,]+");

    /**
     * <pre>
     * case-insensitive matching, the flag must be trimmed, vote does not need to be trimmed.
     * * `!` or `-` prefix means not, `-a`, `!a` is NOT `a`
     * * `a` votes `b` = `0`
     * * `!a` votes `b` = `1`
     * * `a` votes `a` = `2`
     * * `!a` votes `a` = `-2`
     * result true if votes > 0, false if <= 0
     * </pre>
     */
    public static int vote(@NotNull final String flag, @NotNull final String vote) {

        final int vln = vote.length();
        final int fln = flag.length();
        int not = 0;
        int off = 0;

        for (int i = 0; i < vln; i++) {
            char c = vote.charAt(i);
            if (c == '-' || c == '!') {
                not = 1;
                off = i + 1;
            }
            else if (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
                off = i + 1;
                continue;
            }
            break;
        }

        final int ln = vln - off;
        if (ln < fln) {
            return not;
        }
        else if (ln > fln) {
            char c = vote.charAt(off + fln);
            if (c != ' ' && c != '\t' && c != '\r' && c != '\n' && c != ',') return not;
        }

        boolean fnd = flag.regionMatches(true, 0, vote, off, fln);
        return fnd ? (not == 0 ? 2 : -2) : not;
    }

    /**
     * <pre>
     * eval the votes to flag, case-insensitive matching,
     * the flag must be trimmed, vote does not need to be trimmed.
     * * `[a,b,c]` is `a or b or c`
     * * null/empty means skip, no vote
     * *  `a` votes `b` = false
     * * `!a` votes `a` = false (veto power)
     * *  `a` votes `a` = true
     * * `!a` votes `b` = true
     * return true if has votes, otherwise false
     * </pre>
     */
    public static boolean hasVote(@Nullable String flag, @Nullable String... votes) {
        if (flag == null || flag.isEmpty() || votes == null) return false;

        boolean voted = false;
        for (String vt : votes) {
            if (vt == null || vt.isEmpty()) continue;

            final int vr = vote(flag, vt);
            if (vr > 0) {
                voted = true;
            }
            else if (vr < 0) {
                return false;
            }
        }

        return voted;
    }

    public static boolean hasVote(@Nullable String flag, @Nullable String votes) {
        if (votes == null || votes.isEmpty()) return false;
        return hasVote(flag, ListSplit.split(votes));
    }

    public static boolean notVote(@Nullable String flag, @Nullable String votes) {
        return !hasVote(flag, votes);
    }

    public static boolean notVote(@Nullable String flag, @Nullable String... votes) {
        return !hasVote(flag, votes);
    }
}

1	package pro.fessional.mirana.cond;
2
3	import org.jetbrains.annotations.NotNull;
4	import org.jetbrains.annotations.Nullable;
5
6	import java.util.Map;
7	import java.util.concurrent.ConcurrentHashMap;
8	import java.util.regex.Pattern;
9
10	/**
11	* global static Flag of Enum
12	*
13	* @author trydofor
14	* @since 2022-01-26
15	*/
16	public class StaticFlag {	×
17
18	private static final Map<Enum<?>, Boolean> JvmFlags = new ConcurrentHashMap<>();	1✔
19
20	public static void setFlag(@NotNull Enum<?> flag) {
21	JvmFlags.put(flag, Boolean.TRUE);	1✔
22	}	1✔
23
24	public static void delFlag(@NotNull Enum<?> flag) {
25	JvmFlags.remove(flag);	1✔
26	}	1✔
27
28	public static boolean hasFlag(@NotNull Enum<?> flag) {
29	final Boolean bol = JvmFlags.get(flag);	1✔
30	return bol != null;	1✔
31	}
32
33	public static boolean anyFlag(@NotNull Enum<?>... flags) {
34	for (Enum<?> flag : flags) {	1✔
35	if (hasFlag(flag)) {	1✔
36	return true;	1✔
37	}
38	}
39	return false;	1✔
40	}
41
42	public static boolean notFlag(@NotNull Enum<?> flag) {
43	final Boolean bol = JvmFlags.get(flag);	1✔
44	return bol == null;	1✔
45	}
46
47	private static final Map<Object, Map<Enum<?>, Boolean>> KeyFlags = new ConcurrentHashMap<>();	1✔
48
49	public static void setFlag(@NotNull Object key, @NotNull Enum<?> flag) {
50	KeyFlags.computeIfAbsent(key, k -> {	1✔
51	Map<Enum<?>, Boolean> map = new ConcurrentHashMap<>();	1✔
52	map.put(flag, Boolean.TRUE);	1✔
53	return map;	1✔
54	});
55	}	1✔
56
57	public static void delFlag(@NotNull Object key, @NotNull Enum<?> flag) {
58	final Map<Enum<?>, Boolean> map = KeyFlags.get(key);	1✔
59	if (map != null) {	1✔
60	map.remove(flag);	1✔
61	}
62	}	1✔
63
64	public static boolean hasFlag(@NotNull Object key, @NotNull Enum<?> flag) {
65	final Map<Enum<?>, Boolean> map = KeyFlags.get(key);	1✔
66	return map != null && map.get(flag) != null;	1✔
67	}
68
69	public static boolean anyFlag(@NotNull Object key, @NotNull Enum<?>... flags) {
70	final Map<Enum<?>, Boolean> map = KeyFlags.get(key);	1✔
71	if (map == null) return false;	1✔
72	for (Enum<?> flag : flags) {	1✔
73	if (map.get(flag) != null) {	1✔
74	return true;	1✔
75	}
76	}
77	return false;	1✔
78	}
79
80	public static boolean notFlag(@NotNull Object key, @NotNull Enum<?> flag) {
81	final Map<Enum<?>, Boolean> map = KeyFlags.get(key);	1✔
82	return map == null \|\| map.get(flag) == null;	1✔
83	}
84
85	private static final Pattern ListSplit = Pattern.compile("[\r\n\t ,]+");	1✔
86
87	/**
88	* <pre>
89	* case-insensitive matching, the flag must be trimmed, vote does not need to be trimmed.
90	* * `!` or `-` prefix means not, `-a`, `!a` is NOT `a`
91	* * `a` votes `b` = `0`
92	* * `!a` votes `b` = `1`
93	* * `a` votes `a` = `2`
94	* * `!a` votes `a` = `-2`
95	* result true if votes > 0, false if <= 0
96	* </pre>
97	*/
98	public static int vote(@NotNull final String flag, @NotNull final String vote) {
99
100	final int vln = vote.length();	1✔
101	final int fln = flag.length();	1✔
102	int not = 0;	1✔
103	int off = 0;	1✔
104
105	for (int i = 0; i < vln; i++) {	1✔
106	char c = vote.charAt(i);	1✔
107	if (c == '-' \|\| c == '!') {	1✔
108	not = 1;	1✔
109	off = i + 1;	1✔
110	}
111	else if (c == ' ' \|\| c == '\t' \|\| c == '\r' \|\| c == '\n') {	1✔
112	off = i + 1;	1✔
113	continue;	1✔
114	}
115	break;
116	}
117
118	final int ln = vln - off;	1✔
119	if (ln < fln) {	1✔
NEW 120	return not;	×
121	}
122	else if (ln > fln) {	1✔
123	char c = vote.charAt(off + fln);	1✔
124	if (c != ' ' && c != '\t' && c != '\r' && c != '\n' && c != ',') return not;	1✔
125	}
126
127	boolean fnd = flag.regionMatches(true, 0, vote, off, fln);	1✔
128	return fnd ? (not == 0 ? 2 : -2) : not;	1✔
129	}
130
131	/**
132	* <pre>
133	* eval the votes to flag, case-insensitive matching,
134	* the flag must be trimmed, vote does not need to be trimmed.
135	* * `[a,b,c]` is `a or b or c`
136	* * null/empty means skip, no vote
137	* * `a` votes `b` = false
138	* * `!a` votes `a` = false (veto power)
139	* * `a` votes `a` = true
140	* * `!a` votes `b` = true
141	* return true if has votes, otherwise false
142	* </pre>
143	*/
144	public static boolean hasVote(@Nullable String flag, @Nullable String... votes) {
145	if (flag == null \|\| flag.isEmpty() \|\| votes == null) return false;	1✔
146
147	boolean voted = false;	1✔
148	for (String vt : votes) {	1✔
149	if (vt == null \|\| vt.isEmpty()) continue;	1✔
150
151	final int vr = vote(flag, vt);	1✔
152	if (vr > 0) {	1✔
153	voted = true;	1✔
154	}
155	else if (vr < 0) {	1✔
156	return false;	1✔
157	}
158	}
159
160	return voted;	1✔
161	}
162
163	public static boolean hasVote(@Nullable String flag, @Nullable String votes) {
164	if (votes == null \|\| votes.isEmpty()) return false;	1✔
165	return hasVote(flag, ListSplit.split(votes));	1✔
166	}
167
168	public static boolean notVote(@Nullable String flag, @Nullable String votes) {
NEW 169	return !hasVote(flag, votes);	×
170	}
171
172	public static boolean notVote(@Nullable String flag, @Nullable String... votes) {
NEW 173	return !hasVote(flag, votes);	×
174	}
175	}

trydofor / professional-mirana / #68

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous