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.util
Class CompilationUnitSorter

java.lang.Object
  extended by 
org.eclipse.jdt.core.util.CompilationUnitSorter

public final class CompilationUnitSorter
extends Object

Operation for sorting members within a compilation unit.

This class provides all functionality via static members.

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

Field Summary
static  String RELATIVE_ORDER
          Name of auxillary property whose value can be used to determine the original relative order of two body declarations.
 
Method Summary
static  TextEdit sort ( CompilationUnit unit, Comparator comparator, int options, TextEditGroup group, IProgressMonitor monitor)
          Reorders the declarations in the given compilation unit according to the specified comparator.
static void sort ( ICompilationUnit compilationUnit, int[] positions, Comparator comparator, int options, IProgressMonitor monitor)
          Deprecated. Clients should port their code to use the new JLS3 AST API and call CompilationUnitSorter.sort(AST.JLS3, compilationUnit, positions, comparator, options, monitor) instead of using this method.
static void sort (int level, ICompilationUnit compilationUnit, int[] positions, Comparator comparator, int options, IProgressMonitor monitor)
          Reorders the declarations in the given compilation unit according to the specified AST level.
 
Methods inherited from class java.lang. Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

RELATIVE_ORDER

public static final 
String RELATIVE_ORDER
Name of auxillary property whose value can be used to determine the original relative order of two body declarations. This allows a comparator to preserve the relative positions of certain kinds of body declarations when required.

All body declarations passed to the comparator's compare method by CompilationUnitSorter.sort carry an Integer-valued property. The body declaration with the lower value comes before the one with the higher value. The exact numeric value of these properties is unspecified.

Example usage:

 BodyDeclaration b1 = (BodyDeclaration) object1;
 BodyDeclaration b2 = (BodyDeclaration) object2;
 Integer i1 = (Integer) b1.getProperty(RELATIVE_ORDER);
 Integer i2 = (Integer) b2.getProperty(RELATIVE_ORDER);
 return i1.intValue() - i2.intValue(); // preserve original order
 

See Also:
sort(ICompilationUnit, int[], Comparator, int, IProgressMonitor), BodyDeclaration, Constant Field Values
Method Detail

sort

public static void sort(
ICompilationUnit compilationUnit,
                        int[] positions,
                        
Comparator comparator,
                        int options,
                        
IProgressMonitor monitor)
                 throws 
JavaModelException
Deprecated. Clients should port their code to use the new JLS3 AST API and call CompilationUnitSorter.sort(AST.JLS3, compilationUnit, positions, comparator, options, monitor) instead of using this method.

Reorders the declarations in the given compilation unit according to JLS2 rules. The caller is responsible for arranging in advance that the given compilation unit is a working copy, and for saving the changes afterwards.

Note: Reordering the members within a type declaration might be more than a cosmetic change and could have potentially serious repercussions. Firstly, the order in which the fields of a type are initialized is significant in the Java language; reordering fields and initializers may result in compilation errors or change the execution behavior of the code. Secondly, reordering a class's members may affect how its instances are serialized. This operation should therefore be used with caution and due concern for potential negative side effects.

The optional positions array contains a non-decreasing ordered list of character-based source positions within the compilation unit's source code string. Upon return from this method, the positions in the array reflect the corresponding new locations in the modified source code string. Note that this operation modifies the given array in place.

The compare method of the given comparator is passed pairs of JLS2 AST body declarations (subclasses of BodyDeclaration) representing body declarations at the same level. The comparator is called on body declarations of nested classes, including anonymous and local classes, but always at the same level. Clients need to provide a comparator implementation (there is no standard comparator). The RELATIVE_ORDER property attached to these AST nodes afforts the comparator a way to preserve the original relative order.

The body declarations passed as parameters to the comparator always carry at least the following minimal signature information:
TypeDeclaration modifiers, isInterface, name, superclass, superInterfaces
RELATIVE_ORDER property
FieldDeclaration modifiers, type, fragments (VariableDeclarationFragments with name only)
RELATIVE_ORDER property
MethodDeclaration modifiers, isConstructor, returnType, name, parameters (SingleVariableDeclarations with name and type only), thrownExceptions
RELATIVE_ORDER property
Initializer modifiers
RELATIVE_ORDER property
Clients should not rely on the AST nodes being properly parented or on having source range information. (Future releases may provide options for requesting additional information like source positions, full ASTs, non-recursive sorting, etc.)

Parameters:
compilationUnit - the given compilation unit, which must be a working copy
positions - an array of source positions to map, or null if none. If supplied, the positions must character-based source positions within the original source code for the given compilation unit, arranged in non-decreasing order. The array is updated in place when this method returns to reflect the corresponding source positions in the permuted source code string (but not necessarily any longer in non-decreasing order).
comparator - the comparator capable of ordering BodyDeclarations; this comparator is passed AST nodes from a JLS2 AST
options - bitwise-or of option flags; 0 for default behavior (reserved for future growth)
monitor - the progress monitor to notify, or null if none
Throws:
JavaModelException - if the compilation unit could not be sorted. Reasons include:
  • The given compilation unit does not exist (ELEMENT_DOES_NOT_EXIST)
  • The given compilation unit is not a working copy (INVALID_ELEMENT_TYPES)
  • A CoreException occurred while accessing the underlying resource
IllegalArgumentException - if the given compilation unit is null or if the given comparator is null.
See Also:
BodyDeclaration, RELATIVE_ORDER

sort

public static void sort(int level,
                        
ICompilationUnit compilationUnit,
                        int[] positions,
                        
Comparator comparator,
                        int options,
                        
IProgressMonitor monitor)
                 throws 
JavaModelException
Reorders the declarations in the given compilation unit according to the specified AST level. The caller is responsible for arranging in advance that the given compilation unit is a working copy, and for saving the changes afterwards.

Note: Reordering the members within a type declaration might be more than a cosmetic change and could have potentially serious repercussions. Firstly, the order in which the fields of a type are initialized is significant in the Java language; reordering fields and initializers may result in compilation errors or change the execution behavior of the code. Secondly, reordering a class's members may affect how its instances are serialized. This operation should therefore be used with caution and due concern for potential negative side effects.

The optional positions array contains a non-decreasing ordered list of character-based source positions within the compilation unit's source code string. Upon return from this method, the positions in the array reflect the corresponding new locations in the modified source code string. Note that this operation modifies the given array in place.

The compare method of the given comparator is passed pairs of body declarations (subclasses of BodyDeclaration) representing body declarations at the same level. The nodes are from an AST of the specified level ( ASTParser.newParser(int). Clients will generally specify AST.JLS3 since that will cover all constructs found in Java 1.0, 1.1, 1.2, 1.3, 1.4, and 1.5 source code. The comparator is called on body declarations of nested classes, including anonymous and local classes, but always at the same level. Clients need to provide a comparator implementation (there is no standard comparator). The RELATIVE_ORDER property attached to these AST nodes afforts the comparator a way to preserve the original relative order.

The body declarations passed as parameters to the comparator always carry at least the following minimal signature information:
TypeDeclaration modifiers, isInterface, name, superclass, superInterfaces, typeParameters
RELATIVE_ORDER property
FieldDeclaration modifiers, type, fragments (VariableDeclarationFragments with name only)
RELATIVE_ORDER property
MethodDeclaration modifiers, isConstructor, returnType, name, typeParameters, parameters (SingleVariableDeclarations with name, type, and modifiers only), thrownExceptions
RELATIVE_ORDER property
Initializer modifiers
RELATIVE_ORDER property
AnnotationTypeDeclaration modifiers, name
RELATIVE_ORDER property
AnnotationTypeMemberDeclaration modifiers, name, type, default
RELATIVE_ORDER property
EnumDeclaration modifiers, name, superInterfaces
RELATIVE_ORDER property
EnumConstantDeclaration modifiers, name, arguments
RELATIVE_ORDER property
Clients should not rely on the AST nodes being properly parented or on having source range information. (Future releases may provide options for requesting additional information like source positions, full ASTs, non-recursive sorting, etc.)

Parameters:
level - the AST level; one of the AST LEVEL constants
compilationUnit - the given compilation unit, which must be a working copy
positions - an array of source positions to map, or null if none. If supplied, the positions must character-based source positions within the original source code for the given compilation unit, arranged in non-decreasing order. The array is updated in place when this method returns to reflect the corresponding source positions in the permuted source code string (but not necessarily any longer in non-decreasing order).
comparator - the comparator capable of ordering BodyDeclarations; this comparator is passed AST nodes from an AST of the specified AST level
options - bitwise-or of option flags; 0 for default behavior (reserved for future growth)
monitor - the progress monitor to notify, or null if none
Throws:
JavaModelException - if the compilation unit could not be sorted. Reasons include:
  • The given compilation unit does not exist (ELEMENT_DOES_NOT_EXIST)
  • The given compilation unit is not a working copy (INVALID_ELEMENT_TYPES)
  • A CoreException occurred while accessing the underlying resource
IllegalArgumentException - if the given compilation unit is null or if the given comparator is null, or if level is not one of the AST JLS level constants.
Since:
3.1
See Also:
BodyDeclaration, RELATIVE_ORDER

sort

public static 
TextEdit sort(
CompilationUnit unit,
                            
Comparator comparator,
                            int options,
                            
TextEditGroup group,
                            
IProgressMonitor monitor)
                     throws 
JavaModelException
Reorders the declarations in the given compilation unit according to the specified comparator. The caller is responsible for arranging in advance that the given compilation unit is a working copy, and for applying the returned TextEdit afterwards.

Note: Reordering the members within a type declaration might be more than a cosmetic change and could have potentially serious repercussions. Firstly, the order in which the fields of a type are initialized is significant in the Java language; reordering fields and initializers may result in compilation errors or change the execution behavior of the code. Secondly, reordering a class's members may affect how its instances are serialized. This operation should therefore be used with caution and due concern for potential negative side effects.

The compare method of the given comparator is passed pairs of body declarations (subclasses of BodyDeclaration) representing body declarations at the same level. The comparator is called on body declarations of nested classes, including anonymous and local classes, but always at the same level. Clients need to provide a comparator implementation (there is no standard comparator). The RELATIVE_ORDER property attached to these AST nodes affords the comparator a way to preserve the original relative order.

The body declarations passed as parameters to the comparator always carry at least the following minimal signature information:
TypeDeclaration modifiers, isInterface, name, superclass, superInterfaces, typeParameters
RELATIVE_ORDER property
FieldDeclaration modifiers, type, fragments (VariableDeclarationFragments with name only)
RELATIVE_ORDER property
MethodDeclaration modifiers, isConstructor, returnType, name, typeParameters, parameters (SingleVariableDeclarations with name, type, and modifiers only), thrownExceptions
RELATIVE_ORDER property
Initializer modifiers
RELATIVE_ORDER property
AnnotationTypeDeclaration modifiers, name
RELATIVE_ORDER property
AnnotationTypeMemberDeclaration modifiers, name, type, default
RELATIVE_ORDER property
EnumDeclaration modifiers, name, superInterfaces
RELATIVE_ORDER property
EnumConstantDeclaration modifiers, name, arguments
RELATIVE_ORDER property

Parameters:
unit - the CompilationUnit to sort
comparator - the comparator capable of ordering BodyDeclarations; this comparator is passed AST nodes from an AST of the specified AST level
options - bitwise-or of option flags; 0 for default behavior (reserved for future growth)
group - the text edit group to use when generating text edits, or null
monitor - the progress monitor to notify, or null if none
Returns:
a TextEdit describing the required edits to do the sort, or null if sorting is not required
Throws:
JavaModelException - if the compilation unit could not be sorted. Reasons include:
  • The given unit was not created from a ICompilationUnit (INVALID_ELEMENT_TYPES)
IllegalArgumentException - if the given compilation unit is null or if the given comparator is null, or if options is not one of the supported levels.
Since:
3.3
See Also:
BodyDeclaration, RELATIVE_ORDER

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