persistentcollection.java

人力资源管理系统主要包括：人员管理、招聘管理、培训管理、奖惩管理和薪金管理五大管理模块。

		return collectionSnapshot;
	}

	/**
	 * Sets the collectionSnapshot.
	 * @param collectionSnapshot The collectionSnapshot to set
	 */
	public void setCollectionSnapshot(CollectionSnapshot collectionSnapshot) {
		this.collectionSnapshot = collectionSnapshot;
	}
	
	/**
	 * Called before inserting rows, to ensure that any surrogate keys
	 * are fully generated
	 */
	public void preInsert(CollectionPersister persister) throws HibernateException {}
	/**
	 * Called after inserting a row, to fetch the natively generated id
	 */
	public void afterRowInsert(CollectionPersister persister, Object entry, int i) throws HibernateException {}
	/**
	 * get all "orphaned" elements
	 */
	public abstract Collection getOrphans(Serializable snapshot) throws HibernateException;

	/**
	 * Get the current session
	 */
	protected final SessionImplementor getSession() {
		return session;
	}

	final class IteratorProxy implements Iterator {
		private final Iterator iter;
		IteratorProxy(Iterator iter) {
			this.iter=iter;
		}
		public boolean hasNext() {
			return iter.hasNext();
		}
		
		public Object next() {
			return iter.next();
		}
		
		public void remove() {
			write();
			iter.remove();
		}
		
	}
	
	final class ListIteratorProxy implements ListIterator {
		private final ListIterator iter;
		ListIteratorProxy(ListIterator iter) {
			this.iter = iter;
		}
		public void add(Object o) {
			write();
			iter.add(o);
		}
		
		public boolean hasNext() {
			return iter.hasNext();
		}
		
		public boolean hasPrevious() {
			return iter.hasPrevious();
		}
		
		public Object next() {
			return iter.next();
		}
		
		public int nextIndex() {
			return iter.nextIndex();
		}
		
		public Object previous() {
			return iter.previous();
		}
		
		public int previousIndex() {
			return iter.previousIndex();
		}
		
		public void remove() {
			write();
			iter.remove();
		}
		
		public void set(Object o) {
			write();
			iter.set(o);
		}
		
	}
	
	class SetProxy implements java.util.Set {
		
		final Collection set;
		
		SetProxy(Collection set) {
			this.set=set;
		}
		public boolean add(Object o) {
			write();
			return set.add(o);
		}
		
		public boolean addAll(Collection c) {
			write();
			return set.addAll(c);
		}
		
		public void clear() {
			write();
			set.clear();
		}
		
		public boolean contains(Object o) {
			return set.contains(o);
		}
		
		public boolean containsAll(Collection c) {
			return set.containsAll(c);
		}
		
		public boolean isEmpty() {
			return set.isEmpty();
		}
		
		public Iterator iterator() {
			return new IteratorProxy( set.iterator() );
		}
		
		public boolean remove(Object o) {
			write();
			return set.remove(o);
		}
		
		public boolean removeAll(Collection c) {
			write();
			return set.removeAll(c);
		}
		
		public boolean retainAll(Collection c) {
			write();
			return set.retainAll(c);
		}
		
		public int size() {
			return set.size();
		}
		
		public Object[] toArray() {
			return set.toArray();
		}
		
		public Object[] toArray(Object[] array) {
			return set.toArray(array);
		}
		
	}
	
	final class ListProxy implements java.util.List {
		
		private final java.util.List list;
		
		ListProxy(java.util.List list) {
			this.list = list;
		}
		
		public void add(int index, Object value) {
			write();
			list.add(index, value);
		}
		
		/**
		 * @see java.util.Collection#add(Object)
		 */
		public boolean add(Object o) {
			write();
			return list.add(o);
		}
		
		/**
		 * @see java.util.Collection#addAll(Collection)
		 */
		public boolean addAll(Collection c) {
			write();
			return list.addAll(c);
		}
		
		/**
		 * @see java.util.List#addAll(int, Collection)
		 */
		public boolean addAll(int i, Collection c) {
			write();
			return list.addAll(i, c);
		}
		
		/**
		 * @see java.util.Collection#clear()
		 */
		public void clear() {
			write();
			list.clear();
		}
		
		/**
		 * @see java.util.Collection#contains(Object)
		 */
		public boolean contains(Object o) {
			return list.contains(o);
		}
		
		/**
		 * @see java.util.Collection#containsAll(Collection)
		 */
		public boolean containsAll(Collection c) {
			return list.containsAll(c);
		}
		
		/**
		 * @see java.util.List#get(int)
		 */
		public Object get(int i) {
			return list.get(i);
		}
		
		/**
		 * @see java.util.List#indexOf(Object)
		 */
		public int indexOf(Object o) {
			return list.indexOf(o);
		}
		
		/**
		 * @see java.util.Collection#isEmpty()
		 */
		public boolean isEmpty() {
			return list.isEmpty();
		}
		
		/**
		 * @see java.util.Collection#iterator()
		 */
		public Iterator iterator() {
			return new IteratorProxy( list.iterator() );
		}
		
		/**
		 * @see java.util.List#lastIndexOf(Object)
		 */
		public int lastIndexOf(Object o) {
			return list.lastIndexOf(o);
		}
		
		/**
		 * @see java.util.List#listIterator()
		 */
		public ListIterator listIterator() {
			return new ListIteratorProxy( list.listIterator() );
		}
		
		/**
		 * @see java.util.List#listIterator(int)
		 */
		public ListIterator listIterator(int i) {
			return new ListIteratorProxy( list.listIterator(i) );
		}
		
		/**
		 * @see java.util.List#remove(int)
		 */
		public Object remove(int i) {
			write();
			return list.remove(i);
		}
		
		/**
		 * @see java.util.Collection#remove(Object)
		 */
		public boolean remove(Object o) {
			write();
			return list.remove(o);
		}
		
		/**
		 * @see java.util.Collection#removeAll(Collection)
		 */
		public boolean removeAll(Collection c) {
			write();
			return list.removeAll(c);
		}
		
		/**
		 * @see java.util.Collection#retainAll(Collection)
		 */
		public boolean retainAll(Collection c) {
			write();
			return list.retainAll(c);
		}
		
		/**
		 * @see java.util.List#set(int, Object)
		 */
		public Object set(int i, Object o) {
			write();
			return list.set(i, o);
		}
		
		/**
		 * @see java.util.Collection#size()
		 */
		public int size() {
			return list.size();
		}
		
		/**
		 * @see java.util.List#subList(int, int)
		 */
		public List subList(int i, int j) {
			return list.subList(i, j);
		}
		
		/**
		 * @see java.util.Collection#toArray()
		 */
		public Object[] toArray() {
			return list.toArray();
		}
		
		/**
		 * @see java.util.Collection#toArray(Object[])
		 */
		public Object[] toArray(Object[] array) {
			return list.toArray(array);
		}
		
	}
	
	
	protected static Collection getOrphans(Collection oldElements, Collection currentElements, SessionImplementor session) 
	throws HibernateException {
		
		// short-circuit(s)
		if ( currentElements.size()==0 ) return oldElements; // no new elements, the old list contains only Orphans
		if ( oldElements.size()==0) return oldElements; // no old elements, so no Orphans neither
		
		// create the collection holding the Orphans
		Collection res = new ArrayList();
		
		// collect EntityIdentifier(s) of the *current* elements - add them into a HashSet for fast access
		java.util.Set currentIds = new HashSet();
		for ( Iterator it=currentElements.iterator(); it.hasNext(); ) {
			Object current = it.next();
			if ( current!=null && session.isSaved(current) ) {
				currentIds.add( session.getEntityIdentifierIfNotUnsaved(current) );
			}
		}
		
		// iterate over the *old* list
		for ( Iterator it=oldElements.iterator(); it.hasNext(); ) {
			Object old = it.next();
			Object id = session.getEntityIdentifierIfNotUnsaved(old);
			if ( !currentIds.contains(id) ) res.add(old);
		}
		
		return res;
	}
		
	static void identityRemove(Collection list, Object object, SessionImplementor session) 
	throws HibernateException {
		
		if ( object!=null && session.isSaved(object) ) {
		
			Serializable idOfCurrent = session.getEntityIdentifierIfNotUnsaved(object);
			Iterator iter = list.iterator();
			while ( iter.hasNext() ) {
				Serializable idOfOld = session.getEntityIdentifierIfNotUnsaved( iter.next() );
				if ( idOfCurrent.equals(idOfOld) ) {
					iter.remove();
					break;
				}
			}
			
		}
	}
}