Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse JDT Release 3.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.eclipse.jdt.core.util
Class CompilationUnitSorter

    java.lang.Object
      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; it is not intended to be instantiated or subclassed.

Since:
  2.1

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 void` | `sort(ICompilationUnit compilationUnit, int[] positions, Comparator comparator, int options, IProgressMonitor monitor)` Reorders the declarations in the given compilation unit.

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

  Reorders the declarations in the given compilation unit. 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 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 `BodyDeclaration`s
    `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`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse JDT Release 3.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

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