EDIT

eu.etaxonomy.taxeditor.cdmlib/META-INF/aop.xml -text

eu.etaxonomy.taxeditor.cdmlib/lib/aspectjrt-1.7.1-sources.jar -text

eu.etaxonomy.taxeditor.cdmlib/lib/aspectjweaver-1.7.1-sources.jar -text

eu.etaxonomy.taxeditor.cdmlib/lib/spring-security-remoting-3.1.3.RELEASE.jar -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/api/lazyloading/CdmLazyLoader.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/remote/api/application/CdmApplicationRemoteConfiguration.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/remote/api/application/CdmApplicationRemoteController.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/remote/api/application/ICdmApplicationRemoteConfiguration.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/org/hibernate/collection/internal/AbstractPersistentCollection.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/org/hibernate/proxy/AbstractLazyInitializer.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/resources/eu/etaxonomy/cdm/httpInvokerServiceClients.xml -text

eu.etaxonomy.taxeditor.cdmlib/src/main/resources/eu/etaxonomy/cdm/remotingApplicationContext.xml -text

eu.etaxonomy.taxeditor.cdmlib/src/main/resources/eu/etaxonomy/cdm/remoting_persistence_security.xml -text

eu.etaxonomy.taxeditor.cdmlib/src/main/resources/eu/etaxonomy/cdm/remoting_services_security.xml -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/remoting/CdmApplicationRemoteControllerTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/remoting/RemoteLazyLoadingTest.java -text

	<classpathentry kind="src" path="src/main/java"/>

	<classpathentry kind="src" path="src/test/java"/>

	<classpathentry kind="src" path="src/main/resources"/>

	<classpathentry exported="true" kind="lib" path="lib/cdmlib-io-3.3.1-SNAPSHOT.jar" sourcepath="lib/cdmlib-io-3.3.1-SNAPSHOT-sources.jar"/>

	<classpathentry exported="true" kind="lib" path="lib/spring-security-remoting-3.1.3.RELEASE.jar"/>

 eu.etaxonomy.cdm.remote.api.application,

 org.springframework.security.remoting.httpinvoker,

 lib/h2mig_pagestore_addon.jar,

 lib/spring-security-remoting-3.1.3.RELEASE.jar

Import-Package: eu.etaxonomy.cdm.api.application

<!DOCTYPE aspectj PUBLIC

        "-//AspectJ//DTD//EN" "http://www.eclipse.org/aspectj/dtd/aspectj.dtd">

<aspectj>

  	<weaver options="-verbose -showWeaveInfo">

    	<include within="org.hibernate.proxy.*" />

    	<include within="org.hibernate.collection.internal.*" />

    	<include within="eu.etaxonomy.cdm.api.lazyloading.*" />

  	</weaver>

    <aspects>

        <!-- use only this aspect for weaving -->

        <aspect name="eu.etaxonomy.cdm.api.lazyloading.CdmLazyLoader" />

    </aspects>

</aspectj>

               lib/h2mig_pagestore_addon.jar,\

               lib/spring-security-remoting-3.1.3.RELEASE.jar

jars.compile.order = .

output.. = bin/

source.. = src/main/java/,\

           src/main/resources/,\

           src/test/java/

   	<dependency>

      <groupId>org.aspectj</groupId>

      <artifactId>aspectjrt</artifactId>

	  <version>1.7.1</version>

	</dependency>

	  <dependency>

	  <groupId>org.aspectj</groupId>

	  <artifactId>aspectjweaver</artifactId>

	  <version>1.7.1</version>

	 </dependency>

package eu.etaxonomy.cdm.api.lazyloading;

import java.beans.Transient;

import java.lang.reflect.Field;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

import java.util.TreeSet;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Pointcut;

import org.hibernate.collection.internal.PersistentList;

import org.hibernate.collection.internal.PersistentMap;

import org.hibernate.collection.internal.PersistentSet;

import org.hibernate.collection.internal.PersistentSortedMap;

import org.hibernate.collection.internal.PersistentSortedSet;

import org.hibernate.collection.spi.PersistentCollection;

import org.hibernate.proxy.LazyInitializer;

import org.springframework.beans.factory.annotation.Autowire;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Configurable;

import org.springframework.stereotype.Component;

import eu.etaxonomy.cdm.api.application.ICdmApplicationConfiguration;

import eu.etaxonomy.cdm.api.service.ICommonService;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.PersistentMultiLanguageText;

@Aspect

@Component

@Configurable(autowire = Autowire.BY_TYPE)

public class CdmLazyLoader {

	private Set classes = new HashSet();

	public static boolean enableWeaving = true;

	private static Set<String> classesToIgnore = new HashSet<String>();

	@Autowired

	private ICommonService commonService;

	public CdmLazyLoader() {

		//classesToIgnore.add("eu.etaxonomy.cdm.model.common.TermVocabulary");

		//classesToIgnore.add("eu.etaxonomy.cdm.model.common.OrderedTermVocabulary");

	}

	/**

	 *  Point cut for the 'initialize' method of the AbstractLazyInitializer.

	 *  

	 */

	@Pointcut("execution(* org.hibernate.proxy.AbstractLazyInitializer.initialize())")

	public void possibleEntityLazyInitializationException() {

	}

	/**

	 *  'Around' advice for the initialization of CDM Entity Objects

	 *  

	 */

	@Around(value = "possibleEntityLazyInitializationException()")

	public Object preloadEntityOnDemand(ProceedingJoinPoint pjp) throws Throwable {		 

		if(enableWeaving) {

			LazyInitializer ll = (LazyInitializer)pjp.getTarget();		

			if(ll.isUninitialized()) {				

				int classid = ((Integer)ll.getIdentifier()).intValue();

				System.out.print("--> AspectJ Compile-Time Weaving " + ll.getEntityName() + " with id " + classid);

				Class clazz = (Class<? extends CdmBase>) Class.forName(ll.getEntityName());

				CdmBase cdmBase = CdmBase.deproxy(commonService.find(clazz,classid),clazz);

				ll.setImplementation(cdmBase);

				System.out.println("....Done");

			}

		}

		return pjp.proceed();		  	    	  

	}

	/**

	 *  Point cut for the 'initialize' method of the AbstractPersistentCollection.

	 *  

	 */

	@Pointcut("execution(protected final void org.hibernate.collection.internal.AbstractPersistentCollection.initialize(..))")

	public void possibleCollectionLazyInitializationException() {

	}

	/**

	 *  'Around' advice for the initialization of Collection objects

	 *  

	 */

	@Around(value = "possibleCollectionLazyInitializationException()")

	@Transient

	public Object preloadCollectionOnDemand(ProceedingJoinPoint pjp) throws Throwable {		 

		if(enableWeaving) {

			PersistentCollection ps = (PersistentCollection) pjp.getTarget();

			if (ps.getOwner() != null && !classesToIgnore.contains(ps.getOwner().getClass().getName()) && !ps.wasInitialized() &&  !classes.contains(ps.getKey())) {

				System.out.print("--> AspectJCompile-Time Weaving " + ps.getRole());                

				classes.add(ps.getKey());

				try {

					String role = ps.getRole();

					String fieldName = role.substring(role.lastIndexOf(".") + 1);

					System.out.print(", field : " + fieldName);

					Object owner = ps.getOwner();

					PersistentCollection col = commonService.initializeCollection(ps); 

					ps.afterInitialize();

					Class<?> clazz = ps.getClass();

					if (clazz != null) {	

						CollectionField cf = getCollectionField(col);

						Field field = clazz.getDeclaredField(cf.getFieldName());

						field.setAccessible(true);

						field.set(ps, cf.getCollection());			       

					}		

				} catch (Exception ex) {

					ex.printStackTrace();

					System.out.println("Error in ReattachSessionAspect : " + ex.getMessage());

				} finally {

					classes.remove(ps.getKey());

					System.out.println("....Done");

				}	

			}

		} 

		return pjp.proceed();

	}

	private CollectionField getCollectionField(PersistentCollection pc) {

		if(pc != null) {

			if(pc instanceof PersistentSet) {

				return new CollectionField(new HashSet((Set)pc), "set");

			}

			if(pc instanceof PersistentSortedSet) {

				return new CollectionField(new TreeSet((Set)pc), "set");

			}

			if(pc instanceof PersistentList) {

				return new CollectionField(new ArrayList((List)pc), "list");

			}

			if(pc instanceof PersistentMap || pc instanceof PersistentMultiLanguageText) {

				return new CollectionField(new HashMap((Map)pc), "map");

			}

			if(pc instanceof PersistentSortedMap) {

				return new CollectionField(new TreeMap((Map)pc), "map");

			}

		}

		return null;

	}

	private String getCollectionFieldName(PersistentCollection pc) {

		if(pc != null) {

			if(pc instanceof PersistentSet || pc instanceof PersistentSortedSet) {

				return "set";

			}

			if(pc instanceof PersistentList) {

				return "list";

			}

			if(pc instanceof PersistentMap || pc instanceof PersistentMultiLanguageText) {

				return "map";

			}

		}

		return null;

	}

	private class CollectionField {

		private Object col;

		private String fieldName;

		public CollectionField(Object col, String fieldName) {

			this.col = col;

			this.fieldName = fieldName;

		}

		public Object getCollection() {

			return this.col;

		}

		public String getFieldName() {

			return this.fieldName;

		}

	}

}

// $Id: CdmApplicationDefaultConfiguration.java 11680 2011-04-04 17:07:39Z a.mueller $

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy 

* http://www.e-taxonomy.eu

* 

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.remote.api.application;

import org.apache.log4j.Logger;

import org.springframework.context.ApplicationContextAware;

import org.springframework.stereotype.Component;

import eu.etaxonomy.cdm.api.application.CdmApplicationConfiguration;

import eu.etaxonomy.cdm.api.application.CdmApplicationDefaultConfiguration;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.conversation.ConversationHolderMock;

/**

 * @author a.mueller

 * @created 21.05.2008

 * @version 1.0

 */

/**

 * @author a.mueller

 * @author j.koch

 */

@Component

public class CdmApplicationRemoteConfiguration extends CdmApplicationConfiguration implements ICdmApplicationRemoteConfiguration, ApplicationContextAware {

	@SuppressWarnings("unused")

	private static final Logger logger = Logger.getLogger(CdmApplicationRemoteConfiguration.class);

	public CdmApplicationRemoteConfiguration() {

	}

	@Override

	public ConversationHolder NewConversation() {

		// TODO Auto-generated method stub

		return new ConversationHolderMock();

	}

}

// $Id: CdmApplicationController.java 11680 2011-04-04 17:07:39Z a.mueller $

/**

 * Copyright (C) 2007 EDIT

 * European Distributed Institute of Taxonomy 

 * http://www.e-taxonomy.eu

 * 

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.cdm.remote.api.application;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;

import org.springframework.context.support.AbstractApplicationContext;

import org.springframework.context.support.GenericApplicationContext;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

import org.springframework.security.access.PermissionEvaluator;

import org.springframework.security.authentication.ProviderManager;

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

import org.springframework.security.core.Authentication;

import org.springframework.security.core.context.SecurityContext;

import org.springframework.security.core.context.SecurityContextHolder;

import org.springframework.transaction.PlatformTransactionManager;

//import org.springframework.transaction.PlatformTransactionManager;

import org.springframework.transaction.TransactionStatus;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.service.IAgentService;

import eu.etaxonomy.cdm.api.service.IClassificationService;

import eu.etaxonomy.cdm.api.service.ICollectionService;

import eu.etaxonomy.cdm.api.service.ICommonService;

import eu.etaxonomy.cdm.api.service.IDatabaseService;

import eu.etaxonomy.cdm.api.service.IDescriptionService;

import eu.etaxonomy.cdm.api.service.IFeatureNodeService;

import eu.etaxonomy.cdm.api.service.IFeatureTreeService;

import eu.etaxonomy.cdm.api.service.IGrantedAuthorityService;

import eu.etaxonomy.cdm.api.service.IGroupService;

import eu.etaxonomy.cdm.api.service.IIdentificationKeyService;

import eu.etaxonomy.cdm.api.service.ILocationService;

import eu.etaxonomy.cdm.api.service.IMediaService;

import eu.etaxonomy.cdm.api.service.INameService;

import eu.etaxonomy.cdm.api.service.IOccurrenceService;

import eu.etaxonomy.cdm.api.service.IPolytomousKeyNodeService;

import eu.etaxonomy.cdm.api.service.IPolytomousKeyService;

import eu.etaxonomy.cdm.api.service.IReferenceService;

import eu.etaxonomy.cdm.api.service.IService;

import eu.etaxonomy.cdm.api.service.ITaxonNodeService;

import eu.etaxonomy.cdm.api.service.ITaxonService;

import eu.etaxonomy.cdm.api.service.ITermService;

import eu.etaxonomy.cdm.api.service.IUserService;

import eu.etaxonomy.cdm.api.service.IVocabularyService;

import eu.etaxonomy.cdm.api.service.IWorkingSetService;

import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;

import eu.etaxonomy.cdm.common.monitor.NullProgressMonitor;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.DefinedTermBase;

import eu.etaxonomy.cdm.persistence.hibernate.permission.ICdmPermissionEvaluator;

/**

 * @author a.mueller

 * @author j.koch

 *

 */

public class CdmApplicationRemoteController  implements ICdmApplicationRemoteConfiguration {

	private static final Logger logger = Logger.getLogger(CdmApplicationRemoteController.class);

	public static final String DEFAULT_APPLICATION_CONTEXT_RESOURCE = "/eu/etaxonomy/cdm/remotingApplicationContext.xml";

	public AbstractApplicationContext applicationContext;

	private ICdmApplicationRemoteConfiguration configuration; 

	private Resource applicationContextResource;

	private IProgressMonitor progressMonitor;

	/**

	 * Constructor, opens a spring ApplicationContext with defaults

	 */

	public static CdmApplicationRemoteController NewInstance() {

		logger.info("Configure CdmApplicationRemoteController with defaults");

		return new CdmApplicationRemoteController(null, null);

	}

	/**

	 * Constructor, opens a spring ApplicationContext with given application context

	 * @param applicationContextResource

	 */

	public static CdmApplicationRemoteController NewInstance(Resource applicationContextResource, IProgressMonitor progressMonitor) {

		logger.info("Configure CdmApplicationRemoteController with given application context");

		return new CdmApplicationRemoteController(applicationContextResource, progressMonitor);

	}

	/**

	 * Constructor, starts the application remote controller

	 * @param applicationContextResource

	 */

	private CdmApplicationRemoteController(Resource applicationContextResource, IProgressMonitor progressMonitor){

		logger.info("Start CdmApplicationRemoteController");

		this.applicationContextResource = applicationContextResource != null ? applicationContextResource : new ClassPathResource(DEFAULT_APPLICATION_CONTEXT_RESOURCE);

		this.progressMonitor = progressMonitor != null ? progressMonitor : new NullProgressMonitor();

		setNewApplicationContext();

	}

	/**

	 * Sets the application context to a new spring ApplicationContext and initializes the Controller

	 */

	private boolean setNewApplicationContext(){

		logger.info("Set new application context");

		progressMonitor.beginTask("Start application context.", 6);

		progressMonitor.worked(1);

		GenericApplicationContext applicationContext =  new GenericApplicationContext();

		XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(applicationContext);

		progressMonitor.subTask("Registering resources.");

		xmlReader.loadBeanDefinitions(applicationContextResource);

		progressMonitor.worked(1);

		progressMonitor.subTask("This might take a while ...");

		applicationContext.refresh();

		applicationContext.start();

		progressMonitor.worked(1);

		progressMonitor.subTask("Cleaning up.");

		setApplicationContext(applicationContext);

		progressMonitor.done();

		return true;

	}

	/**

	 * Tests if some DefinedTermsAreMissing.

	 * @return true, if at least one is missing, else false

	 */

	public boolean testDefinedTermsAreMissing(){

		UUID englishUuid = UUID.fromString("e9f8cdb7-6819-44e8-95d3-e2d0690c3523");

		DefinedTermBase<?> english = this.getTermService().find(englishUuid);

		if ( english == null || ! english.getUuid().equals(englishUuid)){

			return true;

		}else{

			return false;

		}

	}

	/**

	 * Sets a new application Context.

	 * @param ac

	 */

	public void setApplicationContext(AbstractApplicationContext ac){

		closeApplicationContext(); //closes old application context if necessary

		applicationContext = ac;

		applicationContext.registerShutdownHook();

		init();

	}

	/* (non-Javadoc)

	 * @see java.lang.Object#finalize()

	 */

	public void finalize(){

		close();

	}

	/**

	 * closes the application

	 */

	public void close(){

		closeApplicationContext();

	}

	/**

	 * closes the application context

	 */

	private void closeApplicationContext(){

		if (applicationContext != null){

			logger.info("Close ApplicationContext");

			applicationContext.close();

		}

	}

	private void init(){

		logger.info("Init " +  this.getClass().getName() + " ... ");

		if (logger.isInfoEnabled()){for (String beanName : applicationContext.getBeanDefinitionNames()){ logger.debug(beanName);}}

		//TODO delete next row (was just for testing)

		if (logger.isInfoEnabled()){

			logger.info("Registered Beans: ");

			String[] beanNames = applicationContext.getBeanDefinitionNames();

			for (String beanName : beanNames){

				logger.info(beanName);

			}

		}

		configuration = new CdmApplicationRemoteConfiguration();

	}

	/* ******  Services *********/

	public final INameService getNameService(){

		return configuration.getNameService();

	}

	public final ITaxonService getTaxonService(){

		return configuration.getTaxonService();

	}

	public final IClassificationService getClassificationService(){

		return configuration.getClassificationService();

	}

	public final ITaxonNodeService getTaxonNodeService(){

		return configuration.getTaxonNodeService();

	}

	public final IReferenceService getReferenceService(){

		return configuration.getReferenceService();

	}

	public final IAgentService getAgentService(){

		return configuration.getAgentService();

	}

	public final ITermService getTermService(){

		return configuration.getTermService();

	}

	public final IDescriptionService getDescriptionService(){

		return configuration.getDescriptionService();

	}

	public final IOccurrenceService getOccurrenceService(){

		return configuration.getOccurrenceService();

	}

	public final IMediaService getMediaService(){

		return configuration.getMediaService();

	}

	public final ICommonService getCommonService(){

		return configuration.getCommonService();

	}

	public final ILocationService getLocationService(){

		return configuration.getLocationService();

	}

	public final IUserService getUserService(){

		return configuration.getUserService();

	}

	public IGroupService getGroupService() {

		return configuration.getGroupService();

	}

	public final ICollectionService getCollectionService(){

		return configuration.getCollectionService();

	}

	public final IFeatureTreeService getFeatureTreeService(){

		return configuration.getFeatureTreeService();

	}

	public final IFeatureNodeService getFeatureNodeService(){

		return configuration.getFeatureNodeService();

	}

	public final IVocabularyService getVocabularyService(){

		return configuration.getVocabularyService();

	}

	public final IIdentificationKeyService getIdentificationKeyService(){

		return configuration.getIdentificationKeyService();

	}

	public final IPolytomousKeyService getPolytomousKeyService(){

		return configuration.getPolytomousKeyService();

	}

	public final IPolytomousKeyNodeService getPolytomousKeyNodeService(){

		return configuration.getPolytomousKeyNodeService();

	}

	public final IService<CdmBase> getMainService(){

		return configuration.getMainService();

	}

	public final IWorkingSetService getWorkingSetService(){

		return configuration.getWorkingSetService();

	}

	@Override

	public ProviderManager getAuthenticationManager() {

		return configuration.getAuthenticationManager();

	}

	@Override

	public ConversationHolder NewConversation() {

		return configuration.NewConversation();

	}

	@Override

	public Object getBean(String name) {

		return configuration.getBean(name);

	}

	@Override

	public IGrantedAuthorityService getGrantedAuthorityService() {

		return configuration.getGrantedAuthorityService();

	}

	@Override

	public ICdmPermissionEvaluator getPermissionEvaluator() {

		return configuration.getPermissionEvaluator();

	}

	@Override

	public void authenticate(String username, String password) {

		configuration.authenticate(username, password);

	}

}

package eu.etaxonomy.cdm.remote.api.application;

import eu.etaxonomy.cdm.api.application.ICdmApplicationConfiguration;

public interface ICdmApplicationRemoteConfiguration extends ICdmApplicationConfiguration {

}

/*

 * Hibernate, Relational Persistence for Idiomatic Java

 *

 * Copyright (c) 2008-2011, Red Hat Inc. or third-party contributors as

 * indicated by the @author tags or express copyright attribution

 * statements applied by the authors.  All third-party contributions are

 * distributed under license by Red Hat Inc.

 *

 * This copyrighted material is made available to anyone wishing to use, modify,

 * copy, or redistribute it subject to the terms and conditions of the GNU

 * Lesser General Public License, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License

 * for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this distribution; if not, write to:

 * Free Software Foundation, Inc.

 * 51 Franklin Street, Fifth Floor

 * Boston, MA  02110-1301  USA

 */

package org.hibernate.collection.internal;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

import javax.naming.NamingException;

import org.hibernate.AssertionFailure;

import org.hibernate.HibernateException;

import org.hibernate.LazyInitializationException;

import org.hibernate.Session;

import org.hibernate.collection.spi.PersistentCollection;

import org.hibernate.engine.internal.ForeignKeys;

import org.hibernate.engine.spi.CollectionEntry;

import org.hibernate.engine.spi.EntityEntry;

import org.hibernate.engine.spi.SessionFactoryImplementor;

import org.hibernate.engine.spi.SessionImplementor;

import org.hibernate.engine.spi.Status;

import org.hibernate.engine.spi.TypedValue;

import org.hibernate.internal.SessionFactoryRegistry;

import org.hibernate.internal.util.MarkerObject;

import org.hibernate.internal.util.collections.EmptyIterator;

import org.hibernate.internal.util.collections.IdentitySet;

import org.hibernate.persister.collection.CollectionPersister;

import org.hibernate.persister.entity.EntityPersister;

import org.hibernate.pretty.MessageHelper;

import org.hibernate.type.Type;

import org.jboss.logging.Logger;

/**

 * Base class implementing {@link org.hibernate.collection.spi.PersistentCollection}

 *

 * @author Gavin King

 */

public abstract class AbstractPersistentCollection implements Serializable, PersistentCollection {

	private static final Logger log = Logger.getLogger( AbstractPersistentCollection.class );

	private static final long serialVersionUID = -7238232378593030571L;

	private transient SessionImplementor session;

	private boolean initialized;

	private transient List<DelayedOperation> operationQueue;

	private transient boolean directlyAccessible;

	private transient boolean initializing;

	private Object owner;

	private int cachedSize = -1;

	private String role;

	private Serializable key;

	// collections detect changes made via their public interface and mark

	// themselves as dirty as a performance optimization

	private boolean dirty;

	private Serializable storedSnapshot;

	private String sessionFactoryUuid;

	private boolean specjLazyLoad = false;

	public final String getRole() {

		return role;

	}

	public final Serializable getKey() {

		return key;

	}

	public final boolean isUnreferenced() {

		return role == null;

	}

	public final boolean isDirty() {

		return dirty;

	}

	public final void clearDirty() {

		dirty = false;

	}

	public final void dirty() {

		dirty = true;

	}

	public final Serializable getStoredSnapshot() {

		return storedSnapshot;

	}

	//Careful: these methods do not initialize the collection.

	/**

	 * Is the initialized collection empty?

	 */

	public abstract boolean empty();

	/**

	 * Called by any read-only method of the collection interface

	 */

	protected final void read() {

		initialize( false );

	}

	/**

	 * Called by the {@link Collection#size} method

	 */

	@SuppressWarnings({"JavaDoc"})

	protected boolean readSize() {

		if ( !initialized ) {

			if ( cachedSize != -1 && !hasQueuedOperations() ) {

				return true;

			}

			else {

				boolean isExtraLazy = withTemporarySessionIfNeeded(

						new LazyInitializationWork<Boolean>() {

							@Override

							public Boolean doWork() {

								CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this );

								if ( entry != null ) {

									CollectionPersister persister = entry.getLoadedPersister();

									if ( persister.isExtraLazy() ) {

										if ( hasQueuedOperations() ) {

											session.flush();

										}

										cachedSize = persister.getSize( entry.getLoadedKey(), session );

										return true;

									}

									else {

										read();

									}

								}

								else{

									throwLazyInitializationExceptionIfNotConnected();

								}

								return false;

							}

						}

				);

				if ( isExtraLazy ) {

					return true;

				}

			}

		}

		return false;

	}

	public static interface LazyInitializationWork<T> {

		public T doWork();

	}

	private <T> T withTemporarySessionIfNeeded(LazyInitializationWork<T> lazyInitializationWork) {

		SessionImplementor originalSession = null;

		boolean isTempSession = false;

		boolean isJTA = false;

		if ( session == null ) {

			if ( specjLazyLoad ) {

				session = openTemporarySessionForLoading();

				isTempSession = true;

			}

			else {

				throwLazyInitializationException( "could not initialize proxy - no Session" );

			}

		}

		else if ( !session.isOpen() ) {

			if ( specjLazyLoad ) {

				originalSession = session;

				session = openTemporarySessionForLoading();

				isTempSession = true;

			}

			else {

				throwLazyInitializationException( "could not initialize proxy - the owning Session was closed" );

			}

		}

		else if ( !session.isConnected() ) {

			if ( specjLazyLoad ) {

				originalSession = session;

				session = openTemporarySessionForLoading();

				isTempSession = true;

			}

			else {

				throwLazyInitializationException( "could not initialize proxy - the owning Session is disconnected" );

			}

		}

		if ( isTempSession ) {

			// TODO: On the next major release, add an

			// 'isJTA' or 'getTransactionFactory' method to Session.

			isJTA = session.getTransactionCoordinator()

					.getTransactionContext().getTransactionEnvironment()

					.getTransactionFactory()

					.compatibleWithJtaSynchronization();

			if ( !isJTA ) {

				// Explicitly handle the transactions only if we're not in

				// a JTA environment.  A lazy loading temporary session can

				// be created even if a current session and transaction are

				// open (ex: session.clear() was used).  We must prevent

				// multiple transactions.

				( ( Session) session ).beginTransaction();

			}

			session.getPersistenceContext().addUninitializedDetachedCollection(

					session.getFactory().getCollectionPersister( getRole() ),

					this

			);

		}

		try {

			return lazyInitializationWork.doWork();

		}

		finally {

			if ( isTempSession ) {

				// make sure the just opened temp session gets closed!

				try {

					if ( !isJTA ) {

						( ( Session) session ).getTransaction().commit();

					}

					( (Session) session ).close();

				}

				catch (Exception e) {

					log.warn( "Unable to close temporary session used to load lazy collection associated to no session" );

				}

				session = originalSession;

			}

		}

	}

	private SessionImplementor openTemporarySessionForLoading() {

		if ( sessionFactoryUuid == null ) {

			throwLazyInitializationException( "SessionFactory UUID not known to create temporary Session for loading" );

		}

		SessionFactoryImplementor sf = (SessionFactoryImplementor)

				SessionFactoryRegistry.INSTANCE.getSessionFactory( sessionFactoryUuid );

		return (SessionImplementor) sf.openSession();

	}

	protected Boolean readIndexExistence(final Object index) {

		if ( !initialized ) {

			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();

							}

							return null;

						}

					}

			);

			if ( extraLazyExistenceCheck != null ) {

				return extraLazyExistenceCheck;

			}

		}

		return null;

	}

	protected Boolean readElementExistence(final Object element) {

		if ( !initialized ) {

			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();

							}

							return null;

						}

					}

			);

			if ( extraLazyExistenceCheck != null ) {

				return extraLazyExistenceCheck;

			}

		}

		return null;

	}

	protected static final Object UNKNOWN = new MarkerObject( "UNKNOWN" );

	protected Object readElementByIndex(final Object index) {

		if ( !initialized ) {

			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();

					}

					return null;

				}

			}

			ExtraLazyElementByIndexReader reader = new ExtraLazyElementByIndexReader();

			//noinspection unchecked

			withTemporarySessionIfNeeded( reader );

			if ( reader.isExtraLazy ) {

				return reader.element;

			}

		}

		return UNKNOWN;

	}

	protected int getCachedSize() {

		return cachedSize;

	}

	private boolean isConnectedToSession() {

		return session != null &&

				session.isOpen() &&

				session.getPersistenceContext().containsCollection( this );

	}

	/**

	 * Called by any writer method of the collection interface

	 */

	protected final void write() {

		initialize( true );

		dirty();

	}

	/**

	 * Is this collection in a state that would allow us to

	 * "queue" operations?

	 */

	@SuppressWarnings({"JavaDoc"})

	protected boolean isOperationQueueEnabled() {

		return !initialized &&

				isConnectedToSession() &&

				isInverseCollection();

	}

	/**

	 * Is this collection in a state that would allow us to

	 * "queue" puts? This is a special case, because of orphan

	 * delete.

	 */

	@SuppressWarnings({"JavaDoc"})

	protected boolean isPutQueueEnabled() {

		return !initialized &&

				isConnectedToSession() &&

				isInverseOneToManyOrNoOrphanDelete();

	}

	/**

	 * Is this collection in a state that would allow us to

	 * "queue" clear? This is a special case, because of orphan

	 * delete.

	 */

	@SuppressWarnings({"JavaDoc"})

	protected boolean isClearQueueEnabled() {

		return !initialized &&

				isConnectedToSession() &&

				isInverseCollectionNoOrphanDelete();

	}

	/**

	 * Is this the "inverse" end of a bidirectional association?

	 */

	@SuppressWarnings({"JavaDoc"})

	private boolean isInverseCollection() {

		CollectionEntry ce = session.getPersistenceContext().getCollectionEntry( this );

		return ce != null && ce.getLoadedPersister().isInverse();

	}

	/**

	 * Is this the "inverse" end of a bidirectional association with

	 * no orphan delete enabled?

	 */

	@SuppressWarnings({"JavaDoc"})

	private boolean isInverseCollectionNoOrphanDelete() {

		CollectionEntry ce = session.getPersistenceContext().getCollectionEntry( this );

		return ce != null &&

				ce.getLoadedPersister().isInverse() &&

				!ce.getLoadedPersister().hasOrphanDelete();

	}

	/**

	 * Is this the "inverse" end of a bidirectional one-to-many, or

	 * of a collection with no orphan delete?

	 */

	@SuppressWarnings({"JavaDoc"})

	private boolean isInverseOneToManyOrNoOrphanDelete() {

		CollectionEntry ce = session.getPersistenceContext().getCollectionEntry( this );

		return ce != null && ce.getLoadedPersister().isInverse() && (

				ce.getLoadedPersister().isOneToMany() ||

						!ce.getLoadedPersister().hasOrphanDelete()

		);

	}

	/**

	 * Queue an addition

	 */

	@SuppressWarnings({"JavaDoc"})

	protected final void queueOperation(DelayedOperation operation) {

		if ( operationQueue == null ) {

			operationQueue = new ArrayList<DelayedOperation>( 10 );

		}

		operationQueue.add( operation );

		dirty = true; //needed so that we remove this collection from the second-level cache

	}

	/**

	 * After reading all existing elements from the database,

	 * add the queued elements to the underlying collection.

	 */

	protected final void performQueuedOperations() {

		for ( DelayedOperation operation : operationQueue ) {

			operation.operate();

		}

	}

	/**

	 * After flushing, re-init snapshot state.

	 */

	public void setSnapshot(Serializable key, String role, Serializable snapshot) {

		this.key = key;

		this.role = role;

		this.storedSnapshot = snapshot;

	}

	/**

	 * After flushing, clear any "queued" additions, since the

	 * database state is now synchronized with the memory state.

	 */

	public void postAction() {

		operationQueue = null;

		cachedSize = -1;

		clearDirty();

	}

	/**

	 * Not called by Hibernate, but used by non-JDK serialization,

	 * eg. SOAP libraries.

	 */

	public AbstractPersistentCollection() {

	}

	protected AbstractPersistentCollection(SessionImplementor session) {

		this.session = session;

	}

	/**

	 * return the user-visible collection (or array) instance

	 */

	public Object getValue() {

		return this;

	}

	/**

	 * Called just before reading any rows from the JDBC result set

	 */

	public void beginRead() {

		// override on some subclasses

		initializing = true;

	}

	/**

	 * Called after reading all rows from the JDBC result set

	 */

	public boolean endRead() {

		//override on some subclasses

		return afterInitialize();

	}

	public boolean afterInitialize() {

		setInitialized();

		//do this bit after setting initialized to true or it will recurse

		if ( operationQueue != null ) {

			performQueuedOperations();

			operationQueue = null;

			cachedSize = -1;

			return false;

		}

		else {

			return true;

		}

	}

	/**

	 * Initialize the collection, if possible, wrapping any exceptions

	 * in a runtime exception

	 *

	 * @param writing currently obsolete

	 *

	 * @throws LazyInitializationException if we cannot initialize

	 */

	protected final void initialize(final boolean writing) {

		if ( initialized ) {

			return;

		}

		withTemporarySessionIfNeeded(

				new LazyInitializationWork<Object>() {

					@Override

					public Object doWork() {

						session.initializeCollection( AbstractPersistentCollection.this, writing );

						return null;

					}

				}

		);

	}

	private void throwLazyInitializationExceptionIfNotConnected() {

		if ( !isConnectedToSession() ) {

			throwLazyInitializationException( "no session or session was closed" );

		}

		if ( !session.isConnected() ) {

			throwLazyInitializationException( "session is disconnected" );

		}

	}

	private void throwLazyInitializationException(String message) {

		throw new LazyInitializationException(

				"failed to lazily initialize a collection" +

						(role == null ? "" : " of role: " + role) +

						", " + message

		);

	}

	protected final void setInitialized() {

		this.initializing = false;

		this.initialized = true;

	}

	protected final void setDirectlyAccessible(boolean directlyAccessible) {

		this.directlyAccessible = directlyAccessible;

	}

	/**

	 * Could the application possibly have a direct reference to

	 * the underlying collection implementation?

	 */

	public boolean isDirectlyAccessible() {

		return directlyAccessible;

	}

	/**

	 * Disassociate this collection from the given session.

	 *

	 * @return true if this was currently associated with the given session

	 */

	public final boolean unsetSession(SessionImplementor currentSession) {

		prepareForPossibleSpecialSpecjInitialization();

		if ( currentSession == this.session ) {

			this.session = null;

			return true;

		}

		else {

			return false;

		}

	}

	protected void prepareForPossibleSpecialSpecjInitialization() {

		if ( session != null ) {

			specjLazyLoad = session.getFactory().getSettings().isInitializeLazyStateOutsideTransactionsEnabled();

			if ( specjLazyLoad && sessionFactoryUuid == null ) {

				try {

					sessionFactoryUuid = (String) session.getFactory().getReference().get( "uuid" ).getContent();

				}

				catch (NamingException e) {

					//not much we can do if this fails...

				}

			}

		}

	}

	/**

	 * Associate the collection with the given session.

	 *

	 * @return false if the collection was already associated with the session

	 *

	 * @throws HibernateException if the collection was already associated

	 * with another open session

	 */

	public final boolean setCurrentSession(SessionImplementor session) throws HibernateException {

		if ( session == this.session ) {

			return false;

		}

		else {

			if ( isConnectedToSession() ) {

				CollectionEntry ce = session.getPersistenceContext().getCollectionEntry( this );

				if ( ce == null ) {

					throw new HibernateException(

							"Illegal attempt to associate a collection with two open sessions"

					);

				}

				else {

					throw new HibernateException(

							"Illegal attempt to associate a collection with two open sessions: " +

									MessageHelper.collectionInfoString(

											ce.getLoadedPersister(), this,

											ce.getLoadedKey(), session

									)

					);

				}

			}

			else {

				this.session = session;

				return true;

			}

		}

	}

	/**

	 * Do we need to completely recreate this collection when it changes?

	 */

	public boolean needsRecreate(CollectionPersister persister) {

		return false;

	}

	/**

	 * To be called internally by the session, forcing

	 * immediate initialization.

	 */

	public final void forceInitialization() throws HibernateException {

		if ( !initialized ) {

			if ( initializing ) {

				throw new AssertionFailure( "force initialize loading collection" );

			}

			if ( session == null ) {

				throw new HibernateException( "collection is not associated with any session" );

			}

			if ( !session.isConnected() ) {

				throw new HibernateException( "disconnected session" );

			}

			session.initializeCollection( this, false );

		}

	}

	/**

	 * Get the current snapshot from the session

	 */

	@SuppressWarnings({"JavaDoc"})

	protected final Serializable getSnapshot() {

		return session.getPersistenceContext().getSnapshot( this );

	}

	/**

	 * Is this instance initialized?

	 */

	public final boolean wasInitialized() {

		return initialized;

	}

	public boolean isRowUpdatePossible() {

		return true;

	}

	/**

	 * Does this instance have any "queued" additions?

	 */