/*
* Licensed to the Apache Software Foundation (ASF) under one or more contributor license
* agreements. See the NOTICE file distributed with this work for additional information regarding
* copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the License. You may obtain a
* copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package org.apache.geode.internal.util;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.apache.geode.DataSerializable;
import org.apache.geode.internal.InternalDataSerializer;
import org.apache.geode.internal.cache.Node;
/**
* Versioned ArrayList which maintains the version everytime the list gets modified. This is
* thread-safe in terms of add and remove operations and also list is an unmodifiable list to avoid
* ConcurrentModificationException.
*
* @see java.util.ConcurrentModificationException
*
*/
public class VersionedArrayList implements DataSerializable, Versionable, Iterable<Node> {
private static final long serialVersionUID = -1455442285961593385L;
/** Version of the list. */
private long version = -1;
/** ArrayList */
private List<Node> list;
// private List vhist = new ArrayList(); // DEBUG
/**
* Constructor for DataSerializable.
*/
public VersionedArrayList() {
this.list = new ArrayList<Node>();
}
/**
* Constructor.
*
* @param size
*/
public VersionedArrayList(int size) {
this.list = new ArrayList<Node>(size);
}
public VersionedArrayList(List<? extends Node> list) {
this.list = Collections.unmodifiableList(list);
// incrementVersion("i->" + list);
incrementVersion();
}
/**
* Adds obj to the list. Addition is done by making a copy of the existing list and then adding
* the obj to the new list and assigning the old list to the new unmodifiable list. This is to
* ensure that the iterator of the list doesn't get ConcurrentModificationException.
*
* @see java.util.ConcurrentModificationException
* @param obj
*/
public synchronized void add(Node obj) {
ArrayList newList = new ArrayList<Node>(this.list);
newList.add(obj);
this.list = Collections.unmodifiableList(newList);
// incrementVersion("a->" + obj);
incrementVersion();
}
/**
* Removes obj from the list. Removal is done by making a copy of the existing list and then
* removing the obj from the new list. If the object was removed, the list is assigning to the new
* unmodifiable list. This is to ensure that the iterator of the list doesn't get
* ConcurrentModificationException.
*
* @return true if the element was removed and the version was changed, otherwise version and list
* are left unmodified.
*
* @see java.util.ConcurrentModificationException
* @param obj the object to remove from the list
*/
public synchronized boolean remove(Node obj) {
ArrayList<Node> newList = new ArrayList<Node>(this.list);
boolean ret = newList.remove(obj);
if (ret) {
this.list = Collections.unmodifiableList(newList);
// incrementVersion("r->" + obj);
incrementVersion();
}
return ret;
}
/**
* Returns the iterator.
*
* @return a list Iterator
*/
public synchronized Iterator<Node> iterator() {
return this.list.iterator();
}
/**
* Returns the size of the list.
*
* @return int
*/
public synchronized int size() {
return this.list.size();
}
/**
* Returns true if obj is present in the list otherwise false.
*
* @param obj
* @return true if obj is present in the list
*/
public boolean contains(Node obj) {
final List<Node> l;
synchronized (this) {
l = this.list;
}
return l.contains(obj);
}
/**
* Returns Object at index i.
*
* @param i
* @return Object
*/
public Object get(int i) {
final List<Node> l;
synchronized (this) {
l = this.list;
}
return l.get(i);
}
/**
* Returns the index of Object if present, else -1.
*
* @param obj
* @return int
*/
public int indexOf(Object obj) {
final List<Node> l;
synchronized (this) {
l = this.list;
}
return l.indexOf(obj);
}
/**
* Returns a copy of the arraylist contained.
*
* @return ArrayList
*/
public Set<Node> getListCopy() {
final List<Node> l;
synchronized (this) {
l = this.list;
}
return new HashSet<Node>(l);
}
/**
* Prints the version and elements of the list.
*
* @return String with version and elements of the list.
*/
@Override
public String toString() {
final List<Node> l;
// final List vh;
synchronized (this) {
l = this.list;
// vh = this.vhist;
}
StringBuffer sb = new StringBuffer();
sb.append("ArrayList version = " + getVersion() + " Elements = { ");
for (int i = 0; i < l.size(); i++) {
sb.append(l.get(i).toString() + ", ");
}
// sb.append("vhist:\n " + vh);
sb.append("}");
return sb.toString();
}
public void toData(DataOutput out) throws IOException {
long v = -1;
final List<Node> l;
// final List vh;
synchronized (this) {
v = this.version;
l = this.list;
// vh = this.vhist;
}
out.writeLong(v);
final int s = l.size();
out.writeInt(s);
for (int k = 0; k < s; k++) {
InternalDataSerializer.invokeToData((l.get(k)), out);
}
// final int sh = vh.size();
// out.writeInt(sh);
// for (int k = 0; k < sh; k++) {
// out.writeUTF((String) vh.get(k));
// }
}
public void fromData(DataInput in) throws IOException, ClassNotFoundException {
final ArrayList<Node> l = new ArrayList<Node>();
final long v = in.readLong();
final int size = in.readInt();
for (int k = 0; k < size; k++) {
l.add(new Node(in));
}
// final ArrayList vh = new ArrayList();
// final int vhsize = in.readInt();
// for (int k = 0; k < vhsize; k++) {
// vh.add(in.readUTF());
// }
synchronized (this) {
this.version = v;
this.list = Collections.unmodifiableList(l);
// this.vhist = Collections.unmodifiableList(vh);
}
}
/*
* (non-Javadoc)
*
* @see org.apache.geode.internal.util.Versionable#getVersion()
*/
public synchronized Comparable getVersion() {
return Long.valueOf(this.version);
}
public boolean isNewerThan(Versionable other) {
if (other instanceof VersionedArrayList) {
final long v = ((Long) other.getVersion()).longValue();
synchronized (this) {
return this.version > v;
}
} else {
final Comparable o = other.getVersion();
return getVersion().compareTo(o) > 0;
}
}
public boolean isOlderThan(Versionable other) {
if (other instanceof VersionedArrayList) {
final long v;
synchronized (other) {
v = ((VersionedArrayList) other).version;
}
synchronized (this) {
return this.version < v;
}
} else {
final Comparable o = other.getVersion();
return getVersion().compareTo(o) < 0;
}
}
public boolean isSame(Versionable other) {
if (other instanceof VersionedArrayList) {
final long v;
synchronized (other) {
v = ((VersionedArrayList) other).version;
}
synchronized (this) {
return this.version == v;
}
} else {
final Comparable o = other.getVersion();
return getVersion().compareTo(o) == 0;
}
}
// private synchronized void incrementVersion(String op)
private synchronized void incrementVersion() {
// DEBUG
// {
// StringWriter s = new StringWriter();
// final String pre =
// "o=" + op +
// ":t=" + System.currentTimeMillis() +
// ":m=" + InternalDistributedSystem.getAnyInstance().getDistributedMember().toString() + ": ";
// s.write(pre);
// PrintWriter p = new PrintWriter(s);
// new Exception().fillInStackTrace().printStackTrace(p);
//
// ArrayList newList = new ArrayList(this.vhist);
// newList.add(pre); // Capture what code added this version
// this.vhist = Collections.unmodifiableList(newList);
// }
++this.version;
}
}