How to use

PersistentIdentifierBag

in

org.hibernate.collection.internal

@Override
public boolean removeAll(Collection c) {
  if ( c.size() > 0 ) {
    boolean result = false;
    for ( Object element : c ) {
      if ( remove( element ) ) {
        result = true;
      }
    }
    return result;
  }
  else {
    return false;
  }
}

@Override
public PersistentCollection instantiate(
  SharedSessionContractImplementor session,
  CollectionPersister persister, Serializable key)
  throws HibernateException {
  return new PersistentIdentifierBag( session );
}

@Override
public boolean addAll(int index, Collection c) {
  if ( c.size() > 0 ) {
    for ( Object element : c ) {
      add( index++, element );
    }
    return true;
  }
  else {
    return false;
  }
}

@Override
public Collection getOrphans(Serializable snapshot, String entityName) throws HibernateException {
  final Map sn = (Map) snapshot;
  return getOrphans( sn.values(), values, entityName, getSession() );
}

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

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

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

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

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

@Override
public boolean needsUpdating(Object entry, int i, Type elemType) throws HibernateException {
  if ( entry == null ) {
    return false;
  }
  final Map snap = (Map) getSnapshot();
  final Object id = identifiers.get( i );
  if ( id == null ) {
    return false;
  }
  final Object old = snap.get( id );
  return old != null && elemType.isDirty( old, entry, getSession() );
}

@Override
public void initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner)
    throws HibernateException {
  final Serializable[] array = (Serializable[]) disassembled;
  final int size = array.length;
  beforeInitialize( persister, size );
  for ( int i = 0; i < size; i+=2 ) {
    identifiers.put(
      (i/2),
      persister.getIdentifierType().assemble( array[i], getSession(), owner )
    );
    values.add( persister.getElementType().assemble( array[i+1], getSession(), owner ) );
  }
}

assertFalse( children.remove( otherChild ) );
assertFalse( children.isDirty() );
assertFalse( children.retainAll( otherCollection ) );
assertFalse( children.isDirty() );
assertFalse( children.removeAll( otherCollection ) );
assertFalse( children.isDirty() );
children.clear();
session.delete( child );
assertTrue( children.isDirty() );
children.clear();
assertFalse( children.isDirty() );

@Override
public void preInsert(CollectionPersister persister) throws HibernateException {
  final Iterator itr = values.iterator();
  int i = 0;
  while ( itr.hasNext() ) {
    final Object entry = itr.next();
    final Integer loc = i++;
    if ( !identifiers.containsKey( loc ) ) {
      //TODO: native ids
      final Serializable id = persister.getIdentifierGenerator().generate( getSession(), entry );
      identifiers.put( loc, id );
    }
  }
}

@Override
public boolean needsUpdating(Object entry, int i) throws HibernateException {
  if ( entry == null ) {
    return false;
  }
  final Map snap = (Map) getSnapshot();
  final Object id = identifiers.get( i );
  if ( id == null ) {
    return false;
  }
  final Object old = snap.get( id );
  return old != null && getCollectionDescriptor().isDirty( old, entry, getSession() );
}

  public void load(Integer idValue, E element) {
    assert isInitializing();
    add( element );
    identifiers.put( idValue, element );
  }
}

@Override
public void initializeFromCache(
    Serializable disassembled,
    Object owner,
    PersistentCollectionDescriptor<?,?,E> collectionDescriptor) {
  final Serializable[] array = (Serializable[]) disassembled;
  final int size = array.length;
  beforeInitialize( size, collectionDescriptor );
  for ( int i = 0; i < size; i+=2 ) {
    identifiers.put(
        (i/2),
        getCollectionDescriptor().getIdDescriptor()
          .getJavaTypeDescriptor()
          .getMutabilityPlan()
          .assemble( array[i] )
    );
    values.add(
        getCollectionDescriptor().getElementDescriptor()
            .getJavaTypeDescriptor()
            .getMutabilityPlan()
            .assemble( array[i+1] )
    );
  }
}

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

@Override
public void clear() {
  initialize( true );
  if ( ! values.isEmpty() || ! identifiers.isEmpty() ) {
    values.clear();
    identifiers.clear();
    dirty();
  }
}

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

@Override
public boolean equalsSnapshot(CollectionPersister persister) throws HibernateException {
  final Type elementType = persister.getElementType();
  final Map snap = (Map) getSnapshot();
  if ( snap.size()!= values.size() ) {
    return false;
  }
  for ( int i=0; i<values.size(); i++ ) {
    final Object value = values.get( i );
    final Object id = identifiers.get( i );
    if ( id == null ) {
      return false;
    }
    final Object old = snap.get( id );
    if ( elementType.isDirty( old, value, getSession() ) ) {
      return false;
    }
  }
  return true;
}