From 38f1e562bf1e1d9d2c837317fced7467f2e81adc Mon Sep 17 00:00:00 2001 From: Ben Culkin Date: Thu, 3 Dec 2020 19:24:23 -0500 Subject: Rename interfaces to match Java style Renames several interfaces named in the IWhatever style, which Java doesn't use --- dice/src/main/java/bjc/dicelang/neodice/Die.java | 96 +++++++++ .../main/java/bjc/dicelang/neodice/DiePool.java | 222 +++++++++++++++++++++ dice/src/main/java/bjc/dicelang/neodice/IDie.java | 96 --------- .../main/java/bjc/dicelang/neodice/IDiePool.java | 222 --------------------- .../bjc/dicelang/neodice/die/PolyhedralDie.java | 2 +- .../java/bjc/dicelang/neodice/die/RerollDie.java | 24 +-- .../dicelang/neodice/diepool/ExpandDiePool.java | 10 +- .../bjc/dicelang/neodice/diepool/FixedDiePool.java | 14 +- .../bjc/dicelang/neodice/diepool/TimesDiePool.java | 10 +- .../dicelang/neodice/diepool/TransformDiePool.java | 8 +- 10 files changed, 352 insertions(+), 352 deletions(-) create mode 100644 dice/src/main/java/bjc/dicelang/neodice/Die.java create mode 100644 dice/src/main/java/bjc/dicelang/neodice/DiePool.java delete mode 100644 dice/src/main/java/bjc/dicelang/neodice/IDie.java delete mode 100644 dice/src/main/java/bjc/dicelang/neodice/IDiePool.java (limited to 'dice/src/main/java/bjc/dicelang/neodice') diff --git a/dice/src/main/java/bjc/dicelang/neodice/Die.java b/dice/src/main/java/bjc/dicelang/neodice/Die.java new file mode 100644 index 0000000..910d173 --- /dev/null +++ b/dice/src/main/java/bjc/dicelang/neodice/Die.java @@ -0,0 +1,96 @@ +package bjc.dicelang.neodice; + +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import bjc.dicelang.neodice.die.*; +import bjc.dicelang.neodice.diepool.*; + +/** + * Represents a single polyhedral die. + * @author Ben Culkin + * + */ +@FunctionalInterface +public interface Die { + /** + * Rolls this die. + * + * @param rng The source for random numbers + * + * @return The result of rolling the die. + */ + public SideType roll(Random rng); + + /** + * Returns a die pool which rolls this die the specified number of times. + * + * @param numTimes The number of times to roll this die. + * + * @return A die pool that rolls this die the specified number of times. + */ + default DiePool times(int numTimes) { + return new ExpandDiePool<>(this, (die, rng) -> { + return Stream.generate(() -> die.roll(rng)) + .limit(numTimes); + }); + }; + + /** + * Returns a die which will reroll this die as long as the provided condition is true. + * + * @param condition The condition to reroll the die on. + * + * @return A die that rerolls when the given condition is met. + */ + default Die reroll( + Comparator comparer, + Predicate condition) { + return RerollDie.create(comparer, this, condition, + (list) -> list.get(list.size())); + } + + /** + * Returns a die which will reroll this die up to a specified number of times, + * as long as the provided condition is true. + * + * @param condition The condition to reroll the die on. + * @param limit The maximum number of times to reroll the die. + * + * @return A die that rerolls when the given condition is met. + */ + default Die reroll( + Comparator comparer, + Predicate condition, + int limit) { + return RerollDie.create(comparer, this, condition, + (list) -> list.get(list.size()), limit); + } + + /** + * Create an stream which gives rolls of this dice. + * + * @param rng The source for random numbers. + * + * @return An iterator which gives rolls of this dice. + */ + default Stream stream(Random rng) { + return Stream.generate(() -> this.roll(rng)); + } + + default Die transform(Function mapper) { + return (rng) -> mapper.apply(this.roll(rng)); + } + + /** + * Create a simple polyhedral die with a fixed number of sides. + * + * @param sides The number of sides for the die. + * + * @return A die which returns a result from 1 to sides. + */ + static Die polyhedral(int sides) { + return new PolyhedralDie(sides); + } +} \ No newline at end of file diff --git a/dice/src/main/java/bjc/dicelang/neodice/DiePool.java b/dice/src/main/java/bjc/dicelang/neodice/DiePool.java new file mode 100644 index 0000000..e3a5782 --- /dev/null +++ b/dice/src/main/java/bjc/dicelang/neodice/DiePool.java @@ -0,0 +1,222 @@ +package bjc.dicelang.neodice; + +import java.util.*; +import java.util.function.*; +import java.util.stream.*; + +import bjc.dicelang.neodice.diepool.*; + +/** + * Represents a pool of dice. + * + * @author Ben Culkin + * + */ +@FunctionalInterface +public interface DiePool { + /** + * Roll each die in the pool, and return the results. + * + * Note that this list is not guaranteed to be the same size every time it + * is rolled, because there are some pool types that could add/remove dice. + * + * @param rng The source for random numbers + * + * @return The result of rolling each die in the pool. + */ + public Stream roll(Random rng); + + /** + * Gets the dice contained in this pool. + * + * Note that the length of this list may not be the same as the length of + * the list returned by roll, because certain pool types may add additional + * dice. + * + * Also note that this list (and the Die instances contained in it) should + * not be modified. That may work for certain pool types, but it isn't + * guaranteed to work, and can lead to unintuitive behavior. For instances, + * certain pool types may return an list where multiple elements of it refer + * to the same Die instance. + * + * The default implementation throws an UnsupportedOperationException. + * + * @return The dice contained in this pool. + * + * @throws UnsupportedOperationException If the composite dice can't be retrieved. + */ + default List> contained() { + throw new UnsupportedOperationException("Can't get composite dice"); + } + + /* + * These die pool operations transform this pool in some way. + */ + + /** + * Returns a version of this die pool which returns its results in sorted + * order. + * + * @param isDescending True to sort in descending order, false to sort in ascending order. + * + * @return The die pool, which returns its results in sorted order. + */ + default DiePool sorted( + Comparator comparer, + boolean isDescending) { + return new TransformDiePool<>(this, + (pool) -> pool.sorted( + isDescending + ? comparer.reversed() + : comparer)); + } + + /** + * Return a die pool which rolls this one, then filters out any results that + * don't match the provided predicate. + * + * @param matcher The predicate that determines + * + * @return A die pool which contains only entries that pass the predicate. + */ + default DiePool filtered(Predicate matcher) { + return new TransformDiePool<>(this, + (pool) -> pool.filter(matcher)); + } + + /** + * Return a die pool which rolls this one, then drops a number of the first values. + * + * @param number The number of first values to drop. + * + * @return A die pool which has the first entries dropped. + */ + default DiePool dropFirst(int number) { + return new TransformDiePool<>(this, + (pool) -> pool.skip(number)); + } + + /** + * Return a die pool which rolls this one, then drops a number of the last values. + * + * @param number The number of last values to drop. + * + * @return A die pool which has the last entries dropped. + */ + default DiePool dropLast(int number) { + return new TransformDiePool<>(this, (pool) -> { + Deque temp = new ArrayDeque<>(); + + pool.forEachOrdered((die) -> temp.add(die)); + + for (int i = 0; i < number; i++) temp.pollLast(); + + return temp.stream(); + }); + } + + /** + * Return a die pool which rolls this one, then keeps a number of the first values. + * + * @param number The number of first values to keep. + * + * @return A die pool which has the first entries kept. + */ + default DiePool keepFirst(int number) { + return new TransformDiePool<>(this, + (pool) -> pool.limit(number)); + } + + /** + * Return a die pool which rolls this one, then keeps a number of the last values. + * + * @param number The number of last values to keep. + * + * @return A die pool which has the last entries kept. + */ + default DiePool keepLast(int number) { + return new TransformDiePool<>(this, (pool) -> { + Deque temp = new ArrayDeque<>(); + + pool.forEachOrdered((die) -> temp.add(die)); + + while (temp.size() > number) temp.pollFirst(); + + return temp.stream(); + }); + } + + /* + * These die-pool operations are formed exclusively through other die pool + * operations. + */ + + /** + * Return a die pool which rolls this one, then drops a number of the lowest values. + * + * @param number The number of lowest values to drop. + * + * @return A die pool which has the lowest entries dropped. + */ + default DiePool dropLowest(Comparator comparer, int number) { + return this.sorted(comparer, false).dropFirst(number); + } + + /** + * Return a die pool which rolls this one, then drops a number of the lowest values. + * + * @param number The number of lowest values to drop. + * + * @return A die pool which has the lowest entries dropped. + */ + default DiePool dropHighest(Comparator comparer,int number) { + return this.sorted(comparer, false).dropLast(number); + } + + /** + * Return a die pool which rolls this one, then keeps a number of the lowest values. + * + * @param number The number of lowest values to keep. + * + * @return A die pool which has the lowest entries kept. + */ + default DiePool keepLowest(Comparator comparer,int number) { + return this.sorted(comparer, false).keepFirst(number); + } + + /** + * Return a die pool which rolls this one, then keeps a number of the highest values. + * + * @param number The number of highest values to keep. + * + * @return A die pool which has the highest entries kept. + */ + default DiePool keepHighest(Comparator comparer,int number) { + return this.sorted(comparer, false).keepLast(number); + } + + /* These are misc. operations that don't form new dice pools. */ + + /** + * Get an iterator which iterates over a single roll of this die pool. + * + * @param rng The source of random numbers. + * + * @return An iterator over a single roll of this die pool. + */ + default Iterator iterator(Random rng) { + return this.roll(rng).iterator(); + } + + /** + * Create a die pool containing the provided dice. + * + * @param dice The dice to put into the pool. + * + * @return A pool which contains the provided dice. + */ + @SafeVarargs + static DiePool containing(Die... dice) { + return new FixedDiePool<>(dice); + } +} \ No newline at end of file diff --git a/dice/src/main/java/bjc/dicelang/neodice/IDie.java b/dice/src/main/java/bjc/dicelang/neodice/IDie.java deleted file mode 100644 index 274af66..0000000 --- a/dice/src/main/java/bjc/dicelang/neodice/IDie.java +++ /dev/null @@ -1,96 +0,0 @@ -package bjc.dicelang.neodice; - -import java.util.*; -import java.util.function.*; -import java.util.stream.*; - -import bjc.dicelang.neodice.die.*; -import bjc.dicelang.neodice.diepool.*; - -/** - * Represents a single polyhedral die. - * @author Ben Culkin - * - */ -@FunctionalInterface -public interface IDie { - /** - * Rolls this die. - * - * @param rng The source for random numbers - * - * @return The result of rolling the die. - */ - public SideType roll(Random rng); - - /** - * Returns a die pool which rolls this die the specified number of times. - * - * @param numTimes The number of times to roll this die. - * - * @return A die pool that rolls this die the specified number of times. - */ - default IDiePool times(int numTimes) { - return new ExpandDiePool<>(this, (die, rng) -> { - return Stream.generate(() -> die.roll(rng)) - .limit(numTimes); - }); - }; - - /** - * Returns a die which will reroll this die as long as the provided condition is true. - * - * @param condition The condition to reroll the die on. - * - * @return A die that rerolls when the given condition is met. - */ - default IDie reroll( - Comparator comparer, - Predicate condition) { - return RerollDie.create(comparer, this, condition, - (list) -> list.get(list.size())); - } - - /** - * Returns a die which will reroll this die up to a specified number of times, - * as long as the provided condition is true. - * - * @param condition The condition to reroll the die on. - * @param limit The maximum number of times to reroll the die. - * - * @return A die that rerolls when the given condition is met. - */ - default IDie reroll( - Comparator comparer, - Predicate condition, - int limit) { - return RerollDie.create(comparer, this, condition, - (list) -> list.get(list.size()), limit); - } - - /** - * Create an stream which gives rolls of this dice. - * - * @param rng The source for random numbers. - * - * @return An iterator which gives rolls of this dice. - */ - default Stream stream(Random rng) { - return Stream.generate(() -> this.roll(rng)); - } - - default IDie transform(Function mapper) { - return (rng) -> mapper.apply(this.roll(rng)); - } - - /** - * Create a simple polyhedral die with a fixed number of sides. - * - * @param sides The number of sides for the die. - * - * @return A die which returns a result from 1 to sides. - */ - static IDie polyhedral(int sides) { - return new PolyhedralDie(sides); - } -} \ No newline at end of file diff --git a/dice/src/main/java/bjc/dicelang/neodice/IDiePool.java b/dice/src/main/java/bjc/dicelang/neodice/IDiePool.java deleted file mode 100644 index b887784..0000000 --- a/dice/src/main/java/bjc/dicelang/neodice/IDiePool.java +++ /dev/null @@ -1,222 +0,0 @@ -package bjc.dicelang.neodice; - -import java.util.*; -import java.util.function.*; -import java.util.stream.*; - -import bjc.dicelang.neodice.diepool.*; - -/** - * Represents a pool of dice. - * - * @author Ben Culkin - * - */ -@FunctionalInterface -public interface IDiePool { - /** - * Roll each die in the pool, and return the results. - * - * Note that this list is not guaranteed to be the same size every time it - * is rolled, because there are some pool types that could add/remove dice. - * - * @param rng The source for random numbers - * - * @return The result of rolling each die in the pool. - */ - public Stream roll(Random rng); - - /** - * Gets the dice contained in this pool. - * - * Note that the length of this list may not be the same as the length of - * the list returned by roll, because certain pool types may add additional - * dice. - * - * Also note that this list (and the Die instances contained in it) should - * not be modified. That may work for certain pool types, but it isn't - * guaranteed to work, and can lead to unintuitive behavior. For instances, - * certain pool types may return an list where multiple elements of it refer - * to the same Die instance. - * - * The default implementation throws an UnsupportedOperationException. - * - * @return The dice contained in this pool. - * - * @throws UnsupportedOperationException If the composite dice can't be retrieved. - */ - default List> contained() { - throw new UnsupportedOperationException("Can't get composite dice"); - } - - /* - * These die pool operations transform this pool in some way. - */ - - /** - * Returns a version of this die pool which returns its results in sorted - * order. - * - * @param isDescending True to sort in descending order, false to sort in ascending order. - * - * @return The die pool, which returns its results in sorted order. - */ - default IDiePool sorted( - Comparator comparer, - boolean isDescending) { - return new TransformDiePool<>(this, - (pool) -> pool.sorted( - isDescending - ? comparer.reversed() - : comparer)); - } - - /** - * Return a die pool which rolls this one, then filters out any results that - * don't match the provided predicate. - * - * @param matcher The predicate that determines - * - * @return A die pool which contains only entries that pass the predicate. - */ - default IDiePool filtered(Predicate matcher) { - return new TransformDiePool<>(this, - (pool) -> pool.filter(matcher)); - } - - /** - * Return a die pool which rolls this one, then drops a number of the first values. - * - * @param number The number of first values to drop. - * - * @return A die pool which has the first entries dropped. - */ - default IDiePool dropFirst(int number) { - return new TransformDiePool<>(this, - (pool) -> pool.skip(number)); - } - - /** - * Return a die pool which rolls this one, then drops a number of the last values. - * - * @param number The number of last values to drop. - * - * @return A die pool which has the last entries dropped. - */ - default IDiePool dropLast(int number) { - return new TransformDiePool<>(this, (pool) -> { - Deque temp = new ArrayDeque<>(); - - pool.forEachOrdered((die) -> temp.add(die)); - - for (int i = 0; i < number; i++) temp.pollLast(); - - return temp.stream(); - }); - } - - /** - * Return a die pool which rolls this one, then keeps a number of the first values. - * - * @param number The number of first values to keep. - * - * @return A die pool which has the first entries kept. - */ - default IDiePool keepFirst(int number) { - return new TransformDiePool<>(this, - (pool) -> pool.limit(number)); - } - - /** - * Return a die pool which rolls this one, then keeps a number of the last values. - * - * @param number The number of last values to keep. - * - * @return A die pool which has the last entries kept. - */ - default IDiePool keepLast(int number) { - return new TransformDiePool<>(this, (pool) -> { - Deque temp = new ArrayDeque<>(); - - pool.forEachOrdered((die) -> temp.add(die)); - - while (temp.size() > number) temp.pollFirst(); - - return temp.stream(); - }); - } - - /* - * These die-pool operations are formed exclusively through other die pool - * operations. - */ - - /** - * Return a die pool which rolls this one, then drops a number of the lowest values. - * - * @param number The number of lowest values to drop. - * - * @return A die pool which has the lowest entries dropped. - */ - default IDiePool dropLowest(Comparator comparer, int number) { - return this.sorted(comparer, false).dropFirst(number); - } - - /** - * Return a die pool which rolls this one, then drops a number of the lowest values. - * - * @param number The number of lowest values to drop. - * - * @return A die pool which has the lowest entries dropped. - */ - default IDiePool dropHighest(Comparator comparer,int number) { - return this.sorted(comparer, false).dropLast(number); - } - - /** - * Return a die pool which rolls this one, then keeps a number of the lowest values. - * - * @param number The number of lowest values to keep. - * - * @return A die pool which has the lowest entries kept. - */ - default IDiePool keepLowest(Comparator comparer,int number) { - return this.sorted(comparer, false).keepFirst(number); - } - - /** - * Return a die pool which rolls this one, then keeps a number of the highest values. - * - * @param number The number of highest values to keep. - * - * @return A die pool which has the highest entries kept. - */ - default IDiePool keepHighest(Comparator comparer,int number) { - return this.sorted(comparer, false).keepLast(number); - } - - /* These are misc. operations that don't form new dice pools. */ - - /** - * Get an iterator which iterates over a single roll of this die pool. - * - * @param rng The source of random numbers. - * - * @return An iterator over a single roll of this die pool. - */ - default Iterator iterator(Random rng) { - return this.roll(rng).iterator(); - } - - /** - * Create a die pool containing the provided dice. - * - * @param dice The dice to put into the pool. - * - * @return A pool which contains the provided dice. - */ - @SafeVarargs - static IDiePool containing(IDie... dice) { - return new FixedDiePool<>(dice); - } -} \ No newline at end of file diff --git a/dice/src/main/java/bjc/dicelang/neodice/die/PolyhedralDie.java b/dice/src/main/java/bjc/dicelang/neodice/die/PolyhedralDie.java index 2909724..07ab183 100644 --- a/dice/src/main/java/bjc/dicelang/neodice/die/PolyhedralDie.java +++ b/dice/src/main/java/bjc/dicelang/neodice/die/PolyhedralDie.java @@ -4,7 +4,7 @@ import java.util.*; import bjc.dicelang.neodice.*; -public class PolyhedralDie implements IDie { +public class PolyhedralDie implements Die { private final int sides; public PolyhedralDie(int sides) { diff --git a/dice/src/main/java/bjc/dicelang/neodice/die/RerollDie.java b/dice/src/main/java/bjc/dicelang/neodice/die/RerollDie.java index f8cb0fa..7925c9d 100644 --- a/dice/src/main/java/bjc/dicelang/neodice/die/RerollDie.java +++ b/dice/src/main/java/bjc/dicelang/neodice/die/RerollDie.java @@ -6,8 +6,8 @@ import java.util.function.*; import bjc.dicelang.neodice.*; import bjc.esodata.*; -public class RerollDie implements IDie { - private final IDie contained; +public class RerollDie implements Die { + private final Die contained; private final Predicate condition; private final Function, SideType> chooser; @@ -18,7 +18,7 @@ public class RerollDie implements IDie { private RerollDie( Comparator comparer, - IDie contained, + Die contained, Predicate condition, Function, SideType> chooser) { this.comparer = comparer; @@ -31,7 +31,7 @@ public class RerollDie implements IDie { private RerollDie( Comparator comparer, - IDie contained, + Die contained, Predicate condition, Function, SideType> chooser, int limit) { @@ -57,15 +57,15 @@ public class RerollDie implements IDie { return chooser.apply(newRolls); } - public static > IDie create( - IDie contained, + public static > Die create( + Die contained, Predicate condition, Function, Side> chooser) { return new RerollDie<>(Comparator.naturalOrder(), contained, condition, chooser); } - public static > IDie create( - IDie contained, + public static > Die create( + Die contained, Predicate condition, Function, Side> chooser, int limit) { @@ -73,17 +73,17 @@ public class RerollDie implements IDie { } - public static IDie create( + public static Die create( Comparator comparer, - IDie contained, + Die contained, Predicate condition, Function, Side> chooser) { return new RerollDie(comparer, contained, condition, chooser); } - public static IDie create( + public static Die create( Comparator comparer, - IDie contained, + Die contained, Predicate condition, Function, Side> chooser, int limit) { diff --git a/dice/src/main/java/bjc/dicelang/neodice/diepool/ExpandDiePool.java b/dice/src/main/java/bjc/dicelang/neodice/diepool/ExpandDiePool.java index 7c58e72..97acc79 100644 --- a/dice/src/main/java/bjc/dicelang/neodice/diepool/ExpandDiePool.java +++ b/dice/src/main/java/bjc/dicelang/neodice/diepool/ExpandDiePool.java @@ -6,13 +6,13 @@ import java.util.stream.*; import bjc.dicelang.neodice.*; -public class ExpandDiePool implements IDiePool { - private final IDie contained; +public class ExpandDiePool implements DiePool { + private final Die contained; - private final BiFunction, Random, Stream> expander; + private final BiFunction, Random, Stream> expander; - public ExpandDiePool(IDie contained, - BiFunction, Random, Stream> expander) { + public ExpandDiePool(Die contained, + BiFunction, Random, Stream> expander) { this.contained = contained; this.expander = expander; } diff --git a/dice/src/main/java/bjc/dicelang/neodice/diepool/FixedDiePool.java b/dice/src/main/java/bjc/dicelang/neodice/diepool/FixedDiePool.java index a536f62..4950407 100644 --- a/dice/src/main/java/bjc/dicelang/neodice/diepool/FixedDiePool.java +++ b/dice/src/main/java/bjc/dicelang/neodice/diepool/FixedDiePool.java @@ -5,17 +5,17 @@ import java.util.stream.*; import bjc.dicelang.neodice.*; -public class FixedDiePool implements IDiePool { - private final List> dice; +public class FixedDiePool implements DiePool { + private final List> dice; - public FixedDiePool(List> dice) { + public FixedDiePool(List> dice) { this.dice = dice; } @SafeVarargs - public FixedDiePool(IDie...dice) { + public FixedDiePool(Die...dice) { this.dice = new ArrayList<>(dice.length); - for (IDie die : dice) { + for (Die die : dice) { this.dice.add(die); } } @@ -26,7 +26,7 @@ public class FixedDiePool implements IDiePool { } @Override - public List> contained() { + public List> contained() { return dice; } @@ -34,7 +34,7 @@ public class FixedDiePool implements IDiePool { @Override public String toString() { return dice.stream() - .map(IDie::toString) + .map(Die::toString) .collect(Collectors.joining(", ")); } diff --git a/dice/src/main/java/bjc/dicelang/neodice/diepool/TimesDiePool.java b/dice/src/main/java/bjc/dicelang/neodice/diepool/TimesDiePool.java index 56fe0e5..e039e47 100644 --- a/dice/src/main/java/bjc/dicelang/neodice/diepool/TimesDiePool.java +++ b/dice/src/main/java/bjc/dicelang/neodice/diepool/TimesDiePool.java @@ -5,11 +5,11 @@ import java.util.stream.*; import bjc.dicelang.neodice.*; -public class TimesDiePool implements IDiePool { - private final IDie contained; +public class TimesDiePool implements DiePool { + private final Die contained; private final int numDice; - public TimesDiePool(IDie contained, int numDice) { + public TimesDiePool(Die contained, int numDice) { this.contained = contained; this.numDice = numDice; } @@ -21,8 +21,8 @@ public class TimesDiePool implements IDiePool { } @Override - public List> contained() { - List> results = new ArrayList<>(numDice); + public List> contained() { + List> results = new ArrayList<>(numDice); for (int index = 0; index < numDice; index++) { results.add(contained); diff --git a/dice/src/main/java/bjc/dicelang/neodice/diepool/TransformDiePool.java b/dice/src/main/java/bjc/dicelang/neodice/diepool/TransformDiePool.java index f590e91..80b563f 100644 --- a/dice/src/main/java/bjc/dicelang/neodice/diepool/TransformDiePool.java +++ b/dice/src/main/java/bjc/dicelang/neodice/diepool/TransformDiePool.java @@ -6,12 +6,12 @@ import java.util.stream.*; import bjc.dicelang.neodice.*; -public class TransformDiePool implements IDiePool { - private final IDiePool contained; +public class TransformDiePool implements DiePool { + private final DiePool contained; private UnaryOperator> transform; - public TransformDiePool(IDiePool contained, + public TransformDiePool(DiePool contained, UnaryOperator> transform) { super(); this.contained = contained; @@ -24,7 +24,7 @@ public class TransformDiePool implements IDiePool { } @Override - public List> contained() { + public List> contained() { return contained.contained(); } -- cgit v1.2.3