public PersistentSet() 
{
		// intentionally empty
}

Empty constructor.

Note: this form is not ever ever ever used by Hibernate; it is, however, needed for SOAP libraries and other such marshalling code.

 public PersistentSet(SessionImplementor session) 
{
		super( session );
}

Constructor matching super. Instantiates a lazy set (the underlying set is un-initialized).

Parameters:

session - The session to which this set will belong.

 public PersistentSet(SessionImplementor session,
    Set set) 
{
		super(session);
		// Sets can be just a view of a part of another collection.
		// do we need to copy it to be sure it won't be changing
		// underneath us?
		// ie. this.set.addAll(set);
		this.set = set;
		setInitialized();
		setDirectlyAccessible(true);
}

Instantiates a non-lazy set (the underlying set is constructed from the incoming set reference).

Parameters:

session - The session to which this set will belong.

set - The underlying set data.

 public boolean add(Object value) 
{
		Boolean exists = isOperationQueueEnabled() ? readElementExistence( value ) : null;
		if ( exists == null ) {
			initialize( true );
			if ( set.add( value ) ) {
				dirty();
				return true;
			}
			else {
				return false;
			}
		}
		else if ( exists.booleanValue() ) {
			return false;
		}
		else {
			queueOperation( new SimpleAdd(value) );
			return true;
		}
}

 public boolean addAll(Collection coll) 
{
		if ( coll.size()  > 0 ) {
			initialize( true );
			if ( set.addAll( coll ) ) {
				dirty();
				return true;
			}
			else {
				return false;
			}
		}
		else {
			return false;
		}
}

 public  void beforeInitialize(CollectionPersister persister,
    int anticipatedSize) 
{
		this.set = ( Set ) persister.getCollectionType().instantiate( anticipatedSize );
}

 public  void beginRead() 
{
		super.beginRead();
		tempList = new ArrayList();
}

 public  void clear() 
{
		if ( isClearQueueEnabled() ) {
			queueOperation( new Clear() );
		}
		else {
			initialize( true );
			if ( !set.isEmpty() ) {
				set.clear();
				dirty();
			}
		}
}

 public boolean contains(Object object) 
{
		Boolean exists = readElementExistence(object);
		return exists==null ? 
				set.contains(object) : 
				exists.booleanValue();
}

 public boolean containsAll(Collection coll) 
{
		read();
		return set.containsAll(coll);
}

 public Serializable disassemble(CollectionPersister persister) throws HibernateException 
{
		Serializable[] result = new Serializable[ set.size() ];
		Iterator iter = set.iterator();
		int i=0;
		while ( iter.hasNext() ) {
			result[i++] = persister.getElementType().disassemble( iter.next(), getSession(), null );
		}
		return result;
}

 public boolean empty() 
{
		return set.isEmpty();
}

 public boolean endRead() 
{
		set.addAll(tempList);
		tempList = null;
		setInitialized();
		return true;
}

 public Iterator entries(CollectionPersister persister) 
{
		return set.iterator();
}

 public boolean entryExists(Object key,
    int i) 
{
		return true;
}

 public boolean equals(Object other) 
{
		read();
		return set.equals(other);
}

 public boolean equalsSnapshot(CollectionPersister persister) throws HibernateException 
{
		Type elementType = persister.getElementType();
		java.util.Map sn = (java.util.Map) getSnapshot();
		if ( sn.size()!=set.size() ) {
			return false;
		}
		else {
			Iterator iter = set.iterator();
			while ( iter.hasNext() ) {
				Object test = iter.next();
				Object oldValue = sn.get(test);
				if ( oldValue==null || elementType.isDirty( oldValue, test, getSession() ) ) return false;
			}
			return true;
		}
}

 public Iterator getDeletes(CollectionPersister persister,
    boolean indexIsFormula) throws HibernateException 
{
		Type elementType = persister.getElementType();
		final java.util.Map sn = (java.util.Map) getSnapshot();
		ArrayList deletes = new ArrayList( sn.size() );
		Iterator iter = sn.keySet().iterator();
		while ( iter.hasNext() ) {
			Object test = iter.next();
			if ( !set.contains(test) ) {
				// the element has been removed from the set
				deletes.add(test);
			}
		}
		iter = set.iterator();
		while ( iter.hasNext() ) {
			Object test = iter.next();
			Object oldValue = sn.get(test);
			if ( oldValue!=null && elementType.isDirty( test, oldValue, getSession() ) ) {
				// the element has changed
				deletes.add(oldValue);
			}
		}
		return deletes.iterator();
}

 public Object getElement(Object entry) 
{
		return entry;
}

 public Object getIndex(Object entry,
    int i,
    CollectionPersister persister) 
{
		throw new UnsupportedOperationException("Sets don't have indexes");
}

 public Collection getOrphans(Serializable snapshot,
    String entityName) throws HibernateException 
{
		java.util.Map sn = (java.util.Map) snapshot;
		return getOrphans( sn.keySet(), set, entityName, getSession() );
}

 public Serializable getSnapshot(CollectionPersister persister) throws HibernateException 
{
		EntityMode entityMode = getSession().getEntityMode();
		//if (set==null) return new Set(session);
		HashMap clonedSet = new HashMap( set.size() );
		Iterator iter = set.iterator();
		while ( iter.hasNext() ) {
			Object copied = persister.getElementType()
					.deepCopy( iter.next(), entityMode, persister.getFactory() );
			clonedSet.put(copied, copied);
		}
		return clonedSet;
}

 public Object getSnapshotElement(Object entry,
    int i) 
{
		throw new UnsupportedOperationException("Sets don't support updating by element");
}

 public int hashCode() 
{
		read();
		return set.hashCode();
}

 public  void initializeFromCache(CollectionPersister persister,
    Serializable disassembled,
    Object owner) throws HibernateException 
{
		Serializable[] array = ( Serializable[] ) disassembled;
		int size = array.length;
		beforeInitialize( persister, size );
		for (int i = 0; i <  size; i++ ) {
			Object element = persister.getElementType().assemble( array[i], getSession(), owner );
			if ( element != null ) {
				set.add( element );
			}
		}
}

 public boolean isEmpty() 
{
		return readSize() ? getCachedSize()==0 : set.isEmpty();
}

 public boolean isRowUpdatePossible() 
{
		return false;
}

 public boolean isSnapshotEmpty(Serializable snapshot) 
{
		return ( (java.util.Map) snapshot ).isEmpty();
}

 public boolean isWrapper(Object collection) 
{
		return set==collection;
}

 public Iterator iterator() 
{
		read();
		return new IteratorProxy( set.iterator() );
}

 public boolean needsInserting(Object entry,
    int i,
    Type elemType) throws HibernateException 
{
		final java.util.Map sn = (java.util.Map) getSnapshot();
		Object oldValue = sn.get(entry);
		// note that it might be better to iterate the snapshot but this is safe,
		// assuming the user implements equals() properly, as required by the Set
		// contract!
		return oldValue==null || elemType.isDirty( oldValue, entry, getSession() );
}

 public boolean needsUpdating(Object entry,
    int i,
    Type elemType) 
{
		return false;
}

 public Object readFrom(ResultSet rs,
    CollectionPersister persister,
    CollectionAliases descriptor,
    Object owner) throws HibernateException, SQLException 
{
		Object element = persister.readElement( rs, owner, descriptor.getSuffixedElementAliases(), getSession() );
		if (element!=null) tempList.add(element);
		return element;
}

 public boolean remove(Object value) 
{
		Boolean exists = isPutQueueEnabled() ? readElementExistence( value ) : null;
		if ( exists==null ) {
			initialize( true );
			if ( set.remove( value ) ) {
				dirty();
				return true;
			}
			else {
				return false;
			}
		}
		else if ( exists.booleanValue() ) {
			queueOperation( new SimpleRemove(value) );
			return true;
		}
		else {
			return false;
		}
}

 public boolean removeAll(Collection coll) 
{
		if ( coll.size()  > 0 ) {
			initialize( true );
			if ( set.removeAll( coll ) ) {
				dirty();
				return true;
			}
			else {
				return false;
			}
		}
		else {
			return false;
		}
}

 public boolean retainAll(Collection coll) 
{
		initialize( true );
		if ( set.retainAll( coll ) ) {
			dirty();
			return true;
		}
		else {
			return false;
		}
}

 public int size() 
{
		return readSize() ? getCachedSize() : set.size();
}

 public Object[] toArray() 
{
		read();
		return set.toArray();
}

 public Object[] toArray(Object[] array) 
{
		read();
		return set.toArray(array);
}

 public String toString() 
{
		//if (needLoading) return "asleep";
		read();
		return set.toString();
}