core/plugins/org.eclipse.dltk.core/model/org/eclipse/dltk/internal/core/Openable.java - dltk/org.eclipse.dltk.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2017 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
  *
  *******************************************************************************/
 package org.eclipse.dltk.internal.core;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IWorkspace;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.core.runtime.OperationCanceledException;
 import org.eclipse.dltk.codeassist.ICompletionEngine;
 import org.eclipse.dltk.codeassist.ISelectionEngine;
 import org.eclipse.dltk.codeassist.ISelectionRequestor;
 import org.eclipse.dltk.compiler.env.IModuleSource;
 import org.eclipse.dltk.compiler.problem.DefaultProblem;
 import org.eclipse.dltk.compiler.problem.IProblemIdentifier;
 import org.eclipse.dltk.compiler.problem.ProblemSeverity;
 import org.eclipse.dltk.core.BufferChangedEvent;
 import org.eclipse.dltk.core.CompletionRequestor;
 import org.eclipse.dltk.core.DLTKCore;
 import org.eclipse.dltk.core.DLTKLanguageManager;
 import org.eclipse.dltk.core.IBuffer;
 import org.eclipse.dltk.core.IBufferChangedListener;
 import org.eclipse.dltk.core.ICompletionRequestorExtension;
 import org.eclipse.dltk.core.IDLTKLanguageToolkit;
 import org.eclipse.dltk.core.IModelElement;
 import org.eclipse.dltk.core.IModelStatusConstants;
 import org.eclipse.dltk.core.IOpenable;
 import org.eclipse.dltk.core.IProjectFragment;
 import org.eclipse.dltk.core.IScriptProject;
 import org.eclipse.dltk.core.ISourceRange;
 import org.eclipse.dltk.core.ModelException;
 import org.eclipse.dltk.core.ScriptModelUtil;
 import org.eclipse.dltk.core.WorkingCopyOwner;

 /**
  * Abstract class for implementations of model elements which are IOpenable.
  *
  * @see IModelElement
  * @see IOpenable
  */
 public abstract class Openable extends ModelElement
 		implements IOpenable, IBufferChangedListener {

 	protected Openable(ModelElement parent) {
 		super(parent);
 	}

 	/**
 	 * The buffer associated with this element has changed. Registers this
 	 * element as being out of synch with its buffer's contents. If the buffer
 	 * has been closed, this element is set as NOT out of synch with the
 	 * contents.
 	 *
 	 * @see IBufferChangedListener
 	 */
 	@Override
 	public void bufferChanged(BufferChangedEvent event) {
 		if (event.getBuffer().isClosed()) {
 			ModelManager.getModelManager().getElementsOutOfSynchWithBuffers()
 					.remove(this);
 			getBufferManager().removeBuffer(event.getBuffer());
 		} else {
 			ModelManager.getModelManager().getElementsOutOfSynchWithBuffers()
 					.add(this);
 		}
 	}

 	/**
 	 * Builds this element's structure and properties in the given info object,
 	 * based on this element's current contents (reuse buffer contents if this
 	 * element has an open buffer, or resource contents if this element does not
 	 * have an open buffer). Children are placed in the given newElements table
 	 * (note, this element has already been placed in the newElements table).
 	 * Returns true if successful, or false if an error is encountered while
 	 * determining the structure of this element.
 	 */
 	protected abstract boolean buildStructure(OpenableElementInfo info,
 			IProgressMonitor pm, Map newElements, IResource underlyingResource)
 			throws ModelException;

 	/*
 	 * Returns whether this element can be removed from the model cache to make
 	 * space.
 	 */
 	public boolean canBeRemovedFromCache() {
 		try {
 			return !hasUnsavedChanges();
 		} catch (ModelException e) {
 			return false;
 		}
 	}

 	/*
 	 * Returns whether the buffer of this element can be removed from the Script
 	 * model cache to make space.
 	 */
 	public boolean canBufferBeRemovedFromCache(IBuffer buffer) {
 		return !buffer.hasUnsavedChanges();
 	}

 	/**
 	 * Close the buffer associated with this element, if any.
 	 */
 	protected void closeBuffer() {
 		if (!hasBuffer())
 			return; // nothing to do
 		IBuffer buffer = getBufferManager().getBuffer(this);
 		if (buffer != null) {
 			buffer.close();
 			buffer.removeBufferChangedListener(this);
 		}
 	}

 	/**
 	 * This element is being closed. Do any necessary cleanup.
 	 */
 	@Override
 	protected void closing(Object info) {
 		closeBuffer();
 	}

 	/**
 	 * @see IModelElement
 	 */
 	@Override
 	public boolean exists() {
 		ModelManager manager = ModelManager.getModelManager();
 		if (manager.getInfo(this) != null)
 			return true;
 		if (!parentExists())
 			return false;
 		IProjectFragment root = getProjectFragment();
 		if (root != null && (root == this || !root.isArchive())) {
 			return resourceExists();
 		}
 		return super.exists();
 	}

 	@Override
 	protected void generateInfos(Object info, HashMap newElements,
 			IProgressMonitor monitor) throws ModelException {

 		if (ModelManager.VERBOSE) {
 			String element;
 			switch (getElementType()) {
 			case SCRIPT_PROJECT:
 				element = "project"; //$NON-NLS-1$
 				break;
 			case PROJECT_FRAGMENT:
 				element = "fragment"; //$NON-NLS-1$
 				break;
 			case SCRIPT_FOLDER:
 				element = "folder"; //$NON-NLS-1$
 				break;
 			case BINARY_MODULE:
 				element = "binary module"; //$NON-NLS-1$
 				break;
 			case SOURCE_MODULE:
 				element = "source module"; //$NON-NLS-1$
 				break;
 			default:
 				element = "element"; //$NON-NLS-1$
 			}
 			System.out.println(Thread.currentThread() + " OPENING " + element //$NON-NLS-1$
 					+ " " + this.toStringWithAncestors()); //$NON-NLS-1$
 		}

 		// open the parent if necessary
 		openParent(info, newElements, monitor);
 		if (monitor != null && monitor.isCanceled())
 			throw new OperationCanceledException();

 		// puts the info before building the structure so that questions to the
 		// handle behave as if the element existed
 		// (case of compilation units becoming working copies)
 		newElements.put(this, info);

 		// build the structure of the openable (this will open the buffer if
 		// needed)
 		try {
 			OpenableElementInfo openableElementInfo = (OpenableElementInfo) info;
 			boolean isStructureKnown = buildStructure(openableElementInfo,
 					monitor, newElements, getResource());
 			openableElementInfo.setIsStructureKnown(isStructureKnown);
 		} catch (ModelException e) {
 			newElements.remove(this);
 			throw e;
 		}

 		// remove out of sync buffer for this element
 		ModelManager.getModelManager().getElementsOutOfSynchWithBuffers()
 				.remove(this);

 		if (ModelManager.VERBOSE) {
 			System.out.println(ModelManager.getModelManager().cache
 					.toStringFillingRation("-> ")); //$NON-NLS-1$
 		}
 	}

 	/**
 	 * Note: a buffer with no unsaved changes can be closed by the Model since
 	 * it has a finite number of buffers allowed open at one time. If this is
 	 * the first time a request is being made for the buffer, an attempt is made
 	 * to create and fill this element's buffer. If the buffer has been closed
 	 * since it was first opened, the buffer is re-created.
 	 *
 	 * @see IOpenable
 	 */
 	@Override
 	public IBuffer getBuffer() throws ModelException {
 		if (hasBuffer()) {
 			// ensure element is open
 			Object info = getElementInfo();
 			IBuffer buffer = getBufferManager().getBuffer(this);
 			if (buffer == null) {
 				// try to (re)open a buffer
 				buffer = openBuffer(null, info);
 			}
 			return buffer;
 		} else {
 			return null;
 		}
 	}

 	/**
 	 * Returns {@link IBuffer} or <code>null</code> if this element is not
 	 * opened yet.
 	 */
 	public IBuffer getBufferNotOpen() throws ModelException {
 		if (hasBuffer()) {
 			return getBufferManager().getBuffer(this);
 		}
 		return null;
 	}

 	/**
 	 * Returns the buffer manager for this element.
 	 */
 	protected BufferManager getBufferManager() {
 		return BufferManager.getDefaultBufferManager();
 	}

 	/**
 	 * Return my underlying resource. Elements that may not have a corresponding
 	 * resource must override this method.
 	 *
 	 * @see IScriptElement
 	 */
 	@Override
 	public IResource getCorrespondingResource() throws ModelException {
 		return getUnderlyingResource();
 	}

 	/*
 	 * @see IModelElement
 	 */
 	@Override
 	public IOpenable getOpenable() {
 		return this;
 	}

 	@Override
 	public IResource getUnderlyingResource() throws ModelException {
 		IResource parentResource = this.parent.getUnderlyingResource();
 		if (parentResource == null) {
 			return null;
 		}
 		int type = parentResource.getType();
 		if (type == IResource.FOLDER || type == IResource.PROJECT) {
 			IContainer folder = (IContainer) parentResource;
 			IResource resource = folder.findMember(getElementName());
 			if (resource == null) {
 				throw newNotPresentException();
 			} else {
 				return resource;
 			}
 		} else {
 			return parentResource;
 		}
 	}

 	/**
 	 * Returns true if this element may have an associated source buffer,
 	 * otherwise false. Subclasses must override as required.
 	 */
 	protected boolean hasBuffer() {
 		return false;
 	}

 	/**
 	 * @see IOpenable
 	 */
 	@Override
 	public boolean hasUnsavedChanges() throws ModelException {

 		if (isReadOnly() || !isOpen()) {
 			return false;
 		}
 		if (hasBuffer()) {
 			IBuffer buf = this.getBufferNotOpen();
 			if (buf != null && buf.hasUnsavedChanges()) {
 				return true;
 			}
 		}
 		// for package fragments, package fragment roots, and projects must
 		// check open buffers
 		// to see if they have an child with unsaved changes
 		int elementType = getElementType();
 		if (elementType == SCRIPT_FOLDER || elementType == PROJECT_FRAGMENT
 				|| elementType == SCRIPT_PROJECT
 				|| elementType == SCRIPT_MODEL) { // fix
 			// for
 			// 1FWNMHH
 			Enumeration openBuffers = getBufferManager().getOpenBuffers();
 			while (openBuffers.hasMoreElements()) {
 				IBuffer buffer = (IBuffer) openBuffers.nextElement();
 				if (buffer.hasUnsavedChanges()) {
 					IModelElement owner = buffer.getOwner();
 					if (isAncestorOf(owner)) {
 						return true;
 					}
 				}
 			}
 		}

 		return false;
 	}

 	/**
 	 * Subclasses must override as required.
 	 *
 	 * @see IOpenable
 	 */
 	@Override
 	public boolean isConsistent() {
 		return true;
 	}

 	/**
 	 *
 	 * @see IOpenable
 	 */
 	@Override
 	public boolean isOpen() {
 		return ModelManager.getModelManager().getInfo(this) != null;
 	}

 	/**
 	 * Returns true if this represents a source element. Openable source
 	 * elements have an associated buffer created when they are opened.
 	 */
 	protected boolean isSourceElement() {
 		return false;
 	}

 	/**
 	 * @see IModelElement
 	 */
 	@Override
 	public boolean isStructureKnown() throws ModelException {
 		return ((OpenableElementInfo) getElementInfo()).isStructureKnown();
 	}

 	/**
 	 * @see IOpenable
 	 */
 	@Override
 	public void makeConsistent(IProgressMonitor monitor) throws ModelException {
 		// only source modules can be inconsistent
 		// other openables cannot be inconsistent so default is to do nothing
 	}

 	/**
 	 * @see IOpenable
 	 */
 	@Override
 	public void open(IProgressMonitor pm) throws ModelException {
 		getElementInfo(pm);
 	}

 	/**
 	 * Opens a buffer on the contents of this element, and returns the buffer,
 	 * or returns <code>null</code> if opening fails. By default, do nothing -
 	 * subclasses that have buffers must override as required.
 	 */
 	protected IBuffer openBuffer(IProgressMonitor pm, Object info)
 			throws ModelException {
 		return null;
 	}

 	/**
 	 * Open the parent element if necessary.
 	 */
 	protected void openParent(Object childInfo, HashMap newElements,
 			IProgressMonitor pm) throws ModelException {

 		Openable openableParent = (Openable) getOpenableParent();
 		if (openableParent != null && !openableParent.isOpen()) {
 			openableParent.generateInfos(openableParent.createElementInfo(),
 					newElements, pm);
 		}
 	}

 	/**
 	 * Answers true if the parent exists (null parent is answering true)
 	 *
 	 */
 	protected boolean parentExists() {
 		IModelElement parentElement = getParent();
 		if (parentElement == null)
 			return true;
 		return parentElement.exists();
 	}

 	/**
 	 * Returns whether the corresponding resource or associated file exists
 	 */
 	protected boolean resourceExists() {
 		IWorkspace workspace = ResourcesPlugin.getWorkspace();
 		if (workspace == null)
 			return false; // workaround for
 		// http://bugs.eclipse.org/bugs/show_bug.cgi?id=34069
 		return Model.getTarget(workspace.getRoot(),
 				this.getPath().makeRelative(), // ensure path is relative (see
 				// http://dev.eclipse.org/bugs/show_bug.cgi?id=22517)
 				true) != null;
 	}

 	/**
 	 * @see IOpenable
 	 */
 	@Override
 	public void save(IProgressMonitor pm, boolean force) throws ModelException {
 		if (isReadOnly()) {
 			throw new ModelException(
 					new ModelStatus(IModelStatusConstants.READ_ONLY, this));
 		}
 		IBuffer buf = getBuffer();
 		if (buf != null) { // some Openables (like a ScriptProject) don't have
 			// a
 			// buffer
 			buf.save(pm, force);
 			this.makeConsistent(pm); // update the element info of this
 			// element
 		}
 	}

 	/**
 	 * Find enclosing project fragment if any
 	 */
 	public IProjectFragment getProjectFragment() {
 		return (IProjectFragment) getAncestor(IModelElement.PROJECT_FRAGMENT);
 	}

 	static class CompletionThread extends Thread {
 		final IDLTKLanguageToolkit toolkit;
 		final IScriptProject project;
 		final IModuleSource cu;
 		final int position;
 		final CompletionRequestor requestor;
 		final NullProgressMonitor monitor = new NullProgressMonitor();

 		public CompletionThread(IDLTKLanguageToolkit toolkit,
 				IScriptProject project, IModuleSource cu, int position,
 				CompletionRequestor requestor) {
 			super("CompletionThread-" + toolkit.getLanguageName());
 			this.toolkit = toolkit;
 			this.project = project;
 			this.cu = cu;
 			this.position = position;
 			this.requestor = requestor;
 		}

 		private boolean done = false;

 		@Override
 		public void run() {
 			// code complete
 			final ICompletionEngine[] engines = DLTKLanguageManager
 					.getCompletionEngines(toolkit.getNatureId());
 			if (engines != null) {
 				for (ICompletionEngine engine : engines) {
 					run(engine);
 					if (requestor.isIgnored(CompletionRequestor.ALL)) {
 						break;
 					}
 					if (monitor.isCanceled())
 						break;
 				}
 			}
 			done = true;
 		}

 		private void run(ICompletionEngine engine) {
 			// engine.setEnvironment(environment);
 			engine.setRequestor(requestor);

 			engine.setOptions(project.getOptions(true));
 			engine.setProject(project);

 			engine.setProgressMonitor(monitor);
 			engine.complete(cu, position, 0);
 		}

 		boolean execute(long timeout) {
 			start();
 			try {
 				join(timeout);
 				if (!done) {
 					monitor.setCanceled(true);
 					interrupt();
 				}
 				return done;
 			} catch (InterruptedException e) {
 				if (DLTKCore.DEBUG) {
 					e.printStackTrace();
 				}
 				return false;
 			}
 		}
 	}

 	/** Code Completion */
 	protected void codeComplete(final IModuleSource cu, final int position,
 			CompletionRequestor requestor, WorkingCopyOwner owner, long timeout)
 			throws ModelException {
 		if (requestor == null) {
 			throw new IllegalArgumentException(
 					Messages.Openable_completionRequesterCannotBeNull);
 		}

 		IBuffer buffer = getBuffer();
 		if (buffer == null) {
 			return;
 		}
 		if (position < -1 || position > buffer.getLength()) {
 			if (DLTKCore.DEBUG) {
 				throw new ModelException(new ModelStatus(
 						IModelStatusConstants.INDEX_OUT_OF_BOUNDS));
 			}
 			return;
 		}

 		IDLTKLanguageToolkit toolkit = DLTKLanguageManager
 				.getLanguageToolkit(this);
 		if (toolkit == null) {
 			return;
 		}

 		CompletionThread thread = new CompletionThread(toolkit,
 				getScriptProject(), cu, position, requestor);
 		if (!thread.execute(timeout)) {
 			Thread.interrupted();
 			requestor.completionFailure(new DefaultProblem(
 					"Computation of proposals takes too long. Please try again.",
 					IProblemIdentifier.NULL, null, ProblemSeverity.WARNING, 0,
 					0, 0));
 			if (requestor instanceof ICompletionRequestorExtension) {
 				((ICompletionRequestorExtension) requestor).reset();
 			}
 		}
 	}

 	static class ModelElementSelectionRequestor implements ISelectionRequestor {
 		private final List<IModelElement> elements = new ArrayList<>();
 		private List<Object> foreignElements;
 		private Map<Object, ISourceRange> ranges;

 		@Override
 		public void acceptForeignElement(Object element) {
 			if (element instanceof IModelElement) {
 				acceptModelElement((IModelElement) element);
 			} else {
 				if (foreignElements == null) {
 					foreignElements = new ArrayList<>();
 				}
 				foreignElements.add(element);
 			}
 		}

 		@Override
 		public void acceptModelElement(IModelElement element) {
 			elements.add(element);
 		}

 		@Override
 		public void acceptElement(Object element, ISourceRange range) {
 			acceptForeignElement(element);
 			if (range != null) {
 				if (ranges == null) {
 					ranges = new HashMap<>();
 				}
 				ranges.put(element, range);
 			}
 		}

 		void addModelElements(IModelElement[] elements) {
 			Collections.addAll(this.elements, elements);
 		}

 		IModelElement[] toModelElementArray() {
 			if (elements.isEmpty()) {
 				return ScriptModelUtil.NO_ELEMENTS;
 			} else {
 				return elements.toArray(new IModelElement[elements.size()]);
 			}
 		}

 		boolean isEmpty() {
 			return elements.isEmpty()
 					&& (foreignElements == null || foreignElements.isEmpty());
 		}

 		CodeSelection asResponse() {
 			if (isEmpty()) {
 				return null;
 			} else {
 				final IModelElement[] elementArray = elements != null
 						&& !elements.isEmpty()
 								? elements.toArray(
 										new IModelElement[elements.size()])
 								: null;
 				final Object[] foreignElementArray = foreignElements != null
 						&& !foreignElements.isEmpty()
 								? foreignElements.toArray()
 								: null;
 				return new CodeSelection(elementArray, foreignElementArray,
 						ranges);
 			}
 		}
 	}

 	private void codeSelect(org.eclipse.dltk.compiler.env.IModuleSource cu,
 			int offset, int length, WorkingCopyOwner owner,
 			ModelElementSelectionRequestor requestor) throws ModelException {

 		ScriptProject project = (ScriptProject) getScriptProject();

 		IBuffer buffer = getBuffer();
 		int end = -1;
 		if (buffer != null) {
 			end = buffer.getLength();
 		}
 		IDLTKLanguageToolkit toolkit = DLTKLanguageManager
 				.getLanguageToolkit(this);
 		if (toolkit == null) {
 			if (DLTKCore.VERBOSE) {
 				System.out.println(
 						"DLTK.Openable.VERBOSE: Failed to detect language toolkit... for module:" //$NON-NLS-1$
 								+ this.getResource().getName());
 			}
 			return;
 		}

 		if (offset < 0 || length < 0
 				|| (end != -1 && (offset + length > end))) {
 			throw new ModelException(
 					new ModelStatus(IModelStatusConstants.INDEX_OUT_OF_BOUNDS));
 		}

 		final ISelectionEngine[] engines = DLTKLanguageManager
 				.getSelectionEngines(toolkit.getNatureId());
 		if (engines != null) {
 			for (ISelectionEngine engine : engines) {
 				engine.setOptions(project.getOptions(true));
 				engine.setRequestor(requestor);
 				final IModelElement[] result = engine.select(cu, offset,
 						offset + length - 1);
 				if (result != null) {
 					requestor.addModelElements(result);
 				}
 				if (!requestor.isEmpty()) {
 					return;
 				}
 			}
 		}
 	}

 	protected IModelElement[] codeSelect(
 			org.eclipse.dltk.compiler.env.IModuleSource cu, int offset,
 			int length, WorkingCopyOwner owner) throws ModelException {
 		final ModelElementSelectionRequestor requestor = new ModelElementSelectionRequestor();
 		codeSelect(cu, offset, length, owner, requestor);
 		return requestor.toModelElementArray();
 	}

 	protected CodeSelection codeSelectAll(
 			org.eclipse.dltk.compiler.env.IModuleSource cu, int offset,
 			int length, WorkingCopyOwner owner) throws ModelException {
 		final ModelElementSelectionRequestor requestor = new ModelElementSelectionRequestor();
 		codeSelect(cu, offset, length, owner, requestor);
 		return requestor.asResponse();
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2005, 2017 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
	*
	*******************************************************************************/
	package org.eclipse.dltk.internal.core;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Enumeration;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.core.resources.IContainer;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.resources.IWorkspace;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.core.runtime.OperationCanceledException;
	import org.eclipse.dltk.codeassist.ICompletionEngine;
	import org.eclipse.dltk.codeassist.ISelectionEngine;
	import org.eclipse.dltk.codeassist.ISelectionRequestor;
	import org.eclipse.dltk.compiler.env.IModuleSource;
	import org.eclipse.dltk.compiler.problem.DefaultProblem;
	import org.eclipse.dltk.compiler.problem.IProblemIdentifier;
	import org.eclipse.dltk.compiler.problem.ProblemSeverity;
	import org.eclipse.dltk.core.BufferChangedEvent;
	import org.eclipse.dltk.core.CompletionRequestor;
	import org.eclipse.dltk.core.DLTKCore;
	import org.eclipse.dltk.core.DLTKLanguageManager;
	import org.eclipse.dltk.core.IBuffer;
	import org.eclipse.dltk.core.IBufferChangedListener;
	import org.eclipse.dltk.core.ICompletionRequestorExtension;
	import org.eclipse.dltk.core.IDLTKLanguageToolkit;
	import org.eclipse.dltk.core.IModelElement;
	import org.eclipse.dltk.core.IModelStatusConstants;
	import org.eclipse.dltk.core.IOpenable;
	import org.eclipse.dltk.core.IProjectFragment;
	import org.eclipse.dltk.core.IScriptProject;
	import org.eclipse.dltk.core.ISourceRange;
	import org.eclipse.dltk.core.ModelException;
	import org.eclipse.dltk.core.ScriptModelUtil;
	import org.eclipse.dltk.core.WorkingCopyOwner;

	/**
	* Abstract class for implementations of model elements which are IOpenable.
	*
	* @see IModelElement
	* @see IOpenable
	*/
	public abstract class Openable extends ModelElement
	implements IOpenable, IBufferChangedListener {

	protected Openable(ModelElement parent) {
	super(parent);
	}

	/**
	* The buffer associated with this element has changed. Registers this
	* element as being out of synch with its buffer's contents. If the buffer
	* has been closed, this element is set as NOT out of synch with the
	* contents.
	*
	* @see IBufferChangedListener
	*/
	@Override
	public void bufferChanged(BufferChangedEvent event) {
	if (event.getBuffer().isClosed()) {
	ModelManager.getModelManager().getElementsOutOfSynchWithBuffers()
	.remove(this);
	getBufferManager().removeBuffer(event.getBuffer());
	} else {
	ModelManager.getModelManager().getElementsOutOfSynchWithBuffers()
	.add(this);
	}
	}

	/**
	* Builds this element's structure and properties in the given info object,
	* based on this element's current contents (reuse buffer contents if this
	* element has an open buffer, or resource contents if this element does not
	* have an open buffer). Children are placed in the given newElements table
	* (note, this element has already been placed in the newElements table).
	* Returns true if successful, or false if an error is encountered while
	* determining the structure of this element.
	*/
	protected abstract boolean buildStructure(OpenableElementInfo info,
	IProgressMonitor pm, Map newElements, IResource underlyingResource)
	throws ModelException;

	/*
	* Returns whether this element can be removed from the model cache to make
	* space.
	*/
	public boolean canBeRemovedFromCache() {
	try {
	return !hasUnsavedChanges();
	} catch (ModelException e) {
	return false;
	}
	}

	/*
	* Returns whether the buffer of this element can be removed from the Script
	* model cache to make space.
	*/
	public boolean canBufferBeRemovedFromCache(IBuffer buffer) {
	return !buffer.hasUnsavedChanges();
	}

	/**
	* Close the buffer associated with this element, if any.
	*/
	protected void closeBuffer() {
	if (!hasBuffer())
	return; // nothing to do
	IBuffer buffer = getBufferManager().getBuffer(this);
	if (buffer != null) {
	buffer.close();
	buffer.removeBufferChangedListener(this);
	}
	}

	/**
	* This element is being closed. Do any necessary cleanup.
	*/
	@Override
	protected void closing(Object info) {
	closeBuffer();
	}

	/**
	* @see IModelElement
	*/
	@Override
	public boolean exists() {
	ModelManager manager = ModelManager.getModelManager();
	if (manager.getInfo(this) != null)
	return true;
	if (!parentExists())
	return false;
	IProjectFragment root = getProjectFragment();
	if (root != null && (root == this \|\| !root.isArchive())) {
	return resourceExists();
	}
	return super.exists();
	}

	@Override
	protected void generateInfos(Object info, HashMap newElements,
	IProgressMonitor monitor) throws ModelException {

	if (ModelManager.VERBOSE) {
	String element;
	switch (getElementType()) {
	case SCRIPT_PROJECT:
	element = "project"; //$NON-NLS-1$
	break;
	case PROJECT_FRAGMENT:
	element = "fragment"; //$NON-NLS-1$
	break;
	case SCRIPT_FOLDER:
	element = "folder"; //$NON-NLS-1$
	break;
	case BINARY_MODULE:
	element = "binary module"; //$NON-NLS-1$
	break;
	case SOURCE_MODULE:
	element = "source module"; //$NON-NLS-1$
	break;
	default:
	element = "element"; //$NON-NLS-1$
	}
	System.out.println(Thread.currentThread() + " OPENING " + element //$NON-NLS-1$
	+ " " + this.toStringWithAncestors()); //$NON-NLS-1$
	}

	// open the parent if necessary
	openParent(info, newElements, monitor);
	if (monitor != null && monitor.isCanceled())
	throw new OperationCanceledException();

	// puts the info before building the structure so that questions to the
	// handle behave as if the element existed
	// (case of compilation units becoming working copies)
	newElements.put(this, info);

	// build the structure of the openable (this will open the buffer if
	// needed)
	try {
	OpenableElementInfo openableElementInfo = (OpenableElementInfo) info;
	boolean isStructureKnown = buildStructure(openableElementInfo,
	monitor, newElements, getResource());
	openableElementInfo.setIsStructureKnown(isStructureKnown);
	} catch (ModelException e) {
	newElements.remove(this);
	throw e;
	}

	// remove out of sync buffer for this element
	ModelManager.getModelManager().getElementsOutOfSynchWithBuffers()
	.remove(this);

	if (ModelManager.VERBOSE) {
	System.out.println(ModelManager.getModelManager().cache
	.toStringFillingRation("-> ")); //$NON-NLS-1$
	}
	}

	/**
	* Note: a buffer with no unsaved changes can be closed by the Model since
	* it has a finite number of buffers allowed open at one time. If this is
	* the first time a request is being made for the buffer, an attempt is made
	* to create and fill this element's buffer. If the buffer has been closed
	* since it was first opened, the buffer is re-created.
	*
	* @see IOpenable
	*/
	@Override
	public IBuffer getBuffer() throws ModelException {
	if (hasBuffer()) {
	// ensure element is open
	Object info = getElementInfo();
	IBuffer buffer = getBufferManager().getBuffer(this);
	if (buffer == null) {
	// try to (re)open a buffer
	buffer = openBuffer(null, info);
	}
	return buffer;
	} else {
	return null;
	}
	}

	/**
	* Returns {@link IBuffer} or <code>null</code> if this element is not
	* opened yet.
	*/
	public IBuffer getBufferNotOpen() throws ModelException {
	if (hasBuffer()) {
	return getBufferManager().getBuffer(this);
	}
	return null;
	}

	/**
	* Returns the buffer manager for this element.
	*/
	protected BufferManager getBufferManager() {
	return BufferManager.getDefaultBufferManager();
	}

	/**
	* Return my underlying resource. Elements that may not have a corresponding
	* resource must override this method.
	*
	* @see IScriptElement
	*/
	@Override
	public IResource getCorrespondingResource() throws ModelException {
	return getUnderlyingResource();
	}

	/*
	* @see IModelElement
	*/
	@Override
	public IOpenable getOpenable() {
	return this;
	}

	@Override
	public IResource getUnderlyingResource() throws ModelException {
	IResource parentResource = this.parent.getUnderlyingResource();
	if (parentResource == null) {
	return null;
	}
	int type = parentResource.getType();
	if (type == IResource.FOLDER \|\| type == IResource.PROJECT) {
	IContainer folder = (IContainer) parentResource;
	IResource resource = folder.findMember(getElementName());
	if (resource == null) {
	throw newNotPresentException();
	} else {
	return resource;
	}
	} else {
	return parentResource;
	}
	}

	/**
	* Returns true if this element may have an associated source buffer,
	* otherwise false. Subclasses must override as required.
	*/
	protected boolean hasBuffer() {
	return false;
	}

	/**
	* @see IOpenable
	*/
	@Override
	public boolean hasUnsavedChanges() throws ModelException {

	if (isReadOnly() \|\| !isOpen()) {
	return false;
	}
	if (hasBuffer()) {
	IBuffer buf = this.getBufferNotOpen();
	if (buf != null && buf.hasUnsavedChanges()) {
	return true;
	}
	}
	// for package fragments, package fragment roots, and projects must
	// check open buffers
	// to see if they have an child with unsaved changes
	int elementType = getElementType();
	if (elementType == SCRIPT_FOLDER \|\| elementType == PROJECT_FRAGMENT
	\|\| elementType == SCRIPT_PROJECT
	\|\| elementType == SCRIPT_MODEL) { // fix
	// for
	// 1FWNMHH
	Enumeration openBuffers = getBufferManager().getOpenBuffers();
	while (openBuffers.hasMoreElements()) {
	IBuffer buffer = (IBuffer) openBuffers.nextElement();
	if (buffer.hasUnsavedChanges()) {
	IModelElement owner = buffer.getOwner();
	if (isAncestorOf(owner)) {
	return true;
	}
	}
	}
	}

	return false;
	}

	/**
	* Subclasses must override as required.
	*
	* @see IOpenable
	*/
	@Override
	public boolean isConsistent() {
	return true;
	}

	/**
	*
	* @see IOpenable
	*/
	@Override
	public boolean isOpen() {
	return ModelManager.getModelManager().getInfo(this) != null;
	}

	/**
	* Returns true if this represents a source element. Openable source
	* elements have an associated buffer created when they are opened.
	*/
	protected boolean isSourceElement() {
	return false;
	}

	/**
	* @see IModelElement
	*/
	@Override
	public boolean isStructureKnown() throws ModelException {
	return ((OpenableElementInfo) getElementInfo()).isStructureKnown();
	}

	/**
	* @see IOpenable
	*/
	@Override
	public void makeConsistent(IProgressMonitor monitor) throws ModelException {
	// only source modules can be inconsistent
	// other openables cannot be inconsistent so default is to do nothing
	}

	/**
	* @see IOpenable
	*/
	@Override
	public void open(IProgressMonitor pm) throws ModelException {
	getElementInfo(pm);
	}

	/**
	* Opens a buffer on the contents of this element, and returns the buffer,
	* or returns <code>null</code> if opening fails. By default, do nothing -
	* subclasses that have buffers must override as required.
	*/
	protected IBuffer openBuffer(IProgressMonitor pm, Object info)
	throws ModelException {
	return null;
	}

	/**
	* Open the parent element if necessary.
	*/
	protected void openParent(Object childInfo, HashMap newElements,
	IProgressMonitor pm) throws ModelException {

	Openable openableParent = (Openable) getOpenableParent();
	if (openableParent != null && !openableParent.isOpen()) {
	openableParent.generateInfos(openableParent.createElementInfo(),
	newElements, pm);
	}
	}

	/**
	* Answers true if the parent exists (null parent is answering true)
	*
	*/
	protected boolean parentExists() {
	IModelElement parentElement = getParent();
	if (parentElement == null)
	return true;
	return parentElement.exists();
	}

	/**
	* Returns whether the corresponding resource or associated file exists
	*/
	protected boolean resourceExists() {
	IWorkspace workspace = ResourcesPlugin.getWorkspace();
	if (workspace == null)
	return false; // workaround for
	// http://bugs.eclipse.org/bugs/show_bug.cgi?id=34069
	return Model.getTarget(workspace.getRoot(),
	this.getPath().makeRelative(), // ensure path is relative (see
	// http://dev.eclipse.org/bugs/show_bug.cgi?id=22517)
	true) != null;
	}

	/**
	* @see IOpenable
	*/
	@Override
	public void save(IProgressMonitor pm, boolean force) throws ModelException {
	if (isReadOnly()) {
	throw new ModelException(
	new ModelStatus(IModelStatusConstants.READ_ONLY, this));
	}
	IBuffer buf = getBuffer();
	if (buf != null) { // some Openables (like a ScriptProject) don't have
	// a
	// buffer
	buf.save(pm, force);
	this.makeConsistent(pm); // update the element info of this
	// element
	}
	}

	/**
	* Find enclosing project fragment if any
	*/
	public IProjectFragment getProjectFragment() {
	return (IProjectFragment) getAncestor(IModelElement.PROJECT_FRAGMENT);
	}

	static class CompletionThread extends Thread {
	final IDLTKLanguageToolkit toolkit;
	final IScriptProject project;
	final IModuleSource cu;
	final int position;
	final CompletionRequestor requestor;
	final NullProgressMonitor monitor = new NullProgressMonitor();

	public CompletionThread(IDLTKLanguageToolkit toolkit,
	IScriptProject project, IModuleSource cu, int position,
	CompletionRequestor requestor) {
	super("CompletionThread-" + toolkit.getLanguageName());
	this.toolkit = toolkit;
	this.project = project;
	this.cu = cu;
	this.position = position;
	this.requestor = requestor;
	}

	private boolean done = false;

	@Override
	public void run() {
	// code complete
	final ICompletionEngine[] engines = DLTKLanguageManager
	.getCompletionEngines(toolkit.getNatureId());
	if (engines != null) {
	for (ICompletionEngine engine : engines) {
	run(engine);
	if (requestor.isIgnored(CompletionRequestor.ALL)) {
	break;
	}
	if (monitor.isCanceled())
	break;
	}
	}
	done = true;
	}

	private void run(ICompletionEngine engine) {
	// engine.setEnvironment(environment);
	engine.setRequestor(requestor);

	engine.setOptions(project.getOptions(true));
	engine.setProject(project);

	engine.setProgressMonitor(monitor);
	engine.complete(cu, position, 0);
	}

	boolean execute(long timeout) {
	start();
	try {
	join(timeout);
	if (!done) {
	monitor.setCanceled(true);
	interrupt();
	}
	return done;
	} catch (InterruptedException e) {
	if (DLTKCore.DEBUG) {
	e.printStackTrace();
	}
	return false;
	}
	}
	}

	/** Code Completion */
	protected void codeComplete(final IModuleSource cu, final int position,
	CompletionRequestor requestor, WorkingCopyOwner owner, long timeout)
	throws ModelException {
	if (requestor == null) {
	throw new IllegalArgumentException(
	Messages.Openable_completionRequesterCannotBeNull);
	}

	IBuffer buffer = getBuffer();
	if (buffer == null) {
	return;
	}
	if (position < -1 \|\| position > buffer.getLength()) {
	if (DLTKCore.DEBUG) {
	throw new ModelException(new ModelStatus(
	IModelStatusConstants.INDEX_OUT_OF_BOUNDS));
	}
	return;
	}

	IDLTKLanguageToolkit toolkit = DLTKLanguageManager
	.getLanguageToolkit(this);
	if (toolkit == null) {
	return;
	}

	CompletionThread thread = new CompletionThread(toolkit,
	getScriptProject(), cu, position, requestor);
	if (!thread.execute(timeout)) {
	Thread.interrupted();
	requestor.completionFailure(new DefaultProblem(
	"Computation of proposals takes too long. Please try again.",
	IProblemIdentifier.NULL, null, ProblemSeverity.WARNING, 0,
	0, 0));
	if (requestor instanceof ICompletionRequestorExtension) {
	((ICompletionRequestorExtension) requestor).reset();
	}
	}
	}

	static class ModelElementSelectionRequestor implements ISelectionRequestor {
	private final List<IModelElement> elements = new ArrayList<>();
	private List<Object> foreignElements;
	private Map<Object, ISourceRange> ranges;

	@Override
	public void acceptForeignElement(Object element) {
	if (element instanceof IModelElement) {
	acceptModelElement((IModelElement) element);
	} else {
	if (foreignElements == null) {
	foreignElements = new ArrayList<>();
	}
	foreignElements.add(element);
	}
	}

	@Override
	public void acceptModelElement(IModelElement element) {
	elements.add(element);
	}

	@Override
	public void acceptElement(Object element, ISourceRange range) {
	acceptForeignElement(element);
	if (range != null) {
	if (ranges == null) {
	ranges = new HashMap<>();
	}
	ranges.put(element, range);
	}
	}

	void addModelElements(IModelElement[] elements) {
	Collections.addAll(this.elements, elements);
	}

	IModelElement[] toModelElementArray() {
	if (elements.isEmpty()) {
	return ScriptModelUtil.NO_ELEMENTS;
	} else {
	return elements.toArray(new IModelElement[elements.size()]);
	}
	}

	boolean isEmpty() {
	return elements.isEmpty()
	&& (foreignElements == null \|\| foreignElements.isEmpty());
	}

	CodeSelection asResponse() {
	if (isEmpty()) {
	return null;
	} else {
	final IModelElement[] elementArray = elements != null
	&& !elements.isEmpty()
	? elements.toArray(
	new IModelElement[elements.size()])
	: null;
	final Object[] foreignElementArray = foreignElements != null
	&& !foreignElements.isEmpty()
	? foreignElements.toArray()
	: null;
	return new CodeSelection(elementArray, foreignElementArray,
	ranges);
	}
	}
	}

	private void codeSelect(org.eclipse.dltk.compiler.env.IModuleSource cu,
	int offset, int length, WorkingCopyOwner owner,
	ModelElementSelectionRequestor requestor) throws ModelException {

	ScriptProject project = (ScriptProject) getScriptProject();

	IBuffer buffer = getBuffer();
	int end = -1;
	if (buffer != null) {
	end = buffer.getLength();
	}
	IDLTKLanguageToolkit toolkit = DLTKLanguageManager
	.getLanguageToolkit(this);
	if (toolkit == null) {
	if (DLTKCore.VERBOSE) {
	System.out.println(
	"DLTK.Openable.VERBOSE: Failed to detect language toolkit... for module:" //$NON-NLS-1$
	+ this.getResource().getName());
	}
	return;
	}

	if (offset < 0 \|\| length < 0
	\|\| (end != -1 && (offset + length > end))) {
	throw new ModelException(
	new ModelStatus(IModelStatusConstants.INDEX_OUT_OF_BOUNDS));
	}

	final ISelectionEngine[] engines = DLTKLanguageManager
	.getSelectionEngines(toolkit.getNatureId());
	if (engines != null) {
	for (ISelectionEngine engine : engines) {
	engine.setOptions(project.getOptions(true));
	engine.setRequestor(requestor);
	final IModelElement[] result = engine.select(cu, offset,
	offset + length - 1);
	if (result != null) {
	requestor.addModelElements(result);
	}
	if (!requestor.isEmpty()) {
	return;
	}
	}
	}
	}

	protected IModelElement[] codeSelect(
	org.eclipse.dltk.compiler.env.IModuleSource cu, int offset,
	int length, WorkingCopyOwner owner) throws ModelException {
	final ModelElementSelectionRequestor requestor = new ModelElementSelectionRequestor();
	codeSelect(cu, offset, length, owner, requestor);
	return requestor.toModelElementArray();
	}

	protected CodeSelection codeSelectAll(
	org.eclipse.dltk.compiler.env.IModuleSource cu, int offset,
	int length, WorkingCopyOwner owner) throws ModelException {
	final ModelElementSelectionRequestor requestor = new ModelElementSelectionRequestor();
	codeSelect(cu, offset, length, owner, requestor);
	return requestor.asResponse();
	}

	}