/** Make sure the right element is removed */ public void testMinusInt() { // First, let's try a list with distinct elements PStack<String> pstack = ConsPStack.<String>empty().plus("C").plus("B").plus("A"); assertEquals(Arrays.asList("A", "B", "C"), pstack); assertEquals(Arrays.asList("B", "C"), pstack.minus(0)); assertEquals(Arrays.asList("A", "B"), pstack.minus(2)); //Now, let's try duplicates pstack = pstack.plus("B"); assertEquals(Arrays.asList("B", "A", "B", "C"), pstack); assertEquals(Arrays.asList("A", "B", "C"), pstack.minus(0)); assertEquals(Arrays.asList("B", "A", "C"), pstack.minus(2)); }
assertEquals(e, pstack.get(k)); assertEquals(list.get(k), pstack.get(k)); UtilityTest.assertEqualsAndHash( pstack, pstack.minus(k).plus(k, pstack.get(k)) ); UtilityTest.assertEqualsAndHash( pstack, pstack.plus(k, 10).minus(k) ); pstack = pstack.minus(k); assertEquals(list.contains(v), pstack.contains(v)); list.remove(v); pstack = pstack.minus(v); pstack = pstack.minus(s);
public PStack<T> minus(Object e) { return boxed.minus(e); } public PStack<T> minusAll(Collection<?> list) {
stack = stack.minus(s); assertTrue(!stack.contains(s));
public PStack<T> minus(int i) { return boxed.minus(i); } public PStack<T> subList(int start, int end) {
public AmortizedPQueue<E> minus() { if (size() == 0) { return this; } int fsize = front.size(); if (fsize == 0) { //If there's nothing on front, dump back onto front //(as stacks, this goes in reverse like we want) //and take one off. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()).minus(); } else if (fsize == 1) { //If there's one element on front, dump back onto front, //but now we've already removed the head. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()); } else { //If there's more than one on front, we pop one off. return new AmortizedPQueue<E>(front.minus(0), back); } }
public AmortizedPQueue<E> minus() { if (size() == 0) { return this; } int fsize = front.size(); if (fsize == 0) { //If there's nothing on front, dump back onto front //(as stacks, this goes in reverse like we want) //and take one off. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()).minus(); } else if (fsize == 1) { //If there's one element on front, dump back onto front, //but now we've already removed the head. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()); } else { //If there's more than one on front, we pop one off. return new AmortizedPQueue<E>(front.minus(0), back); } }
/** * @param e * @return * @see org.pcollections.MapPSet#minus(java.lang.Object) */ public PStackX<T> minus(Object e) { return this.withStack(stack.minus(e)); }
/** * @param i * @return * @see org.pcollections.PStack#minus(int) */ public PStackX<T> minus(int i) { return this.withStack(stack.minus(i)); }
public PersistentStack<T> pop() { if (stack.isEmpty()) { return this; } return new PersistentStack<>(stack.minus(0)); }
@Override public LinkedListX<T> minus(Object remove) { return from(get().minus(remove)); }
@Override public LinkedListX<T> minus(int i) { return from(get().minus(i)); }
@Override public List<T> next() { for(int i=0;i<increment && list.get().size()>0;i++) list.mutate(var -> var.minus(0)); for (int i = 0; list.get().size() < windowSize && it.hasNext(); i++) { if(it.hasNext()){ list.mutate(var -> var.plus(Math.max(0,var.size()),it.next())); } } return list.get(); }
@Override public List<T> next() { for(int i=0;i<increment && list.get().size()>0;i++) list.mutate(var -> var.minus(0)); for (int i = 0; list.get().size() < windowSize && it.hasNext(); i++) { if(it.hasNext()){ list.mutate(var -> var.plus(Math.max(0,var.size()),it.next())); } } return list.get(); }
@Override public List<T> next() { for(int i=0;i<increment && list.get().size()>0;i++) list.mutate(var -> var.minus(0)); for (int i = 0; list.get().size() < windowSize && it.hasNext(); i++) { if(it.hasNext()){ list.mutate(var -> var.plus(Math.max(0,var.size()),it.next())); } } return list.get(); }
@Override public Streamable<T> next() { for(int i=0;i<increment && list.get().size()>0;i++) list.mutate(var -> var.minus(0)); for (int i = 0; list.get().size() < windowSize && it.hasNext(); i++) { if(it.hasNext()){ list.mutate(var -> var.plus(Math.max(0,var.size()),it.next())); } } return Streamable.fromIterable(list.get()); }
private PStack<Function> swapFn(final Function fn) { if (functionList.size() == 0) return functionList.plus(fn); functionList.get(functionList.size() - 1); final PStack<Function> removed = functionList.minus(functionList.size() - 1); return removed.plus(removed.size(), fn); }
private PStack<Function> swapFn(Function fn){ if(functionList.size()==0) return functionList.plus(fn); Function before = functionList.get(functionList.size()-1); PStack<Function> removed = functionList.minus(functionList.size()-1); return removed.plus(removed.size(),fn); } private PStack<Function> swapComposeFn(Function fn){
private PStack<Function> swapComposeFn(Function fn){ if(functionList.size()==0){ if(this.firstRecover.size()==0){ return functionList.plus(fn); }else{ Function except = t-> { try{ return fn.apply(t); }catch(Throwable e){ return composeFirstRecovery().apply(e); } }; return functionList.plus(except); } } Function before = functionList.get(functionList.size()-1); PStack<Function> removed = functionList.minus(functionList.size()-1); return removed.plus(removed.size(),fn.compose(before)); } private Function composeFirstRecovery() {
public AmortizedPQueue<E> minus() { if (size() == 0) { return this; } int fsize = front.size(); if (fsize == 0) { //If there's nothing on front, dump back onto front //(as stacks, this goes in reverse like we want) //and take one off. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()).minus(); } else if (fsize == 1) { //If there's one element on front, dump back onto front, //but now we've already removed the head. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()); } else { //If there's more than one on front, we pop one off. return new AmortizedPQueue<E>(front.minus(0), back); } }