[cvs] / jsr166 / src / main / java / util / Vector.java Repository:
ViewVC logotype

Diff of /jsr166/src/main/java/util/Vector.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2, Sat Nov 26 03:12:10 2005 UTC revision 1.3, Sun Nov 27 14:54:23 2005 UTC
# Line 1056  Line 1056 
1056      }      }
1057    
1058      /**      /**
1059         * {@inheritDoc}
1060         */
1061        public synchronized ListIterator<E> listIterator() {
1062            return new VectorIterator(0);
1063        }
1064    
1065        /**
1066       * Returns an iterator over the elements in this list in proper sequence.       * Returns an iterator over the elements in this list in proper sequence.
1067       *       *
1068       * @return an iterator over the elements in this list in proper sequence       * @return an iterator over the elements in this list in proper sequence
# Line 1065  Line 1072 
1072      }      }
1073    
1074      /**      /**
1075       * A streamlined version of AbstractList.Itr.       * A streamlined version of AbstractList.ListItr.
1076       */       */
1077      final class VectorIterator implements ListIterator<E> {      private final class VectorIterator implements ListIterator<E> {
1078          int cursor;           // index of next element to return;          int cursor;                // current position
1079          int lastRet;          // index of last element, or -1 if no such          int lastRet;               // index of last returned element
1080          int expectedModCount; // to check for CME          int expectedModCount; // to check for CME
1081    
1082          VectorIterator(int index) {          VectorIterator(int index) {
1083              cursor = index;              cursor = index;
             lastRet = -1;  
1084              expectedModCount = modCount;              expectedModCount = modCount;
1085                lastRet = -1;
1086          }          }
1087    
1088          public boolean hasNext() {          public boolean hasNext() {
1089              // Racy but within spec and backwards-compatible              // Racy but within spec, since modifications are checked
1090              return cursor < elementCount;              // within or after synchronization in next/previous
1091                return cursor < Vector.this.elementCount;
1092          }          }
1093    
1094          public boolean hasPrevious() {          public boolean hasPrevious() {
# Line 1096  Line 1104 
1104          }          }
1105    
1106          public E next() {          public E next() {
             synchronized(Vector.this) {  
                 if (expectedModCount == modCount) {  
                     int i = cursor;  
                     if (i < elementCount) {  
1107                          try {                          try {
1108                              E e = (E)elementData[i];                  int i = cursor;
1109                    E next = get(i);
1110                              lastRet = i;                              lastRet = i;
1111                              cursor = i + 1;                              cursor = i + 1;
1112                              return e;                  return next;
1113                          } catch (IndexOutOfBoundsException fallthrough) {              } catch (IndexOutOfBoundsException ex) {
                         }  
                     }  
                 }  
                 // Prefer reporting CME if applicable on failures  
                 if (expectedModCount == modCount)  
1114                      throw new NoSuchElementException();                      throw new NoSuchElementException();
1115                } finally {
1116                    if (expectedModCount != modCount)
1117                  throw new ConcurrentModificationException();                  throw new ConcurrentModificationException();
1118              }              }
1119          }          }
   
1120          public E previous() {          public E previous() {
             synchronized(Vector.this) {  
                 if (expectedModCount == modCount) {  
                     int i = cursor - 1;  
                     if (i < elementCount) {  
1121                          try {                          try {
1122                              E e = (E)elementData[i];                  int i = cursor - 1;
1123                    E prev = get(i);
1124                              lastRet = i;                              lastRet = i;
1125                              cursor = i;                              cursor = i;
1126                              return e;                  return prev;
1127                          } catch (IndexOutOfBoundsException fallthrough) {              } catch (IndexOutOfBoundsException ex) {
                         }  
                     }  
                 }  
                 if (expectedModCount == modCount)  
1128                      throw new NoSuchElementException();                      throw new NoSuchElementException();
1129                } finally {
1130                    if (expectedModCount != modCount)
1131                  throw new ConcurrentModificationException();                  throw new ConcurrentModificationException();
1132              }              }
1133          }          }
1134    
1135          public void remove() {          public void remove() {
1136              if (lastRet < 0)              if (lastRet == -1)
1137                  throw new IllegalStateException();                  throw new IllegalStateException();
1138              synchronized(Vector.this) {              if (expectedModCount != modCount)
                 if (modCount != expectedModCount)  
1139                      throw new ConcurrentModificationException();                      throw new ConcurrentModificationException();
1140                try {
1141                  Vector.this.remove(lastRet);                  Vector.this.remove(lastRet);
1142                  if (lastRet < cursor)                  if (lastRet < cursor)
1143                      cursor--;                      cursor--;
1144                  lastRet = -1;                  lastRet = -1;
1145                  expectedModCount = modCount;                  expectedModCount = modCount;
1146                } catch (IndexOutOfBoundsException e) {
1147                    throw new ConcurrentModificationException();
1148              }              }
1149          }          }
1150    
1151          public void set(E e) {          public void set(E e) {
1152              if (lastRet < 0)              if (lastRet == -1)
1153                  throw new IllegalStateException();                  throw new IllegalStateException();
1154              synchronized(Vector.this) {              if (expectedModCount != modCount)
                 if (modCount != expectedModCount)  
1155                      throw new ConcurrentModificationException();                      throw new ConcurrentModificationException();
1156                try {
1157                  Vector.this.set(lastRet, e);                  Vector.this.set(lastRet, e);
1158                  expectedModCount = modCount;                  expectedModCount = modCount;
1159                } catch (IndexOutOfBoundsException ex) {
1160                    throw new ConcurrentModificationException();
1161              }              }
1162          }          }
1163    
1164          public void add(E e) {          public void add(E e) {
1165              synchronized(Vector.this) {              if (expectedModCount != modCount)
                 if (modCount != expectedModCount)  
1166                      throw new ConcurrentModificationException();                      throw new ConcurrentModificationException();
1167                  Vector.this.add(cursor++, e);              try {
1168                    int i = cursor;
1169                    Vector.this.add(i, e);
1170                    cursor = i + 1;
1171                  lastRet = -1;                  lastRet = -1;
1172                  expectedModCount = modCount;                  expectedModCount = modCount;
1173                } catch (IndexOutOfBoundsException ex) {
1174                    throw new ConcurrentModificationException();
1175              }              }
1176          }          }
1177      }      }
   
1178  }  }

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8