Home >> All >> javax >> ide >> model >> java >> source >> [ tree Javadoc ]

• javax.ide.model.java.source.tree: Javadoc index of package javax.ide.model.java.source.tree.


Package Samples:

• javax.ide.model.java.source.tree

Classes:

• AnnotationT: An annotation (not to be confused with annotation type). Any declaration may be annotated, in particular, that means any T that extends HasModifiersT. For more information, please refer to the JLS 3rd ed, section 9.7. The first annotation variant is called a "normal" annotation. Consider: // Normal annotation RequestForEnhancement( id = 2868724, synopsis = "Provide time-travel functionality", engineer = "Mr. Peabody", date = "4/1/2004" ) public static void travelThroughTime(Date destination) { ... } getArguments() will return a list of four elements, each one will be an AssignmentExpressionT. The ...
• TreeKind: The TreeKind enumeration identifies each individual kind of Tree. For code-readability, all constants have been prefixed as TREE_*. Constants for subinterfaces of StatementT have been prefixed as TREE_STMT_*. Constants for subinterfaces of ExpressionT have been prefixed as TREE_EXPR_*. Constants for subinterfaces of DocT have been prefixed as TREE_DOC_*. Though the doc structure is not part of the Java Language specification (moreover, there is no specification of doc structure), doc comment constants have been included because refactoring features may need to access and mutate doc comment contents. ...
• DocTagT: A tag within a doc comment. Unlike com.sun.javadoc.Tag, a DocTagT does not represent text. A DocTagT only represents words prefixed with a leading that follow the javadoc rules, i.e. a block tag starts on its own line and an inline tag is prefixed with '. The doc tag name are composed of a leading followed by a qualified name where, unlike in Java, '-' in considered to be part of a tag identifier. "Standard tag" means a tag defined by the standard doclet.
• AssertStatementT: An assert statement. JLS3 14.10. An assert statement has a conditional expression and an optional detail message expression. Here are some examples: assert enabled == true; assert(enabled == true); assert enabled == true: "Not enabled"; If there is a second expression and the condition evaluates to false, then the second expression is evaluated and then converted to a String used to create a new AssertionError.
• LiteralExpressionT: An expression representing a lexer literal. Class literals and this literals, though called "literal", are not here considered to be literal expressions. As a result of this definition, the value of all LiteralExpressionTs can be determined at parse-time whereas the value of class literals and this literals can only be determined at compile-time.
• DocElementT: Common supertype for all elements that are a part of a doc comment. Not named DocT in order to avoid confusion with com.sun.javadoc.Doc which is not the base supertype of all doc elements. "Comment text" refers to text with leading asterisks stripped. "Processed text" refers to text with tags stripped.
• StatementT: Common supertype of all statements. All statements can be classified as: simple, block, compound. Block statements are statements that are blocks. Simple statements have no child statements and optionally have expressions. Compound statements have child statements and optionally have expressions.
• DocCommentT: A doc comment (short for "documentation comment"). Corresponds to com.sun.javadoc.Doc in the Doclet API. Named DocCommentT to avoid confusion with the other convention of ExpressionT and StatementT that indicate common supertypes because the DocCommentT is not a common supertype.
• InfixExpressionT: An expression involving an infix operation (but not an assignment operation). Infix expressions usually have two operands. Commutative and associative operators may have more than two. The infix operators are: + - * / % && || & | ^ instanceof
• WrapperExpressionT: An expression wrapping another one, either with parentheses or brackets. Notice the difference between a WrapperExpression and a ListExpression. Wrapper expressions always have a single operand whereas list expressions may have a variable number of operands.
• TypecastExpressionT: An expression performing a typecast operation. Though technically, a typecast is a prefix operation, it is here represented separately because it has two operands (a type lhs and an expression rhs) and it is not commonly thought of as a typical prefix operator.
• ExpressionT: Common supertypes for all expressions. If it is a primary, selector, or method invocation, it has a name. Otherwise, it is an operator of some sort and has operands. With each enumerated constant is a description of which fields are non-null and useful.
• BlockT: A code block. Blocks may be children of methods declarations, constructor declarations, class initializers, and statements. A block may contain any child that extends BlockElementT, in particular: ClassT, LocalVariableDeclT, StatementT, SwitchLabelT.
• TypeExpressionT: An expression wrapping a type reference. The following operators all have type operands (which are type expressions): instanceof, typecast, class literal, and qualified this literal. Type expressions have no operands.
• SimpleStatementT: Common supertype for statements that have no child statement but may optionally have expressions. This includes the following types of statements: empty, expression, break, continue, return, throw, assert.
• OperatorExpressionT: Common supertype for multi-operand operations. Note: Here, "operator" is NOT synonymous with "has operands". All expressions may have operands, but not all expressions perform operations on their operands.
• UnaryExpressionT: An expression performing a prefix or postfix operation, but not a typecast operation. The prefix operations are: + - ++ -- ~ ! The postfix operations are: ++ --
• ConditionalStatementT: Common supertype for compound statements having (requiring) a conditional expression. This includes: do, if, while. Note that a for expression is not considered to be a conditional statement.
• FileT: The root of a source file, also called a compilation unit. From the root, a client may retrieve the package declaration, the import declarations, and all top-level type declarations.
• NameT: A name, simple or qualified. In certain cases, it may contain non-identifier characters. For example, in an import declaration, the name will include the trailing ".*".
• NewArrayExpressionT: An expression creating a new array. Array creators come in two flavors: normal and (explicitly) initialized. TODO: Explain what array dimensions are returned.
• InterfacesT: An interfaces clause of a type declaration. On a "class" or "enum" type, this is the "extends" clause. On an "interface" type, this is the "implements" clause.
• DereferenceExpressionT: Common supertype for expressions performing dereference operations. The three dereference expressions are: array access, method call, and dot dereference.
• AssignmentExpressionT: An expression performing an assignment operation. The assignment operators are: = *= /= %= += -= >= >>>= &= ^= |=
• ListExpressionT: An expression wrapping a list of expressions. Examples are: argument lists, array constants, and bracket dereference lists.

Home | Contact Us | Privacy Policy | Terms of Service