ref #9204 further uncritical updates to AbstractPersistentCollection

diff --git a/eu.etaxonomy.taxeditor.cdmlib/src/main/java/org/hibernate/collection/internal/AbstractPersistentCollection.java b/eu.etaxonomy.taxeditor.cdmlib/src/main/java/org/hibernate/collection/internal/AbstractPersistentCollection.java
index e9ae6870e3efa007bf337202c45335ccc5753c14..a9501ec719a653ec3c6c16ea4665bd8c81008ba3 100644 (file)
--- a/eu.etaxonomy.taxeditor.cdmlib/src/main/java/org/hibernate/collection/internal/AbstractPersistentCollection.java
+++ b/eu.etaxonomy.taxeditor.cdmlib/src/main/java/org/hibernate/collection/internal/AbstractPersistentCollection.java
@@ -352,28 +352,28 @@ public abstract class AbstractPersistentCollection implements Serializable, Pers
                                LOG.info("--> readIndexExistence, of " + getRole() + " with key " + getKey());
                                read();
                        } else {
-                               Boolean extraLazyExistenceCheck = withTemporarySessionIfNeeded(
-                                               new LazyInitializationWork<Boolean>() {
-                                                       @Override
-                                                       public Boolean doWork() {
-                                                               CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this );
-                                                               CollectionPersister persister = entry.getLoadedPersister();
-                                                               if ( persister.isExtraLazy() ) {
-                                                                       if ( hasQueuedOperations() ) {
-                                                                               session.flush();
-                                                                       }
-                                                                       return persister.indexExists( entry.getLoadedKey(), index, session );
-                                                               }
-                                                               else {
-                                                                       read();
+                       final Boolean extraLazyExistenceCheck = withTemporarySessionIfNeeded(
+                                       new LazyInitializationWork<Boolean>() {
+                                               @Override
+                                               public Boolean doWork() {
+                                                       final CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this );
+                                                       final CollectionPersister persister = entry.getLoadedPersister();
+                                                       if ( persister.isExtraLazy() ) {
+                                                               if ( hasQueuedOperations() ) {
+                                                                       session.flush();
                                                                }
-                                                               return null;
+                                                               return persister.indexExists( entry.getLoadedKey(), index, session );
                                                        }
+                                                       else {
+                                                               read();
+                                                       }
+                                                       return null;
                                                }
-                                               );
-                               if ( extraLazyExistenceCheck != null ) {
-                                       return extraLazyExistenceCheck;
-                               }
+                                       }
+                       );
+                       if ( extraLazyExistenceCheck != null ) {
+                               return extraLazyExistenceCheck;
+                       }
                        }
                }
                return null;
@@ -388,28 +388,28 @@ public abstract class AbstractPersistentCollection implements Serializable, Pers
                                read();
 
                        } else {
-                               Boolean extraLazyExistenceCheck = withTemporarySessionIfNeeded(
-                                               new LazyInitializationWork<Boolean>() {
-                                                       @Override
-                                                       public Boolean doWork() {
-                                                               CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this );
-                                                               CollectionPersister persister = entry.getLoadedPersister();
-                                                               if ( persister.isExtraLazy() ) {
-                                                                       if ( hasQueuedOperations() ) {
-                                                                               session.flush();
-                                                                       }
-                                                                       return persister.elementExists( entry.getLoadedKey(), element, session );
-                                                               }
-                                                               else {
-                                                                       read();
+                       final Boolean extraLazyExistenceCheck = withTemporarySessionIfNeeded(
+                                       new LazyInitializationWork<Boolean>() {
+                                               @Override
+                                               public Boolean doWork() {
+                                                       final CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this );
+                                                       final CollectionPersister persister = entry.getLoadedPersister();
+                                                       if ( persister.isExtraLazy() ) {
+                                                               if ( hasQueuedOperations() ) {
+                                                                       session.flush();
                                                                }
-                                                               return null;
+                                                               return persister.elementExists( entry.getLoadedKey(), element, session );
                                                        }
+                                                       else {
+                                                               read();
+                                                       }
+                                                       return null;
                                                }
-                                               );
-                               if ( extraLazyExistenceCheck != null ) {
-                                       return extraLazyExistenceCheck;
-                               }
+                                       }
+                       );
+                       if ( extraLazyExistenceCheck != null ) {
+                               return extraLazyExistenceCheck;
+                       }
                        }
                }
                return null;
@@ -426,34 +426,34 @@ public abstract class AbstractPersistentCollection implements Serializable, Pers
                                read();
 
                        } else {
-                               class ExtraLazyElementByIndexReader implements LazyInitializationWork {
-                                       private boolean isExtraLazy;
-                                       private Object element;
+                       class ExtraLazyElementByIndexReader implements LazyInitializationWork {
+                               private boolean isExtraLazy;
+                               private Object element;
 
-                                       @Override
-                                       public Object doWork() {
-                                               CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this );
-                                               CollectionPersister persister = entry.getLoadedPersister();
-                                               isExtraLazy = persister.isExtraLazy();
-                                               if ( isExtraLazy ) {
-                                                       if ( hasQueuedOperations() ) {
-                                                               session.flush();
-                                                       }
-                                                       element = persister.getElementByIndex( entry.getLoadedKey(), index, session, owner );
-                                               }
-                                               else {
-                                                       read();
+                               @Override
+                               public Object doWork() {
+                                       final CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this );
+                                       final CollectionPersister persister = entry.getLoadedPersister();
+                                       isExtraLazy = persister.isExtraLazy();
+                                       if ( isExtraLazy ) {
+                                               if ( hasQueuedOperations() ) {
+                                                       session.flush();
                                                }
-                                               return null;
+                                               element = persister.getElementByIndex( entry.getLoadedKey(), index, session, owner );
+                                       }
+                                       else {
+                                               read();
                                        }
+                                       return null;
                                }
+                       }
 
-                               ExtraLazyElementByIndexReader reader = new ExtraLazyElementByIndexReader();
-                               //noinspection unchecked
-                               withTemporarySessionIfNeeded( reader );
-                               if ( reader.isExtraLazy ) {
-                                       return reader.element;
-                               }
+                       final ExtraLazyElementByIndexReader reader = new ExtraLazyElementByIndexReader();
+                       //noinspection unchecked
+                       withTemporarySessionIfNeeded( reader );
+                       if ( reader.isExtraLazy ) {
+                               return reader.element;
+                       }
                        }
                }
                return UNKNOWN;
@@ -643,24 +643,23 @@ public abstract class AbstractPersistentCollection implements Serializable, Pers
         * @throws LazyInitializationException if we cannot initialize
         */
        protected final void initialize(final boolean writing) {
-           if ( initialized ) {
-               return;
-           }
-
+               if ( initialized ) {
+                       return;
+               }
            // In remoting we are sure that session is null
            // both when using property paths and switching off conversations
            if(session == null && remoting) {
                remoteInitialize();
-           } else {
-               withTemporarySessionIfNeeded(
-                       new LazyInitializationWork<Object>() {
-                           @Override
-                           public Object doWork() {
-                               session.initializeCollection( AbstractPersistentCollection.this, writing );
-                               return null;
-                           }
-                       }
-                       );
+           } else { //keep formatting to ease update to newer hibernate version
+               withTemporarySessionIfNeeded(
+                               new LazyInitializationWork<Object>() {
+                                       @Override
+                                       public Object doWork() {
+                                               session.initializeCollection( AbstractPersistentCollection.this, writing );
+                                               return null;
+                                       }
+                               }
+               );
            }
        }
 
@@ -696,8 +695,8 @@ public abstract class AbstractPersistentCollection implements Serializable, Pers
        }
 
        @Override
-    public final boolean unsetSession(SessionImplementor currentSession) {
-               prepareForPossibleSpecialSpecjInitialization();
+       public final boolean unsetSession(SessionImplementor currentSession) {
+               prepareForPossibleLoadingOutsideTransaction();
                if ( currentSession == this.session ) {
                        this.session = null;
                        return true;
@@ -707,7 +706,7 @@ public abstract class AbstractPersistentCollection implements Serializable, Pers
                }
        }
 
-       protected void prepareForPossibleSpecialSpecjInitialization() {
+       protected void prepareForPossibleLoadingOutsideTransaction() {
                if ( session != null ) {
                        specjLazyLoad = session.getFactory().getSettings().isInitializeLazyStateOutsideTransactionsEnabled();