private static Change createPackageFragmentRootDeleteChange(IPackageFragmentRoot root)
throws JavaModelException {
IResource resource = root.getResource();
if (resource != null && resource.isLinked()) {
// XXX using this code is a workaround for jcore bug 31998
// jcore cannot handle linked stuff
// normally, we should always create DeletePackageFragmentRootChange
CompositeChange composite =
new DynamicValidationStateChange(
RefactoringCoreMessages.DeleteRefactoring_delete_package_fragment_root);
ClasspathChange change =
ClasspathChange.removeEntryChange(root.getJavaProject(), root.getRawClasspathEntry());
if (change != null) {
composite.add(change);
}
Assert.isTrue(!Checks.isClasspathDelete(root)); // checked in preconditions
composite.add(createDeleteChange(resource));
return composite;
} else {
Assert.isTrue(!root.isExternal());
// TODO remove the query argument
return new DeletePackageFragmentRootChange(root, true, null);
}
}
public void setTask(Task task) {
Assert.isTrue(task != null);
InputOutputSpecification iospec = task.getIoSpecification();
Assert.isTrue(iospec != null && iospec.getInputSets().size() > 0);
this.task = task;
}
/**
* This method is not meant for public use. Only for testing. use {@link
* #removePluginDependency(IProject, IProject)} instead. If doMangle is true, then add an extra
* space in the text to remove so that previously mangled plugin entries can be removed
*/
public static IStatus removePluginDependency(
IProject dependent, IProject plugin, boolean doMangle) throws CoreException {
Assert.isTrue(
GrailsNature.isGrailsProject(dependent), dependent.getName() + " is not a grails project");
Assert.isTrue(
GrailsNature.isGrailsPluginProject(plugin),
plugin.getName() + " is not a grails plugin project");
IFile buildConfigFile = dependent.getFile(BUILD_CONFIG_LOCATION);
String textToRemove = createDependencyText(dependent, plugin, doMangle);
if (dependencyExists(buildConfigFile, textToRemove)) {
char[] contents = ((CompilationUnit) JavaCore.create(buildConfigFile)).getContents();
String newText = String.valueOf(contents).replace(textToRemove, "");
InputStream stream = createInputStream(dependent, newText);
buildConfigFile.setContents(stream, true, true, null);
return Status.OK_STATUS;
} else {
return new Status(
IStatus.WARNING,
GrailsCoreActivator.PLUGIN_ID,
"Could not remove a dependency from "
+ dependent.getName()
+ " to in place plugin "
+ plugin.getName()
+ ". Try manually editing the BuildConfig.groovy file.");
}
}
public String suggestNewVariableName(
String[] prefixes,
String[] suffixes,
String oldVariableName,
String oldTypeName,
String newTypeName) {
Assert.isNotNull(prefixes);
Assert.isNotNull(suffixes);
Assert.isNotNull(oldVariableName);
Assert.isNotNull(oldTypeName);
Assert.isNotNull(newTypeName);
Assert.isTrue(oldVariableName.length() > 0);
Assert.isTrue(oldTypeName.length() > 0);
Assert.isTrue(newTypeName.length() > 0);
final String usedPrefix = findLongestPrefix(oldVariableName, prefixes);
final String usedSuffix = findLongestSuffix(oldVariableName, suffixes);
final String strippedVariableName =
oldVariableName.substring(
usedPrefix.length(), oldVariableName.length() - usedSuffix.length());
String newVariableName = match(oldTypeName, newTypeName, strippedVariableName);
return (newVariableName != null) ? usedPrefix + newVariableName + usedSuffix : null;
}
/**
* Checks whether the content of <code>document</code> in the range (<code>offset</code>, <code>
* length</code>) contains the <code>new</code> keyword.
*
* @param document the document being modified
* @param offset the first character position in <code>document</code> to be considered
* @param length the length of the character range to be considered
* @param partitioning the document partitioning
* @return <code>true</code> if the specified character range contains a <code>new</code> keyword,
* <code>false</code> otherwise.
*/
private static boolean isNewMatch(
IDocument document, int offset, int length, String partitioning) {
Assert.isTrue(length >= 0);
Assert.isTrue(offset >= 0);
Assert.isTrue(offset + length < document.getLength() + 1);
try {
String text = document.get(offset, length);
int pos = text.indexOf("new"); // $NON-NLS-1$
while (pos != -1 && !isDefaultPartition(document, pos + offset, partitioning))
pos = text.indexOf("new", pos + 2); // $NON-NLS-1$
if (pos < 0) return false;
if (pos != 0 && Character.isJavaIdentifierPart(text.charAt(pos - 1))) return false;
if (pos + 3 < length && Character.isJavaIdentifierPart(text.charAt(pos + 3))) return false;
return true;
} catch (BadLocationException e) {
}
return false;
}
/**
* This method is not meant for public use. Only for testing. use {@link
* #addPluginDependency(IProject, IProject)} instead. If doMangle is true, then add an extra space
* in the added text so that it cannot be removed.
*/
public static IStatus addPluginDependency(IProject dependent, IProject plugin, boolean doMangle)
throws CoreException {
Assert.isTrue(
GrailsNature.isGrailsProject(dependent), dependent.getName() + " is not a grails project");
Assert.isTrue(
GrailsNature.isGrailsPluginProject(plugin),
plugin.getName() + " is not a grails plugin project");
IFile buildConfigFile = dependent.getFile(BUILD_CONFIG_LOCATION);
// next create the text to add to BuildConfig.groovy
String textToAdd = createDependencyText(dependent, plugin, doMangle);
if (!dependencyExists(buildConfigFile, textToAdd)) {
InputStream stream = createInputStream(dependent, textToAdd);
buildConfigFile.appendContents(stream, true, true, null);
return Status.OK_STATUS;
} else {
return new Status(
IStatus.WARNING,
GrailsCoreActivator.PLUGIN_ID,
"Could not add a dependency from "
+ dependent.getName()
+ " to in place plugin "
+ plugin.getName()
+ ". Try manually editing the BuildConfig.groovy file.");
}
}
private RefactoringStatus checkAccessorDeclarations(IProgressMonitor pm, IMethod existingAccessor)
throws CoreException {
RefactoringStatus result = new RefactoringStatus();
SearchPattern pattern =
SearchPattern.createPattern(
existingAccessor,
IJavaSearchConstants.DECLARATIONS,
SearchUtils.GENERICS_AGNOSTIC_MATCH_RULE);
IJavaSearchScope scope = SearchEngine.createHierarchyScope(fField.getDeclaringType());
SearchResultGroup[] groupDeclarations =
RefactoringSearchEngine.search(pattern, scope, pm, result);
Assert.isTrue(groupDeclarations.length > 0);
if (groupDeclarations.length != 1) {
String message =
Messages.format(
RefactoringCoreMessages.RenameFieldRefactoring_overridden,
JavaElementUtil.createMethodSignature(existingAccessor));
result.addError(message);
} else {
SearchResultGroup group = groupDeclarations[0];
Assert.isTrue(group.getSearchResults().length > 0);
if (group.getSearchResults().length != 1) {
String message =
Messages.format(
RefactoringCoreMessages.RenameFieldRefactoring_overridden_or_overrides,
JavaElementUtil.createMethodSignature(existingAccessor));
result.addError(message);
}
}
return result;
}
private void testInvariants(int node) {
if (node == -1) {
return;
}
// Get the current tree size (we will later force the tree size
// to be recomputed from scratch -- if everything works properly, then
// there should be no change.
int treeSize = getSubtreeSize(node);
int left = leftSubTree[node];
int right = rightSubTree[node];
int unsorted = nextUnsorted[node];
if (isUnsorted(node)) {
Assert.isTrue(left == -1, "unsorted nodes shouldn't have a left subtree"); // $NON-NLS-1$
Assert.isTrue(right == -1, "unsorted nodes shouldn't have a right subtree"); // $NON-NLS-1$
}
if (left != -1) {
testInvariants(left);
Assert.isTrue(
parentTree[left] == node, "left node has invalid parent pointer"); // $NON-NLS-1$
}
if (right != -1) {
testInvariants(right);
Assert.isTrue(
parentTree[right] == node, "right node has invalid parent pointer"); // $NON-NLS-1$
}
int previous = node;
while (unsorted != -1) {
int oldTreeSize = this.treeSize[unsorted];
recomputeTreeSize(unsorted);
Assert.isTrue(
this.treeSize[unsorted] == oldTreeSize,
"Invalid node size for unsorted node"); //$NON-NLS-1$
Assert.isTrue(
leftSubTree[unsorted] == -1,
"unsorted nodes shouldn't have left subtrees"); //$NON-NLS-1$
Assert.isTrue(
rightSubTree[unsorted] == -1,
"unsorted nodes shouldn't have right subtrees"); //$NON-NLS-1$
Assert.isTrue(
parentTree[unsorted] == previous,
"unsorted node has invalid parent pointer"); //$NON-NLS-1$
Assert.isTrue(
contents[unsorted] != lazyRemovalFlag,
"unsorted nodes should not be lazily removed"); //$NON-NLS-1$
previous = unsorted;
unsorted = nextUnsorted[unsorted];
}
// Note that we've already tested that the child sizes are correct... if our size is
// correct, then recomputing it now should not cause any change.
recomputeTreeSize(node);
Assert.isTrue(treeSize == getSubtreeSize(node), "invalid tree size"); // $NON-NLS-1$
}
/** Constructor. */
public EEnumComboBoxDataProvider(Object axisElement) {
Object object = AxisUtils.getRepresentedElement(axisElement);
Assert.isTrue(object instanceof EStructuralFeature);
EStructuralFeature feature = (EStructuralFeature) object;
EClassifier type = feature.getEType();
Assert.isTrue(type instanceof EEnum);
this.eenum = (EEnum) type;
}
@Override
public void setInput(IWorkbenchPart part, ISelection selection) {
super.setInput(part, selection);
Assert.isTrue(selection instanceof IStructuredSelection);
Object input = ((IStructuredSelection) selection).getFirstElement();
Assert.isTrue(input instanceof UserGroup);
this.userGroup = (UserGroup) input;
}
/**
* Creates a new extract constant refactoring
*
* @param unit the compilation unit, or <code>null</code> if invoked by scripting
* @param selectionStart
* @param selectionLength
*/
public ExtractConstantRefactoring(IJavaScriptUnit unit, int selectionStart, int selectionLength) {
Assert.isTrue(selectionStart >= 0);
Assert.isTrue(selectionLength >= 0);
fSelectionStart = selectionStart;
fSelectionLength = selectionLength;
fCu = unit;
fCuRewrite = null;
fLinkedProposalModel = null;
fConstantName = ""; // $NON-NLS-1$
}
/**
* Creates a new extract constant refactoring
*
* @param unit the compilation unit, or <code>null</code> if invoked by scripting
* @param selectionStart start
* @param selectionLength length
*/
public ExtractConstantRefactoring(
ICompilationUnit unit, int selectionStart, int selectionLength) {
Assert.isTrue(selectionStart >= 0);
Assert.isTrue(selectionLength >= 0);
fSelectionStart = selectionStart;
fSelectionLength = selectionLength;
fCu = unit;
fCuRewrite = null;
fLinkedProposalModel = null;
fConstantName = ""; // $NON-NLS-1$
fCheckResultForCompileProblems = true;
}
public ExtractConstantRefactoring(
JavaScriptUnit astRoot, int selectionStart, int selectionLength) {
Assert.isTrue(selectionStart >= 0);
Assert.isTrue(selectionLength >= 0);
Assert.isTrue(astRoot.getTypeRoot() instanceof IJavaScriptUnit);
fSelectionStart = selectionStart;
fSelectionLength = selectionLength;
fCu = (IJavaScriptUnit) astRoot.getTypeRoot();
fCuRewrite = new CompilationUnitRewrite(fCu, astRoot);
fLinkedProposalModel = null;
fConstantName = ""; // $NON-NLS-1$
}
/**
* Checks whether <code>position</code> resides in a default (Java) partition of <code>document
* </code>.
*
* @param document the document being modified
* @param position the position to be checked
* @param partitioning the document partitioning
* @return <code>true</code> if <code>position</code> is in the default partition of <code>
* document</code>, <code>false</code> otherwise
*/
private static boolean isDefaultPartition(IDocument document, int position, String partitioning) {
Assert.isTrue(position >= 0);
Assert.isTrue(position <= document.getLength());
try {
ITypedRegion region = TextUtilities.getPartition(document, partitioning, position, false);
return region.getType().equals(IDocument.DEFAULT_CONTENT_TYPE);
} catch (BadLocationException e) {
}
return false;
}
@Override
public void setInput(IWorkbenchPart part, ISelection selection) {
super.setInput(part, selection);
if (test != null) {
test.getAllLanguages().removePropertyChangeListener(this);
}
Assert.isTrue(selection instanceof IStructuredSelection);
Object input = ((IStructuredSelection) selection).getFirstElement();
Assert.isTrue(input instanceof TestEditPart);
test = (Test) ((TestEditPart) input).getModel();
AllLanguages langs = test.getAllLanguages();
langs.addPropertyChangeListener(this);
}
public String suggestNewMethodName(String oldMethodName, String oldTypeName, String newTypeName) {
Assert.isNotNull(oldMethodName);
Assert.isNotNull(oldTypeName);
Assert.isNotNull(newTypeName);
Assert.isTrue(oldMethodName.length() > 0);
Assert.isTrue(oldTypeName.length() > 0);
Assert.isTrue(newTypeName.length() > 0);
resetPrefixes();
return match(oldTypeName, newTypeName, oldMethodName);
}
private static boolean hasReadOnlyResourcesAndSubResources(IJavaScriptElement javaElement)
throws CoreException {
switch (javaElement.getElementType()) {
case IJavaScriptElement.CLASS_FILE:
// if this assert fails, it means that a precondition is missing
Assert.isTrue(((IClassFile) javaElement).getResource() instanceof IFile);
// fall thru
case IJavaScriptElement.JAVASCRIPT_UNIT:
IResource resource = ReorgUtils.getResource(javaElement);
return (resource != null && Resources.isReadOnly(resource));
case IJavaScriptElement.PACKAGE_FRAGMENT:
IResource packResource = ReorgUtils.getResource(javaElement);
if (packResource == null) return false;
IPackageFragment pack = (IPackageFragment) javaElement;
if (Resources.isReadOnly(packResource)) return true;
Object[] nonJava = pack.getNonJavaScriptResources();
for (int i = 0; i < nonJava.length; i++) {
Object object = nonJava[i];
if (object instanceof IResource
&& hasReadOnlyResourcesAndSubResources((IResource) object)) return true;
}
return hasReadOnlyResourcesAndSubResources(pack.getChildren());
case IJavaScriptElement.PACKAGE_FRAGMENT_ROOT:
IPackageFragmentRoot root = (IPackageFragmentRoot) javaElement;
if (root.isArchive()) return false;
IResource pfrResource = ReorgUtils.getResource(javaElement);
if (pfrResource == null) return false;
if (Resources.isReadOnly(pfrResource)) return true;
Object[] nonJava1 = root.getNonJavaScriptResources();
for (int i = 0; i < nonJava1.length; i++) {
Object object = nonJava1[i];
if (object instanceof IResource
&& hasReadOnlyResourcesAndSubResources((IResource) object)) return true;
}
return hasReadOnlyResourcesAndSubResources(root.getChildren());
case IJavaScriptElement.FIELD:
case IJavaScriptElement.IMPORT_CONTAINER:
case IJavaScriptElement.IMPORT_DECLARATION:
case IJavaScriptElement.INITIALIZER:
case IJavaScriptElement.METHOD:
case IJavaScriptElement.TYPE:
return false;
default:
Assert.isTrue(false); // not handled here
return false;
}
}
/**
* Creates a group with border (label in border). Accepted button styles are: SWT.RADIO,
* SWT.CHECK, SWT.TOGGLE For border styles see <code>Group</code>
*/
public SelectionButtonDialogFieldGroup(
final int buttonsStyle,
final String[] buttonNames,
final int nColumns,
final int borderStyle) {
super();
Assert.isTrue(
buttonsStyle == SWT.RADIO || buttonsStyle == SWT.CHECK || buttonsStyle == SWT.TOGGLE);
fButtonNames = buttonNames;
final int nButtons = buttonNames.length;
fButtonsSelected = new boolean[nButtons];
fButtonsEnabled = new boolean[nButtons];
for (int i = 0; i < nButtons; i++) {
fButtonsSelected[i] = false;
fButtonsEnabled[i] = true;
}
if (buttonsStyle == SWT.RADIO) {
fButtonsSelected[0] = true;
}
fGroupBorderStyle = borderStyle;
fGroupNumberOfColumns = nColumns <= 0 ? nButtons : nColumns;
fButtonsStyle = buttonsStyle;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets
* .Composite)
*/
public void createPartControl(Composite parent) {
Assert.isTrue(fViewer == null);
fTypeComparator = new ScriptElementTypeComparator();
// Setup viewer
fViewer = createViewer(parent);
initDragAndDrop();
fLabelProvider = createLabelProvider();
fViewer.setLabelProvider(createDecoratingLabelProvider(fLabelProvider));
fViewer.setComparator(createModelElementComparator());
fViewer.setUseHashlookup(true);
fTitleProvider = createTitleProvider();
createContextMenu();
getSite().setSelectionProvider(fViewer);
if (fMemento != null) { // initialize linking state before creating the
// actions
restoreLinkingEnabled(fMemento);
}
createActions(); // call before registering for selection changes
addKeyListener();
if (fMemento != null) restoreState(fMemento);
getSite().setSelectionProvider(fViewer);
// Status line
IStatusLineManager slManager = getViewSite().getActionBars().getStatusLineManager();
fViewer.addSelectionChangedListener(createStatusBarUpdater(slManager));
hookViewerListeners();
// Filters
addFilters();
// Initialize viewer input
fViewer.setContentProvider(createContentProvider());
setInitialInput();
// Initialize selection
setInitialSelection();
fMemento = null;
// Listen to page changes
getViewSite().getPage().addPostSelectionListener(this);
getViewSite().getPage().addPartListener(fPartListener);
fillActionBars(getViewSite().getActionBars());
IContextService ctxService = (IContextService) getSite().getService(IContextService.class);
if (ctxService != null) {
fContextActivation = ctxService.activateContext(DLTKUIPlugin.CONTEXT_VIEWS);
}
setHelp();
}
/* (non-Javadoc)
* @see org.eclipse.tm.tcf.protocol.Protocol.ChannelOpenListener#onChannelOpen(org.eclipse.tm.tcf.protocol.IChannel)
*/
@Override
public void onChannelOpen(IChannel channel) {
Assert.isNotNull(channel);
Assert.isTrue(Protocol.isDispatchThread());
// Trace the channel opening
LogUtils.logMessageForChannel(
channel,
Messages.InternalChannelOpenListener_onChannelOpen_message,
"debug/channels",
this); //$NON-NLS-1$
// As the channel has just opened, there should be no channel listener, but better be safe and
// check.
IChannel.IChannelListener channelListener = channelListeners.remove(channel);
if (channelListener != null) channel.removeChannelListener(channelListener);
// Create a new channel listener instance
channelListener = new InternalChannelListener(channel);
// Add the channel listener to the global map
setChannelListener(channel, channelListener);
// Attach channel listener to the channel
channel.addChannelListener(channelListener);
// Fire the property change event for the channel
Tcf.fireChannelStateChangeListeners(channel, IChannel.STATE_OPEN);
}
/**
* Adds the given change to the list of children. The change to be added can be <code>null</code>.
* Adding a "null" change does nothing.
*
* @param change the change to add
*/
public void add(Change change) {
if (change != null) {
Assert.isTrue(change.getParent() == null);
fChanges.add(change);
change.setParent(this);
}
}
/**
* Adapts the behavior of the contained components to the change encoded in the given event.
*
* <p>Clients are not allowed to call this method if the old setup with text tools is in use.
*
* @param event the event to which to adapt
* @see DartSourceViewerConfiguration#JavaSourceViewerConfiguration(IColorManager,
* IPreferenceStore, ITextEditor, String)
*/
public void handlePropertyChangeEvent(PropertyChangeEvent event) {
Assert.isTrue(isNewSetup());
if (fCodeScanner.affectsBehavior(event)) {
fCodeScanner.adaptToPreferenceChange(event);
}
if (fMultilineCommentScanner.affectsBehavior(event)) {
fMultilineCommentScanner.adaptToPreferenceChange(event);
}
if (fSinglelineCommentScanner.affectsBehavior(event)) {
fSinglelineCommentScanner.adaptToPreferenceChange(event);
}
if (fStringScanner.affectsBehavior(event)) {
fStringScanner.adaptToPreferenceChange(event);
}
if (fMultilineStringScanner.affectsBehavior(event)) {
fMultilineStringScanner.adaptToPreferenceChange(event);
}
if (fJavaDocScanner.affectsBehavior(event)) {
fJavaDocScanner.adaptToPreferenceChange(event);
}
if (fJavaDoubleClickSelector != null
&& JavaScriptCore.COMPILER_SOURCE.equals(event.getProperty())) {
if (event.getNewValue() instanceof String) {
fJavaDoubleClickSelector.setSourceVersion((String) event.getNewValue());
}
}
}
/**
* Returns this field editor's text control.
*
* <p>The control is created if it does not yet exist
*
* @param parent the parent
* @return the text control
*/
public Text getTextControl(Composite parent) {
if (textField == null) {
textField = new Text(parent, SWT.SINGLE | SWT.BORDER);
textField.setEchoChar('*');
textField.setFont(parent.getFont());
switch (validateStrategy) {
case VALIDATE_ON_KEY_STROKE:
textField.addKeyListener(
new KeyAdapter() {
/** {@inheritDoc} */
@Override
public void keyReleased(KeyEvent e) {
valueChanged();
}
});
break;
case VALIDATE_ON_FOCUS_LOST:
textField.addKeyListener(
new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
clearErrorMessage();
}
});
textField.addFocusListener(
new FocusAdapter() {
@Override
public void focusGained(FocusEvent e) {
refreshValidState();
}
@Override
public void focusLost(FocusEvent e) {
valueChanged();
clearErrorMessage();
}
});
break;
default:
Assert.isTrue(false, "Unknown validate strategy"); // $NON-NLS-1$
}
textField.addDisposeListener(
new DisposeListener() {
@Override
public void widgetDisposed(DisposeEvent event) {
textField = null;
}
});
if (textLimit > 0) { // Only set limits above 0 - see SWT spec
textField.setTextLimit(textLimit);
}
} else {
checkParent(textField, parent);
}
return textField;
}
/**
* The limit is the maximum number of directories managed by this store. This number must be power
* of 2 and do not exceed 256. The location should be an existing valid directory.
*/
public BlobStore(IFileStore store, int limit) {
Assert.isNotNull(store);
localStore = store;
Assert.isTrue(localStore.fetchInfo().isDirectory());
Assert.isTrue(
limit == 256
|| limit == 128
|| limit == 64
|| limit == 32
|| limit == 16
|| limit == 8
|| limit == 4
|| limit == 2
|| limit == 1);
mask = (byte) (limit - 1);
}
/**
* Method to be called if the initialization of the collector is finished. The creator of the
* collector must call this method in order to "activate" the collector finally.
*/
public final synchronized void initDone() {
Assert.isTrue(initDone == false);
if (callback != null) {
removeCallback(callback);
}
initDone = true;
}
public ArrayType createArrayType(TType elementType, int dimensions) {
Assert.isTrue(!elementType.isArrayType());
Assert.isTrue(!elementType.isAnonymous());
Assert.isTrue(dimensions > 0);
int index = dimensions - 1;
Map arrayTypes = getArrayTypesMap(index);
ArrayType result = (ArrayType) arrayTypes.get(elementType);
if (result != null) return result;
result =
new ArrayType(
this, BindingKey.createArrayTypeBindingKey(elementType.getBindingKey(), dimensions));
arrayTypes.put(elementType, result);
result.initialize(elementType, dimensions);
return result;
}
/** Restores the object state from the memento. */
public IStatus restoreState() {
Assert.isTrue(!isRestored());
IStatus result = Status.OK_STATUS;
IMemento memento = this.memento;
this.memento = null;
String factoryId = memento.getString(IWorkbenchConstants.TAG_FACTORY_ID);
if (factoryId == null) {
WorkbenchPlugin.log("Unable to restore mru list - no input factory ID."); // $NON-NLS-1$
return result;
}
IElementFactory factory = PlatformUI.getWorkbench().getElementFactory(factoryId);
if (factory == null) {
return result;
}
IMemento persistableMemento = memento.getChild(IWorkbenchConstants.TAG_PERSISTABLE);
if (persistableMemento == null) {
WorkbenchPlugin.log(
"Unable to restore mru list - no input element state: " + factoryId); // $NON-NLS-1$
return result;
}
IAdaptable adaptable = factory.createElement(persistableMemento);
if (adaptable == null || (adaptable instanceof IEditorInput) == false) {
return result;
}
input = (IEditorInput) adaptable;
// Get the editor descriptor.
String editorId = memento.getString(IWorkbenchConstants.TAG_ID);
if (editorId != null) {
IEditorRegistry registry = WorkbenchPlugin.getDefault().getEditorRegistry();
descriptor = registry.findEditor(editorId);
}
return result;
}
/**
* Writes the given AbstractDataTree to the given stream. This writes a single DataTree or
* DeltaDataTree, ignoring parent trees.
*
* @param path Only writes data for the subtree rooted at the given path, and for all nodes
* directly between the root and the subtree.
* @param depth In the subtree rooted at the given path, only write up to this depth. A depth of
* infinity is given by the constant D_INFINITE.
*/
public void writeTree(AbstractDataTree tree, IPath path, int depth, DataOutput output)
throws IOException {
this.output = output;
/* tunnel down relevant path */
AbstractDataTreeNode node = tree.getRootNode();
IPath currentPath = Path.ROOT;
String[] segments = path.segments();
for (int i = 0; i < segments.length; i++) {
String nextSegment = segments[i];
/* write this node to the output */
writeSingleNode(node, currentPath);
currentPath = currentPath.append(nextSegment);
node = node.childAtOrNull(nextSegment);
/* write the number of children for this node */
if (node != null) {
writeNumber(1);
} else {
/* can't navigate down the path, just give up with what we have so far */
writeNumber(0);
return;
}
}
Assert.isTrue(currentPath.equals(path), "dtree.navigationError"); // $NON-NLS-1$
/* recursively write the subtree we're interested in */
writeNode(node, path, depth);
}
public static String asString(ASTNode node) {
Assert.isTrue(node.getAST().apiLevel() == AST.JLS3);
ASTFlattener flattener = new ASTFlattener();
node.accept(flattener);
return flattener.getResult();
}
TableColumnLayout getTableLayout() {
Layout layout = table.getParent().getLayout();
Assert.isTrue(
layout instanceof TableColumnLayout,
"Table parent layout needs to be a TableColumnLayout!");
return (TableColumnLayout) layout;
}
