/**
* Convert an arithmetic expression in infix notation (e.g 1+2) to postfix notation (e.g 12+) Only
* simple expressions not containing brackets are supported. <br>
* A description of the algorithm used to accomplish this task can be found at:
* http://scriptasylum.com/tutorials/infix_postfix/algorithms/infix-postfix/index.htm <br>
* Basically the list of {@code Tokens} is being scanned from left to right, all operands
* (numbers) are pushed onto a {@code Stack}. If the {@code Token} is an operator it is compared
* to the operator on top of the {@code Stack}. If the operator on top of the {@code Stack} has a
* higher or equal weight than the current operator, the top of the {@code Stack} is pushed to the
* postfix list. Therefore the operators with higher weight are going to be executed first when
* the expression is evaluated. This process continues until the top of the {@code Stack} has a
* lower weight than the current operator or the {@code Stack} is empty. Then the current operator
* is pushed onto the {@code Stack}.
*
* @param tokenizer The {@code Tokenizer} which will be converted to postfix. It must not be
* {@code null}.
* @return The resulting {@code List} of {@code Token}s in postfix order.
*/
private static List<Token> postfix(Tokenizer tokenizer) {
Stack<Token> stack = new Stack<>();
List<Token> postfix = new LinkedList<>();
BiPredicate<Token, Token> hasHigherOrEqualWeight =
(t1, t2) ->
Operators.getOpWeight(t1.getOperator()) - Operators.getOpWeight(t2.getOperator()) >= 0;
while (tokenizer.hasNext()) {
Token t = tokenizer.next();
switch (t.getType()) {
case NUMBER:
postfix.add(t);
break;
case OPERATOR:
if (!stack.isEmpty() && hasHigherOrEqualWeight.test(stack.peek(), t)) {
while (!stack.isEmpty() && hasHigherOrEqualWeight.test(stack.peek(), t)) {
postfix.add(stack.pop());
}
stack.push(t);
} else {
stack.push(t);
}
break;
case OPENING_BRACKET:
case CLOSING_BRACKET:
throw new IllegalArgumentException(
"Cannot create postfix expression if the source contains brackets.");
}
}
while (!stack.isEmpty()) postfix.add(stack.pop());
return postfix;
}
private boolean compatible(Bet bet1, Bet bet2) {
Map<BetType, BiPredicate<Bet, Bet>> subMap;
BiPredicate<Bet, Bet> check;
if ((subMap = COMPATIBLE_CHECKS.getOrDefault(bet1.getType(), null)) != null
&& (check = subMap.getOrDefault(bet2.getType(), null)) != null)
return check.test(bet1, bet2);
else if ((subMap = COMPATIBLE_CHECKS.getOrDefault(bet2.getType(), null)) != null
&& (check = subMap.getOrDefault(bet1.getType(), null)) != null)
return check.test(bet2, bet1);
else return true;
}
// l + <first|acc|last> + r
private R connectOne(T first, R acc, T last) {
synchronized (root) {
Connector<T, R> l = left;
if (l == null) {
return pushRight(acc, last);
}
if (l.acc == NONE) {
l.acc = acc;
l.left = first;
l.right = last;
return connectEmpty();
}
T laright = l.right;
if (mergeable.test(laright, first)) {
l.acc = combiner.apply(l.acc, acc);
l.right = last;
return connectEmpty();
}
left = null;
l.rhs = null;
l.right = none();
if (l.left != NONE) {
return pushRight(acc, last);
}
acc = pushRight(acc, last);
if (acc != NONE) left = new Connector<>(null, acc, this);
return l.drain();
}
}
// <?|acc|last> + r
private R pushRight(R acc, T last) {
cur = none();
if (right == null) return acc;
synchronized (root) {
Connector<T, R> r = right;
if (r == null) return acc;
right = null;
r.lhs = null;
T raleft = r.left;
r.left = none();
if (r.acc == NONE) {
if (acc == NONE) {
r.drain();
} else {
r.acc = acc;
r.right = last;
}
return none();
}
if (acc == NONE) {
return r.drainRight();
}
if (mergeable.test(last, raleft)) {
r.acc = combiner.apply(acc, r.acc);
return r.drainRight();
}
if (r.right == NONE) right = new Connector<>(this, r.drain(), null);
return acc;
}
}
// l + r
private R connectEmpty() {
synchronized (root) {
Connector<T, R> l = left, r = right;
if (l == null) {
return pushRight(none(), none());
}
left = right = null;
l.rhs = null;
T laright = l.right;
l.right = none();
if (l.acc == NONE) {
if (r == null) l.drain();
else {
if (l.lhs != null) {
l.lhs.right = r;
r.lhs = l.lhs;
}
}
return none();
}
if (r == null) {
return l.drainLeft();
}
r.lhs = null;
if (r.acc == NONE) {
if (r.rhs != null) {
r.rhs.left = l;
l.rhs = r.rhs;
l.right = laright;
}
return none();
}
T raleft = r.left;
r.left = none();
if (mergeable.test(laright, raleft)) {
R acc = combiner.apply(l.acc, r.acc);
if (l.left == NONE && r.right == NONE) {
l.drain();
r.drain();
return acc;
}
l.acc = acc;
l.right = r.right;
if (r.rhs != null) {
r.rhs.left = l;
l.rhs = r.rhs;
}
return none();
}
if (l.left == NONE) {
if (r.right == NONE) right = new Connector<>(this, r.drain(), null);
return l.drain();
}
return r.drainRight();
}
}
private <E extends Exception> void assertBiPredicate(
BiPredicate<Object, Object> test, Class<E> type) {
assertNotNull(test);
try {
test.test(null, null);
fail();
} catch (Exception e) {
assertException(type, e, "null:null");
}
}
final boolean forEachWhile(BiPredicate<? super K, ? super V> predicate) {
for (long a,
tail,
allocations = (a = ~bitSet) << (tail = Long.numberOfLeadingZeros(a)),
allocIndex = 64 - tail;
allocations != 0;
allocations <<= 1, allocIndex--) {
if (allocations < 0
&& !predicate.test(this.<K>readKey(allocIndex), this.<V>readValue(allocIndex))) {
return false;
}
}
return true;
}
@Override
public ImmutableMap<K, V> filtered(BiPredicate<? super K, ? super V> condition) {
Object[] newValues = this.values.clone();
int newSize = this.size;
int len = this.values.length;
for (int i = 0; i < len; i++) {
Object value = this.values[i];
if (value != null) {
if (!condition.test(this.keys[i], (V) value)) {
newValues[i] = null;
newSize--;
}
}
}
return new EnumMap(this.type, this.keys, newValues, newSize);
}
final int removeIf(
SmoothieMap<K, V> map, BiPredicate<? super K, ? super V> filter, int modCount) {
if (isEmpty()) return modCount;
long startSlot = 0;
while (readSlot(startSlot) != 0) {
startSlot++;
}
for (long slotIndex = startSlot + 1, slot, allocIndex;
slotIndex != startSlot;
slotIndex = nextSlotIndex(slotIndex)) {
if ((slot = readSlot(slotIndex)) != 0) {
if (filter.test(readKey((allocIndex = allocIndex(slot))), readValue(allocIndex))) {
if (remove(map, slotIndex, allocIndex)) slotIndex = prevSlotIndex(slotIndex);
modCount++;
}
}
}
return modCount;
}
public boolean test(Path path, BasicFileAttributes attrs) {
visited.add(path);
return pred.test(path, attrs);
}
@Test
public void canAdaptPredicate() {
final Predicate<Pair<O, O>> predicate = new Always<>();
final BiPredicate<O, O> adapted = Tuples.Pairs.untupled(predicate);
Assert.assertTrue(adapted.test(O.IGNORED, O.IGNORED));
}
private Function<Object[], Boolean> normalize(BiPredicate<Object[], Object[]> source) {
return pp -> source.test(pp, pp);
}
