path: root/bundles/org.eclipse.wst.sse.core/src/org/eclipse/wst/sse/core/internal/model/AbstractModelLoader.java

/*******************************************************************************
 * Copyright (c) 2001, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Jens Lukowski/Innoopract - initial renaming/restructuring
 *     
 *******************************************************************************/
package org.eclipse.wst.sse.core.internal.model;

import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocumentExtension3;
import org.eclipse.wst.sse.core.internal.Logger;
import org.eclipse.wst.sse.core.internal.document.IDocumentLoader;
import org.eclipse.wst.sse.core.internal.encoding.EncodingMemento;
import org.eclipse.wst.sse.core.internal.encoding.EncodingRule;
import org.eclipse.wst.sse.core.internal.ltk.modelhandler.IModelHandler;
import org.eclipse.wst.sse.core.internal.ltk.parser.BlockMarker;
import org.eclipse.wst.sse.core.internal.ltk.parser.BlockTagParser;
import org.eclipse.wst.sse.core.internal.ltk.parser.RegionParser;
import org.eclipse.wst.sse.core.internal.ltk.parser.StructuredDocumentRegionHandler;
import org.eclipse.wst.sse.core.internal.ltk.parser.StructuredDocumentRegionHandlerExtension;
import org.eclipse.wst.sse.core.internal.ltk.parser.StructuredDocumentRegionParser;
import org.eclipse.wst.sse.core.internal.ltk.parser.StructuredDocumentRegionParserExtension;
import org.eclipse.wst.sse.core.internal.provisional.IModelLoader;
import org.eclipse.wst.sse.core.internal.provisional.INodeAdapterFactory;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.document.IEncodedDocument;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredPartitioning;
import org.eclipse.wst.sse.core.internal.text.BasicStructuredDocument;
import org.eclipse.wst.sse.core.internal.text.rules.StructuredTextPartitioner;
import org.eclipse.wst.sse.core.internal.util.Assert;


/**
 * This class reads a file and creates an Structured Model.
 */
public abstract class AbstractModelLoader implements IModelLoader {
	protected static final int encodingNameSearchLimit = 1000;

	private static long computeMem() {
		for (int i = 0; i < 5; i++) {
			System.gc();
			System.runFinalization();
		}
		return Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
	}

	private boolean DEBUG = false;
	protected IDocumentLoader documentLoaderInstance;

	/**
	 * AbstractLoader constructor also initializes encoding converter/mapper
	 */
	public AbstractModelLoader() {
		super();
	}

	protected void addFactories(IStructuredModel model, List factoryList) {
		Assert.isNotNull(model);
		FactoryRegistry registry = model.getFactoryRegistry();
		Assert.isNotNull(registry, "IStructuredModel " + model.getId() + " has a null FactoryRegistry"); //$NON-NLS-1$ //$NON-NLS-2$
		if (factoryList != null) {
			Iterator iterator = factoryList.iterator();
			while (iterator.hasNext()) {
				INodeAdapterFactory factory = (INodeAdapterFactory) iterator.next();
				registry.addFactory(factory);
			}
		}
	}

	/**
	 * This method should perform all the model initialization required before
	 * it contains content, namely, it should call newModel, the
	 * createNewStructuredDocument(), then add those adapter factories which
	 * must be set before content is applied. This method should be called by
	 * "load" method. (this is tentative API)
	 */
	public IStructuredModel createModel() {
		documentLoaderInstance = null;
		IStructuredModel model = newModel();
		IEncodedDocument structuredDocument = getDocumentLoader().createNewStructuredDocument();
		if (structuredDocument instanceof IStructuredDocument) {
			model.setStructuredDocument((IStructuredDocument) structuredDocument);
			addFactories(model, getAdapterFactories());
			//
			initEmbeddedTypePre(model, (IStructuredDocument) structuredDocument);
			initEmbeddedTypePost(model);
			// For types with propagating adapters, its important
			// that the propagating adapter be in place before the contents
			// are set.
			preLoadAdapt(model);
		}
		return model;
	}

	public IStructuredModel createModel(IStructuredDocument structuredDocument, String baseLocation, IModelHandler handler) {
		documentLoaderInstance = null;
		IStructuredModel model = newModel();
		model.setBaseLocation(baseLocation);
		
		// handler must be set early, incase a re-init is 
		// required during creation.
		model.setModelHandler(handler);
		
		addFactories(model, getAdapterFactories());
		// For types with propagating adapters, it's important
		// that the propagating adapter be in place before the contents
		// are set.
		preLoadAdapt(model);
		initEmbeddedTypePre(model, structuredDocument);

		model.setStructuredDocument(structuredDocument);
		//
		initEmbeddedTypePost(model);

		return model;
	}

	/**
	 * This method is used for cloning models.
	 */
	public IStructuredModel createModel(IStructuredModel oldModel) {
		documentLoaderInstance = null;
		IStructuredModel newModel = newModel();
		IStructuredDocument oldStructuredDocument = oldModel.getStructuredDocument();
		IStructuredDocument newStructuredDocument = oldStructuredDocument.newInstance();
		newModel.setStructuredDocument(newStructuredDocument);
		// NOTE: we DO NOT simply add the standard ones to the new model
		// addFactories(newModel, getAdapterFactories());
		// Now, we take the opportunity to add Factories from the oldModel's
		// registry to the new model's registry .. if they do not already
		// exist there.
		duplicateFactoryRegistry(newModel, oldModel);
		if (newModel instanceof AbstractStructuredModel) {
			((AbstractStructuredModel) newModel).setContentTypeIdentifier(oldModel.getContentTypeIdentifier());
		}
		// addFactories(newModel, oldModel);
		initEmbeddedType(oldModel, newModel);
		// For types with propagating adapters, its important
		// that the propagating adapter be in place before the contents
		// are set.
		preLoadAdapt(newModel);
		return newModel;
	}

	private void duplicateFactoryRegistry(IStructuredModel newModel, IStructuredModel oldModel) {
		List oldAdapterFactories = oldModel.getFactoryRegistry().getFactories();
		List newAdapterFactories = new ArrayList();
		Iterator oldListIterator = oldAdapterFactories.iterator();
		while (oldListIterator.hasNext()) {
			INodeAdapterFactory oldAdapterFactory = (INodeAdapterFactory) oldListIterator.next();
			// now "clone" the adapterfactory
			newAdapterFactories.add(oldAdapterFactory.copy());
		}
		// now that we have the "cloned" list, add to new model
		addFactories(newModel, newAdapterFactories);
	}

	/**
	 * This method must return those factories which must be attached to the
	 * structuredModel before content is applied.
	 */
	public List getAdapterFactories() {
		// abstract method returns none
		return new ArrayList(0);
	}

	abstract public IDocumentLoader getDocumentLoader();

	/**
	 * Method initEmbeddedType, "pre"-stage. Nothing to do here in super class.
	 * 
	 * @param model
	 */
	protected void initEmbeddedTypePre(IStructuredModel model) {
	}

	/**
	 * Method initEmbeddedType, "pre"-stage. By default simply calls the
	 * version of this method that uses only the structured model.
	 * 
	 * @param model
	 *            the model for which to initialize
	 * @param structuredDocument
	 *            The structured document containing the text content for the
	 *            model, which may be a different instance than what is in the
	 *            model at this stage.
	 */
	protected void initEmbeddedTypePre(IStructuredModel model, IStructuredDocument structuredDocument) {
		initEmbeddedTypePre(model);
	}
		
	protected void initEmbeddedTypePost(IStructuredModel model) {
	}

	/**
	 * Method initEmbeddedType. Nothing to do here in super class.
	 * 
	 * @param oldModel
	 * @param newModel
	 */
	protected void initEmbeddedType(IStructuredModel oldModel, IStructuredModel newModel) {
	}

	public void load(IFile file, IStructuredModel model) throws IOException, CoreException {
		IEncodedDocument structuredDocument = model.getStructuredDocument();
		if (file == null)
			structuredDocument = getDocumentLoader().createNewStructuredDocument();
		else
			structuredDocument = getDocumentLoader().createNewStructuredDocument(file);

		// TODO: need to straighten out IEncodedDocument mess
		if (structuredDocument instanceof IStructuredDocument)
			transformInstance(model.getStructuredDocument(), (IStructuredDocument) structuredDocument);
		else
			model.getStructuredDocument().set(structuredDocument.get());

		// original hack
		// model.setStructuredDocument((IStructuredDocument)
		// structuredDocument);
		// ((IStructuredDocument) structuredDocument).fireNewDocument(this);
		documentLoaderInstance = null;
		// technicq of future
		// model.setStructuredDocument((IStructuredDocument)
		// structuredDocument);
		// documentLoaderInstance = null;
	}

	public void load(InputStream inputStream, IStructuredModel model, EncodingRule encodingRule) throws UnsupportedEncodingException, java.io.IOException {
		// note we don't open the stream, so we don't close it
		IEncodedDocument structuredDocument = model.getStructuredDocument();
		if (inputStream == null) {
			structuredDocument = getDocumentLoader().createNewStructuredDocument();
		}
		else {
			// assume's model has been initialized already with base location
			structuredDocument = getDocumentLoader().createNewStructuredDocument(model.getBaseLocation(), inputStream, encodingRule);
			// TODO: model's not designed for this!
			// we want to move to this "set" method, but the 'fire' was needed
			// as
			// a work around for strucutredModel not handling 'set' right, but
			// that 'fireNewDocument' method was causing unbalance
			// "aboutToChange" and "changed"
			// events.
			// model.setStructuredDocument((IStructuredDocument)
			// structuredDocument);
			// ((IStructuredDocument)
			// structuredDocument).fireNewDocument(this);
			model.getStructuredDocument().set(structuredDocument.get());

		}
		documentLoaderInstance = null;

	}

	/**
	 * deprecated -- use EncodingRule form
	 */
	synchronized public void load(InputStream inputStream, IStructuredModel model, String encodingName, String lineDelimiter) throws UnsupportedEncodingException, java.io.IOException {
		// note we don't open the stream, so we don't close it
		// TEMP work around to maintain previous function,
		// until everyone can change to EncodingRule.FORCE_DEFAULT
		if (encodingName != null && encodingName.trim().length() == 0) {
			// redirect to new method
			load(inputStream, model, EncodingRule.FORCE_DEFAULT);
		}
		else {
			load(inputStream, model, EncodingRule.CONTENT_BASED);
		}
	}

	public void load(String filename, InputStream inputStream, IStructuredModel model, String junk, String dummy) throws UnsupportedEncodingException, java.io.IOException {

		long memoryUsed = 0;
		if (DEBUG) {
			memoryUsed = computeMem();
			System.out.println("measuring heap memory for " + filename); //$NON-NLS-1$
			// System.out.println("heap memory used before load: " +
			// memoryUsed);
		}

		// during an initial load, we expect the olddocument to be empty
		// during re-load, however, it would be full.
		IEncodedDocument newstructuredDocument = null;
		IEncodedDocument oldStructuredDocument = model.getStructuredDocument();

		// get new document
		if (inputStream == null) {
			newstructuredDocument = getDocumentLoader().createNewStructuredDocument();
		}
		else {
			newstructuredDocument = getDocumentLoader().createNewStructuredDocument(filename, inputStream);
		}
		if (DEBUG) {
			long memoryAtEnd = computeMem();
			// System.out.println("heap memory used after loading new
			// document: " + memoryAtEnd);
			System.out.println("    heap memory implied used by document: " + (memoryAtEnd - memoryUsed)); //$NON-NLS-1$
		}


		// TODO: need to straighten out IEncodedDocument mess
		if (newstructuredDocument instanceof IStructuredDocument) {
			transformInstance((IStructuredDocument) oldStructuredDocument, (IStructuredDocument) newstructuredDocument);
		}
		else {
			// we don't really expect this case, just included for safety
			oldStructuredDocument.set(newstructuredDocument.get());
		}
		// original hack
		// model.setStructuredDocument((IStructuredDocument)
		// structuredDocument);
		// ((IStructuredDocument) structuredDocument).fireNewDocument(this);
		documentLoaderInstance = null;
		// technicq of future
		// model.setStructuredDocument((IStructuredDocument)
		// structuredDocument);
		// documentLoaderInstance = null;
		if (DEBUG) {
			long memoryAtEnd = computeMem();
			// System.out.println("heap memory used after setting to model: "
			// + memoryAtEnd);
			System.out.println("    heap memory implied used by document and model: " + (memoryAtEnd - memoryUsed)); //$NON-NLS-1$
		}

	}

	/**
	 * required by interface, being declared here abstractly just as another
	 * reminder.
	 */
	abstract public IStructuredModel newModel();

	/**
	 * There's nothing to do here in abstract class for initializing adapters.
	 * Subclasses can and should override this method and provide proper
	 * intialization (For example, to get DOM document and 'getAdapter' on it,
	 * so that the first node/notifier has the adapter on it.)
	 */
	protected void preLoadAdapt(IStructuredModel structuredModel) {


	}

	/**
	 * Normally, here in the abstact class, there's nothing to do, but we will
	 * reset text, since this MIGHT end up being called to recover from error
	 * conditions (e.g. IStructuredDocument exceptions) And, can be called by
	 * subclasses.
	 */
	public IStructuredModel reinitialize(IStructuredModel model) {
		// Note: the "minimumization" routines
		// of 'replaceText' allow many old nodes to pass through, when
		// really its assumed they are created anew.
		// so we need to use 'setText' (I think "setText' ends up
		// throwing a 'newModel' event though, that may have some
		// implications.
		model.getStructuredDocument().setText(this, model.getStructuredDocument().get());
		return model;
	}

	/**
	 * This method gets a fresh copy of the data, and repopulates the models
	 * ... by a call to setText on the structuredDocument. This method is
	 * needed in some cases where clients are sharing a model and then changes
	 * canceled. Say for example, one editor and several "displays" are
	 * sharing a model, if the editor is closed without saving changes, then
	 * the displays still need a model, but they should revert to the original
	 * unsaved version.
	 */
	synchronized public void reload(InputStream inputStream, IStructuredModel structuredModel) {
		documentLoaderInstance = null;
		try {
			// temp solution ... we should be able to do better (more
			// efficient) in future.
			// Adapters will (probably) need to be sensitive to the fact that
			// the document instance changed
			// (by being life cycle listeners)
			load(inputStream, structuredModel, EncodingRule.CONTENT_BASED);

			// // Note: we apparently read the data (and encoding) correctly
			// // before, we just need to make sure we followed the same rule
			// as
			// // before.
			// EncodingMemento previousMemento =
			// structuredModel.getStructuredDocument().getEncodingMemento();
			// EncodingRule previousRule = previousMemento.getEncodingRule();
			// //IFile file = ResourceUtil.getFileFor(structuredModel);
			// // Note: there's opportunity here for some odd behavior, if the
			// // settings have changed from the first load to the reload.
			// But,
			// // hopefully,
			// // will result in the intended behavior.
			// Reader allTextReader =
			// getDocumentLoader().readInputStream(inputStream, previousRule);
			//
			// // TODO: avoid use of String instance
			// getDocumentLoader().reload(structuredModel.getStructuredDocument(),
			// allTextReader);
			// // and now "reset" encoding memento to keep it current with the
			// // one
			// // that was just determined.
			// structuredModel.getStructuredDocument().setEncodingMemento(getDocumentLoader().getEncodingMemento());
			// structuredModel.setDirtyState(false);
			// StructuredTextUndoManager undoMgr =
			// structuredModel.getUndoManager();
			// if (undoMgr != null) {
			// undoMgr.reset();
			// }
		}
		catch (UnsupportedEncodingException e) {
			// couldn't happen. The program has apparently
			// read the model once, and there'd be no reason the encoding
			// could not be used again.
			Logger.logException("Warning:  XMLLoader::reload.  This exception really should not have happened!! But will attemp to continue after dumping stack trace", e); //$NON-NLS-1$
			throw new Error("Program Error", e); //$NON-NLS-1$
		}
		catch (IOException e) {
			// couldn't happen. The program has apparently
			// read the model once, and there'd be no (common) reason it
			// couldn't be loaded again.
			Logger.logException("Warning:  XMLLoader::reload.  This exception really should not have happened!! But will attemp to continue after dumping stack trace", e); //$NON-NLS-1$
			throw new Error("Program Error", e); //$NON-NLS-1$
		}
	}

	/**
	 * this work is done better elsewhere, but done here for this version to
	 * reduce changes. especially since the need for it should go away once we
	 * no longer need to re-use old document instance.
	 */
	private void transformInstance(IStructuredDocument oldInstance, IStructuredDocument newInstance) {
		/**
		 * https://w3.opensource.ibm.com/bugzilla/show_bug.cgi?id=4920
		 * 
		 * JSP taglib support broken, correct by duplicating extended setup
		 * information (BlockTagParser extension,
		 * StructuredDocumentRegionParser extensions)
		 */
		RegionParser oldParser = oldInstance.getParser();
		RegionParser newParser = newInstance.getParser().newInstance();
		// Register all of the old StructuredDocumentRegionHandlers on the new
		// parser
		if (oldParser instanceof StructuredDocumentRegionParserExtension && newParser instanceof StructuredDocumentRegionParserExtension) {
			List oldHandlers = ((StructuredDocumentRegionParserExtension) oldParser).getStructuredDocumentRegionHandlers();
			for (int i = 0; i < oldHandlers.size(); i++) {
				StructuredDocumentRegionHandler handler = ((StructuredDocumentRegionHandler) oldHandlers.get(i));
				if (handler instanceof StructuredDocumentRegionHandlerExtension) {
					/**
					 * Skip the transferring here, the handler will do this
					 * after everything else but the source is transferred.
					 */
				}
				else {
					((StructuredDocumentRegionParser) oldParser).removeStructuredDocumentRegionHandler(handler);
					((StructuredDocumentRegionParser) newParser).addStructuredDocumentRegionHandler(handler);
					handler.resetNodes();
				}
			}
		}
		// Add any global BlockMarkers to the new parser
		if (oldParser instanceof BlockTagParser && newParser instanceof BlockTagParser) {
			List oldBlockMarkers = ((BlockTagParser) oldParser).getBlockMarkers();
			for (int i = 0; i < oldBlockMarkers.size(); i++) {
				BlockMarker blockMarker = ((BlockMarker) oldBlockMarkers.get(i));
				if (blockMarker.isGlobal()) {
					((BlockTagParser) newParser).addBlockMarker(blockMarker);
				}
			}
		}

		((BasicStructuredDocument) oldInstance).setParser(newParser);

		((BasicStructuredDocument) oldInstance).setReParser(newInstance.getReParser().newInstance());

		if (newInstance.getDocumentPartitioner() instanceof StructuredTextPartitioner) {
			StructuredTextPartitioner partitioner = null;
			if (oldInstance instanceof IDocumentExtension3 && newInstance instanceof IDocumentExtension3) {
				partitioner = ((StructuredTextPartitioner) ((IDocumentExtension3) newInstance).getDocumentPartitioner(IStructuredPartitioning.DEFAULT_STRUCTURED_PARTITIONING));
				if (partitioner != null) {
					partitioner = (StructuredTextPartitioner) partitioner.newInstance();
				}
				((IDocumentExtension3) oldInstance).setDocumentPartitioner(IStructuredPartitioning.DEFAULT_STRUCTURED_PARTITIONING, partitioner);
			}
			if (partitioner == null) {
				partitioner = (StructuredTextPartitioner) ((StructuredTextPartitioner) newInstance.getDocumentPartitioner()).newInstance();
				oldInstance.setDocumentPartitioner(partitioner);
			}
			if (partitioner != null) {
				partitioner.connect(oldInstance);
			}
		}

		String existingLineDelimiter = null;
		try {
			existingLineDelimiter = newInstance.getLineDelimiter(0);
		}
		catch (BadLocationException e) {
			// if empty file, assume platform default
			// TODO: should be using user set preference, per content type?
			existingLineDelimiter = System.getProperty("line.separator"); //$NON-NLS-1$
		}

		oldInstance.setLineDelimiter(existingLineDelimiter); //$NON-NLS-1$);
		if (newInstance.getEncodingMemento() != null) {
			oldInstance.setEncodingMemento((EncodingMemento) newInstance.getEncodingMemento().clone());
		}

		/**
		 * https://w3.opensource.ibm.com/bugzilla/show_bug.cgi?id=4920
		 * 
		 * JSP taglib support broken, correct by duplicating extended setup
		 * information (BlockTagParser extension,
		 * StructuredDocumentRegionParser extensions)
		 */
		if (oldParser instanceof StructuredDocumentRegionParserExtension && newParser instanceof StructuredDocumentRegionParserExtension) {
			List oldHandlers = ((StructuredDocumentRegionParserExtension) oldParser).getStructuredDocumentRegionHandlers();
			for (int i = 0; i < oldHandlers.size(); i++) {
				StructuredDocumentRegionHandler handler = ((StructuredDocumentRegionHandler) oldHandlers.get(i));
				if (handler instanceof StructuredDocumentRegionHandlerExtension) {
					StructuredDocumentRegionHandlerExtension handlerExtension = (StructuredDocumentRegionHandlerExtension) handler;
					handlerExtension.setStructuredDocument(oldInstance);
				}
			}
		}
		String holdString = newInstance.get();
		newInstance = null;
		oldInstance.set(holdString);
	}
}