@Override public void clear() { for (int i = 0; i < NUMBER_OF_BUCKETS; i++) { this.buckets[i].clear(); } size = 0; }
protected final MaterialRequestObject findRequestInQueue(DoubleLinkedList<MaterialRequestObject> queue) { int numberOfElements = queue.size(); for (int handledElements = 0; handledElements < numberOfElements; handledElements++) { MaterialRequestObject request = queue.getFront(); // if the request is done if (request.isFinished()) { request.requestQueue = null; queue.popFront(); // remove the request numberOfElements--; } // if all needed are in delivery, or there can not be any more in delivery else if (!request.canTakeMoreOffers()) { queue.pushEnd(queue.popFront()); // move the request to the end. } // everything fine, take this request else { if (request.isRoundRobinRequest()) { queue.pushEnd(queue.popFront()); // put the request to the end of the queue. } return request; } } return null; }
@Override public void remove() { list.remove(next.prev); } }
@Test public void testIteratorRemove() { for (int i = 0; i < TEST_NUMBERS; i++) { list.pushEnd(new DoubleLinkedIntListItem(i)); } int i = 0; Iterator<DoubleLinkedIntListItem> iter = list.iterator(); while (iter.hasNext()) { assertEquals(i, iter.next().value); iter.remove(); i++; } assertEquals(TEST_NUMBERS, i); assertEquals(0, list.size()); assertTrue(list.isEmpty()); assertFalse(list.iterator().hasNext()); }
@Test public void testMerge() { DoubleLinkedList<DoubleLinkedIntListItem> list2 = new DoubleLinkedList<>(); for (int i = 0; i < TEST_NUMBERS; i++) { list.pushEnd(new DoubleLinkedIntListItem(i)); list2.pushEnd(new DoubleLinkedIntListItem(i)); } list2.mergeInto(list); assertEquals(0, list2.size()); assertEquals(TEST_NUMBERS * 2, list.size()); assertEquals(list2.head, ((DoubleLinkedListItem<DoubleLinkedIntListItem>) list2.head).next); assertEquals(list2.head, ((DoubleLinkedListItem<DoubleLinkedIntListItem>) list2.head).prev); int i = 0; for (DoubleLinkedIntListItem curr : list) { assertEquals(i % TEST_NUMBERS, curr.value); i++; } }
@Test public void testRemoveByHandle() { DoubleLinkedIntListItem handles[] = new DoubleLinkedIntListItem[TEST_NUMBERS]; for (int i = 0; i < TEST_NUMBERS; i++) { handles[i] = new DoubleLinkedIntListItem(i); list.pushFront(handles[i]); } list.remove(handles[4]); list.remove(handles[7]); assertEquals("incorrect size after removing 2 values", TEST_NUMBERS - 2, list.size()); assertNull("the removed item should not hold a 'next' reference", handles[4].next); assertNull("the removed item should not hold a 'prev' reference", handles[4].prev); assertNull("the removed item should not hold a 'next' reference", handles[7].next); assertNull("the removed item should not hold a 'prev' reference", handles[7].prev); for (int i = TEST_NUMBERS - 1; i >= 0; i--) { if (i == 4 || i == 7) { // skip the removed values continue; } assertEquals(i, list.popFront().value); } assertEquals("incorrect size after popFront all values", 0, list.size()); }
@Test public void testPushEndAndPopFront() { assertEquals(0, list.size()); for (int i = 0; i < TEST_NUMBERS; i++) { list.pushEnd(new DoubleLinkedIntListItem(i)); assertEquals(i + 1, list.size()); } for (int i = 0; i < TEST_NUMBERS; i++) { assertEquals(10 - i, list.size()); assertEquals(i, list.popFront().value); } assertEquals(0, list.size()); }
@Test public void testIteratorRemoveHalf() { for (int i = 0; i < TEST_NUMBERS; i++) { list.pushEnd(new DoubleLinkedIntListItem(i)); } int i = 0; Iterator<DoubleLinkedIntListItem> iter = list.iterator(); while (iter.hasNext()) { DoubleLinkedIntListItem curr = iter.next(); assertEquals(i, curr.value); if (curr.value % 2 == 0) { iter.remove(); } i++; } assertEquals(TEST_NUMBERS / 2, list.size()); assertTrue(list.iterator().hasNext()); i = 1; for (DoubleLinkedIntListItem curr : list) { assertEquals(i, curr.value); i += 2; } }
@Override public void moveObjectsOfPositionTo(ShortPoint2D position, AbstractMaterialRequestPriorityQueue newAbstractQueue) { assert newAbstractQueue instanceof SimpleMaterialRequestPriorityQueue : "can't move positions between diffrent types of queues."; SimpleMaterialRequestPriorityQueue newQueue = (SimpleMaterialRequestPriorityQueue) newAbstractQueue; for (int queueIdx = 0; queueIdx < queues.length; queueIdx++) { Iterator<MaterialRequestObject> iter = queues[queueIdx].iterator(); while (iter.hasNext()) { MaterialRequestObject curr = iter.next(); if (curr.getPosition().equals(position)) { iter.remove(); newQueue.queues[queueIdx].pushEnd(curr); curr.requestQueue = newQueue; } } } }
@Test public void testPushFrontAndPopFront() { assertEquals(0, list.size()); for (int i = 0; i < TEST_NUMBERS; i++) { list.pushFront(new DoubleLinkedIntListItem(i)); assertEquals(i + 1, list.size()); } for (int i = TEST_NUMBERS - 1; i >= 0; i--) { assertEquals(i + 1, list.size()); assertEquals(i, list.popFront().value); } assertEquals(0, list.size()); }
/** * Updates the priority of the given queue item from the oldPriority to the newPriority. * <p /> * NOTE: The given {@link MaterialRequestObject} must be in the queue with the given oldPriority! There will be no checks! * * @param oldPriority * @param newPriority * @param materialRequest */ final void updatePriority(EPriority oldPriority, EPriority newPriority, MaterialRequestObject materialRequest) { EBuildingType buildingType = materialRequest.getBuildingType(); getQueue(oldPriority, buildingType).remove(materialRequest); getQueue(newPriority, buildingType).pushFront(materialRequest); // TODO @Andreas Eberle: check if this should be pushEnd() }
/** * Inserts the request with the default priority. * * @param materialRequest * The {@link MaterialRequestObject} that shall be inserted. */ public final void insertRequest(MaterialRequestObject materialRequest) { getQueue(EPriority.DEFAULT, materialRequest.getBuildingType()).pushEnd(materialRequest); materialRequest.requestQueue = this; }
private void assertListEquals(DoubleLinkedList<DoubleLinkedIntListItem> list0, DoubleLinkedList<DoubleLinkedIntListItem> list1) { assertEquals(list0.size(), list1.size()); int size = list0.size(); for (int i = 0; i < size; i++) { assertEquals(list0.popFront().value, list1.popFront().value); } assertEquals(0, list0.size()); assertEquals(0, list1.size()); }
@Override public void mergeInto(AbstractMaterialRequestPriorityQueue newAbstractQueue) { assert newAbstractQueue instanceof SimpleMaterialRequestPriorityQueue : "can't move positions between diffrent types of queues."; SimpleMaterialRequestPriorityQueue newQueue = (SimpleMaterialRequestPriorityQueue) newAbstractQueue; for (int queueIdx = 0; queueIdx < queues.length; queueIdx++) { DoubleLinkedList<MaterialRequestObject> currList = queues[queueIdx]; DoubleLinkedList<MaterialRequestObject> newList = newQueue.queues[queueIdx]; for (MaterialRequestObject request : currList) { request.requestQueue = newQueue; } currList.mergeInto(newList); } }
/** * Generates a new array of {@link DoubleLinkedList}s of the given length. The array will be filled with new {@link DoubleLinkedList} objects. * * @param length * Length of the resulting array. * @return */ public static <T extends DoubleLinkedListItem<T>> DoubleLinkedList<T>[] getArray(final int length) { @SuppressWarnings("unchecked") DoubleLinkedList<T>[] array = new DoubleLinkedList[length]; for (int i = 0; i < length; i++) { array[i] = new DoubleLinkedList<>(); } return array; }
@Override public void insert(int elementId, float rank) { buckets[getRankIdx(rank)].pushFront(handles[elementId]); size++; }