| /******************************************************************************* |
| * Copyright (c) 2014, 2016 1C-Soft LLC 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: |
| * Vladimir Piskarev (1C) - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.handly.model.impl; |
| |
| import static org.eclipse.handly.context.Contexts.EMPTY_CONTEXT; |
| import static org.eclipse.handly.context.Contexts.of; |
| import static org.eclipse.handly.context.Contexts.with; |
| import static org.eclipse.handly.model.IElementDeltaConstants.F_WORKING_COPY; |
| import static org.eclipse.handly.util.ToStringOptions.FORMAT_STYLE; |
| import static org.eclipse.handly.util.ToStringOptions.FormatStyle.MEDIUM; |
| |
| import java.util.Map; |
| import java.util.concurrent.TimeUnit; |
| import java.util.concurrent.TimeoutException; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.core.runtime.SubProgressMonitor; |
| import org.eclipse.handly.buffer.IBuffer; |
| import org.eclipse.handly.context.IContext; |
| import org.eclipse.handly.internal.Activator; |
| import org.eclipse.handly.model.IElement; |
| import org.eclipse.handly.snapshot.ISnapshot; |
| import org.eclipse.handly.snapshot.ISnapshotProvider; |
| import org.eclipse.handly.snapshot.NonExpiringSnapshot; |
| import org.eclipse.handly.util.Property; |
| import org.eclipse.handly.util.TextRange; |
| |
| /** |
| * Common superclass for source files. |
| * <p> |
| * This abstract implementation doesn't depend on a specific representation for |
| * the underlying file, like <code>IFile</code> or <code>IFileStore</code>. |
| * The binding has to be made in a subclass. |
| * </p> |
| * <p> |
| * If a notification manager is registered in the model context, this class |
| * will take advantage of it to send out working copy notifications. See |
| * {@link #hWorkingCopyModeChanged()} and {@link NotifyingReconcileOperation}. |
| * </p> |
| * |
| * @see WorkspaceSourceFile |
| */ |
| public abstract class SourceFile |
| extends SourceElement |
| implements ISourceFileImpl |
| { |
| /** |
| * Constructs a handle for a source file with the given parent element and |
| * the given name. |
| * |
| * @param parent the parent of the element, |
| * or <code>null</code> if the element has no parent |
| * @param name the name of the element, or <code>null</code> |
| * if the element has no name |
| */ |
| public SourceFile(Element parent, String name) |
| { |
| super(parent, name); |
| } |
| |
| @Override |
| public final IBuffer hBuffer(IContext context, IProgressMonitor monitor) |
| throws CoreException |
| { |
| if (monitor == null) |
| monitor = new NullProgressMonitor(); |
| monitor.beginTask("", 100); //$NON-NLS-1$ |
| try |
| { |
| WorkingCopyInfo info = hAcquireExistingWorkingCopy( |
| new SubProgressMonitor(monitor, 10)); |
| if (info == null) |
| { |
| return hFileBuffer(context, new SubProgressMonitor(monitor, |
| 90)); |
| } |
| else |
| { |
| try |
| { |
| IBuffer buffer = info.getBuffer(); |
| buffer.addRef(); |
| return buffer; |
| } |
| finally |
| { |
| hReleaseWorkingCopy(); |
| } |
| } |
| } |
| finally |
| { |
| monitor.done(); |
| } |
| } |
| |
| /** |
| * If this source file is not already in working copy mode, switches it |
| * into a working copy, associates it with a working copy buffer via a new |
| * working copy info, and acquires an independent ownership of the working |
| * copy (and, hence, of the working copy buffer). Performs atomically. |
| * <p> |
| * In working copy mode the source file's structure and properties |
| * shall no longer correspond to the underlying resource contents |
| * and must no longer be updated by a resource delta processor. |
| * Instead, the source file's structure and properties can be explicitly |
| * {@link #hReconcile(IContext, IProgressMonitor) reconciled} with the |
| * current contents of the working copy buffer. |
| * </p> |
| * <p> |
| * This method supports the following options, which may be specified |
| * in the given context: |
| * </p> |
| * <ul> |
| * <li> |
| * {@link #WORKING_COPY_BUFFER} - Specifies the working copy buffer. |
| * If not set, a default buffer is associated with the working copy. |
| * </li> |
| * <li> |
| * {@link #WORKING_COPY_INFO_FACTORY} - Specifies the working copy info factory. |
| * If not set, a default factory is used for obtaining a new working copy info. |
| * </li> |
| * </ul> |
| * <p> |
| * If the source file was already in working copy mode, this method acquires |
| * a new independent ownership of the working copy by incrementing an internal |
| * counter and returns the info associated with the working copy; the given |
| * context is ignored. The returned info is owned by the working copy and |
| * must not be explicitly disposed by the client. |
| * </p> |
| * <p> |
| * Each successful call to this method must ultimately be followed |
| * by exactly one call to <code>hReleaseWorkingCopy</code>. |
| * </p> |
| * |
| * @param context the operation context (not <code>null</code>) |
| * @param monitor a progress monitor, or <code>null</code> |
| * if progress reporting is not desired |
| * @return the working copy info previously associated with |
| * this source file, or <code>null</code> if there was no |
| * working copy info for this source file |
| * @throws CoreException if the working copy could not be created successfully |
| * @throws OperationCanceledException if this method is canceled |
| * @see #hReleaseWorkingCopy() |
| * @see #hAcquireExistingWorkingCopy(IProgressMonitor) |
| */ |
| public final WorkingCopyInfo hBecomeWorkingCopy(IContext context, |
| IProgressMonitor monitor) throws CoreException |
| { |
| if (context == null) |
| throw new IllegalArgumentException(); |
| IBuffer buffer = context.get(WORKING_COPY_BUFFER); |
| if (buffer == null) |
| { |
| try (IBuffer defaultBuffer = hFileBuffer(context, monitor)) |
| { |
| return hBecomeWorkingCopy(with(of(WORKING_COPY_BUFFER, |
| defaultBuffer), context), monitor); |
| } |
| } |
| WorkingCopyProvider provider = new WorkingCopyProvider() |
| { |
| @Override |
| protected WorkingCopyInfo doAcquireWorkingCopy() |
| { |
| return hElementManager().putWorkingCopyInfoIfAbsent( |
| SourceFile.this, buffer, context.get( |
| WORKING_COPY_INFO_FACTORY)); |
| } |
| |
| @Override |
| protected boolean isCanceled() |
| { |
| if (monitor == null) |
| return false; |
| return monitor.isCanceled(); |
| } |
| }; |
| WorkingCopyInfo oldInfo = provider.acquireWorkingCopy(); |
| if (oldInfo == null) |
| { |
| boolean success = false; |
| try |
| { |
| WorkingCopyInfo newInfo = |
| hElementManager().peekAtWorkingCopyInfo(this); |
| newInfo.initTask.execute(context, monitor); |
| success = true; |
| } |
| finally |
| { |
| if (!success) |
| hReleaseWorkingCopy(); |
| } |
| } |
| return oldInfo; |
| } |
| |
| /** |
| * Specifies the working copy buffer. |
| * @see #hBecomeWorkingCopy(IContext, IProgressMonitor) |
| */ |
| public static final Property<IBuffer> WORKING_COPY_BUFFER = Property.get( |
| SourceFile.class.getName() + ".workingCopyBuffer", IBuffer.class); //$NON-NLS-1$ |
| /** |
| * Specifies the working copy info factory. |
| * @see #hBecomeWorkingCopy(IContext, IProgressMonitor) |
| */ |
| public static final Property<WorkingCopyInfo.Factory> WORKING_COPY_INFO_FACTORY = |
| Property.get(SourceFile.class.getName() + ".workingCopyInfoFactory", //$NON-NLS-1$ |
| WorkingCopyInfo.Factory.class); |
| |
| /** |
| * If this source file is in working copy mode, acquires a new independent |
| * ownership of the working copy by incrementing an internal counter and |
| * returns the info associated with the working copy. The returned info is |
| * owned by the working copy and must not be explicitly disposed by the client. |
| * Returns <code>null</code> if this source file is not a working copy. |
| * Performs atomically. |
| * <p> |
| * Each successful call to this method that did not return <code>null</code> |
| * must ultimately be followed by exactly one call to <code>hReleaseWorkingCopy</code>. |
| * </p> |
| * |
| * @return the working copy info for this source file, |
| * or <code>null</code> if this source file is not a working copy |
| * @see #hReleaseWorkingCopy() |
| * @see #hBecomeWorkingCopy(IContext, IProgressMonitor) |
| */ |
| public final WorkingCopyInfo hAcquireExistingWorkingCopy( |
| IProgressMonitor monitor) |
| { |
| WorkingCopyProvider provider = new WorkingCopyProvider() |
| { |
| @Override |
| protected WorkingCopyInfo doAcquireWorkingCopy() |
| { |
| return hElementManager().getWorkingCopyInfo(SourceFile.this); |
| } |
| |
| @Override |
| protected boolean isCanceled() |
| { |
| if (monitor == null) |
| return false; |
| return monitor.isCanceled(); |
| } |
| }; |
| return provider.acquireWorkingCopy(); |
| } |
| |
| /** |
| * Relinquishes an independent ownership of the working copy by decrementing |
| * an internal counter. If there are no remaining owners of the working copy, |
| * switches this source file from working copy mode back to its original mode |
| * and releases the working copy buffer. Performs atomically. |
| * <p> |
| * Each independent ownership of the working copy must ultimately end |
| * with exactly one call to this method. Clients that do not own the |
| * working copy must not call this method. |
| * </p> |
| * |
| * @return <code>true</code> if this source file was switched from |
| * working copy mode back to its original mode, <code>false</code> |
| * otherwise |
| */ |
| public final boolean hReleaseWorkingCopy() |
| { |
| WorkingCopyInfo info = hElementManager().releaseWorkingCopyInfo(this); |
| if (info == null) |
| throw new IllegalStateException("Not a working copy: " + hToString( //$NON-NLS-1$ |
| of(FORMAT_STYLE, MEDIUM))); |
| if (info.isDisposed() && info.created) |
| { |
| hWorkingCopyModeChanged(); |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * If this source file is in working copy mode, returns the working copy info |
| * without acquiring an independent ownership of the working copy. The |
| * returned info is owned by the working copy and must not be explicitly |
| * disposed by the client. Returns <code>null</code> if this source file |
| * is not a working copy. |
| * <p> |
| * Note that if this method is invoked by a client that does not own the |
| * working copy, the returned info may get disposed from another thread. |
| * </p> |
| * |
| * @return the working copy info for this source file, |
| * or <code>null</code> if this source file is not a working copy |
| * @see #hAcquireExistingWorkingCopy(IProgressMonitor) |
| * @see #hBecomeWorkingCopy(IContext, IProgressMonitor) |
| */ |
| public final WorkingCopyInfo hWorkingCopyInfo() |
| { |
| WorkingCopyInfo info = hElementManager().peekAtWorkingCopyInfo(this); |
| if (info == null) |
| return null; |
| if (info.created) |
| return info; |
| // special case: wc creation is in progress on the current thread |
| if (this.equals(CURRENTLY_RECONCILED.get())) |
| return info; |
| return null; |
| } |
| |
| @Override |
| public final boolean hIsWorkingCopy() |
| { |
| return hWorkingCopyInfo() != null; |
| } |
| |
| @Override |
| public final boolean hNeedsReconciling() |
| { |
| WorkingCopyInfo info = hAcquireExistingWorkingCopy(null); |
| if (info == null) |
| return false; |
| else |
| { |
| try |
| { |
| return info.needsReconciling(); |
| } |
| finally |
| { |
| hReleaseWorkingCopy(); |
| } |
| } |
| } |
| |
| @Override |
| public final void hReconcile(IContext context, IProgressMonitor monitor) |
| throws CoreException |
| { |
| if (monitor == null) |
| monitor = new NullProgressMonitor(); |
| monitor.beginTask("", 100); //$NON-NLS-1$ |
| try |
| { |
| WorkingCopyInfo info = hAcquireExistingWorkingCopy( |
| new SubProgressMonitor(monitor, 10)); |
| if (info == null) |
| return; // not a working copy |
| else |
| { |
| try |
| { |
| info.reconcile(context, new SubProgressMonitor(monitor, |
| 90)); |
| } |
| finally |
| { |
| hReleaseWorkingCopy(); |
| } |
| } |
| } |
| finally |
| { |
| monitor.done(); |
| } |
| } |
| |
| /** |
| * Returns a reconcile operation for this source file. |
| * <p> |
| * This implementation returns a new instance of {@link |
| * NotifyingReconcileOperation} if there is a notification manager |
| * registered in the model context. Otherwise, a new instance of |
| * {@link ReconcileOperation} is returned. |
| * </p> |
| * <p> |
| * Clients are not intended to invoke this method, but may override it. |
| * </p> |
| * |
| * @return a reconcile operation for this source file (not <code>null</code>) |
| */ |
| protected ReconcileOperation hReconcileOperation() |
| { |
| if (hModel().getModelContext().get(INotificationManager.class) != null) |
| return new NotifyingReconcileOperation(); |
| |
| return new ReconcileOperation(); |
| } |
| |
| /** |
| * Returns a context to be associated with a new working copy of this |
| * source file. The given operation context is propagated from the |
| * {@link #hBecomeWorkingCopy} method. |
| * <p> |
| * This implementation returns an empty context. Subclasses may override. |
| * </p> |
| * |
| * @param context the operation context (never <code>null</code>) |
| * @return the working copy context (not <code>null</code>) |
| */ |
| protected IContext hWorkingCopyContext(IContext context) |
| { |
| return EMPTY_CONTEXT; |
| } |
| |
| /** |
| * Notifies about a working copy mode change: either the source file |
| * became a working copy or reverted back from the working copy mode. |
| * <p> |
| * This implementation does nothing if no notification manager is |
| * registered in the model context. Otherwise, it sends out a delta |
| * notification indicating the nature of the working copy mode change. |
| * </p> |
| * <p> |
| * Clients are not intended to invoke this method, but may override it. |
| * </p> |
| */ |
| protected void hWorkingCopyModeChanged() |
| { |
| INotificationManager notificationManager = |
| hModel().getModelContext().get(INotificationManager.class); |
| if (notificationManager == null) |
| return; |
| |
| ElementDelta.Factory deltaFactory = hModel().getModelContext().get( |
| ElementDelta.Factory.class); |
| if (deltaFactory == null) |
| deltaFactory = element -> new ElementDelta(element); |
| ElementDelta rootDelta = deltaFactory.newDelta(hRoot()); |
| ElementDelta.Builder builder = new ElementDelta.Builder(rootDelta); |
| if (hFileExists()) |
| builder.changed(this, F_WORKING_COPY); |
| else if (hIsWorkingCopy()) |
| builder.added(this, F_WORKING_COPY); |
| else |
| builder.removed(this, F_WORKING_COPY); |
| notificationManager.fireElementChangeEvent(new ElementChangeEvent( |
| ElementChangeEvent.POST_CHANGE, builder.getDelta())); |
| } |
| |
| @Override |
| protected void hValidateExistence(IContext context) throws CoreException |
| { |
| if (!hIsWorkingCopy()) |
| { |
| if (!hFileExists()) |
| throw hDoesNotExistException(); |
| } |
| } |
| |
| @Override |
| void hBuildStructure0(IContext context, IProgressMonitor monitor) |
| throws CoreException |
| { |
| if (!context.containsKey(SOURCE_CONTENTS) && !context.containsKey( |
| SOURCE_AST)) |
| { |
| if (hIsWorkingCopy()) |
| throw new AssertionError(); |
| // NOTE: source files that are not working copies must reflect |
| // the structure of the underlying file rather than the buffer |
| NonExpiringSnapshot snapshot; |
| try (ISnapshotProvider provider = hFileSnapshotProvider()) |
| { |
| try |
| { |
| snapshot = new NonExpiringSnapshot(provider); |
| } |
| catch (IllegalStateException e) |
| { |
| Throwable cause = e.getCause(); |
| if (cause instanceof CoreException) |
| throw (CoreException)cause; |
| throw new CoreException(Activator.createErrorStatus( |
| e.getMessage(), e)); |
| } |
| } |
| context = with(of(SOURCE_CONTENTS, snapshot.getContents()), of( |
| SOURCE_SNAPSHOT, snapshot.getWrappedSnapshot()), context); |
| } |
| |
| super.hBuildStructure0(context, monitor); |
| |
| Map<IElement, Object> newElements = context.get(NEW_ELEMENTS); |
| Object body = newElements.get(this); |
| if (body instanceof SourceElementBody) |
| { |
| SourceElementBody thisBody = (SourceElementBody)body; |
| |
| String source = context.get(SOURCE_CONTENTS); |
| if (source != null) |
| thisBody.setFullRange(new TextRange(0, source.length())); |
| |
| ISnapshot snapshot = context.get(SOURCE_SNAPSHOT); |
| if (snapshot != null) |
| setSnapshot(thisBody, snapshot, newElements); |
| } |
| } |
| |
| /** |
| * Returns whether the underlying file exists. |
| * |
| * @return <code>true</code> if the underlying file exists, |
| * and <code>false</code> otherwise |
| */ |
| protected abstract boolean hFileExists(); |
| |
| /** |
| * Returns a snapshot provider for the underlying file's stored contents. |
| * <p> |
| * The client takes (potentially shared) ownership of the returned provider |
| * and is responsible for releasing it. The provider will be disposed |
| * only after it is released by every owner. The provider must not |
| * be accessed by clients that don't own it. |
| * </p> |
| * |
| * @return a snapshot provider for the underlying file's stored contents |
| * (not <code>null</code>) |
| * @see ISnapshotProvider |
| */ |
| protected abstract ISnapshotProvider hFileSnapshotProvider(); |
| |
| /** |
| * Returns the buffer opened for the underlying file of this source file. |
| * Note that buffers may be shared by multiple clients, so the returned buffer |
| * may have unsaved changes if it has been modified by another client. |
| * <p> |
| * The client takes (potentially shared) ownership of the returned buffer |
| * and is responsible for releasing it. The buffer will be disposed |
| * only after it is released by every owner. The buffer must not |
| * be accessed by clients that don't own it. |
| * </p> |
| * <p> |
| * Implementations are encouraged to support the following standard options, |
| * which may be specified in the given context: |
| * </p> |
| * <ul> |
| * <li> |
| * {@link org.eclipse.handly.model.Elements#CREATE_BUFFER CREATE_BUFFER} - |
| * Indicates whether a new buffer should be created if none already exists. |
| * </li> |
| * </ul> |
| * |
| * @param context the operation context (never <code>null</code>) |
| * @param monitor a progress monitor, or <code>null</code> |
| * if progress reporting is not desired |
| * @return the buffer opened for the underlying file of this source file, |
| * or <code>null</code> if <code>CREATE_BUFFER == false</code> and |
| * there is currently no buffer opened for that file |
| * @throws CoreException if the buffer could not be opened successfully |
| * @throws OperationCanceledException if this method is canceled |
| * @see IBuffer |
| */ |
| protected abstract IBuffer hFileBuffer(IContext context, |
| IProgressMonitor monitor) throws CoreException; |
| |
| /** |
| * Creates and initializes bodies for this element and for each |
| * of its descendant elements according to options specified in the |
| * given context. Uses the {@link #NEW_ELEMENTS} map in the given context |
| * to associate the created bodies with their respective elements. |
| * <p> |
| * The following context options influence how the structure is built and, |
| * if simultaneously present, must be mutually consistent: |
| * </p> |
| * <ul> |
| * <li> |
| * {@link #SOURCE_AST} - Specifies the AST to use when building the structure. |
| * The AST is safe to read in the dynamic context of this method call, but |
| * must not be modified. |
| * </li> |
| * <li> |
| * {@link #SOURCE_CONTENTS} - Specifies the source string to use when |
| * building the structure. |
| * </li> |
| * </ul> |
| * <p> |
| * At least one of <code>SOURCE_AST</code> or <code>SOURCE_CONTENTS</code> |
| * will have a non-null value in the given context. |
| * </p> |
| * <p> |
| * The given context may provide additional data that this method can use, |
| * including the following: |
| * </p> |
| * <ul> |
| * <li> |
| * {@link #SOURCE_SNAPSHOT} - Specifies the source snapshot from which |
| * <code>SOURCE_AST</code> was created or <code>SOURCE_CONTENTS</code> |
| * was obtained. The snapshot may expire. |
| * </li> |
| * </ul> |
| * |
| * @param context the operation context (never <code>null</code>) |
| * @param monitor a progress monitor (never <code>null</code>) |
| * @throws CoreException if this method fails |
| * @throws OperationCanceledException if this method is canceled |
| */ |
| @Override |
| protected abstract void hBuildStructure(IContext context, |
| IProgressMonitor monitor) throws CoreException; |
| |
| /** |
| * Specifies the source AST. |
| * @see #hBuildStructure(IContext, IProgressMonitor) |
| */ |
| protected static final Property<Object> SOURCE_AST = Property.get( |
| SourceFile.class.getName() + ".sourceAst", Object.class); //$NON-NLS-1$ |
| /** |
| * Specifies the source string. |
| * @see #hBuildStructure(IContext, IProgressMonitor) |
| */ |
| protected static final Property<String> SOURCE_CONTENTS = Property.get( |
| SourceFile.class.getName() + ".sourceContents", String.class); //$NON-NLS-1$ |
| /** |
| * Specifies the source snapshot. |
| * @see #hBuildStructure(IContext, IProgressMonitor) |
| */ |
| protected static final Property<ISnapshot> SOURCE_SNAPSHOT = Property.get( |
| SourceFile.class.getName() + ".sourceSnapshot", ISnapshot.class); //$NON-NLS-1$ |
| |
| @Override |
| protected void hGenerateAncestorBodies(IContext context, |
| IProgressMonitor monitor) throws CoreException |
| { |
| if (hIsWorkingCopy()) |
| return; // don't open ancestors for a working copy |
| super.hGenerateAncestorBodies(context, monitor); |
| } |
| |
| @Override |
| protected boolean hClose(boolean external) |
| { |
| if (hIsWorkingCopy()) |
| return false; // a working copy cannot be removed |
| return super.hClose(external); |
| } |
| |
| @Override |
| protected void hToStringName(StringBuilder builder, IContext context) |
| { |
| if (hIsWorkingCopy()) |
| builder.append("[Working copy] "); //$NON-NLS-1$ |
| super.hToStringName(builder, context); |
| } |
| |
| private static void setSnapshot(SourceElementBody body, ISnapshot snapshot, |
| Map<IElement, Object> newElements) |
| { |
| body.setSnapshot(snapshot); |
| for (IElement child : body.getChildren()) |
| { |
| Object childBody = newElements.get(child); |
| if (childBody instanceof SourceElementBody) |
| { |
| setSnapshot((SourceElementBody)childBody, snapshot, |
| newElements); |
| } |
| } |
| } |
| |
| /** |
| * Indicates whether the structure should be rebuilt when reconciling |
| * is forced. Default value: <code>false</code>. |
| * @see ReconcileOperation#reconcile(IContext, IProgressMonitor) |
| */ |
| protected static final Property<Boolean> REBUILD_STRUCTURE_IF_FORCED = |
| Property.get(SourceFile.class.getName() + ".rebuildStructureIfForced", //$NON-NLS-1$ |
| Boolean.class).withDefault(false); |
| /** |
| * Indicates whether reconciling was forced, i.e. the working copy buffer |
| * has not been modified since the last time it was reconciled. |
| * Default value: <code>false</code>. |
| * @see ReconcileOperation#reconcile(IContext, IProgressMonitor) |
| */ |
| static final Property<Boolean> RECONCILING_FORCED = Property.get( |
| SourceFile.class.getName() + ".reconcilingForced", //$NON-NLS-1$ |
| Boolean.class).withDefault(false); |
| |
| private static final ThreadLocal<SourceFile> CURRENTLY_RECONCILED = |
| new ThreadLocal<SourceFile>(); // the source file being reconciled |
| |
| /** |
| * A reconcile operation for this source file. |
| * <p> |
| * Clients are not intended to use instances of this class or a subclass |
| * of this class, but may extend it to augment the default behavior, e.g. |
| * to send out a delta notification indicating the nature of the change |
| * of the working copy since the last time it was reconciled. Clients that |
| * extend this class or a subclass of this class should consider |
| * overriding {@link SourceFile#hReconcileOperation()} method. |
| * </p> |
| * |
| * @see NotifyingReconcileOperation |
| */ |
| protected class ReconcileOperation |
| { |
| /** |
| * Reconciles this working copy according to options specified |
| * in the given context. |
| * <p> |
| * The following context options can influence whether the structure |
| * of the working copy gets rebuilt: |
| * </p> |
| * <ul> |
| * <li> |
| * {@link #REBUILD_STRUCTURE_IF_FORCED} - Indicates whether the structure |
| * should be rebuilt even if reconciling was forced, i.e. the working copy |
| * buffer has not been modified since the last time it was reconciled. |
| * </li> |
| * </ul> |
| * <p> |
| * The following context options influence rebuilding of the structure |
| * of the working copy and, if simultaneously present, must be mutually |
| * consistent: |
| * </p> |
| * <ul> |
| * <li> |
| * {@link #SOURCE_AST} - Specifies the AST to use when building the |
| * structure. The AST is safe to read in the dynamic context of this |
| * method call, but must not be modified. |
| * </li> |
| * <li> |
| * {@link #SOURCE_CONTENTS} - Specifies the source string to use when |
| * building the structure. |
| * </li> |
| * </ul> |
| * <p> |
| * At least one of <code>SOURCE_AST</code> or <code>SOURCE_CONTENTS</code> |
| * must have a non-null value in the given context. |
| * </p> |
| * <p> |
| * The given context may provide additional data that this method can use, |
| * including the following: |
| * </p> |
| * <ul> |
| * <li> |
| * {@link #SOURCE_SNAPSHOT} - Specifies the source snapshot from which |
| * <code>SOURCE_AST</code> was created or <code>SOURCE_CONTENTS</code> |
| * was obtained. The snapshot may expire. |
| * </li> |
| * </ul> |
| * <p> |
| * Subclasses may override this method, but must call the <b>super</b> |
| * implementation. |
| * </p> |
| * |
| * @param context the operation context (not <code>null</code>) |
| * @param monitor a progress monitor, or <code>null</code> |
| * if progress reporting is not desired |
| * @throws CoreException if the working copy cannot be reconciled |
| * @throws OperationCanceledException if this method is canceled |
| */ |
| protected void reconcile(IContext context, IProgressMonitor monitor) |
| throws CoreException |
| { |
| if (context.get(SOURCE_AST) == null && context.get( |
| SOURCE_CONTENTS) == null) |
| { |
| throw new IllegalArgumentException(); |
| } |
| WorkingCopyInfo info = hElementManager().peekAtWorkingCopyInfo( |
| SourceFile.this); |
| boolean create = !info.created; // case of wc creation |
| if (create || !context.getOrDefault(RECONCILING_FORCED) |
| || context.getOrDefault(REBUILD_STRUCTURE_IF_FORCED)) |
| { |
| if (CURRENTLY_RECONCILED.get() != null) |
| throw new AssertionError(); // should never happen |
| CURRENTLY_RECONCILED.set(SourceFile.this); |
| try |
| { |
| hOpen(with(of(FORCE_OPEN, true), context), monitor); |
| } |
| finally |
| { |
| CURRENTLY_RECONCILED.set(null); |
| } |
| } |
| if (create) |
| { |
| if (!info.created) |
| throw new AssertionError(); // should never happen |
| hWorkingCopyModeChanged(); // notify about wc creation |
| } |
| } |
| } |
| |
| /** |
| * Reconciles this working copy and sends out a delta notification |
| * indicating the nature of the change of the working copy since |
| * the last time it was reconciled. Uses the notification manager |
| * registered in the model context. |
| * |
| * @see INotificationManager |
| */ |
| protected class NotifyingReconcileOperation |
| extends ReconcileOperation |
| { |
| @Override |
| protected void reconcile(IContext context, IProgressMonitor monitor) |
| throws CoreException |
| { |
| ElementDelta.Factory deltaFactory = hModel().getModelContext().get( |
| ElementDelta.Factory.class); |
| if (deltaFactory == null) |
| deltaFactory = element -> new ElementDelta(element); |
| ElementDelta rootDelta = deltaFactory.newDelta(SourceFile.this); |
| ElementDifferencer differ = new ElementDifferencer( |
| new ElementDelta.Builder(rootDelta)); |
| |
| doReconcile(context, monitor); |
| |
| differ.buildDelta(); |
| if (!differ.isEmptyDelta()) |
| { |
| hModel().getModelContext().get( |
| INotificationManager.class).fireElementChangeEvent( |
| new ElementChangeEvent( |
| ElementChangeEvent.POST_RECONCILE, |
| differ.getDelta())); |
| } |
| } |
| |
| /** |
| * This implementation calls {@link ReconcileOperation#reconcile( |
| * IContext, IProgressMonitor) super.reconcile(..)}. |
| * <p> |
| * Subclasses may override this method, but must call its <b>super</b> |
| * implementation. |
| * </p> |
| * |
| * @param context the operation context (not <code>null</code>) |
| * @param monitor a progress monitor, or <code>null</code> |
| * if progress reporting is not desired |
| * @throws CoreException if the working copy cannot be reconciled |
| * @throws OperationCanceledException if this method is canceled |
| */ |
| protected void doReconcile(IContext context, IProgressMonitor monitor) |
| throws CoreException |
| { |
| super.reconcile(context, monitor); |
| } |
| } |
| |
| private abstract class WorkingCopyProvider |
| { |
| public WorkingCopyInfo acquireWorkingCopy() |
| { |
| for (;;) |
| { |
| if (isCanceled()) |
| throw new OperationCanceledException(); |
| WorkingCopyInfo info = doAcquireWorkingCopy(); |
| if (info == null) |
| return null; |
| boolean success = false; |
| try |
| { |
| success = waitForInit(info); |
| } |
| finally |
| { |
| if (!success) |
| hReleaseWorkingCopy(); |
| } |
| if (success) |
| return info; |
| } |
| } |
| |
| protected abstract WorkingCopyInfo doAcquireWorkingCopy(); |
| |
| protected boolean isCanceled() |
| { |
| return false; |
| } |
| |
| private boolean waitForInit(WorkingCopyInfo info) |
| { |
| for (int i = 0; i < 10; i++) |
| { |
| if (isCanceled()) |
| throw new OperationCanceledException(); |
| try |
| { |
| return info.initTask.wasSuccessful(10, |
| TimeUnit.MILLISECONDS); |
| } |
| catch (InterruptedException e) |
| { |
| } |
| catch (TimeoutException e) |
| { |
| } |
| } |
| return false; |
| } |
| } |
| } |
