Clover coverage report - JBind Project
Coverage timestamp: Fr Mai 28 2004 11:17:36 CEST
file stats: LOC: 261   Methods: 18
NCLOC: 221   Classes: 2
This license of Clover is provided to support the development of JBind only. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover.
 
 Source file Conditionals Statements Methods TOTAL
FilterListIterator.java 32,4% 24,3% 33,3% 27%
 1   
 /*
 2   
  * JBind
 3   
  *
 4   
  * Copyright (c) by Stefan Wachter. All rights reserved.
 5   
  *
 6   
  * Usage, modification, and redistribution is subject to license terms that are
 7   
  * available at 'http://www.jbind.org'. The JBind license is like the
 8   
  * 'Apache Software License V 1.1'.
 9   
  */
 10   
 package org.jbind.util.collection;
 11   
 
 12   
 import java.util.ArrayList;
 13   
 import java.util.List;
 14   
 import java.util.ListIterator;
 15   
 import java.util.NoSuchElementException;
 16   
 
 17   
 import org.jbind.base.Console;
 18   
 
 19   
 public class FilterListIterator implements ListIterator {
 20   
 
 21   
   public static interface Test {
 22   
     boolean test(Object anObject);
 23   
   }
 24   
 
 25   
   private ListIterator myIterator = null;
 26   
   private Test myTest = null;
 27   
 
 28   
   private static byte NO = 0;
 29   
   private static byte PREVIOUS = -1;
 30   
   private static byte NEXT = 1;
 31   
 
 32   
   private byte myLastDirection = NO;
 33   
 
 34   
   private Object myObject = null;
 35   
   private int myIndex = 0;
 36   
   private int myDelta = 0;
 37   
 
 38  14830
   public FilterListIterator(ListIterator anIterator, Test aTest) {
 39  14830
     myIterator = anIterator;
 40  14830
     myTest = aTest;
 41   
   }
 42   
 
 43  35981
   private void gotoNext() {
 44  35981
     if (myDelta > 0) {
 45  10660
       return;
 46   
     }
 47  25321
     myIndex = -1;
 48  25321
     while (myDelta < 0) {
 49  0
       myIterator.next();
 50  0
       myDelta++;
 51   
     }
 52  25321
     while (myIterator.hasNext()) {
 53  23768
       int idx = myIterator.nextIndex();
 54  23768
       myObject = myIterator.next();
 55  23768
       myDelta++;
 56  23768
       if (myTest.test(myObject)) {
 57  10769
         myIndex = idx;
 58  10769
         break;
 59   
       }
 60   
     }
 61   
   }
 62   
 
 63  0
   private void gotoPrevious() {
 64  0
     if (myDelta < 0) {
 65  0
       return;
 66   
     }
 67  0
     myIndex = -1;
 68  0
     while (myDelta > 0) {
 69  0
       myIterator.previous();
 70  0
       myDelta--;
 71   
     }
 72  0
     while (myIterator.hasPrevious()) {
 73  0
       int idx = myIterator.previousIndex();
 74  0
       myObject = myIterator.previous();
 75  0
       myDelta--;
 76  0
       if (myTest.test(myObject)) {
 77  0
         myIndex = idx;
 78  0
         break;
 79   
       }
 80   
     }
 81   
   }
 82   
 
 83  10697
   public Object next() {
 84  10697
     gotoNext();
 85  10697
     myLastDirection = NEXT;
 86  10697
     return nextOrPrevious();
 87   
   }
 88   
 
 89  0
   public Object previous() {
 90  0
     gotoPrevious();
 91  0
     myLastDirection = PREVIOUS;
 92  0
     return nextOrPrevious();
 93   
   }
 94   
 
 95  10697
   private Object nextOrPrevious() {
 96  10697
     if (myIndex == -1) {
 97  0
       throw new NoSuchElementException();
 98   
     }
 99  10697
     myDelta = 0;
 100  10697
     return myObject;
 101   
   }
 102   
 
 103  25284
   public boolean hasNext() {
 104  25284
     gotoNext();
 105  25284
     return -1 != myIndex;
 106   
   }
 107   
 
 108  0
   public boolean hasPrevious() {
 109  0
     gotoPrevious();
 110  0
     return -1 != myIndex;
 111   
   }
 112   
 
 113  0
   public int nextIndex() {
 114  0
     gotoNext();
 115  0
     return nextOrPreviousIndex();
 116   
   }
 117   
 
 118  0
   public int previousIndex() {
 119  0
     gotoPrevious();
 120  0
     return nextOrPreviousIndex();
 121   
   }
 122   
 
 123  0
   private int nextOrPreviousIndex() {
 124  0
     if (myIndex == -1) {
 125  0
       throw new NoSuchElementException();
 126   
     }
 127  0
     return myIndex;
 128   
   }
 129   
 
 130  4
   public void remove() {
 131  4
     if (myLastDirection == NO) {
 132  0
       throw new IllegalStateException();
 133   
     }
 134  4
     if (myDelta < 0) {
 135  0
       while (myDelta < 0) {
 136  0
         myIterator.next();
 137  0
         myDelta++;
 138   
       }
 139  0
       if (myLastDirection == PREVIOUS) {
 140  0
         myIterator.next();
 141  0
         myIterator.previous();
 142   
       }
 143  4
     } else if (myDelta > 0) {
 144  0
       while (myDelta > 0) {
 145  0
         myIterator.previous();
 146  0
         myDelta--;
 147   
       }
 148  0
       if (myLastDirection == NEXT) {
 149  0
         myIterator.previous();
 150  0
         myIterator.next();
 151   
       }
 152   
     }
 153  4
     myLastDirection = NO;
 154  4
     myIterator.remove();
 155   
   }
 156   
 
 157  0
   public void set(Object obj) {
 158  0
     throw new UnsupportedOperationException();
 159   
   }
 160  0
   public void add(Object obj) {
 161  0
     throw new UnsupportedOperationException();
 162   
   }
 163   
 
 164  0
   private static List createList() {
 165  0
     ArrayList list = new ArrayList();
 166  0
     list.add("0");
 167  0
     list.add("1");
 168  0
     list.add("2");
 169  0
     list.add("3");
 170  0
     list.add("4");
 171  0
     list.add("5");
 172  0
     return list;
 173   
   }
 174   
 
 175  0
   private static ListIterator filter(List aList) {
 176  0
     ListIterator i = new FilterListIterator(aList.listIterator(), new Test() {
 177  0
       public boolean test(Object anObject) {
 178  0
         return Integer.parseInt((String)anObject) % 2 == 0;
 179   
       }
 180   
     });
 181  0
     return i;
 182   
   }
 183   
 
 184  0
   public static void main(String args[]) {
 185  0
     List l = createList();
 186  0
     ListIterator i;
 187  0
     i = filter(l);
 188   
     assert !i.hasPrevious();
 189   
     assert i.hasNext();
 190   
     assert 0 == i.nextIndex();
 191   
     assert "0".equals(i.next());
 192   
     assert i.hasPrevious();
 193   
     assert i.hasNext();
 194   
     assert 0 == i.previousIndex();
 195   
     assert 2 == i.nextIndex();
 196   
     assert "2".equals(i.next());
 197   
     assert i.hasPrevious();
 198   
     assert i.hasNext();
 199   
     assert 2 == i.previousIndex();
 200   
     assert 4 == i.nextIndex();
 201   
     assert "4".equals(i.next());
 202   
     assert i.hasPrevious();
 203   
     assert !i.hasNext();
 204   
     assert 4 == i.previousIndex();
 205   
 
 206  0
     i = filter(l);
 207  0
     i.hasNext();
 208  0
     i.hasNext();
 209   
     assert "0".equals(i.next());
 210  0
     i.hasPrevious();
 211   
     assert "2".equals(i.next());
 212  0
     i.hasNext();
 213  0
     i.hasPrevious();
 214   
     assert "2".equals(i.previous());
 215   
     assert i.hasPrevious();
 216   
     assert "0".equals(i.previous());
 217   
     assert !i.hasPrevious();
 218   
 
 219  0
     i = filter(l);
 220   
     assert "0".equals(i.next());
 221   
     assert "2".equals(i.next());
 222   
     assert 2 == i.previousIndex();
 223   
     assert 4 == i.nextIndex();
 224  0
     i.remove();
 225   
     assert 0 == i.previousIndex() : i.previousIndex();
 226   
     assert "0".equals(i.previous());
 227   
     assert !i.hasPrevious();
 228   
     assert i.hasNext();
 229   
     assert 0 == i.nextIndex();
 230  0
     i.remove();
 231   
     assert i.hasNext();
 232   
     assert 2 == i.nextIndex();
 233   
     assert "4".equals(i.next());
 234   
 
 235  0
     l = createList();
 236  0
     i = filter(l);
 237  0
     i.next();
 238  0
     i.remove();
 239  0
     i.next();
 240  0
     i.remove();
 241  0
     i = filter(l);
 242   
     assert "4".equals(i.next());
 243   
 
 244  0
     l = createList();
 245  0
     i = filter(l);
 246  0
     i.next();
 247  0
     i.hasNext();
 248  0
     i.remove();
 249   
     assert !i.hasPrevious();
 250   
     assert "2".equals(i.next());
 251   
     assert "4".equals(i.next());
 252  0
     i.hasPrevious();
 253  0
     i.remove();
 254   
     assert !i.hasNext();
 255   
     assert "2".equals(i.previous());
 256   
 
 257  0
     Console.out("FilterListIterator ok");
 258   
   }
 259   
 
 260   
 }
 261