linkimpl.java

这个是perst-269.zip下面的SOURCECODE,和大家分享了。

package org.garret.perst.impl;
import  org.garret.perst.*;
import  java.util.*;
import  java.lang.reflect.Array;

public class LinkImpl<T extends IPersistent> implements Link<T> { 
    private final void modify() { 
        if (owner != null) { 
            owner.modify();
        }
    }

    public int size() {
        return used;
    }

    public void setSize(int newSize) { 
        if (newSize < used) { 
            for (int i = used; --i >= newSize; arr[i] = null);
        } else { 
            reserveSpace(newSize - used);            
        }
        used = newSize;
    }

    public T get(int i) {
        if (i < 0 || i >= used) { 
            throw new IndexOutOfBoundsException();
        }
        return (T)loadElem(i);
    }

    public IPersistent getRaw(int i) {
        if (i < 0 || i >= used) { 
            throw new IndexOutOfBoundsException();
        }
        return arr[i];
    }

    public void pin() { 
        for (int i = 0, n = used; i < n; i++) { 
            arr[i] = loadElem(i);
        }
    }

    public void unpin() { 
        for (int i = 0, n = used; i < n; i++) { 
            IPersistent elem = arr[i];
            if (elem != null && !elem.isRaw() && elem.isPersistent()) { 
                arr[i] = new PersistentStub(elem.getStorage(), elem.getOid());
            }
        }
    }


    public T set(int i, T obj) {
        if (i < 0 || i >= used) { 
            throw new IndexOutOfBoundsException();
        }
        T prev = (T)loadElem(i);
        arr[i] = obj;
        modify();
        return prev;
    }

    public void setObject(int i, T obj) {
        if (i < 0 || i >= used) { 
            throw new IndexOutOfBoundsException();
        }
        arr[i] = obj;
        modify();
    }

    public boolean isEmpty() {
        return used == 0;
    }

    protected void removeRange(int fromIndex, int toIndex) {
        int size = used;
 	int numMoved = size - toIndex;
        System.arraycopy(arr, toIndex, arr, fromIndex, numMoved);

	// Let gc do its work
	int newSize = size - (toIndex-fromIndex);
	while (size != newSize) {
	    arr[--size] = null;
        }                                       
        used = size;
        modify();
    }

 
    public void removeObject(int i) {
        if (i < 0 || i >= used) { 
            throw new IndexOutOfBoundsException();
        }
        used -= 1;
        System.arraycopy(arr, i+1, arr, i, used-i);
        arr[used] = null;
        modify();
    }

    public T remove(int i) {
        if (i < 0 || i >= used) { 
            throw new IndexOutOfBoundsException();
        }
        T obj = (T)loadElem(i);
        used -= 1;
        System.arraycopy(arr, i+1, arr, i, used-i);
        arr[used] = null;
        modify();
        return obj;
    }

    void reserveSpace(int len) { 
        if (used + len > arr.length) { 
            IPersistent[] newArr = new IPersistent[used + len > arr.length*2 ? used + len : arr.length*2];
            System.arraycopy(arr, 0, newArr, 0, used);
            arr = newArr;
        }
        modify();
    }

    public void add(int i, T obj) { 
        insert(i, obj);
    }

    public void insert(int i, T obj) { 
         if (i < 0 || i > used) { 
            throw new IndexOutOfBoundsException();
        }
        reserveSpace(1);
        System.arraycopy(arr, i, arr, i+1, used-i);
        arr[i] = obj;
        used += 1;
    }

    public boolean add(T obj) {
        reserveSpace(1);
        arr[used++] = obj;
        return true;
    }

    public void addAll(T[] a) {
        addAll(a, 0, a.length);
    }
    
    public boolean addAll(int index, Collection<? extends T> c) {
	boolean modified = false;
	Iterator<? extends T> e = c.iterator();
	while (e.hasNext()) {
	    add(index++, e.next());
	    modified = true;
	}
	return modified;
    }

    public void addAll(T[] a, int from, int length) {
        reserveSpace(length);
        System.arraycopy(a, from, arr, used, length);
        used += length;
    }

    public boolean addAll(Link<T> link) {        
        int n = link.size();
        reserveSpace(n);
        for (int i = 0, j = used; i < n; i++, j++) { 
            arr[j] = link.getRaw(i);
        }
        used += n;
        return true;
    }

    public Object[] toArray() {
        return toPersistentArray();
    }

    public IPersistent[] toRawArray() {
        return arr;
    }

    public IPersistent[] toPersistentArray() {
        IPersistent[] a = new IPersistent[used];
        for (int i = used; --i >= 0;) { 
            a[i] = loadElem(i);
        }
        return a;
    }
    
    public <T> T[] toArray(T[] arr) {
        if (arr.length < used) { 
            arr = (T[])Array.newInstance(arr.getClass().getComponentType(), used);
        }
        for (int i = used; --i >= 0;) { 
            arr[i] = (T)loadElem(i);
        }
        if (arr.length > used) { 
            arr[used] = null;
        }
        return arr;
    }
    
    public boolean contains(Object obj) {
        return indexOf(obj) >= 0;
    }

    public boolean containsObject(T obj) {
        return indexOfObject(obj) >= 0;
    }

    public int lastIndexOfObject(Object obj) {
        int oid;
        IPersistent[] a = arr;
        if (obj instanceof IPersistent && (oid = ((IPersistent)obj).getOid()) != 0) { 
            for (int i = used; --i >= 0;) {
                IPersistent elem = a[i];
                if (elem != null && elem.getOid() == oid) {
                    return i;
                }
            }
        } else { 
            for (int i = used; --i >= 0;) {
                if (a[i] == obj) {
                    return i;
                }
            }
        }
        return -1;
    }
    
    public int indexOfObject(Object obj) {
        int oid;
        IPersistent[] a = arr;
        if (obj instanceof IPersistent && (oid = ((IPersistent)obj).getOid()) != 0) { 
            for (int i = 0, n = used; i < n; i++) {
                IPersistent elem = a[i];
                if (elem != null && elem.getOid() == oid) {
                    return i;
                }
            }
        } else { 
            for (int i = 0, n = used; i < n; i++) {
                if (a[i] == obj) {
                    return i;
                }
            }
        }
        return -1;
    }
    
    public int indexOf(Object obj) {
        if (obj == null) { 
            for (int i = 0, n = used; i < n; i++) {
                if (arr[i] == null) {
                    return i;
                }
            }
        } else { 
            for (int i = 0, n = used; i < n; i++) {
                if (obj.equals(loadElem(i))) {
                    return i;
                }
            }
        }
        return -1;
    }
    
    public int lastIndexOf(Object obj) {
        if (obj == null) { 
            for (int i = used; --i >= 0;) {
                if (arr[i] == null) {
                    return i;
                }
            }
        } else { 
            for (int i = used; --i >= 0;) {
                if (obj.equals(loadElem(i))) {
                    return i;
                }
            }
        }
        return -1;
    }
    
    public boolean containsElement(int i, T obj) {
        IPersistent elem = arr[i];
        return elem == obj || (elem != null && elem.getOid() != 0 && elem.getOid() == obj.getOid());
    }

    public void clear() { 
        for (int i = used; --i >= 0;) { 
            arr[i] = null;
        }
        used = 0;
        modify();
    }

    public List<T> subList(int fromIndex, int toIndex) {
        return new SubList<T>(this, fromIndex, toIndex);
    }

    static class SubList<T extends IPersistent> extends AbstractList<T> implements RandomAccess {
        private LinkImpl<T> l;
        private int offset;
        private int size;