Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Programming
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Databases
Mail Systems
openSolaris
Eclipse Documentation
Techotopia.com
Virtuatopia.com

How To Guides
Virtualization
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Windows
Problem Solutions
Privacy Policy

  




 

 


Eclipse JDT
Release 3.5

org.eclipse.jdt.core.dom.rewrite
Class ASTRewrite

java.lang.Object
  extended by 
org.eclipse.jdt.core.dom.rewrite.ASTRewrite

public class ASTRewrite
extends Object

Infrastructure for modifying code by describing changes to AST nodes. The AST rewriter collects descriptions of modifications to nodes and translates these descriptions into text edits that can then be applied to the original source. The key thing is that this is all done without actually modifying the original AST, which has the virtue of allowing one to entertain several alternate sets of changes on the same AST (e.g., for calculating quick fix proposals). The rewrite infrastructure tries to generate minimal text changes, preserve existing comments and indentation, and follow code formatter settings. If the freedom to explore multiple alternate changes is not required, consider using the AST's built-in rewriter (see CompilationUnit.rewrite(IDocument, Map)).

The following code snippet illustrated usage of this class:

 Document document = new Document("import java.util.List;\nclass X {}\n");
 ASTParser parser = ASTParser.newParser(AST.JLS3);
 parser.setSource(document.get().toCharArray());
 CompilationUnit cu = (CompilationUnit) parser.createAST(null);
 AST ast = cu.getAST();
 ImportDeclaration id = ast.newImportDeclaration();
 id.setName(ast.newName(new String[] {"java", "util", "Set"}));
 ASTRewrite rewriter = ASTRewrite.create(ast);
 TypeDeclaration td = (TypeDeclaration) cu.types().get(0);
 ITrackedNodePosition tdLocation = rewriter.track(td);
 ListRewrite lrw = rewriter.getListRewrite(cu, CompilationUnit.IMPORTS_PROPERTY);
 lrw.insertLast(id, null);
 TextEdit edits = rewriter.rewriteAST(document, null);
 UndoEdit undo = null;
 try {
     undo = edits.apply(document);
 } catch(MalformedTreeException e) {
     e.printStackTrace();
 } catch(BadLocationException e) {
     e.printStackTrace();
 }
 assert "import java.util.List;\nimport java.util.Set;\nclass X {}\n".equals(document.get());
 // tdLocation.getStartPosition() and tdLocation.getLength()
 // are new source range for "class X {}" in document.get()
 

This class is not intended to be subclassed.

Since:
3.0
Restriction:
This class is not intended to be subclassed by clients.
Restriction:
This class is not intended to be instantiated by clients.

Constructor Summary
protected ASTRewrite ( AST ast)
          Internal constructor.
 
Method Summary
static  ASTRewrite create ( AST ast)
          Creates a new instance for describing manipulations of the given AST.
  ASTNode createCopyTarget ( ASTNode node)
          Creates and returns a placeholder node for a true copy of the given node.
  ASTNode createGroupNode ( ASTNode[] targetNodes)
          Creates and returns a node that represents a sequence of nodes.
  ASTNode createMoveTarget ( ASTNode node)
          Creates and returns a placeholder node for the new locations of the given node.
  ASTNode createStringPlaceholder ( String code, int nodeType)
          Creates and returns a placeholder node for a source string that is to be inserted into the output document at the position corresponding to the placeholder.
  Object get ( ASTNode node, StructuralPropertyDescriptor property)
          Returns the value of the given property as managed by this rewriter.
  AST getAST ()
          Returns the AST the rewrite was set up on.
  TargetSourceRangeComputer getExtendedSourceRangeComputer ()
          Returns the extended source range computer for this AST rewriter.
  ListRewrite getListRewrite ( ASTNode node, ChildListPropertyDescriptor property)
          Creates and returns a new rewriter for describing modifications to the given list property of the given node.
protected  org.eclipse.jdt.internal.core.dom.rewrite.NodeInfoStore getNodeStore ()
          Internal method.
protected  org.eclipse.jdt.internal.core.dom.rewrite.RewriteEventStore getRewriteEventStore ()
          Internal method.
 void remove ( ASTNode node, TextEditGroup editGroup)
          Removes the given node from its parent in this rewriter.
 void replace ( ASTNode node, ASTNode replacement, TextEditGroup editGroup)
          Replaces the given node in this rewriter.
  TextEdit rewriteAST ()
          Converts all modifications recorded by this rewriter into an object representing the the corresponding text edits to the source of a ITypeRoot from which the AST was created from.
  TextEdit rewriteAST ( IDocument document, Map options)
          Converts all modifications recorded by this rewriter into an object representing the corresponding text edits to the given document containing the original source code.
 void set ( ASTNode node, StructuralPropertyDescriptor property, Object value, TextEditGroup editGroup)
          Sets the given property of the given node.
 void setTargetSourceRangeComputer ( TargetSourceRangeComputer computer)
          Sets a custom target source range computer for this AST rewriter.
  String toString ()
          Returns a string suitable for debugging purposes (only).
  ITrackedNodePosition track ( ASTNode node)
          Returns an object that tracks the source range of the given node across the rewrite to its AST.
 
Methods inherited from class java.lang. Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Constructor Detail

ASTRewrite

protected ASTRewrite(
AST ast)
Internal constructor. Creates a new instance for the given AST. Clients should use create(AST) to create instances.

Parameters:
ast - the AST being rewritten
Method Detail

create

public static 
ASTRewrite create(
AST ast)
Creates a new instance for describing manipulations of the given AST.

Parameters:
ast - the AST whose nodes will be rewritten
Returns:
the new rewriter instance

getAST

public final 
AST getAST()
Returns the AST the rewrite was set up on.

Returns:
the AST the rewrite was set up on

getRewriteEventStore

protected final org.eclipse.jdt.internal.core.dom.rewrite.RewriteEventStore getRewriteEventStore()
Internal method. Returns the internal event store. Clients should not use.

Returns:
Returns the internal event store. Clients should not use.

getNodeStore

protected final org.eclipse.jdt.internal.core.dom.rewrite.NodeInfoStore getNodeStore()
Internal method. Returns the internal node info store. Clients should not use.

Returns:
Returns the internal info store. Clients should not use.

rewriteAST

public 
TextEdit rewriteAST(
IDocument document,
                           
Map options)
                    throws 
IllegalArgumentException
Converts all modifications recorded by this rewriter into an object representing the corresponding text edits to the given document containing the original source code. The document itself is not modified.

For nodes in the original that are being replaced or deleted, this rewriter computes the adjusted source ranges by calling getTargetSourceRangeComputer().computeSourceRange(node).

Calling this methods does not discard the modifications on record. Subsequence modifications are added to the ones already on record. If this method is called again later, the resulting text edit object will accurately reflect the net cumulative affect of all those changes.

Parameters:
document - original document containing source code
options - the table of formatter options (key type: String; value type: String); or null to use the standard global options JavaCore.getOptions()
Returns:
text edit object describing the changes to the document corresponding to the changes recorded by this rewriter
Throws:
IllegalArgumentException - An IllegalArgumentException is thrown if the document passed does not correspond to the AST that is rewritten.

rewriteAST

public 
TextEdit rewriteAST()
                    throws 
JavaModelException,
                           
IllegalArgumentException
Converts all modifications recorded by this rewriter into an object representing the the corresponding text edits to the source of a ITypeRoot from which the AST was created from. The type root's source itself is not modified by this method call.

Important: This API can only be used if the modified AST has been created from a ITypeRoot with source. That means ASTParser.setSource(ICompilationUnit), ASTParser.setSource(IClassFile) or ASTParser.setSource(ITypeRoot) has been used when initializing the ASTParser. A IllegalArgumentException is thrown otherwise. An IllegalArgumentException is also thrown when the type roots buffer does not correspond anymore to the AST. Use rewriteAST(IDocument, Map) for all ASTs created from other content.

For nodes in the original that are being replaced or deleted, this rewriter computes the adjusted source ranges by calling getTargetSourceRangeComputer().computeSourceRange(node).

Calling this methods does not discard the modifications on record. Subsequence modifications are added to the ones already on record. If this method is called again later, the resulting text edit object will accurately reflect the net cumulative affect of all those changes.

Returns:
text edit object describing the changes to the document corresponding to the changes recorded by this rewriter
Throws:
JavaModelException - A JavaModelException is thrown when the underlying compilation units buffer could not be accessed.
IllegalArgumentException - An IllegalArgumentException is thrown if the document passed does not correspond to the AST that is rewritten.
Since:
3.2

remove

public final void remove(
ASTNode node,
                         
TextEditGroup editGroup)
Removes the given node from its parent in this rewriter. The AST itself is not actually modified in any way; rather, the rewriter just records a note that this node should not be there.

Parameters:
node - the node being removed. The node can either be an original node in the AST or (since 3.4) a new node already inserted or used as replacement in this AST rewriter.
editGroup - the edit group in which to collect the corresponding text edits, or null if ungrouped
Throws:
IllegalArgumentException - if the node is null, or if the node is not part of this rewriter's AST, or if the described modification is invalid (such as removing a required node)

replace

public final void replace(
ASTNode node,
                          
ASTNode replacement,
                          
TextEditGroup editGroup)
Replaces the given node in this rewriter. The replacement node must either be brand new (not part of the original AST) or a placeholder node (for example, one created by createCopyTarget(ASTNode) or createStringPlaceholder(String, int)). The AST itself is not actually modified in any way; rather, the rewriter just records a note that this node has been replaced.

Parameters:
node - the node being replaced. The node can either be an original node in the AST or (since 3.4) a new node already inserted or used as replacement in this AST rewriter.
replacement - the replacement node, or null if no replacement
editGroup - the edit group in which to collect the corresponding text edits, or null if ungrouped
Throws:
IllegalArgumentException - if the node is null, or if the node is not part of this rewriter's AST, or if the replacement node is not a new node (or placeholder), or if the described modification is otherwise invalid

set

public final void set(
ASTNode node,
                      
StructuralPropertyDescriptor property,
                      
Object value,
                      
TextEditGroup editGroup)
Sets the given property of the given node. If the given property is a child property, the value must be a replacement node that is either be brand new (not part of the original AST) or a placeholder node (for example, one created by createCopyTarget(ASTNode) or createStringPlaceholder(String, int)); or it must be null, indicating that the child should be deleted. If the given property is a simple property, the value must be the new value (primitive types must be boxed) or null. The AST itself is not actually modified in any way; rather, the rewriter just records a note that this node has been changed in the specified way.

Parameters:
node - the node
property - the node's property; either a simple property or a child property
value - the replacement child or new value, or null if none
editGroup - the edit group in which to collect the corresponding text edits, or null if ungrouped
Throws:
IllegalArgumentException - if the node or property is null, or if the node is not part of this rewriter's AST, or if the property is not a node property, or if the described modification is invalid

get

public 
Object get(
ASTNode node,
                  
StructuralPropertyDescriptor property)
Returns the value of the given property as managed by this rewriter. If the property has been removed, null is returned. If it has been replaced, the replacing value is returned. If the property has not been changed yet, the original value is returned.

For child list properties use ListRewrite.getRewrittenList() to get access to the rewritten nodes in a list.

Parameters:
node - the node
property - the node's property
Returns:
the value of the given property as managed by this rewriter
Since:
3.2

getListRewrite

public final 
ListRewrite getListRewrite(
ASTNode node,
                                        
ChildListPropertyDescriptor property)
Creates and returns a new rewriter for describing modifications to the given list property of the given node.

Parameters:
node - the node
property - the node's property; the child list property
Returns:
a new list rewriter object
Throws:
IllegalArgumentException - if the node or property is null, or if the node is not part of this rewriter's AST, or if the property is not a node property, or if the described modification is invalid

track

public final 
ITrackedNodePosition track(
ASTNode node)
Returns an object that tracks the source range of the given node across the rewrite to its AST. Upon return, the result object reflects the given node's current source range in the AST. After rewrite is called, the result object is updated to reflect the given node's source range in the rewritten AST.

Parameters:
node - the node to track
Returns:
an object that tracks the source range of node
Throws:
IllegalArgumentException - if the node is null, or if the node is not part of this rewriter's AST, or if the node is already being tracked

createStringPlaceholder

public final 
ASTNode createStringPlaceholder(
String code,
                                             int nodeType)
Creates and returns a placeholder node for a source string that is to be inserted into the output document at the position corresponding to the placeholder. The string will be inserted without being reformatted beyond correcting the indentation level. The placeholder node can either be inserted as new or used to replace an existing node.

Parameters:
code - the string to be inserted; lines should should not have extra indentation
nodeType - the ASTNode type that corresponds to the passed code.
Returns:
the new placeholder node
Throws:
IllegalArgumentException - if the code is null, or if the node type is invalid

createGroupNode

public final 
ASTNode createGroupNode(
ASTNode[] targetNodes)
Creates and returns a node that represents a sequence of nodes. Each of the given nodes must be either be brand new (not part of the original AST), or a placeholder node (for example, one created by createCopyTarget(ASTNode) or createStringPlaceholder(String, int)), or another group node. The type of the returned node is unspecified. The returned node can be used to replace an existing node (or as an element of another group node). When the document is rewritten, the source code for each of the given nodes is inserted, in order, into the output document at the position corresponding to the group (indentation is adjusted).

Parameters:
targetNodes - the nodes to go in the group
Returns:
the new group node
Throws:
IllegalArgumentException - if the targetNodes is null or empty
Since:
3.1

createCopyTarget

public final 
ASTNode createCopyTarget(
ASTNode node)
Creates and returns a placeholder node for a true copy of the given node. The placeholder node can either be inserted as new or used to replace an existing node. When the document is rewritten, a copy of the source code for the given node is inserted into the output document at the position corresponding to the placeholder (indentation is adjusted).

Parameters:
node - the node to create a copy placeholder for
Returns:
the new placeholder node
Throws:
IllegalArgumentException - if the node is null, or if the node is not part of this rewriter's AST

createMoveTarget

public final 
ASTNode createMoveTarget(
ASTNode node)
Creates and returns a placeholder node for the new locations of the given node. After obtaining a placeholder, the node should then to be removed or replaced. The placeholder node can either be inserted as new or used to replace an existing node. When the document is rewritten, the source code for the given node is inserted into the output document at the position corresponding to the placeholder (indentation is adjusted).

Parameters:
node - the node to create a move placeholder for
Returns:
the new placeholder node
Throws:
IllegalArgumentException - if the node is null, or if the node is not part of this rewriter's AST

getExtendedSourceRangeComputer

public final 
TargetSourceRangeComputer getExtendedSourceRangeComputer()
Returns the extended source range computer for this AST rewriter. The default value is a new TargetSourceRangeComputer().

Returns:
an extended source range computer
Since:
3.1

setTargetSourceRangeComputer

public final void setTargetSourceRangeComputer(
TargetSourceRangeComputer computer)
Sets a custom target source range computer for this AST rewriter. This is advanced feature to modify how comments are associated with nodes, which should be done only in special cases.

Parameters:
computer - a target source range computer, or null to restore the default value of new TargetSourceRangeComputer()
Since:
3.1

toString

public 
String toString()
Returns a string suitable for debugging purposes (only).

Overrides:
toString in class Object
Returns:
a debug string

Eclipse JDT
Release 3.5

Copyright (c) IBM Corp. and others 2000, 2008. All Rights Reserved.

 
 
  Published under the terms of the Eclipse Public License Version 1.0 ("EPL") Design by Interspire