foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/helper/NonSynchronizedVector.java - eclipselink - Git at Google

 /*
  * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0,
  * or the Eclipse Distribution License v. 1.0 which is available at
  * http://www.eclipse.org/org/documents/edl-v10.php.
  *
  * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
  */

 // Contributors:
 //     Oracle - initial API and implementation from Oracle TopLink
 package org.eclipse.persistence.internal.helper;

 import java.util.*;

 /**
  * Vector subclass that removes the synchronization.
  */
 public class NonSynchronizedVector extends Vector {
     public static NonSynchronizedVector newInstance(int initialCapacity, int capacityIncrement) {
         return new NonSynchronizedVector(initialCapacity, capacityIncrement);
     }

     public static NonSynchronizedVector newInstance(int initialCapacity) {
         return new NonSynchronizedVector(initialCapacity);
     }

     public static NonSynchronizedVector newInstance() {
         return new NonSynchronizedVector();
     }

     public static NonSynchronizedVector newInstance(Collection c) {
         return new NonSynchronizedVector(c);
     }

     public NonSynchronizedVector(int initialCapacity, int capacityIncrement) {
         super(initialCapacity, capacityIncrement);
     }

     public NonSynchronizedVector(int initialCapacity) {
         super(initialCapacity);
     }

     public NonSynchronizedVector() {
         super();
     }

     public NonSynchronizedVector(Collection c) {
         super(c);
     }

     @Override
     public void copyInto(Object anArray[]) {
         System.arraycopy(elementData, 0, anArray, 0, elementCount);
     }

     @Override
     public void trimToSize() {
         modCount++;
         int oldCapacity = elementData.length;
         if (elementCount < oldCapacity) {
             Object oldData[] = elementData;
             elementData = new Object[elementCount];
             System.arraycopy(oldData, 0, elementData, 0, elementCount);
         }
     }

     @Override
     public void ensureCapacity(int minCapacity) {
         modCount++;
         ensureCapacityHelper(minCapacity);
     }

     private void ensureCapacityHelper(int minCapacity) {
         int oldCapacity = elementData.length;
         if (minCapacity > oldCapacity) {
             Object oldData[] = elementData;
             int newCapacity = (capacityIncrement > 0) ?
             (oldCapacity + capacityIncrement) : (oldCapacity * 2);
             if (newCapacity < minCapacity) {
                 newCapacity = minCapacity;
             }
             elementData = new Object[newCapacity];
             System.arraycopy(oldData, 0, elementData, 0, elementCount);
         }
     }

     @Override
     public void setSize(int newSize) {
         modCount++;
         if (newSize > elementCount) {
             ensureCapacityHelper(newSize);
         } else {
             for (int i = newSize ; i < elementCount ; i++) {
             elementData[i] = null;
             }
         }
         elementCount = newSize;
     }

     @Override
     public int capacity() {
         return elementData.length;
     }

     @Override
     public Object clone() {
         return new NonSynchronizedVector(this);
     }

     @Override
     public int size() {
         return elementCount;
     }

     @Override
     public boolean isEmpty() {
         return elementCount == 0;
     }

     @Override
     public Enumeration elements() {
         return new Enumeration() {
             int count = 0;

             @Override
             public boolean hasMoreElements() {
                 return count < elementCount;
             }

             @Override
             public Object nextElement() {
                 if (count < elementCount) {
                     return elementData[count++];
                 }
                 throw new NoSuchElementException("Vector Enumeration");
             }
         };
     }

     @Override
     public int indexOf(Object elem, int index) {
         if (elem == null) {
             for (int i = index ; i < elementCount ; i++)
             if (elementData[i]==null)
                 return i;
         } else {
             for (int i = index ; i < elementCount ; i++)
             if (elem.equals(elementData[i]))
                 return i;
         }
         return -1;
     }

     @Override
     public int lastIndexOf(Object elem) {
         return lastIndexOf(elem, elementCount-1);
     }

     @Override
     public int lastIndexOf(Object elem, int index) {
         if (index >= elementCount)
             throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
         if (elem == null) {
             for (int i = index; i >= 0; i--)
             if (elementData[i]==null)
                 return i;
         } else {
             for (int i = index; i >= 0; i--)
             if (elem.equals(elementData[i]))
                 return i;
         }
         return -1;
     }

     @Override
     public Object elementAt(int index) {
         if (index >= elementCount) {
             throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
         }
         return elementData[index];
     }

     @Override
     public Object firstElement() {
         if (elementCount == 0) {
             throw new NoSuchElementException();
         }
         return elementData[0];
     }

     @Override
     public Object lastElement() {
         if (elementCount == 0) {
             throw new NoSuchElementException();
         }
         return elementData[elementCount - 1];
     }

     @Override
     public void setElementAt(Object obj, int index) {
         if (index >= elementCount) {
             throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                  elementCount);
         }
         elementData[index] = obj;
     }

     @Override
     public void removeElementAt(int index) {
         modCount++;
         if (index >= elementCount) {
             throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                  elementCount);
         } else if (index < 0) {
             throw new ArrayIndexOutOfBoundsException(index);
         }
         int j = elementCount - index - 1;
         if (j > 0) {
             System.arraycopy(elementData, index + 1, elementData, index, j);
         }
         elementCount--;
         elementData[elementCount] = null; /* to let gc do its work */
     }

     @Override
     public void insertElementAt(Object obj, int index) {
         modCount++;
         if (index > elementCount) {
             throw new ArrayIndexOutOfBoundsException(index
                                  + " > " + elementCount);
         }
         ensureCapacityHelper(elementCount + 1);
         System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
         elementData[index] = obj;
         elementCount++;
     }

     @Override
     public void addElement(Object obj) {
         modCount++;
         ensureCapacityHelper(elementCount + 1);
         elementData[elementCount++] = obj;
     }

     @Override
     public boolean removeElement(Object obj) {
         modCount++;
         int i = indexOf(obj);
         if (i >= 0) {
             removeElementAt(i);
             return true;
         }
         return false;
     }

     @Override
     public void removeAllElements() {
         modCount++;
         // Let gc do its work
         for (int i = 0; i < elementCount; i++)
             elementData[i] = null;

         elementCount = 0;
     }

     @Override
     public Object[] toArray() {
         Object[] result = new Object[elementCount];
         System.arraycopy(elementData, 0, result, 0, elementCount);
         return result;
     }

     @Override
     public Object[] toArray(Object a[]) {
         if (a.length < elementCount)
             a = (Object[])java.lang.reflect.Array.newInstance(
                                 a.getClass().getComponentType(), elementCount);

         System.arraycopy(elementData, 0, a, 0, elementCount);

         if (a.length > elementCount)
             a[elementCount] = null;

         return a;
     }

     @Override
     public Object get(int index) {
         if (index >= elementCount)
             throw new ArrayIndexOutOfBoundsException(index);

         return elementData[index];
     }

     @Override
     public Object set(int index, Object element) {
         if (index >= elementCount)
             throw new ArrayIndexOutOfBoundsException(index);

         Object oldValue = elementData[index];
         elementData[index] = element;
         return oldValue;
     }

     @Override
     public boolean add(Object o) {
         modCount++;
         ensureCapacityHelper(elementCount + 1);
         elementData[elementCount++] = o;
         return true;
     }

     @Override
     public Object remove(int index) {
         modCount++;
         if (index >= elementCount)
             throw new ArrayIndexOutOfBoundsException(index);
         Object oldValue = elementData[index];

         int numMoved = elementCount - index - 1;
         if (numMoved > 0)
             System.arraycopy(elementData, index+1, elementData, index,
                      numMoved);
         elementData[--elementCount] = null; // Let gc do its work

         return oldValue;
     }

     @Override
     public boolean containsAll(Collection c) {
         Iterator e = c.iterator();
         while (e.hasNext())
             if(!contains(e.next()))
                 return false;

         return true;
     }

     @Override
     public boolean addAll(Collection c) {
         modCount++;
             Object[] a = c.toArray();
             int numNew = a.length;
         ensureCapacityHelper(elementCount + numNew);
             System.arraycopy(a, 0, elementData, elementCount, numNew);
             elementCount += numNew;
         return numNew != 0;
     }

     @Override
     public boolean removeAll(Collection c) {
         boolean modified = false;
         Iterator e = iterator();
         while (e.hasNext()) {
             if(c.contains(e.next())) {
             e.remove();
             modified = true;
             }
         }
         return modified;
     }

     @Override
     public boolean retainAll(Collection c)  {
         boolean modified = false;
         Iterator e = iterator();
         while (e.hasNext()) {
             if(!c.contains(e.next())) {
             e.remove();
             modified = true;
             }
         }
         return modified;
     }

     @Override
     public boolean addAll(int index, Collection c) {
         modCount++;
         if (index < 0 || index > elementCount)
             throw new ArrayIndexOutOfBoundsException(index);

             Object[] a = c.toArray();
         int numNew = a.length;
         ensureCapacityHelper(elementCount + numNew);

         int numMoved = elementCount - index;
         if (numMoved > 0)
             System.arraycopy(elementData, index, elementData, index + numNew,
                      numMoved);

             System.arraycopy(a, 0, elementData, index, numNew);
         elementCount += numNew;
         return numNew != 0;
     }

     @Override
     public boolean equals(Object o) {
         if (o == this)
             return true;
         if (!(o instanceof List))
             return false;

         List list = (List) o;
         int size = size();
         if (list.size() != size) {
             return false;
         }
         for (int index = 0; index < size; index++) {
             Object left = get(index);
             Object right = list.get(index);
             if ((left != right) && ((left == null) || (right == null) || (!left.equals(right)))) {
                 return false;
             }
         }
         return true;
     }

     @Override
     public int hashCode() {
         int hashCode = 1;
         int size = size();
         for (int index = 0; index < size; index++) {
             Object obj = get(index);
             hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
         }
         return hashCode;
     }

     @Override
     public String toString() {
         StringBuilder buf = new StringBuilder();
         Iterator e = iterator();
         buf.append("[");
         int maxIndex = size() - 1;
         for (int i = 0; i <= maxIndex; i++) {
             buf.append(String.valueOf(e.next()));
             if (i < maxIndex)
             buf.append(", ");
         }
         buf.append("]");
         return buf.toString();
     }

     @Override
     protected void removeRange(int fromIndex, int toIndex) {
         modCount++;
         int numMoved = elementCount - toIndex;
             System.arraycopy(elementData, toIndex, elementData, fromIndex,
                              numMoved);

         // Let gc do its work
         int newElementCount = elementCount - (toIndex-fromIndex);
         while (elementCount != newElementCount)
             elementData[--elementCount] = null;
     }

     private void writeObject(java.io.ObjectOutputStream s)
         throws java.io.IOException
     {
         s.defaultWriteObject();
     }

     @Override
     public List subList(int fromIndex, int toIndex) {
         return new NonSynchronizedSubVector(this, fromIndex, toIndex);
     }

 }
	/*
	* Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0,
	* or the Eclipse Distribution License v. 1.0 which is available at
	* http://www.eclipse.org/org/documents/edl-v10.php.
	*
	* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
	*/

	// Contributors:
	// Oracle - initial API and implementation from Oracle TopLink
	package org.eclipse.persistence.internal.helper;

	import java.util.*;

	/**
	* Vector subclass that removes the synchronization.
	*/
	public class NonSynchronizedVector extends Vector {
	public static NonSynchronizedVector newInstance(int initialCapacity, int capacityIncrement) {
	return new NonSynchronizedVector(initialCapacity, capacityIncrement);
	}

	public static NonSynchronizedVector newInstance(int initialCapacity) {
	return new NonSynchronizedVector(initialCapacity);
	}

	public static NonSynchronizedVector newInstance() {
	return new NonSynchronizedVector();
	}

	public static NonSynchronizedVector newInstance(Collection c) {
	return new NonSynchronizedVector(c);
	}

	public NonSynchronizedVector(int initialCapacity, int capacityIncrement) {
	super(initialCapacity, capacityIncrement);
	}

	public NonSynchronizedVector(int initialCapacity) {
	super(initialCapacity);
	}

	public NonSynchronizedVector() {
	super();
	}

	public NonSynchronizedVector(Collection c) {
	super(c);
	}

	@Override
	public void copyInto(Object anArray[]) {
	System.arraycopy(elementData, 0, anArray, 0, elementCount);
	}

	@Override
	public void trimToSize() {
	modCount++;
	int oldCapacity = elementData.length;
	if (elementCount < oldCapacity) {
	Object oldData[] = elementData;
	elementData = new Object[elementCount];
	System.arraycopy(oldData, 0, elementData, 0, elementCount);
	}
	}

	@Override
	public void ensureCapacity(int minCapacity) {
	modCount++;
	ensureCapacityHelper(minCapacity);
	}

	private void ensureCapacityHelper(int minCapacity) {
	int oldCapacity = elementData.length;
	if (minCapacity > oldCapacity) {
	Object oldData[] = elementData;
	int newCapacity = (capacityIncrement > 0) ?
	(oldCapacity + capacityIncrement) : (oldCapacity * 2);
	if (newCapacity < minCapacity) {
	newCapacity = minCapacity;
	}
	elementData = new Object[newCapacity];
	System.arraycopy(oldData, 0, elementData, 0, elementCount);
	}
	}

	@Override
	public void setSize(int newSize) {
	modCount++;
	if (newSize > elementCount) {
	ensureCapacityHelper(newSize);
	} else {
	for (int i = newSize ; i < elementCount ; i++) {
	elementData[i] = null;
	}
	}
	elementCount = newSize;
	}

	@Override
	public int capacity() {
	return elementData.length;
	}

	@Override
	public Object clone() {
	return new NonSynchronizedVector(this);
	}

	@Override
	public int size() {
	return elementCount;
	}

	@Override
	public boolean isEmpty() {
	return elementCount == 0;
	}

	@Override
	public Enumeration elements() {
	return new Enumeration() {
	int count = 0;

	@Override
	public boolean hasMoreElements() {
	return count < elementCount;
	}

	@Override
	public Object nextElement() {
	if (count < elementCount) {
	return elementData[count++];
	}
	throw new NoSuchElementException("Vector Enumeration");
	}
	};
	}

	@Override
	public int indexOf(Object elem, int index) {
	if (elem == null) {
	for (int i = index ; i < elementCount ; i++)
	if (elementData[i]==null)
	return i;
	} else {
	for (int i = index ; i < elementCount ; i++)
	if (elem.equals(elementData[i]))
	return i;
	}
	return -1;
	}

	@Override
	public int lastIndexOf(Object elem) {
	return lastIndexOf(elem, elementCount-1);
	}

	@Override
	public int lastIndexOf(Object elem, int index) {
	if (index >= elementCount)
	throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
	if (elem == null) {
	for (int i = index; i >= 0; i--)
	if (elementData[i]==null)
	return i;
	} else {
	for (int i = index; i >= 0; i--)
	if (elem.equals(elementData[i]))
	return i;
	}
	return -1;
	}

	@Override
	public Object elementAt(int index) {
	if (index >= elementCount) {
	throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
	}
	return elementData[index];
	}

	@Override
	public Object firstElement() {
	if (elementCount == 0) {
	throw new NoSuchElementException();
	}
	return elementData[0];
	}

	@Override
	public Object lastElement() {
	if (elementCount == 0) {
	throw new NoSuchElementException();
	}
	return elementData[elementCount - 1];
	}

	@Override
	public void setElementAt(Object obj, int index) {
	if (index >= elementCount) {
	throw new ArrayIndexOutOfBoundsException(index + " >= " +
	elementCount);
	}
	elementData[index] = obj;
	}

	@Override
	public void removeElementAt(int index) {
	modCount++;
	if (index >= elementCount) {
	throw new ArrayIndexOutOfBoundsException(index + " >= " +
	elementCount);
	} else if (index < 0) {
	throw new ArrayIndexOutOfBoundsException(index);
	}
	int j = elementCount - index - 1;
	if (j > 0) {
	System.arraycopy(elementData, index + 1, elementData, index, j);
	}
	elementCount--;
	elementData[elementCount] = null; /* to let gc do its work */
	}

	@Override
	public void insertElementAt(Object obj, int index) {
	modCount++;
	if (index > elementCount) {
	throw new ArrayIndexOutOfBoundsException(index
	+ " > " + elementCount);
	}
	ensureCapacityHelper(elementCount + 1);
	System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
	elementData[index] = obj;
	elementCount++;
	}

	@Override
	public void addElement(Object obj) {
	modCount++;
	ensureCapacityHelper(elementCount + 1);
	elementData[elementCount++] = obj;
	}

	@Override
	public boolean removeElement(Object obj) {
	modCount++;
	int i = indexOf(obj);
	if (i >= 0) {
	removeElementAt(i);
	return true;
	}
	return false;
	}

	@Override
	public void removeAllElements() {
	modCount++;
	// Let gc do its work
	for (int i = 0; i < elementCount; i++)
	elementData[i] = null;

	elementCount = 0;
	}

	@Override
	public Object[] toArray() {
	Object[] result = new Object[elementCount];
	System.arraycopy(elementData, 0, result, 0, elementCount);
	return result;
	}

	@Override
	public Object[] toArray(Object a[]) {
	if (a.length < elementCount)
	a = (Object[])java.lang.reflect.Array.newInstance(
	a.getClass().getComponentType(), elementCount);

	System.arraycopy(elementData, 0, a, 0, elementCount);

	if (a.length > elementCount)
	a[elementCount] = null;

	return a;
	}

	@Override
	public Object get(int index) {
	if (index >= elementCount)
	throw new ArrayIndexOutOfBoundsException(index);

	return elementData[index];
	}

	@Override
	public Object set(int index, Object element) {
	if (index >= elementCount)
	throw new ArrayIndexOutOfBoundsException(index);

	Object oldValue = elementData[index];
	elementData[index] = element;
	return oldValue;
	}

	@Override
	public boolean add(Object o) {
	modCount++;
	ensureCapacityHelper(elementCount + 1);
	elementData[elementCount++] = o;
	return true;
	}

	@Override
	public Object remove(int index) {
	modCount++;
	if (index >= elementCount)
	throw new ArrayIndexOutOfBoundsException(index);
	Object oldValue = elementData[index];

	int numMoved = elementCount - index - 1;
	if (numMoved > 0)
	System.arraycopy(elementData, index+1, elementData, index,
	numMoved);
	elementData[--elementCount] = null; // Let gc do its work

	return oldValue;
	}

	@Override
	public boolean containsAll(Collection c) {
	Iterator e = c.iterator();
	while (e.hasNext())
	if(!contains(e.next()))
	return false;

	return true;
	}

	@Override
	public boolean addAll(Collection c) {
	modCount++;
	Object[] a = c.toArray();
	int numNew = a.length;
	ensureCapacityHelper(elementCount + numNew);
	System.arraycopy(a, 0, elementData, elementCount, numNew);
	elementCount += numNew;
	return numNew != 0;
	}

	@Override
	public boolean removeAll(Collection c) {
	boolean modified = false;
	Iterator e = iterator();
	while (e.hasNext()) {
	if(c.contains(e.next())) {
	e.remove();
	modified = true;
	}
	}
	return modified;
	}

	@Override
	public boolean retainAll(Collection c) {
	boolean modified = false;
	Iterator e = iterator();
	while (e.hasNext()) {
	if(!c.contains(e.next())) {
	e.remove();
	modified = true;
	}
	}
	return modified;
	}

	@Override
	public boolean addAll(int index, Collection c) {
	modCount++;
	if (index < 0 \|\| index > elementCount)
	throw new ArrayIndexOutOfBoundsException(index);

	Object[] a = c.toArray();
	int numNew = a.length;
	ensureCapacityHelper(elementCount + numNew);

	int numMoved = elementCount - index;
	if (numMoved > 0)
	System.arraycopy(elementData, index, elementData, index + numNew,
	numMoved);

	System.arraycopy(a, 0, elementData, index, numNew);
	elementCount += numNew;
	return numNew != 0;
	}

	@Override
	public boolean equals(Object o) {
	if (o == this)
	return true;
	if (!(o instanceof List))
	return false;

	List list = (List) o;
	int size = size();
	if (list.size() != size) {
	return false;
	}
	for (int index = 0; index < size; index++) {
	Object left = get(index);
	Object right = list.get(index);
	if ((left != right) && ((left == null) \|\| (right == null) \|\| (!left.equals(right)))) {
	return false;
	}
	}
	return true;
	}

	@Override
	public int hashCode() {
	int hashCode = 1;
	int size = size();
	for (int index = 0; index < size; index++) {
	Object obj = get(index);
	hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
	}
	return hashCode;
	}

	@Override
	public String toString() {
	StringBuilder buf = new StringBuilder();
	Iterator e = iterator();
	buf.append("[");
	int maxIndex = size() - 1;
	for (int i = 0; i <= maxIndex; i++) {
	buf.append(String.valueOf(e.next()));
	if (i < maxIndex)
	buf.append(", ");
	}
	buf.append("]");
	return buf.toString();
	}

	@Override
	protected void removeRange(int fromIndex, int toIndex) {
	modCount++;
	int numMoved = elementCount - toIndex;
	System.arraycopy(elementData, toIndex, elementData, fromIndex,
	numMoved);

	// Let gc do its work
	int newElementCount = elementCount - (toIndex-fromIndex);
	while (elementCount != newElementCount)
	elementData[--elementCount] = null;
	}

	private void writeObject(java.io.ObjectOutputStream s)
	throws java.io.IOException
	{
	s.defaultWriteObject();
	}

	@Override
	public List subList(int fromIndex, int toIndex) {
	return new NonSynchronizedSubVector(this, fromIndex, toIndex);
	}

	}