Open Source Repository

Home /hibernate/hibernate-3.2.7.ga | Repository Home


org/hibernate/collection/PersistentIdentifierBag.java
//$Id: PersistentIdentifierBag.java 10739 2006-11-06 22:00:41Z [email protected] $
package org.hibernate.collection;

import java.io.Serializable;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;

import org.hibernate.EntityMode;
import org.hibernate.HibernateException;
import org.hibernate.loader.CollectionAliases;
import org.hibernate.engine.SessionImplementor;
import org.hibernate.persister.collection.CollectionPersister;
import org.hibernate.type.Type;

/**
 * An <tt>IdentifierBag</tt> implements "bag" semantics more efficiently than
 * a regular <tt>Bag</tt> by adding a synthetic identifier column to the
 * table. This identifier is unique for all rows in the table, allowing very
 * efficient updates and deletes. The value of the identifier is never exposed
 * to the application.<br>
 <br>
 <tt>IdentifierBag</tt>s may not be used for a many-to-one association.
 * Furthermore, there is no reason to use <tt>inverse="true"</tt>.
 *
 @author Gavin King
 */
public class PersistentIdentifierBag extends AbstractPersistentCollection implements List {

  protected List values; //element
  protected Map identifiers; //index -> id

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

  public PersistentIdentifierBag() {} //needed for SOAP libraries, etc

  public PersistentIdentifierBag(SessionImplementor session, Collection coll) {
    super(session);
    if (coll instanceof List) {
      values = (Listcoll;
    }
    else {
      values = new ArrayList();
      Iterator iter = coll.iterator();
      while iter.hasNext() ) {
        values.additer.next() );
      }
    }
    setInitialized();
    setDirectlyAccessible(true);
    identifiers = new HashMap();
  }

  public void initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)
  throws HibernateException {
    Serializable[] array = (Serializable[]) disassembled;
    int size = array.length;
    beforeInitializepersister, size );
    for int i = 0; i < size; i+=) {
      identifiers.put(
        new Integer(i/2),
        persister.getIdentifierType().assemblearray[i], getSession(), owner )
      );
      values.addpersister.getElementType().assemblearray[i+1], getSession(), owner ) );
    }
  }

  public Object getIdentifier(Object entry, int i) {
    return identifiers.getnew Integer(i) );
  }
  
  public boolean isWrapper(Object collection) {
    return values==collection;
  }
  
  public boolean add(Object o) {
    write();
    values.add(o);
    return true;
  }

  public void clear() {
    initializetrue );
    if ! values.isEmpty() || ! identifiers.isEmpty() ) {
      values.clear();
      identifiers.clear();
      dirty();
    }
  }

  public boolean contains(Object o) {
    read();
    return values.contains(o);
  }

  public boolean containsAll(Collection c) {
    read();
    return values.containsAll(c);
  }

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

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

  public boolean remove(Object o) {
    initializetrue );
    int index = values.indexOf(o);
    if (index>=0) {
      beforeRemove(index);
      values.remove(index);
      dirty();
      return true;
    }
    else {
      return false;
    }
  }

  public boolean removeAll(Collection c) {
    if c.size() ) {
      boolean result = false;
      Iterator iter = c.iterator();
      while iter.hasNext() ) {
        if removeiter.next() ) ) result=true;
      }
      return result;
    }
    else {
      return false;
    }
  }

  public boolean retainAll(Collection c) {
    initializetrue );
    if values.retainAll) ) {
      dirty();
      return true;
    }
    else {
      return false;
    }
  }

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

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

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

  public void beforeInitialize(CollectionPersister persister, int anticipatedSize) {
    identifiers = anticipatedSize <= new HashMap() new HashMapanticipatedSize + (int)( anticipatedSize * .75f ).75f );
    values = anticipatedSize <= new ArrayList() new ArrayListanticipatedSize );
  }

  public Serializable disassemble(CollectionPersister persister)
      throws HibernateException {
    Serializable[] result = new Serializablevalues.size() ];
    int i=0;
    for (int j=0; j< values.size(); j++) {
      Object value = values.get(j);
      result[i++= persister.getIdentifierType().disassembleidentifiers.getnew Integer(j) ), getSession()null );
      result[i++= persister.getElementType().disassemblevalue, getSession()null );
    }
    return result;
  }

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

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

  public boolean entryExists(Object entry, int i) {
    return entry!=null;
  }

  public boolean equalsSnapshot(CollectionPersister persisterthrows HibernateException {
    Type elementType = persister.getElementType();
    Map snap = (MapgetSnapshot();
    if snap.size()!= values.size() ) return false;
    for int i=0; i<values.size(); i++ ) {
      Object value = values.get(i);
      Object id = identifiers.getnew Integer(i) );
      if (id==nullreturn false;
      Object old = snap.get(id);
      if elementType.isDirtyold, value, getSession() ) ) return false;
    }
    return true;
  }

  public boolean isSnapshotEmpty(Serializable snapshot) {
    return ( (Mapsnapshot ).isEmpty();
  }
  
  public Iterator getDeletes(CollectionPersister persister, boolean indexIsFormulathrows HibernateException {
    Map snap = (MapgetSnapshot();
    List deletes = new ArrayListsnap.keySet() );
    for int i=0; i<values.size(); i++ ) {
      if values.get(i)!=null deletes.removeidentifiers.getnew Integer(i) ) );
    }
    return deletes.iterator();
  }

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

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

  public Object getSnapshotElement(Object entry, int i) {
    Map snap = (MapgetSnapshot();
    Object id = identifiers.getnew Integer(i) );
    return snap.get(id);
  }

  public boolean needsInserting(Object entry, int i, Type elemType)
    throws HibernateException {

    Map snap = (MapgetSnapshot();
    Object id = identifiers.getnew Integer(i) );
    return entry!=null && id==null || snap.get(id)==null );
  }

  public boolean needsUpdating(Object entry, int i, Type elemTypethrows HibernateException {

    if (entry==nullreturn false;
    Map snap = (MapgetSnapshot();
    Object id = identifiers.getnew Integer(i) );
    if (id==nullreturn false;
    Object old = snap.get(id);
    return old!=null && elemType.isDirtyold, entry, getSession() );
  }


  public Object readFrom(
    ResultSet rs,
    CollectionPersister persister,
    CollectionAliases descriptor,
    Object owner)
    throws HibernateException, SQLException {

    Object element = persister.readElementrs, owner, descriptor.getSuffixedElementAliases(), getSession() );
    Object old = identifiers.put(
      new Integervalues.size() ),
      persister.readIdentifierrs, descriptor.getSuffixedIdentifierAlias(), getSession() )
    );
    if old==null values.add(element)//maintain correct duplication if loaded in a cartesian product
    return element;
  }

  public Serializable getSnapshot(CollectionPersister persister)
    throws HibernateException {
    
    EntityMode entityMode = getSession().getEntityMode();
    
    HashMap map = new HashMapvalues.size() );
    Iterator iter = values.iterator();
    int i=0;
    while iter.hasNext() ) {
      Object value = iter.next();
      map.put(
        identifiers.getnew Integer(i++) ),
        persister.getElementType().deepCopy(value, entityMode, persister.getFactory())
      );
    }
    return map;
  }

  public Collection getOrphans(Serializable snapshot, String entityNamethrows HibernateException {
    Map sn = (Mapsnapshot;
    return getOrphanssn.values(), values, entityName, getSession() );
  }

  public void preInsert(CollectionPersister persisterthrows HibernateException {
    Iterator iter = values.iterator();
    int i=0;
    while iter.hasNext() ) {
      Object entry = iter.next();
      Integer loc = new Integer(i++);
      if !identifiers.containsKey(loc) ) { //TODO: native ids
        Serializable id = persister.getIdentifierGenerator().generategetSession(), entry );
        identifiers.put(loc, id);
      }
    }
  }

  public void add(int index, Object element) {
    write();
    beforeAdd(index);
    values.add(index, element);
  }

  public boolean addAll(int index, Collection c) {
    if c.size() ) {
      Iterator iter = c.iterator();
      while iter.hasNext() ) {
        addindex++, iter.next() );
      }
      return true;
    }
    else {
      return false;
    }
  }

  public Object get(int index) {
    read();
    return values.get(index);
  }

  public int indexOf(Object o) {
    read();
    return values.indexOf(o);
  }

  public int lastIndexOf(Object o) {
    read();
    return values.lastIndexOf(o);
  }

  public ListIterator listIterator() {
    read();
    return new ListIteratorProxyvalues.listIterator() );
  }

  public ListIterator listIterator(int index) {
    read();
    return new ListIteratorProxyvalues.listIterator(index) );
  }

  private void beforeRemove(int index) {
    Object removedId = identifiers.getnew Integer(index) );
    int last = values.size()-1;
    for int i=index; i<last; i++ ) {
      Object id = identifiers.getnew Integer(i+1) );
          if id==null ) {
        identifiers.removenew Integer(i) );
          }
          else {
        identifiers.putnew Integer(i), id );
          }
    }
    identifiers.putnew Integer(last), removedId );
  }

  private void beforeAdd(int index) {
    for int i=index; i<values.size(); i++ ) {
      identifiers.putnew Integer(i+1), identifiers.getnew Integer(i) ) );
    }
    identifiers.removenew Integer(index) );
  }

  public Object remove(int index) {
    write();
    beforeRemove(index);
    return values.remove(index);
  }

  public Object set(int index, Object element) {
    write();
    return values.set(index, element);
  }

  public List subList(int fromIndex, int toIndex) {
    read();
    return new ListProxyvalues.subList(fromIndex, toIndex) );
  }

  public boolean addAll(Collection c) {
    if c.size()) {
      write();
      return values.addAll(c);
    }
    else {
      return false;
    }
  }

  public void afterRowInsert(
    CollectionPersister persister,
    Object entry,
    int i)
    throws HibernateException {
    //TODO: if we are using identity columns, fetch the identifier
  }

}