@Override @Atomic(readOnly = true) public boolean containsAll(Collection<?> c) { return super.containsAll(c); }
@Override @Atomic(readOnly = true) /** Note that this operation is only transactional if both lists are transactional. **/ public boolean equals(Object o) { return super.equals(o); }
@Atomic public void editPaymentMethod(PaymentMethod paymentMethod, String code, LocalizedString description, String paymentReferenceFormat) { paymentMethod.edit(code, description, paymentReferenceFormat == null ? "" : paymentReferenceFormat); }
@Atomic public void setDefaultPaymentMethods(PaymentMethod defaultCashPaymentMethod, PaymentMethod defaultSibsPaymentMethod, PaymentMethod defaultRefundPaymentMethod) { PaymentMethod.setDefaultPaymentMethods(defaultCashPaymentMethod, defaultSibsPaymentMethod, defaultRefundPaymentMethod); }
@Override @Atomic(readOnly = true) public int hashCode() { int value = 0; for (E o : entries.get()) { if (o != null) { value += o.hashCode(); } } return value; }
@Override @Atomic(readOnly = true) public int hashCode() { return super.hashCode(); }
@Override @Atomic(readOnly = true) public int indexOf(Object o) { return super.indexOf(o); }
@Override @Atomic(readOnly = true) public int lastIndexOf(Object o) { return super.lastIndexOf(o); }
@Override @Atomic(readOnly = true) public E getLast() { if (isEmpty()) { throw new NoSuchElementException(); } return peekLast(); }
@Override @Atomic(readOnly = true) public E getFirst() { if (isEmpty()) { throw new NoSuchElementException(); } return peekFirst(); }
@Override @Atomic(speculativeReadOnly = false) public boolean addAll(int index, Collection<? extends E> c) { int size = size(); if (index > size) { throw new IndexOutOfBoundsException(); } ensureCapacity(size + c.size()); return super.addAll(index, c); }
@Override @Atomic(readOnly = true) public Object[] toArray() { return toArray(new Object[size()]); }
@Override @Atomic(readOnly = true) public E peekLast() { try { return get(size() - 1); } catch (IndexOutOfBoundsException e) { return null; } }
/** * Returns a new list, with the same elements as the current list, but with * a reversed order. **/ @Atomic(readOnly = true) public VArrayList<E> reversed() { return new VArrayList<E>(descendingIterator()); }
@Override public void remove() { throw new UnsupportedOperationException(); } }
@Override @Atomic(readOnly = true) public Object[] toArray() { int size = size(); Cons<E> elems = entries.get(); Object[] result = new Object[size]; Iterator<?> iter = elems.iterator(); for (int i = 0; i < size; i++) { result[i] = iter.next(); } return result; }
@Override @Atomic(readOnly = true) public E peek() { Cons<E> frontElems = front.get(); if (frontElems.isEmpty()) { return null; } else { return frontElems.first(); } }
@Atomic(speculativeReadOnly = false) public void trimToSize() { int size = size(); if (array().length > size) { resize(size); } }
@Override @Atomic(canFail = false) public void clear() { front.put((Cons<E>) Cons.empty()); rear.put((Cons<E>) Cons.empty()); size.putInt(0); }
@Override @Atomic(speculativeReadOnly = true) public boolean add(E e) { int size = size(); ensureCapacity(size + 1); array().put(size, e); this.size.putInt(size + 1); return true; }