167 lines
6.0 KiB
Java
167 lines
6.0 KiB
Java
/*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
package fr.neatmonster.nocheatplus.utilities;
|
|
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashSet;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import fr.neatmonster.nocheatplus.checks.CheckType;
|
|
|
|
public class CheckTypeUtil {
|
|
|
|
/** All descendants recursively. */
|
|
private static final Map<CheckType, Set<CheckType>> descendantsMap = new HashMap<CheckType, Set<CheckType>>();
|
|
/** Direct children only. */
|
|
private static final Map<CheckType, Set<CheckType>> directChildrenMap = new HashMap<CheckType, Set<CheckType>>();
|
|
/** Checks/groups that might be run off the primary thread. */
|
|
private static final Set<CheckType> needSync = new HashSet<CheckType>();
|
|
/** Check including all descendants recursively, for convenient iteration. */
|
|
private static final Map<CheckType, Set<CheckType>> withDescendantsMap = new HashMap<CheckType, Set<CheckType>>();
|
|
|
|
static {
|
|
// Parent/children relations.
|
|
|
|
// Recursive first.
|
|
// TODO: Really recursive (...). So create direct children first, then others from those.
|
|
final Map<CheckType, Set<CheckType>> map = new HashMap<CheckType, Set<CheckType>>();
|
|
for (final CheckType type : CheckType.values()) {
|
|
map.put(type, new LinkedHashSet<CheckType>());
|
|
}
|
|
for (final CheckType type : CheckType.values()) {
|
|
if (type != CheckType.ALL) {
|
|
map.get(CheckType.ALL).add(type);
|
|
}
|
|
for (final CheckType other : CheckType.values()) {
|
|
if (isAncestor(other, type)) {
|
|
map.get(other).add(type);
|
|
}
|
|
}
|
|
}
|
|
for (final CheckType parent : map.keySet()) {
|
|
final Set<CheckType> set = map.get(parent);
|
|
descendantsMap.put(parent, Collections.unmodifiableSet(set));
|
|
final Set<CheckType> wpSet = new LinkedHashSet<CheckType>(set);
|
|
wpSet.add(parent);
|
|
withDescendantsMap.put(parent,
|
|
Collections.unmodifiableSet(wpSet));
|
|
}
|
|
|
|
// Direct children only.
|
|
for (final CheckType parent : map.keySet()) {
|
|
final Set<CheckType> set = new LinkedHashSet<CheckType>(map.get(parent));
|
|
final Iterator<CheckType> it = set.iterator();
|
|
while (it.hasNext()) {
|
|
if (it.next().getParent() != parent) {
|
|
it.remove();
|
|
}
|
|
}
|
|
directChildrenMap.put(parent, Collections.unmodifiableSet(set));
|
|
}
|
|
|
|
// needSync: Note that tests use the same definitions.
|
|
for (final CheckType checkType : new CheckType[] { CheckType.CHAT,
|
|
CheckType.NET }) {
|
|
needSync.addAll(getWithDescendants(checkType));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get an unmodifiable collection of descendants for the given check type.
|
|
* Always returns a collection, does not contain check type itself.
|
|
*
|
|
* @param type
|
|
* the check type
|
|
* @return the descendants
|
|
*/
|
|
public static final Set<CheckType> getDescendants(
|
|
final CheckType type) {
|
|
return descendantsMap.get(type);
|
|
}
|
|
|
|
/**
|
|
* Get an unmodifiable collection of direct children for the given check
|
|
* type. Always returns a collection, does not contain check type itself.
|
|
*
|
|
* @param type
|
|
* the check type
|
|
* @return the children
|
|
*/
|
|
public static final Set<CheckType> getDirectChildren(
|
|
final CheckType type) {
|
|
return directChildrenMap.get(type);
|
|
}
|
|
|
|
/**
|
|
* Get an unmodifiable collection of the given check type with descendants.
|
|
* Always returns a collection, does contain the check type itself.
|
|
*
|
|
* @param type
|
|
* the check type
|
|
* @return the given check type with descendants
|
|
*/
|
|
public static final Set<CheckType> getWithDescendants(
|
|
final CheckType type) {
|
|
return withDescendantsMap.get(type);
|
|
}
|
|
|
|
/**
|
|
* Check if the supposed ancestor is an ancestor of the supposed descendant.
|
|
* Equality doesn't match here.
|
|
*
|
|
* @param supposedAncestor
|
|
* the supposed parent
|
|
* @param supposedDescendant
|
|
* the supposed child
|
|
* @return true, if is parent
|
|
*/
|
|
public static final boolean isAncestor(final CheckType supposedAncestor,
|
|
final CheckType supposedDescendant) {
|
|
// TODO: Perhaps rename to isAncestor !?
|
|
if (supposedAncestor == supposedDescendant) {
|
|
return false;
|
|
} else if (supposedAncestor == CheckType.ALL) {
|
|
return true;
|
|
}
|
|
CheckType parent = supposedDescendant.getParent();
|
|
while (parent != null)
|
|
if (parent == supposedAncestor) {
|
|
return true;
|
|
} else {
|
|
parent = parent.getParent();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Test if the check type requires synchronization. This indicates, if a
|
|
* check can be called off primary thread at all.
|
|
* <hr>
|
|
* That should be CHAT and NET checks, currently.
|
|
*
|
|
* @param type
|
|
* the check type
|
|
* @return true, if successful
|
|
*/
|
|
public static final boolean needsSynchronization(final CheckType type) {
|
|
return needSync.contains(type);
|
|
}
|
|
|
|
}
|