louisdevie/tatsuki
1
0
Fork 0
Code Issues Actions Packages Activity

(java) FlagGraph base class and tests

Browse Source
This commit is contained in:
Louis Devie
2026-04-02 23:11:34 +02:00
parent a56febbbb5
commit c0ddacb25e
23 changed files with 863 additions and 306 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/FlagDefinition.java
View File

@@ -5,18 +5,19 @@ import java.util.Optional;
/**
* Represents a single flag defined in a {@link FlagGraph}.
*
* @param <V> The type of the flag's value.
* @param <S> A set of this type of flags.
*/
public interface FlagDefinition<S> {
public interface FlagDefinition<V, S> {
/**
* The alias of the flag.
* The alias of the flag. A composed flag always has an alias.
*/
Optional<String> getAlias();
Optional<String> alias();
/**
* A set containing the value of the flag, or multiple values if it is a composed flag.
* The value of the flag. A composed flag has no value.
*/
S values();
Optional<V> value();
/**
* Test if this flag and all its parents are present in the set.

360
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/FlagGraph.java
View File

@@ -1,8 +1,7 @@
package fr.louisdevie.tatsuki;
import java.util.Collection;
import java.util.Optional;
import java.util.Set;
import java.lang.reflect.Array;
import java.util.*;
/**
* Represents a group of flags of type {@link V} and the relationships between
@@ -11,71 +10,128 @@ import java.util.Set;
* @param <V> The type of the flag values.
* @param <S> The type used to contain the flags.
*/
public interface FlagGraph<V, S> {
public abstract class FlagGraph<V, S> {
private final HashMap<V, FlagDefinition<V, S>> definitionsByValue;
private final HashMap<String, FlagDefinition<V, S>> definitionsByAlias;
protected FlagGraph(Collection<? extends FlagDefinition<V, S>> c) {
this.definitionsByValue = new HashMap<>();
this.definitionsByAlias = new HashMap<>();
for (var definition : c) {
if (definition.value().isPresent()) {
V value = definition.value().get();
if (this.definitionsByValue.put(value, definition) != null) {
throw new IllegalArgumentException(String.format("Duplicate value \"%s\"", value));
}
if (definition.alias().isPresent()) {
String alias = definition.alias().get();
if (this.definitionsByAlias.put(alias, definition) != null) {
throw new IllegalArgumentException(String.format("Duplicate alias \"%s\"", alias));
}
}
} else {
String alias = definition.alias().orElseThrow(() ->
new IllegalArgumentException("Invalid flag definition: a composed flag must always have an alias")
);
if (this.definitionsByAlias.put(alias, definition) != null) {
throw new IllegalArgumentException(String.format("Duplicate alias \"%s\"", alias));
}
}
}
}
/**
* Returns the number of definitions in this graph.
*/
int size();
public int size() {
return this.definitionsByValue.size() +
(int) this.definitionsByAlias.values().stream()
.filter(d -> d.value().isEmpty())
.count();
}
/**
* Returns {@code true} if this graph contains no definitions.
*/
boolean isEmpty();
/**
* Returns {@code true} if this graph contains a definition with the specified alias.
*/
boolean containsAlias(String alias);
public boolean isEmpty() {
return this.definitionsByValue.isEmpty() && this.definitionsByAlias.isEmpty();
}
/**
* Returns {@code true} if this graph contains a definition with the specified value.
*/
boolean containsValue(V value);
public boolean containsValue(V value) {
return this.definitionsByValue.containsKey(value);
}
/**
* Returns {@code true} if this graph contains a definition with the specified alias.
*/
public boolean containsAlias(String alias) {
return this.definitionsByAlias.containsKey(alias);
}
/**
* Returns {@code true} if the specified definition belongs to this graph.
*/
boolean containsDefinition(FlagDefinition<S> definition);
/**
* Returns the flag definition with the specified alias.
*
* @param alias The alias of the flag.
*
* @return An {@link Optional} of the corresponding definition, or an empty
* {@link Optional} if there is no definition with this alias.
*/
Optional<FlagDefinition<S>> definitionNamed(String alias);
public boolean containsDefinition(FlagDefinition<V, S> definition) {
return this.definitionsByValue.containsValue(definition) || this.definitionsByAlias.containsValue(definition);
}
/**
* Returns the flag definition with the specified value.
*
* @param value The base value of the flag.
*
* @return An {@link Optional} of the corresponding definition, or an empty
* {@link Optional} if there is no definition with this value.
*/
Optional<FlagDefinition<S>> definitionOf(V value);
public Optional<FlagDefinition<V, S>> definitionOf(V value) {
return Optional.ofNullable(this.definitionsByValue.get(value));
}
/**
* Returns the flag definition with the specified alias.
*
* @param alias The alias of the flag.
* @return An {@link Optional} of the corresponding definition, or an empty
* {@link Optional} if there is no definition with this alias.
*/
public Optional<FlagDefinition<V, S>> definitionNamed(String alias) {
return Optional.ofNullable(this.definitionsByAlias.get(alias));
}
/**
* Returns a {@link Set} view of the aliases defined in this graph.
*/
Set<String> aliasSet();
public Set<String> aliasSet() {
return new ReadOnlyKeySet<>(this.definitionsByAlias);
}
/**
* Returns a {@link Set} view of the values defined in this graph.
*/
Set<V> valueSet();
public Set<V> valueSet() {
return new ReadOnlyKeySet<>(this.definitionsByValue);
}
/**
* Returns a list of all the defined flags.
* Returns a {@link Set} view of all the defined flags.
*/
Collection<FlagDefinition<S>> definitions();
public Set<FlagDefinition<V, S>> definitions() {
return new DefinitionSet();
}
/**
* Creates a set of flags from a list of values.
*/
@SuppressWarnings("unchecked")
public abstract S of(V... values);
/**
* Creates a set of flags from a list of aliases.
*/
S named(String... aliases);
public abstract S named(String... aliases);
/**
* Checks whether the first set of flags includes at least one of the flags
@@ -86,7 +142,7 @@ public interface FlagGraph<V, S> {
* @param flags - A set of flags.
* @param required - The flags to search for in the first set.
*/
boolean hasAny(S flags, S required);
public abstract boolean hasAny(S flags, S required);
/**
* Checks whether the first set of flags includes all the flags from the
@@ -97,7 +153,7 @@ public interface FlagGraph<V, S> {
* @param flags - A set of flags.
* @param required - The flags to search for in the first set.
*/
boolean hasAll(S flags, S required);
public abstract boolean hasAll(S flags, S required);
/**
* Filters a flag set so that it only contains the flags that were defined
@@ -108,7 +164,7 @@ public interface FlagGraph<V, S> {
* @return A new set of flags.
* @see #maximum
*/
S minimum(S flags);
public abstract S minimum(S flags);
/**
* Filters a flag set so that it only contains the flags that were defined
@@ -119,5 +175,241 @@ public interface FlagGraph<V, S> {
* @return A new set of flags.
* @see #minimum
*/
S maximum(S flags);
public abstract S maximum(S flags);
private static class ReadOnlyKeySet<K> implements Set<K> {
private final Set<K> underlying;
public ReadOnlyKeySet(HashMap<K, ?> map) {
this.underlying = map.keySet();
}
@Override
public int size() {
return this.underlying.size();
}
@Override
public boolean isEmpty() {
return this.underlying.isEmpty();
}
@Override
public boolean contains(Object o) {
return this.underlying.contains(o);
}
@Override
public Iterator<K> iterator() {
return this.underlying.iterator();
}
@Override
public Object[] toArray() {
return this.underlying.toArray();
}
@Override
public <T> T[] toArray(T[] a) {
return this.underlying.toArray(a);
}
@Override
public boolean add(K key) {
throw new UnsupportedOperationException();
}
@Override
public boolean remove(Object o) {
throw new UnsupportedOperationException();
}
@Override
public boolean containsAll(Collection<?> c) {
return this.underlying.containsAll(c);
}
@Override
public boolean addAll(Collection<? extends K> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean retainAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean removeAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public void clear() {
throw new UnsupportedOperationException();
}
}
private static class DefinitionIterator<V, S> implements Iterator<FlagDefinition<V, S>> {
private final Iterator<FlagDefinition<V, S>> byValueIterator;
private final Iterator<FlagDefinition<V, S>> byAliasIterator;
private FlagDefinition<V, S> nextDefinition;
public DefinitionIterator(HashMap<?, FlagDefinition<V, S>> byValue, HashMap<?, FlagDefinition<V, S>> byAlias) {
this.byValueIterator = byValue.values().iterator();
this.byAliasIterator = byAlias.values().iterator();
this.lookahead();
}
private void lookahead() {
FlagDefinition<V, S> found = null;
if (this.byValueIterator.hasNext()) {
found = this.byValueIterator.next();
}
while (found == null && this.byAliasIterator.hasNext()) {
found = this.byAliasIterator.next();
if (found.alias().isPresent()) {
found = null;
}
}
this.nextDefinition = found;
}
@Override
public boolean hasNext() {
return this.nextDefinition != null;
}
@Override
public FlagDefinition<V, S> next() {
var nextDefinition = this.nextDefinition;
if (nextDefinition == null) {
throw new NoSuchElementException();
}
this.lookahead();
return nextDefinition;
}
}
private class DefinitionSet implements Set<FlagDefinition<V, S>> {
@Override
public int size() {
return FlagGraph.this.size();
}
@Override
public boolean isEmpty() {
return FlagGraph.this.isEmpty();
}
@Override
public boolean contains(Object o) {
// noinspection SuspiciousMethodCalls
return FlagGraph.this.definitionsByValue.containsValue(o) ||
FlagGraph.this.definitionsByAlias.containsValue(o);
}
@Override
public Iterator<FlagDefinition<V, S>> iterator() {
return new DefinitionIterator<>(FlagGraph.this.definitionsByValue, FlagGraph.this.definitionsByAlias);
}
@Override
public Object[] toArray() {
int maxSize = FlagGraph.this.definitionsByValue.size() + FlagGraph.this.definitionsByAlias.size();
Object[] array = new Object[maxSize];
int i = 0;
for (var definition : FlagGraph.this.definitionsByValue.values()) {
array[i++] = definition;
}
for (var definition : FlagGraph.this.definitionsByAlias.values()) {
if (definition.value().isEmpty()) {
array[i++] = definition;
}
}
return Arrays.copyOf(array, i);
}
@Override
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
int maxSize = FlagGraph.this.definitionsByValue.size() + FlagGraph.this.definitionsByAlias.size();
T[] array = (T[]) Array.newInstance(a.getClass().componentType(), maxSize);
;
int i = 0;
for (var definition : FlagGraph.this.definitionsByValue.values()) {
array[i++] = (T) definition;
}
for (var definition : FlagGraph.this.definitionsByAlias.values()) {
if (definition.value().isEmpty()) {
array[i++] = (T) definition;
}
}
if (i > a.length) {
return Arrays.copyOf(array, i);
} else {
Arrays.fill(a, null);
System.arraycopy(array, 0, a, 0, i);
return array;
}
}
@Override
public boolean add(FlagDefinition<V, S> vsFlagDefinition) {
throw new UnsupportedOperationException();
}
@Override
public boolean remove(Object o) {
throw new UnsupportedOperationException();
}
@Override
public boolean containsAll(Collection<?> c) {
boolean result = true;
for (Object o : c) {
result = this.contains(o);
if (!result) break;
}
return result;
}
@Override
public boolean addAll(Collection<? extends FlagDefinition<V, S>> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean retainAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean removeAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public void clear() {
throw new UnsupportedOperationException();
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Set<?> otherSet)) return false;
int count = 0;
for (var definition : FlagGraph.this.definitionsByValue.values()) {
if (!otherSet.contains(definition)) return false;
count++;
}
for (var definition : FlagGraph.this.definitionsByAlias.values()) {
if (definition.value().isEmpty()) {
if (!otherSet.contains(definition)) return false;
count++;
}
}
return count == otherSet.size();
}
}
}

51
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/bitflags/BigBitFlagGraph.java
View File

@@ -9,56 +9,15 @@ import java.util.List;
import java.util.Optional;
import java.util.Set;
public class BigBitFlagGraph implements FlagGraph<BigInteger, BigInteger> {
public class BigBitFlagGraph extends FlagGraph<BigInteger, BigInteger> {
@Override
public int size() {
return 0;
protected BigBitFlagGraph(Collection<FlagDefinition<BigInteger, BigInteger>> c) {
super(c);
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public boolean containsAlias(String alias) {
return false;
}
@Override
public boolean containsValue(BigInteger value) {
return false;
}
@Override
public boolean containsDefinition(FlagDefinition<BigInteger> definition) {
return false;
}
@Override
public Optional<FlagDefinition<BigInteger>> definitionNamed(String alias) {
return Optional.empty();
}
@Override
public Optional<FlagDefinition<BigInteger>> definitionOf(BigInteger value) {
return Optional.empty();
}
@Override
public Set<String> aliasSet() {
return Set.of();
}
@Override
public Set<BigInteger> valueSet() {
return Set.of();
}
@Override
public Collection<FlagDefinition<BigInteger>> definitions() {
return List.of();
public BigInteger of(BigInteger... values) {
return null;
}
@Override

4
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/bitflags/BigBitFlagsIterator.java → java/tatsuki/src/main/java/fr/louisdevie/tatsuki/bitflags/BigBitFlagIterator.java
View File

@@ -4,11 +4,11 @@ import java.math.BigInteger;
import java.util.Iterator;
import java.util.NoSuchElementException;
public class BigBitFlagsIterator implements Iterator<BigInteger> {
public class BigBitFlagIterator implements Iterator<BigInteger> {
private BigInteger value;
private BigInteger current;
public BigBitFlagsIterator(BigInteger value) {
public BigBitFlagIterator(BigInteger value) {
this.value = value;
this.current = BigInteger.ONE;
}

54
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/bitflags/BitFlagGraph.java
View File

@@ -8,57 +8,16 @@ import java.util.List;
import java.util.Optional;
import java.util.Set;
public class BitFlagGraph implements FlagGraph<Integer, Integer> {
public class BitFlagGraph extends FlagGraph<Integer, Integer> {
protected BitFlagGraph(Collection<FlagDefinition<Integer, Integer>> c) {
super(c);
}
@Override
public int size() {
public Integer of(Integer... values) {
return 0;
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public boolean containsAlias(String alias) {
return false;
}
@Override
public boolean containsValue(Integer value) {
return false;
}
@Override
public boolean containsDefinition(FlagDefinition<Integer> definition) {
return false;
}
@Override
public Optional<FlagDefinition<Integer>> definitionNamed(String alias) {
return Optional.empty();
}
@Override
public Optional<FlagDefinition<Integer>> definitionOf(Integer value) {
return Optional.empty();
}
@Override
public Set<String> aliasSet() {
return Set.of();
}
@Override
public Set<Integer> valueSet() {
return Set.of();
}
@Override
public Collection<FlagDefinition<Integer>> definitions() {
return List.of();
}
@Override
public Integer named(String... aliases) {
return 0;
@@ -83,4 +42,5 @@ public class BitFlagGraph implements FlagGraph<Integer, Integer> {
public Integer maximum(Integer flags) {
return 0;
}
}

4
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/bitflags/BitFlagsIterator.java → java/tatsuki/src/main/java/fr/louisdevie/tatsuki/bitflags/BitFlagIterator.java
View File

@@ -3,11 +3,11 @@ package fr.louisdevie.tatsuki.bitflags;
import java.util.Iterator;
import java.util.NoSuchElementException;
public class BitFlagsIterator implements Iterator<Integer> {
public class BitFlagIterator implements Iterator<Integer> {
private int value;
private int current;
public BitFlagsIterator(int value) {
public BitFlagIterator(int value) {
this.value = value;
this.current = 1;
}

6
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/bitflags/BitFlags.java
View File

@@ -109,7 +109,7 @@ public final class BitFlags {
private record IterableInteger(int value) implements Iterable<Integer> {
public Iterator<Integer> iterator() {
return new BitFlagsIterator(this.value);
return new BitFlagIterator(this.value);
}
}
@@ -122,7 +122,7 @@ public final class BitFlags {
private record IterableLong(long value) implements Iterable<Long> {
public Iterator<Long> iterator() {
return new LongBitFlagsIterator(this.value);
return new LongBitFlagIterator(this.value);
}
}
@@ -135,7 +135,7 @@ public final class BitFlags {
private record IterableBigInteger(BigInteger value) implements Iterable<BigInteger> {
public Iterator<BigInteger> iterator() {
return new BigBitFlagsIterator(this.value);
return new BigBitFlagIterator(this.value);
}
}
}

51
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/bitflags/LongBitFlagGraph.java
View File

@@ -8,56 +8,15 @@ import java.util.List;
import java.util.Optional;
import java.util.Set;
public class LongBitFlagGraph implements FlagGraph<Long, Long> {
public class LongBitFlagGraph extends FlagGraph<Long, Long> {
@Override
public int size() {
return 0;
protected LongBitFlagGraph(Collection<FlagDefinition<Long, Long>> c) {
super(c);
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public boolean containsAlias(String alias) {
return false;
}
@Override
public boolean containsValue(Long value) {
return false;
}
@Override
public boolean containsDefinition(FlagDefinition<Long> definition) {
return false;
}
@Override
public Optional<FlagDefinition<Long>> definitionNamed(String alias) {
return Optional.empty();
}
@Override
public Optional<FlagDefinition<Long>> definitionOf(Long value) {
return Optional.empty();
}
@Override
public Set<String> aliasSet() {
return Set.of();
}
@Override
public Set<Long> valueSet() {
return Set.of();
}
@Override
public Collection<FlagDefinition<Long>> definitions() {
return List.of();
public Long of(Long... values) {
return 0L;
}
@Override

4
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/bitflags/LongBitFlagsIterator.java → java/tatsuki/src/main/java/fr/louisdevie/tatsuki/bitflags/LongBitFlagIterator.java
View File

@@ -3,11 +3,11 @@ package fr.louisdevie.tatsuki.bitflags;
import java.util.Iterator;
import java.util.NoSuchElementException;
public class LongBitFlagsIterator implements Iterator<Long> {
public class LongBitFlagIterator implements Iterator<Long> {
private long value;
private long current;
public LongBitFlagsIterator(long value) {
public LongBitFlagIterator(long value) {
this.value = value;
this.current = 1L;
}

89
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/builders/FlagSetBuilder.java Normal file
View File

@@ -0,0 +1,89 @@
package fr.louisdevie.tatsuki.builders;
import fr.louisdevie.tatsuki.builders.syntax.AsOrComposeValues;
import fr.louisdevie.tatsuki.builders.syntax.AsOrRequiresOrDefineOrComposeValues;
import fr.louisdevie.tatsuki.builders.syntax.RequiresOrDefineOrComposeValues;
import java.util.ArrayList;
import java.util.HashMap;
public abstract class FlagSetBuilder<V, R> implements AsOrRequiresOrDefineOrComposeValues<V, R>, AsOrComposeValues<V, R> {
private final ArrayList<PartialFlagDefinition<V>> definitions;
private final HashMap<String, PartialFlagDefinition<V>> aliasToDefinition;
private final HashMap<V, PartialFlagDefinition<V>> valueToDefinition;
private PartialFlagDefinition<V> currentDefinition;
protected FlagSetBuilder() {
this.definitions = new ArrayList<>();
this.aliasToDefinition = new HashMap<>();
this.valueToDefinition = new HashMap<>();
this.currentDefinition = null;
}
@Override
public RequiresOrDefineOrComposeValues<V, R> as(String alias) {
if (this.currentDefinition == null) {
throw new IllegalStateException("Attempt to set an alias while there is no current definition");
}
this.currentDefinition.setAlias(alias);
return this;
}
@Override
public RequiresOrDefineOrComposeValues<V, R> requires(String... aliases) {
throw new RuntimeException("Not implemented");
}
@Override
@SuppressWarnings("unchecked")
public RequiresOrDefineOrComposeValues<V, R> requiresValues(V... values) {
throw new RuntimeException("Not implemented");
}
@Override
public AsOrRequiresOrDefineOrComposeValues<V, R> defineValue(V value) {
this.finishCurrentDefinition();
this.currentDefinition = new PartialValueFlagDefinition<>(value);
return this;
}
@Override
public AsOrComposeValues<V, R> compose(String... aliases) {
throw new RuntimeException("Not implemented");
}
@Override
@SuppressWarnings("unchecked")
public AsOrComposeValues<V, R> composeValues(V... values) {
if (this.currentDefinition != null && !this.currentDefinition.isComposition()) {
this.finishCurrentDefinition();
}
this.currentDefinition = new PartialComposedFlagDefinition<>();
for (V value: values) {
this.currentDefinition.addParent(this.referenceToValue(value));
}
return this;
}
protected void finishCurrentDefinition() {
if (this.currentDefinition != null) {
this.definitions.add(this.currentDefinition);
this.currentDefinition = null;
}
}
protected ArrayList<PartialFlagDefinition<V>> partialDefinitions() {
return this.definitions;
}
private PartialFlagDefinition<V> referenceToValue(V value) {
var definition = this.valueToDefinition.get(value);
if (definition == null) {
definition = new ForwardReferenceByValue<>(value);
}
return definition;
}
}

34
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/builders/ForwardReferenceByValue.java Normal file
View File

@@ -0,0 +1,34 @@
package fr.louisdevie.tatsuki.builders;
class ForwardReferenceByValue<V> implements PartialFlagDefinition<V> {
private final V value;
public ForwardReferenceByValue(V value) {
this.value = value;
}
@Override
public void setAlias(String alias) {
throw new UnsupportedOperationException("Attempt to modify a forward reference");
}
@Override
public void addParent(PartialFlagDefinition<V> parent) {
throw new UnsupportedOperationException("Attempt to modify a forward reference");
}
@Override
public boolean isComposition() {
return false;
}
@Override
public String alias() {
return "";
}
@Override
public V value() {
return null;
}
}

31
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/builders/PartialComposedFlagDefinition.java Normal file
View File

@@ -0,0 +1,31 @@
package fr.louisdevie.tatsuki.builders;
class PartialComposedFlagDefinition<V> implements PartialFlagDefinition<V> {
public PartialComposedFlagDefinition() {
}
@Override
public void setAlias(String alias) {
throw new RuntimeException("Not implemented");
}
@Override
public void addParent(PartialFlagDefinition<V> parent) {
throw new RuntimeException("Not implemented");
}
@Override
public boolean isComposition() {
return false;
}
@Override
public String alias() {
return "";
}
@Override
public V value() {
return null;
}
}

13
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/builders/PartialFlagDefinition.java Normal file
View File

@@ -0,0 +1,13 @@
package fr.louisdevie.tatsuki.builders;
public interface PartialFlagDefinition<V> {
void setAlias(String alias);
void addParent(PartialFlagDefinition<V> parent);
boolean isComposition();
String alias();
V value();
}

38
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/builders/PartialValueFlagDefinition.java Normal file
View File

@@ -0,0 +1,38 @@
package fr.louisdevie.tatsuki.builders;
class PartialValueFlagDefinition<V> implements PartialFlagDefinition<V> {
private final V value;
private String alias;
public PartialValueFlagDefinition(V value) {
this.value = value;
}
@Override
public void setAlias(String alias) {
if (alias == null) {
throw new NullPointerException("null flag alias");
}
this.alias = alias;
}
@Override
public void addParent(PartialFlagDefinition<V> parent) {
throw new RuntimeException("Not implemented");
}
@Override
public boolean isComposition() {
return false;
}
@Override
public String alias() {
return this.alias;
}
@Override
public V value() {
return this.value;
}
}

7
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/builders/syntax/DefineOrComposeValues.java
View File

@@ -1,7 +1,7 @@
package fr.louisdevie.tatsuki.builders.syntax;
public interface DefineOrComposeValues<V, R> extends Root<R> {
public interface DefineOrComposeValues<V, R> {
/**
* Define a flag with the given value.
*
@@ -26,4 +26,9 @@ public interface DefineOrComposeValues<V, R> extends Root<R> {
*/
@SuppressWarnings("unchecked")
AsOrComposeValues<V, R> composeValues(V... values);
/**
* Build a flag set with the flags previously defined.
*/
R build();
}

12
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/builders/syntax/Root.java
View File

@@ -1,12 +0,0 @@
package fr.louisdevie.tatsuki.builders.syntax;
/**
* Builder syntax root.
* @param <R> The result type produced by the builder.
*/
public interface Root<R> {
/**
* Build a flag set with the flags previously defined.
*/
R build();
}

27
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/collections/CollectionFlagGraphBuilder.java
View File

@@ -1,27 +0,0 @@
package fr.louisdevie.tatsuki.collections;
import fr.louisdevie.tatsuki.builders.syntax.AsOrComposeValues;
import fr.louisdevie.tatsuki.builders.syntax.AsOrRequiresOrDefineOrComposeValues;
import fr.louisdevie.tatsuki.builders.syntax.DefineOrComposeValues;
class CollectionFlagGraphBuilder<E> implements DefineOrComposeValues<E, SetFlagGraph<E>> {
@Override
public AsOrRequiresOrDefineOrComposeValues<E, SetFlagGraph<E>> defineValue(E value) {
return null;
}
@Override
public AsOrComposeValues<E, SetFlagGraph<E>> compose(String... aliases) {
return null;
}
@Override
public AsOrComposeValues<E, SetFlagGraph<E>> composeValues(E... values) {
return null;
}
@Override
public SetFlagGraph<E> build() {
return null;
}
}

25
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/collections/SetFlagDefinition.java
View File

@@ -1,19 +1,32 @@
package fr.louisdevie.tatsuki.collections;
import fr.louisdevie.tatsuki.FlagDefinition;
import fr.louisdevie.tatsuki.builders.PartialFlagDefinition;
import java.util.Optional;
import java.util.Set;
class SetFlagDefinition<E> implements FlagDefinition<Set<E>> {
@Override
public Optional<String> getAlias() {
return Optional.empty();
class SetFlagDefinition<E> implements FlagDefinition<E, Set<E>> {
private final String alias;
private final E value;
private SetFlagDefinition(String alias, E value) {
this.alias = alias;
this.value = value;
}
public static <E> SetFlagDefinition<E> fromPartial(PartialFlagDefinition<E> partialFlagDefinition) {
return new SetFlagDefinition<>(partialFlagDefinition.alias(), partialFlagDefinition.value());
}
@Override
public Set<E> values() {
return Set.of();
public Optional<String> alias() {
return Optional.ofNullable(this.alias);
}
@Override
public Optional<E> value() {
return Optional.ofNullable(this.value);
}
@Override

79
java/tatsuki/src/main/java/fr/louisdevie/tatsuki/collections/SetFlagGraph.java
View File

@@ -1,71 +1,27 @@
package fr.louisdevie.tatsuki.collections;
import fr.louisdevie.tatsuki.FlagGraph;
import fr.louisdevie.tatsuki.builders.FlagSetBuilder;
import fr.louisdevie.tatsuki.builders.syntax.DefineOrComposeValues;
import fr.louisdevie.tatsuki.FlagDefinition;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.Set;
public class SetFlagGraph<E> implements FlagGraph<E, Set<E>> {
public static <E> DefineOrComposeValues<E, SetFlagGraph<E>> builder() {
return new CollectionFlagGraphBuilder<>();
}
import java.util.*;
import java.util.stream.Collectors;
public class SetFlagGraph<E> extends FlagGraph<E, Set<E>> {
SetFlagGraph(Collection<SetFlagDefinition<E>> c) {
super(c);
}
public static <E> DefineOrComposeValues<E, SetFlagGraph<E>> builder() {
return new Builder<>();
}
@Override
public int size() {
return 0;
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public boolean containsAlias(String alias) {
return false;
}
@Override
public boolean containsValue(E value) {
return false;
}
@Override
public boolean containsDefinition(FlagDefinition<Set<E>> definition) {
return false;
}
@Override
public Optional<FlagDefinition<Set<E>>> definitionNamed(String alias) {
return Optional.empty();
}
@Override
public Optional<FlagDefinition<Set<E>>> definitionOf(E value) {
return Optional.empty();
}
@Override
public Set<String> aliasSet() {
return Set.of();
}
@Override
public Set<E> valueSet() {
return Set.of();
}
@Override
public Collection<FlagDefinition<Set<E>>> definitions() {
return List.of();
@SuppressWarnings("unchecked")
public Set<E> of(E... values) {
return Arrays.stream(values)
.filter(this::containsValue)
.collect(Collectors.toUnmodifiableSet());
}
@Override
@@ -92,4 +48,13 @@ public class SetFlagGraph<E> implements FlagGraph<E, Set<E>> {
public Set<E> maximum(Set<E> flags) {
return Set.of();
}
static class Builder<E> extends FlagSetBuilder<E, SetFlagGraph<E>> {
@Override
public SetFlagGraph<E> build() {
this.finishCurrentDefinition();
var definitions = this.partialDefinitions().stream().map(SetFlagDefinition::fromPartial).toList();
return new SetFlagGraph<>(definitions);
}
}
}

146
java/tatsuki/src/test/java/fr/louisdevie/tatsuki/FlagGraphTests.java Normal file
View File

@@ -0,0 +1,146 @@
package fr.louisdevie.tatsuki;
import org.junit.jupiter.api.Test;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.*;
public class FlagGraphTests {
@Test
public void size() {
final var noFlags = new MockFlagGraph();
assertEquals(0, noFlags.size());
final var flags = new MockFlagGraph(
new MockFlagDefinition("A", "1"),
new MockFlagDefinition("B", null),
new MockFlagDefinition(null, "2")
);
assertEquals(3, flags.size());
}
@Test
public void isEmpty() {
final var noFlags = new MockFlagGraph();
assertTrue(noFlags.isEmpty());
final var flags = new MockFlagGraph(
new MockFlagDefinition("A", "x"),
new MockFlagDefinition("B", null),
new MockFlagDefinition(null, "y")
);
assertFalse(flags.isEmpty());
}
@Test
public void containsValue() {
final var flags = new MockFlagGraph(
new MockFlagDefinition("A", "x"),
new MockFlagDefinition("B", null),
new MockFlagDefinition(null, "y")
);
assertTrue(flags.containsValue("A"));
assertTrue(flags.containsValue("B"));
assertFalse(flags.containsValue("C"));
}
@Test
public void containsAlias() {
final var flags = new MockFlagGraph(
new MockFlagDefinition("A", "x"),
new MockFlagDefinition("B", null),
new MockFlagDefinition(null, "y")
);
assertTrue(flags.containsAlias("x"));
assertTrue(flags.containsAlias("y"));
assertFalse(flags.containsAlias("z"));
}
@Test
public void containsDefinition() {
final var inGraph = new MockFlagDefinition("A", "x");
final var notInGraph = new MockFlagDefinition("B", "y");
final var flags = new MockFlagGraph(inGraph);
assertTrue(flags.containsDefinition(inGraph));
assertFalse(flags.containsDefinition(notInGraph));
}
@Test
public void definitionOf() {
final var x = new MockFlagDefinition("A", "x");
final var y = new MockFlagDefinition("B", "y");
final var flags = new MockFlagGraph(x, y);
assertTrue(flags.definitionOf("A").isPresent());
assertSame(x, flags.definitionOf("A").get());
assertTrue(flags.definitionOf("B").isPresent());
assertSame(y, flags.definitionOf("B").get());
assertTrue(flags.definitionOf("C").isEmpty());
}
@Test
public void definitionNamed() {
final var x = new MockFlagDefinition("A", "x");
final var y = new MockFlagDefinition("B", "y");
final var flags = new MockFlagGraph(x, y);
assertTrue(flags.definitionNamed("x").isPresent());
assertSame(x, flags.definitionNamed("x").get());
assertTrue(flags.definitionNamed("y").isPresent());
assertSame(y, flags.definitionNamed("y").get());
assertTrue(flags.definitionNamed("z").isEmpty());
}
@Test
public void aliasSet() {
final var flags = new MockFlagGraph(
new MockFlagDefinition("A", "x"),
new MockFlagDefinition("B", null),
new MockFlagDefinition(null, "y")
);
assertEquals(Set.of("x", "y"), flags.aliasSet());
assertThrows(UnsupportedOperationException.class, () -> flags.aliasSet().remove("x"));
assertThrows(UnsupportedOperationException.class, () -> flags.aliasSet().add("z"));
}
@Test
public void valueSet() {
final var flags = new MockFlagGraph(
new MockFlagDefinition("A", "x"),
new MockFlagDefinition("B", null),
new MockFlagDefinition(null, "y")
);
assertEquals(Set.of("A", "B"), flags.valueSet());
assertThrows(UnsupportedOperationException.class, () -> flags.valueSet().remove("A"));
assertThrows(UnsupportedOperationException.class, () -> flags.valueSet().add("C"));
}
@Test
public void definitions() {
final var x = new MockFlagDefinition("A", "x");
final var B = new MockFlagDefinition("B", null);
final var y = new MockFlagDefinition(null, "y");
final var flags = new MockFlagGraph(x, B, y);
assertEquals(Set.of(x, B, y), flags.definitions());
assertThrows(UnsupportedOperationException.class, () -> flags.valueSet().remove("A"));
assertThrows(UnsupportedOperationException.class, () -> flags.valueSet().add("C"));
}
}

38
java/tatsuki/src/test/java/fr/louisdevie/tatsuki/MockFlagDefinition.java Normal file
View File

@@ -0,0 +1,38 @@
package fr.louisdevie.tatsuki;
import java.util.Optional;
public class MockFlagDefinition implements FlagDefinition<String, String> {
private final String value;
private final String alias;
public MockFlagDefinition(String value, String alias) {
this.value = value;
this.alias = alias;
}
@Override
public Optional<String> alias() {
return Optional.ofNullable(this.alias);
}
@Override
public Optional<String> value() {
return Optional.ofNullable(this.value);
}
@Override
public boolean isIn(String set) {
throw new UnsupportedOperationException();
}
@Override
public String addTo(String set) {
throw new UnsupportedOperationException();
}
@Override
public String removeFrom(String set) {
throw new UnsupportedOperationException();
}
}

40
java/tatsuki/src/test/java/fr/louisdevie/tatsuki/MockFlagGraph.java Normal file
View File

@@ -0,0 +1,40 @@
package fr.louisdevie.tatsuki;
import java.util.Arrays;
public class MockFlagGraph extends FlagGraph<String, String> {
@SafeVarargs
public MockFlagGraph(FlagDefinition<String, String>... definitions) {
super(Arrays.stream(definitions).toList());
}
@Override
public String of(String... values) {
throw new UnsupportedOperationException();
}
@Override
public String named(String... aliases) {
throw new UnsupportedOperationException();
}
@Override
public boolean hasAny(String flags, String required) {
throw new UnsupportedOperationException();
}
@Override
public boolean hasAll(String flags, String required) {
throw new UnsupportedOperationException();
}
@Override
public String minimum(String flags) {
throw new UnsupportedOperationException();
}
@Override
public String maximum(String flags) {
throw new UnsupportedOperationException();
}
}

45
java/tatsuki/src/test/java/fr/louisdevie/tatsuki/collections/CollectionFlagGraphTests.java → java/tatsuki/src/test/java/fr/louisdevie/tatsuki/collections/SetFlagGraphTests.java
View File

@@ -6,7 +6,20 @@ import java.util.Set;
import static org.junit.jupiter.api.Assertions.*;
public class CollectionFlagGraphTests {
public class SetFlagGraphTests {
@Test
public void of() {
final var flags = SetFlagGraph.<Integer>builder()
.defineValue(12).as("a")
.defineValue(45).as("b")
.defineValue(78).as("c")
.build();
assertEquals(Set.of(), flags.of());
assertEquals(Set.of(12), flags.of(12));
assertEquals(Set.of(12, 78), flags.of(12, 54, 78));
}
@Test
public void named() {
final var flags = SetFlagGraph.<Integer>builder()
@@ -16,9 +29,9 @@ public class CollectionFlagGraphTests {
.compose("a", "b").as("ab")
.build();
assertEquals(Set.of(), flags.named()) ;
assertEquals(Set.of(12), flags.named("a")) ;
assertEquals(Set.of(12, 45, 78), flags.named("ab", "c")) ;
assertEquals(Set.of(), flags.named());
assertEquals(Set.of(12), flags.named("a"));
assertEquals(Set.of(12, 45, 78), flags.named("ab", "c"));
}
@Test
@@ -59,11 +72,11 @@ public class CollectionFlagGraphTests {
.defineValue(78).requiresValues(45)
.build();
assertEquals(Set.of(), flags.maximum(Set.of())) ;
assertEquals(Set.of(12), flags.maximum(Set.of(12))) ;
assertEquals(Set.of(12, 45), flags.maximum(Set.of(45))) ;
assertEquals(Set.of(12, 45, 78), flags.maximum(Set.of(78))) ;
assertEquals(Set.of(), flags.maximum(Set.of(99))) ;
assertEquals(Set.of(), flags.maximum(Set.of()));
assertEquals(Set.of(12), flags.maximum(Set.of(12)));
assertEquals(Set.of(12, 45), flags.maximum(Set.of(45)));
assertEquals(Set.of(12, 45, 78), flags.maximum(Set.of(78)));
assertEquals(Set.of(), flags.maximum(Set.of(99)));
}
@Test
@@ -74,12 +87,12 @@ public class CollectionFlagGraphTests {
.defineValue(78).requiresValues(45)
.build();
assertEquals(Set.of(), flags.minimum(Set.of())) ;
assertEquals(Set.of(12), flags.minimum(Set.of(12))) ;
assertEquals(Set.of(), flags.minimum(Set.of(45))) ;
assertEquals(Set.of(12, 45), flags.minimum(Set.of(12, 45))) ;
assertEquals(Set.of(12), flags.minimum(Set.of(12, 78))) ;
assertEquals(Set.of(12, 45, 78), flags.minimum(Set.of(12, 45, 78))) ;
assertEquals(Set.of(), flags.minimum(Set.of(99))) ;
assertEquals(Set.of(), flags.minimum(Set.of()));
assertEquals(Set.of(12), flags.minimum(Set.of(12)));
assertEquals(Set.of(), flags.minimum(Set.of(45)));
assertEquals(Set.of(12, 45), flags.minimum(Set.of(12, 45)));
assertEquals(Set.of(12), flags.minimum(Set.of(12, 78)));
assertEquals(Set.of(12, 45, 78), flags.minimum(Set.of(12, 45, 78)));
assertEquals(Set.of(), flags.minimum(Set.of(99)));
}
}