/**
* Creates a Tree of the given elements.
*
* @param <T> Component type of the List.
* @param values Zero or more values.
* @return A Tree containing the given values.
* @throws NullPointerException if {@code values} is null
*/
@SuppressWarnings("varargs")
@SafeVarargs
static <T> Tree<T> of(T... values) {
Objects.requireNonNull(values, "values is null");
List<T> list = List.of(values);
return list.isEmpty() ? Empty.instance() : new Node<>(list.head(), list.tail().map(Tree::of));
}
/**
* Creates a Tree of the given elements.
*
* <p>If the given iterable is a tree, it is returned as result. if the iteration order of the
* elements is stable.
*
* @param <T> Component type of the List.
* @param iterable An Iterable of elements.
* @return A list containing the given elements in the same order.
* @throws NullPointerException if {@code elements} is null
*/
@SuppressWarnings("unchecked")
static <T> Tree<T> ofAll(Iterable<? extends T> iterable) {
Objects.requireNonNull(iterable, "iterable is null");
if (iterable instanceof Tree) {
return (Tree<T>) iterable;
} else {
final List<T> list = List.ofAll(iterable);
return list.isEmpty() ? Empty.instance() : new Node<>(list.head(), list.tail().map(Tree::of));
}
}
@Override
protected PriorityQueue<Byte> ofAll(byte[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
protected PriorityQueue<Character> ofAll(char[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
protected PriorityQueue<Double> ofAll(double[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
protected PriorityQueue<Float> ofAll(float[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
protected PriorityQueue<Integer> ofAll(int[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
public <U> Array<U> scanRight(U zero, BiFunction<? super T, ? super U, ? extends U> operation) {
Objects.requireNonNull(operation, "operation is null");
return Collections.scanRight(
this, zero, operation, List.empty(), List::prepend, list -> Array.wrap(list.toJavaArray()));
}
@Override
protected PriorityQueue<Long> ofAll(long[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
protected PriorityQueue<Short> ofAll(short[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
default <U> Seq<U> scanRight(U zero, BiFunction<? super T, ? super U, ? extends U> operation) {
Objects.requireNonNull(operation, "operation is null");
return Collections.scanRight(
this, zero, operation, List.empty(), List::prepend, Function.identity());
}
/**
* Returns a new Node containing the given value and having no children.
*
* @param value A value
* @param <T> Value type
* @return A new Node instance.
*/
static <T> Node<T> of(T value) {
return new Node<>(value, List.empty());
}
@Override
protected PriorityQueue<Boolean> ofAll(boolean[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
/**
* Returns a new Node containing the given value and having the given children.
*
* @param value A value
* @param children The child nodes, possibly empty
* @param <T> Value type
* @return A new Node instance.
*/
static <T> Node<T> of(T value, Iterable<Node<T>> children) {
Objects.requireNonNull(children, "children is null");
return new Node<>(value, List.ofAll(children));
}
public void clearMessages() {
messages.clear();
getRootStyleNode().removeChildrenAll();
rootMessageStyleNodes.clear();
endMarginNode = null;
newMessageSeparatorNode = null;
}
public List<AnalyzedMessage> getMessages(int offset, int length) {
List<AnalyzedMessage> list = new ArrayList<>();
for (int i = 0; i < rootMessageStyleNodes.size(); i++) {
StyleNode node = rootMessageStyleNodes.get(i);
if (JUtils.intersects(offset, length, node.getOffset(), node.getLength())) {
list.add(messages.get(i));
}
}
return list;
}
protected Supplier<List<Person>> scrumMasterSupplier() {
return () -> {
Skill smSkill = organisationProperty().get().getSmSkill();
Person currentProductOwner = productOwnerProperty().get();
List<Person> currentDevTeam = devTeamProperty().get();
// person has sm skill and does not currently have any other role in the team
return teamMembersProperty()
.get()
.stream()
.filter(
person ->
person.observableSkills().contains(smSkill)
&& !person.equals(currentProductOwner)
&& !currentDevTeam.contains(person))
.collect(Collectors.toList());
};
}
@Override
public void setTypeVariables(List<TypeVariable> typeVariables) {
declaration.setTypeParameters(
typeVariables
.stream()
.map(getContext()::unresolveTypeVariable)
.collect(Collectors.toList()));
}
public void allRayIntersections(Vec raypt, Vec rayNormalizedDir, Consumer<Tp> cons) {
if (!intersectsWithRay(raypt, rayNormalizedDir)) return;
container.forEach(cons);
forAllSubtree(
(i, j, k) -> {
if (subtree[i][j][k] != null)
subtree[i][j][k].allRayIntersections(raypt, rayNormalizedDir, cons);
});
}
static void graphsToFile(List<Triplet<FooGraph, List<Integer>, FooGraph>> l, String name) {
try {
PrintWriter writer = new PrintWriter(name, "UTF-8");
writer.println("graph G {");
int offset = 0;
for (Triplet<FooGraph, List<Integer>, FooGraph> t : l) {
FooGraph g = t.getValue0();
List<Integer> markedNodes = t.getValue1();
FooGraph markedEdges = t.getValue2();
for (int i = 0; i < g.numVertices(); i++) {
String vertex = "" + (offset + i);
if (markedNodes != null && markedNodes.contains(i)) {
vertex += " [fillcolor = red, style=filled]";
}
writer.println(vertex);
}
for (int i = 0; i < g.numVertices(); i++) {
for (int j = i + 1; j < g.numVertices(); j++) {
if (g.adj[i][j]) {
String edge = (offset + i) + " -- " + (offset + j);
if (markedEdges != null && markedEdges.adj[i][j]) {
edge += " [color = red, penwidth=6.0]";
}
writer.println(edge);
}
}
}
writer.println("");
offset += g.numVertices();
}
writer.println("}");
writer.close();
} catch (IOException e) {
System.err.println("Caught IOException: " + e.getMessage());
}
}
public void add(Tp obj, int maxDepth) {
if (!in(0, 0, 0, 2, obj)) throw new RuntimeException("Object is out of octree");
if (maxDepth != 0) {
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k)
if (in(i, j, k, 1, obj)) {
if (subtree[i][j][k] == null)
subtree[i][j][k] = new Octree(xc[i], xc[i + 1], yc[j], yc[j + 1], zc[k], zc[k + 1]);
subtree[i][j][k].add(obj, maxDepth - 1);
return;
}
}
// Gstate.counter++;
container.add(obj);
// System.out.println("gstate counter:" + Gstate.counter);
}
@Override
@SuppressWarnings("unchecked")
protected final <T> PriorityQueue<T> of(T... elements) {
return PriorityQueue.ofAll(toStringComparator(), List.of(elements));
}
/**
* Returns a new Node containing the given value and having the given children.
*
* @param value A value
* @param children The child nodes, possibly empty
* @param <T> Value type
* @return A new Node instance.
*/
@SuppressWarnings("varargs")
@SafeVarargs
static <T> Node<T> of(T value, Node<T>... children) {
Objects.requireNonNull(children, "children is null");
return new Node<>(value, List.of(children));
}
public void appendMessages(List<AnalyzedMessage> newMessages) {
if (newMessages.size() == 0) return;
List<AnalyzedMessage> oldMessages = new ArrayList<>(messages);
if (messageFilter != null) newMessages = CUtils.filter(newMessages, messageFilter);
messages.addAll(newMessages);
List<StyleNode> msgNodes =
CUtils.map(
newMessages,
m -> {
StyleNode n = builder.buildMessage(m);
n.updateTree(NStyleUtils.getTemplateManager());
return n;
});
rootMessageStyleNodes.addAll(msgNodes);
List<StyleNode> appendNodes = new ArrayList<>();
List<StyleNode> removeNodes = new ArrayList<>();
if (oldMessages.size() > 0) {
appendNodes.add(builder.buildTemplate("message_separator"));
if (newMessages.size() > 0) {
if (newMessageSeparatorNode != null) removeNodes.add(newMessageSeparatorNode);
newMessageSeparatorNode = builder.buildTemplate("new_message_separator");
if (newMessageSeparatorNode != null) appendNodes.add(newMessageSeparatorNode);
}
}
for (int i = 0; i < msgNodes.size(); i++) {
StyleNode n = msgNodes.get(i);
appendNodes.add(n);
if (i < msgNodes.size() - 1) appendNodes.add(builder.buildTemplate("message_separator"));
}
if (endMarginTemplateId != null) {
if (endMarginNode != null) removeNodes.add(endMarginNode);
endMarginNode = builder.buildTemplate(endMarginTemplateId);
appendNodes.add(endMarginNode);
}
runWithNoRedraw(
() -> {
CUtils.forEach(removeNodes, node -> node.getParent().removeChild(node));
getRootStyleNode().addChildAll(appendNodes);
try {
getRootStyleNode().updateTree(NStyleUtils.getTemplateManager());
} catch (RuntimeException e) {
DialogUtils.openError(null, "Script error", e.toString());
}
});
}
public TeamViewModel() {
createValidators();
ListProperty<Person> peopleInOrganisation = new SimpleListProperty<>();
peopleInOrganisation.bind(
Bindings.createObjectBinding(
() -> {
if (organisationProperty().get() != null) {
return organisationProperty().get().getPeople();
} else {
return FXCollections.observableArrayList();
}
},
organisationProperty()));
ListProperty<Team> teamsInOrganisation = new SimpleListProperty<>();
teamsInOrganisation.bind(
Bindings.createObjectBinding(
() -> {
if (organisationProperty().get() != null) {
return organisationProperty().get().getTeams();
} else {
return FXCollections.observableArrayList();
}
},
organisationProperty()));
ListProperty<Person> peopleInTeams = new SimpleListProperty<>();
peopleInTeams.bind(
Bindings.createObjectBinding(
() -> {
return teamsInOrganisation
.stream()
.flatMap(team -> team.observableTeamMembers().stream()) // TODO listen
.collect(GoatCollectors.toObservableList());
},
teamsInOrganisation));
eligibleTeamMembers = new SimpleListProperty<>();
eligibleTeamMembers.bind(
Bindings.createObjectBinding(
() -> {
return peopleInOrganisation
.stream()
.filter(
person ->
!peopleInTeams.contains(person) // no team in model
|| person.getTeam() == modelWrapper.get()) // this team in model
.collect(GoatCollectors.toObservableList());
},
peopleInOrganisation,
peopleInTeams));
eligibleDevs = new SimpleListProperty<>();
eligibleDevs.bind(
Bindings.createObjectBinding(
() -> {
return teamMembersProperty()
.get()
.stream() // is in team
.filter(
person ->
!person.equals(productOwnerProperty().get()) // not PO
&& !person.equals(scrumMasterProperty().get())) // not SM
.collect(GoatCollectors.toObservableList());
},
teamMembersProperty(),
productOwnerProperty(),
scrumMasterProperty()));
teamMembersProperty()
.addListener(
(ListChangeListener.Change<? extends Person> change) -> {
change.next();
List<? extends Person> removed = change.getRemoved();
devTeamProperty().removeAll(removed);
if (removed.contains(productOwnerProperty().get())) {
productOwnerProperty().set(null);
}
if (removed.contains(scrumMasterProperty().get())) {
scrumMasterProperty().set(null);
}
});
}
public List<Answer> classicFind(Predicate<Answer> pred) {
List<Answer> results = new ArrayList<Answer>();
for (Answer answer : answers.values()) if (pred.test(answer)) results.add(answer);
return results;
}
private List<Annotation> getAnnotationsInternal(List<AnnotationExpr> l) {
return l.stream()
.map(AnnotationParser::annotationFromAnnotationExpr)
.collect(Collectors.toList());
}
@Test
public void toListIsSortedAccordingToComparator() {
final Comparator<Integer> comparator = composedComparator();
final PriorityQueue<Integer> queue = PriorityQueue.ofAll(comparator, values);
assertThat(queue.toList()).isEqualTo(values.sorted(comparator));
}
public class PriorityQueueTest extends AbstractTraversableTest {
private final List<Integer> values =
List.of(
3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9, 3, 2, 3, 8, 4, 6, 2, 6, 4, 3, 3, 8, 3, 2, 7,
9, 5, 0, 2, 8, 8, 4, 1, 9, 7, 1, 6, 9, 3, 9, 9, 3, 7, 5, 1, 0);
@Override
protected <T> Collector<T, ArrayList<T>, PriorityQueue<T>> collector() {
return PriorityQueue.collector();
}
@Override
protected <T> PriorityQueue<T> empty() {
return PriorityQueue.empty(toStringComparator());
}
@Override
protected <T> PriorityQueue<T> of(T element) {
return PriorityQueue.ofAll(toStringComparator(), List.of(element));
}
@Override
@SuppressWarnings("unchecked")
protected final <T> PriorityQueue<T> of(T... elements) {
return PriorityQueue.ofAll(toStringComparator(), List.of(elements));
}
@Override
protected <T> PriorityQueue<T> ofAll(Iterable<? extends T> elements) {
return PriorityQueue.ofAll(toStringComparator(), elements);
}
@Override
protected <T> Traversable<T> ofJavaStream(Stream<? extends T> javaStream) {
return PriorityQueue.ofAll(toStringComparator(), javaStream);
}
@Override
protected PriorityQueue<Boolean> ofAll(boolean[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
protected PriorityQueue<Byte> ofAll(byte[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
protected PriorityQueue<Character> ofAll(char[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
protected PriorityQueue<Double> ofAll(double[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
protected PriorityQueue<Float> ofAll(float[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
protected PriorityQueue<Integer> ofAll(int[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
protected PriorityQueue<Long> ofAll(long[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
protected PriorityQueue<Short> ofAll(short[] array) {
return PriorityQueue.ofAll(List.ofAll(array));
}
@Override
protected <T> PriorityQueue<T> tabulate(int n, Function<? super Integer, ? extends T> f) {
return PriorityQueue.tabulate(n, f);
}
@Override
protected <T> PriorityQueue<T> fill(int n, Supplier<? extends T> s) {
return PriorityQueue.fill(n, s);
}
@Override
protected boolean useIsEqualToInsteadOfIsSameAs() {
return true;
}
@Override
protected int getPeekNonNilPerformingAnAction() {
return 1;
}
@Override
protected boolean emptyShouldBeSingleton() {
return false;
}
@Override
protected boolean isOrdered() {
return true;
}
private static SerializableComparator<Object> toStringComparator() {
return (o1, o2) -> String.valueOf(o1).compareTo(String.valueOf(o2));
}
private static Comparator<Integer> composedComparator() {
final Comparator<Integer> bitCountComparator =
(o1, o2) -> Integer.compare(bitCount(o1), bitCount(o2));
return bitCountComparator.thenComparing(naturalComparator());
}
@Test
@Override
public void shouldScanLeftWithNonComparable() {
// The resulting type would need a comparator
}
@Test
@Override
public void shouldScanRightWithNonComparable() {
// The resulting type would need a comparator
}
@Override
public void shouldPreserveSingletonInstanceOnDeserialization() {
// The empty PriorityQueue encapsulates a comparator and therefore cannot be a singleton
}
// -- static narrow
@Test
public void shouldNarrowQueue() {
final PriorityQueue<Double> doubles = of(1.0d);
final PriorityQueue<Number> numbers = PriorityQueue.narrow(doubles);
final int actual = numbers.enqueue(new BigDecimal("2.0")).sum().intValue();
assertThat(actual).isEqualTo(3);
}
// -- toList
@Test
public void toListIsSortedAccordingToComparator() {
final Comparator<Integer> comparator = composedComparator();
final PriorityQueue<Integer> queue = PriorityQueue.ofAll(comparator, values);
assertThat(queue.toList()).isEqualTo(values.sorted(comparator));
}
// -- merge
@Test
public void shouldMergeTwoPriorityQueues() {
final PriorityQueue<Integer> source = of(3, 1, 4, 1, 5);
final PriorityQueue<Integer> target = of(9, 2, 6, 5, 3);
assertThat(source.merge(target)).isEqualTo(of(3, 1, 4, 1, 5, 9, 2, 6, 5, 3));
assertThat(PriorityQueue.of(3).merge(PriorityQueue.of(toStringComparator(), 1)))
.isEqualTo(of(3, 1));
}
// -- distinct
@Test
public void shouldComputeDistinctOfNonEmptyTraversableUsingKeyExtractor() {
final Comparator<String> comparator = (o1, o2) -> Integer.compare(o1.charAt(1), o2.charAt(1));
assertThat(
PriorityQueue.of(comparator, "5c", "1a", "3a", "1a", "2a", "4b", "3b")
.distinct()
.map(s -> s.substring(1)))
.isEqualTo(of("a", "b", "c"));
}
// -- removeAll
@Test
public void shouldRemoveAllElements() {
assertThat(of(3, 1, 4, 1, 5, 9, 2, 6).removeAll(of(1, 9, 1, 2))).isEqualTo(of(3, 4, 5, 6));
}
// -- enqueueAll
@Test
public void shouldEnqueueAllElements() {
assertThat(of(3, 1, 4).enqueueAll(of(1, 5, 9, 2))).isEqualTo(of(3, 1, 4, 1, 5, 9, 2));
}
// -- peek
@Test(expected = NoSuchElementException.class)
public void shouldFailPeekOfEmpty() {
empty().peek();
}
// -- dequeue
@Test
public void shouldDeque() {
assertThat(of(3, 1, 4, 1, 5).dequeue()).isEqualTo(Tuple.of(1, of(3, 4, 1, 5)));
}
@Test(expected = NoSuchElementException.class)
public void shouldFailDequeueOfEmpty() {
empty().dequeue();
}
// -- toPriorityQueue
@Test
public void shouldKeepInstanceOfPriorityQueue() {
final PriorityQueue<Integer> queue = PriorityQueue.of(1, 3, 2);
assertThat(queue.toPriorityQueue()).isSameAs(queue);
}
// -- property based tests
@Test
public void shouldBehaveExactlyLikeAnotherPriorityQueue() {
for (int i = 0; i < 10; i++) {
final Random random = getRandom(-1);
final java.util.PriorityQueue<Integer> mutablePriorityQueue = new java.util.PriorityQueue<>();
javaslang.collection.PriorityQueue<Integer> functionalPriorityQueue =
javaslang.collection.PriorityQueue.empty();
final int size = 100_000;
for (int j = 0; j < size; j++) {
/* Insert */
if (random.nextInt() % 3 == 0) {
assertMinimumsAreEqual(mutablePriorityQueue, functionalPriorityQueue);
final int value = random.nextInt(size) - (size / 2);
mutablePriorityQueue.add(value);
functionalPriorityQueue = functionalPriorityQueue.enqueue(value);
}
assertMinimumsAreEqual(mutablePriorityQueue, functionalPriorityQueue);
/* Delete */
if (random.nextInt() % 5 == 0) {
if (!mutablePriorityQueue.isEmpty()) {
mutablePriorityQueue.poll();
}
if (!functionalPriorityQueue.isEmpty()) {
functionalPriorityQueue = functionalPriorityQueue.tail();
}
assertMinimumsAreEqual(mutablePriorityQueue, functionalPriorityQueue);
}
}
final Collection<Integer> oldValues =
mutablePriorityQueue.stream().sorted().collect(toList());
final Collection<Integer> newValues = functionalPriorityQueue.toJavaList();
assertThat(oldValues).isEqualTo(newValues);
}
}
private void assertMinimumsAreEqual(
java.util.PriorityQueue<Integer> oldQueue, PriorityQueue<Integer> newQueue) {
assertThat(oldQueue.isEmpty()).isEqualTo(newQueue.isEmpty());
if (!newQueue.isEmpty()) {
assertThat(oldQueue.peek()).isEqualTo(newQueue.head());
}
}
}
@Override
protected <T> PriorityQueue<T> of(T element) {
return PriorityQueue.ofAll(toStringComparator(), List.of(element));
}