| Home >> All >> org >> eclipse >> jdt |
| • | org.eclipse.jdt.core.* (271) | • | org.eclipse.jdt.debug.* (49) | • | org.eclipse.jdt.internal.* (2530) |
| • | org.eclipse.jdt.junit.* (2) | • | org.eclipse.jdt.launching.* (38) | • | org.eclipse.jdt.ui.* (144) |
Package Samples:
• org.eclipse.jdt.internal.junit.runner
• org.eclipse.jdt.internal.debug.eval.ast.instructions
• org.eclipse.jdt.internal.debug.eval.ast.engine
• org.eclipse.jdt.internal.debug.eval
• org.eclipse.jdt.internal.debug.core.model
• org.eclipse.jdt.internal.debug.core.logicalstructures
• org.eclipse.jdt.internal.debug.core
• org.eclipse.jdt.internal.debug.core.breakpoints
• org.eclipse.jdt.internal.debug.core.hcr
• org.eclipse.jdt.debug.core
• org.eclipse.jdt.debug.eval
• org.eclipse.jdt.junit
• org.eclipse.jdt.internal.junit.wizards
• org.eclipse.jdt.internal.junit.ui
• org.eclipse.jdt.internal.junit.refactoring
• org.eclipse.jdt.internal.junit.launcher
• org.eclipse.jdt.internal.junit.util
• org.eclipse.jdt.internal.debug.ui.sourcelookup
• org.eclipse.jdt.internal.debug.ui.snippeteditor
• org.eclipse.jdt.internal.debug.ui.propertypages
Classes:
• IClasspathEntry: An entry on a Java project classpath identifying one or more package fragment roots. A classpath entry has a content kind (either source, K_SOURCE , or binary, K_BINARY ), which is inherited by each package fragment root and package fragment associated with the entry. A classpath entry can refer to any of the following: Source code in the current project. In this case, the entry identifies a root folder in the current project containing package fragments and .java source files. The root folder itself represents a default package, subfolders represent package fragments, and .java files represent ...
• IJavaElementDelta: A Java element delta describes changes in Java element between two discrete points in time. Given a delta, clients can access the element that has changed, and any children that have changed. Deltas have a different status depending on the kind of change they represent. The list below summarizes each status (as returned by getKind ) and its meaning (see individual constants for a more detailled description): ADDED - The element described by the delta has been added. REMOVED - The element described by the delta has been removed. CHANGED - The element described by the delta has been changed in some ...
• ASTVisitor: A visitor for abstract syntax trees. For each different concrete AST node type T there are a pair of methods: public boolean visit( T node) - Visits the given node to perform some arbitrary operation. If true is returned, the given node's child nodes will be visited next; however, if false is returned, the given node's child nodes will not be visited. The default implementation provided by this class does nothing and returns true (with the exception of ASTVisitor.visit(Javadoc) 55 ). Subclasses may reimplement this method as needed. public void endVisit( T node) - Visits the given node to perform ...
• ASTNode: Abstract superclass of all Abstract Syntax Tree (AST) node types. An AST node represents a Java source code construct, such as a name, type, expression, statement, or declaration. Each AST node belongs to a unique AST instance, called the owning AST. The children of an AST node always have the same owner as their parent node. If a node from one AST is to be added to a different AST, the subtree must be cloned first to ensure that the added nodes have the correct owning AST. When an AST node is part of an AST, it has a unique parent node. Clients can navigate upwards, from child to parent, as well ...
• Signature: Provides methods for encoding and decoding type and method signature strings. Signatures obtained from parsing source (".java") files differ subtly from ones obtained from pre-compiled binary (".class") files in class names are usually left unresolved in the former. For example, the normal resolved form of the type "String" embeds the class's package name ("Ljava.lang.String;" or "Ljava/lang/String;"), whereas the unresolved form contains only what is written "QString;". Generic types introduce to the Java language in J2SE 1.5 add three new facets to signatures: type variables, parameterized types ...
• SearchParticipant: A search participant describes a particular extension to a generic search mechanism, permitting combined search actions which will involve all required participants. A search participant is involved in the indexing phase and in the search phase. The indexing phase consists in taking one or more search documents, parse them, and add index entries in an index chosen by the participant. An index is identified by a path on disk. The search phase consists in selecting the indexes corresponding to a search pattern and a search scope, from these indexes the search infrastructure extracts the document ...
• ASTParser: A Java language parser for creating abstract syntax trees (ASTs). Example: Create basic AST from source string char[] source = ...; ASTParser parser = ASTParser.newParser(AST.JLS2); // handles JLS2 (J2SE 1.4) parser.setSource(source); CompilationUnit result = (CompilationUnit) parser.createAST(null); Once a configured parser instance has been used to create an AST, the settings are automicatically returned to their defaults, ready for the parser instance to be reused. There are a number of configurable features: Source string from char[] 55 , ICompilationUnit 55 , or IClassFile 55 , and limited ...
• IDOMNode: Nodes represent structural fragments of a Java source file, also known as document fragments. Their implementation is known as a DOM (Document Object Model) - in this case a JDOM (Java DOM). A root node (node with no parent or siblings) represents the root of a document fragment (DF). A complete Java document is represented by a compilation unit node ( IDOMCompilationUnit ). In this way, a DF is comprised of DFs, and a document itself (compilation unit) is also a DF. A DF may be created empty and programmatically filled, or it may be created from a source code string. The IDOMFactory allows the ...
• AST: Umbrella owner and abstract syntax tree node factory. An AST instance serves as the common owner of any number of AST nodes, and as the factory for creating new AST nodes owned by that instance. Abstract syntax trees may be hand constructed by clients, using the new TYPE factory methods to create new nodes, and the various set CHILD methods (see ASTNode and its subclasses) to connect them together. Each AST node belongs to a unique AST instance, called the owning AST. The children of an AST node always have the same owner as their parent node. If a node from one AST is to be added to a different ...
• HierarchicalASTVisitor: This class provides a convenient behaviour-only extension mechanism for the ASTNode hierarchy. If you feel like you would like to add a method to the ASTNode hierarchy (or a subtree of the hierarchy), and you want to have different implementations of it at different points in the hierarchy, simply create a HierarchicalASTVisitor representing the new method and all its implementations, locating each implementation within the right visit(XX) method. If you wanted to add a method implementation to abstract class Foo, an ASTNode descendant, put your implementation in visit(Foo). This class will provide ...
• IEvaluationContext: An evaluation context supports evaluating code snippets. A code snippet is pretty much any valid piece of Java code that could be pasted into the body of a method and compiled. However, there are two areas where the rules are slightly more liberal. First, a code snippet can return heterogeneous types. Inside the same code snippet an int could be returned on one line, and a String on the next, etc. For example, the following would be considered a valid code snippet: char c = '3'; switch (c) { case '1': return 1; case '2': return '2'; case '3': return "3"; default: return null; } Second, if the last ...
• SearchPattern: A search pattern defines how search results are found. Use SearchPattern.createPattern to create a search pattern. Search patterns are used during the search phase to decode index entries that were added during the indexing phase (see SearchDocument.addIndexEntry(char[], char[]) 55 ). When an index is queried, the index categories and keys to consider are retrieved from the search pattern using getIndexCategories() 55 and getIndexKey() 55 , as well as the match rule (see getMatchRule() 55 ). A blank pattern is then created (see getBlankPattern() 55 ). This blank pattern is used as a record as follows. ...
• ASTRewrite: Infrastucture 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. ...
• MethodDeclaration: Method declaration AST node type. A method declaration is the union of a method declaration and a constructor declaration. For JLS2: MethodDeclaration: [ Javadoc ] { Modifier } ( Type | void ) Identifier ( [ FormalParameter { , FormalParameter } ] ) { [ ] } [ throws TypeName { , TypeName } ] ( Block | ; ) ConstructorDeclaration: [ Javadoc ] { Modifier } Identifier ( [ FormalParameter { , FormalParameter } ] ) [ throws TypeName { , TypeName } ] Block For JLS3, type parameters and reified modifiers (and annotations) were added: MethodDeclaration: [ Javadoc ] { ExtendedModifier } [ < TypeParameter ...
• TypeDeclaration: Type declaration AST node type. A type declaration is the union of a class declaration and an interface declaration. For JLS2: TypeDeclaration: ClassDeclaration InterfaceDeclaration ClassDeclaration: [ Javadoc ] { Modifier } class Identifier [ extends Type] [ implements Type { , Type } ] { { ClassBodyDeclaration | ; } } InterfaceDeclaration: [ Javadoc ] { Modifier } interface Identifier [ extends Type { , Type } ] { { InterfaceBodyDeclaration | ; } } For JLS3, type parameters and reified modifiers (and annotations) were added, and the superclass type name and superinterface types names are generalized ...
• IDOMFactory: A factory used to create document fragment (DF) nodes. An IDOMCompilationUnit represents the root of a complete JDOM (that is, a ".java" file). Other node types represent fragments of a compilation unit. The factory can be used to create empty DFs or it can create DFs from source strings. All DFs created empty are assigned default values as required, such that a call to IDOMNode.getContents will generate a valid source string. See individual create methods for details on the default values supplied. The factory does its best to recognize Java structures in the source provided. If the factory is ...
• DOMNode: DOMNode provides an implementation for IDOMNode . A node represents a document fragment. When a node is created, its contents are located in a contiguous range of a shared document. A shared document is a char array, and is shared in the sense that the contents of other document fragments may also be contained in the array. A node maintains indicies of relevant portions of its contents in the shared document. Thus the original document and indicies create a form from which to generate the contents of the document fragment. As attributes of a node are changed, the node attempts to maintain the original ...
• IWorkingCopy: Common protocol for Java elements that support working copies. A working copy of a Java element acts just like a regular element (handle), except it is not attached to an underlying resource. A working copy is not visible to the rest of the Java model. Changes in a working copy's buffer are not realized in a resource. To bring the Java model up-to-date with a working copy's contents, an explicit commit must be performed on the working copy. Other operations performed on a working copy update the contents of the working copy's buffer but do not commit the contents of the working copy. Note: The ...
• IRuntimeClasspathEntryResolver: Resolves variable and/or container runtime classpath entries in the context of a launch configuration or Java project. A resolver can be declared as an extension ( org.eclipse.jdt.launching.runtimeClasspathEntryResolver ), or be registered with the JavaRuntime programatically. A resolver is registered for a specific classpath VARIABLE and/or CONTAINER . A resolver is consulted when a runtime classpath entry is needs to be resolved. A resolver extension is defined in plugin.xml . Following is an example definition of a runtime classpath entry resolver extension. <extension point="org.eclipse.jdt.launching.runtimeClasspathEntryResolvers"> ...
• OverflowingLRUCache: The OverflowingLRUCache is an LRUCache which attempts to maintain a size equal or less than its fSpaceLimit by removing the least recently used elements. The cache will remove elements which successfully close and all elements which are explicitly removed. If the cache cannot remove enough old elements to add new elements it will grow beyond fSpaceLimit . Later, it will attempt to shink back to the maximum space limit. The method close should attempt to close the element. If the element is successfully closed it will return true and the element will be removed from the cache. Otherwise the element ...
• CompletionProposal: Completion proposal. In typical usage, the user working in a Java code editor issues a code assist command. This command results in a call to ICodeAssist.codeComplete(position, completionRequestor) passing the current position in the source code. The code assist engine analyzes the code in the buffer, determines what kind of Java language construct is at that position, and proposes ways to complete that construct. These proposals are instances of subclasses of CompletionProposal . These proposals, perhaps after sorting and filtering, are presented to the user to make a choice. The proposal is as ...
• ClassInstanceCreation: Class instance creation expression AST node type. For JLS2: ClassInstanceCreation: [ Expression . ] new Name ( [ Expression { , Expression } ] ) [ AnonymousClassDeclaration ] For JLS3, type arguments are added and the type name is generalized to a type so that parameterized types can be instantiated: ClassInstanceCreation: [ Expression . ] new [ < Type { , Type } > ] Type ( [ Expression { , Expression } ] ) [ AnonymousClassDeclaration ] Not all node arragements will represent legal Java constructs. In particular, it is nonsense if the type is a primitive type or an array type (primitive types ...
• IOpenable: Common protocol for Java elements that must be opened before they can be navigated or modified. Opening a textual element (such as a compilation unit) involves opening a buffer on its contents. While open, any changes to the buffer can be reflected in the element's structure; see isConsistent and makeConsistent(IProgressMonitor) . To reduce complexity in clients, elements are automatically opened by the Java model as element properties are accessed. The Java model maintains an LRU cache of open elements, and automatically closes elements as they are swapped out of the cache to make room for other ...
• FieldAccess: Field access expression AST node type. FieldAccess: Expression . Identifier Note that there are several kinds of expressions that resemble field access expressions: qualified names, this expressions, and super field access expressions. The following guidelines help with correct usage: An expression like "foo.this" can only be represented as a this expression ( ThisExpression ) containing a simple name. "this" is a keyword, and therefore invalid as an identifier. An expression like "this.foo" can only be represented as a field access expression ( FieldAccess ) containing a this expression and a ...
• IRuntimeClasspathProvider: A classpath provider computes an unresolved classpath for a launch configuration, and resolves classpath entries for a launch configuration. A classpath provider is defined as an extension of type org.eclipse.jdt.launching.classpathProvider . A provider is registered with an identifier that can be referenced by a launch configuration. A classpath provider is consulted to compute a classpath or source lookup path when a launch configuration references a provider in one or both of the following attributes: ATTR_CLASSPATH_PROVIDER ATTR_SOURCE_PATH_PROVIDER A provider extension is defined in plugin.xml ...
| Home | Contact Us | Privacy Policy | Terms of Service |