Example usage for org.eclipse.jdt.core.dom Dimension annotations

List of usage examples for org.eclipse.jdt.core.dom Dimension annotations

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.dom.*
  5. Dimension
  6. annotations

Introduction

In this page you can find the example usage for org.eclipse.jdt.core.dom Dimension annotations.

Prototype

ASTNode.NodeList annotations

To view the source code for org.eclipse.jdt.core.dom Dimension annotations.

Click Source Link

Document

The list of annotations for this dimension (element type: Annotation ).

Usage

From source file:at.bestsolution.fxide.jdt.corext.dom.ASTFlattener.java

License:Open Source License

@Override
public boolean visit(Dimension node) {
    this.fBuffer.append(" ");//$NON-NLS-1$
    printAnnotationsList(node.annotations());
    this.fBuffer.append("[]"); //$NON-NLS-1$
    return false;
}

From source file:com.bsiag.eclipse.jdt.java.formatter.SpacePreparator.java

License:Open Source License

@Override
public boolean visit(Dimension node) {
    List<Annotation> annotations = node.annotations();
    if (!annotations.isEmpty())
        handleToken(annotations.get(0), TokenNameAT, true, false);
    return true;//from  w  w  w.ja  v  a  2s .c o  m
}

From source file:com.google.googlejavaformat.java.JavaInputAstVisitor.java

License:Apache License

/** Visitor method for {@link Dimension}s. */
@Override/*from  ww w .  j  a v  a 2 s. co  m*/
public boolean visit(Dimension node) {
    sync(node);
    if (!node.annotations().isEmpty()) {
        builder.open(ZERO);
        visitAnnotations(node.annotations(), BreakOrNot.NO, BreakOrNot.NO);
        builder.breakToFill(" ");
        builder.close();
    }
    token("[");
    token("]");
    return false;
}

From source file:com.google.googlejavaformat.java.JavaInputAstVisitor.java

License:Apache License

/** Helper method for {@link ArrayCreation}s and {@link ArrayType}s. */
private void visitArrayType(ArrayType node, DimensionsOrNot includeDimensions) {
    if (includeDimensions.isYes() && !node.dimensions().isEmpty()) {
        builder.open(plusFour);/*from w w  w  .j a va2  s .c o m*/
    }
    node.getElementType().accept(this);
    if (includeDimensions.isYes()) {
        for (Dimension dimension : (List<Dimension>) node.dimensions()) {
            builder.breakToFill(dimension.annotations().isEmpty() ? "" : " ");
            visit(dimension);
        }
    }
    if (includeDimensions.isYes() && !node.dimensions().isEmpty()) {
        builder.close();
    }
}

From source file:com.google.googlejavaformat.java.JavaInputAstVisitor.java

License:Apache License

/**
 * Emit extra dimensions (if any)./*  w  ww .  jav  a 2  s .  c om*/
 * @param plusIndent the extra indentation for the extra dimensions
 * @param extraDimensions the extra {@link Dimension}s
 */
void extraDimensions(Indent plusIndent, List<Dimension> extraDimensions) {
    builder.open(plusIndent);
    for (Dimension extraDimension : extraDimensions) {
        builder.breakToFill(extraDimension.annotations().isEmpty() ? "" : " ");
        visit(extraDimension);
    }
    builder.close();
}

From source file:com.j2swift.ast.DebugASTPrinter.java

License:Apache License

@Override
public boolean visit(Dimension node) {
    if (!node.annotations().isEmpty()) {
        sb.append(' ');
    }//from w w w .  j av  a 2s  .  c o m
    for (Annotation x : node.annotations()) {
        x.accept(this);
        sb.append(' ');
    }
    sb.append("[]");
    return false;
}

From source file:org.codemucker.jmutate.ast.JAstFlattener.java

License:Open Source License

public boolean visit(Dimension node) {
    List annotations = node.annotations();
    if (annotations.size() > 0)
        this.buffer.append(' ');
    visitAnnotationsList(annotations);//from  w  w  w. j  a va2  s  . c o m
    this.buffer.append("[]"); //$NON-NLS-1$
    return false;
}

From source file:org.decojer.cavaj.utils.Expressions.java

License:Open Source License

/**
 * New type.//from  ww  w  .  j av a 2s .c om
 *
 * @param t
 *            type
 * @param context
 *            context
 * @return AST type
 */
@SuppressWarnings("deprecation")
public static Type newType(@Nonnull final T t, @Nonnull final Element context) {
    final AST ast = context.getCu().getAst();
    // handle array first because annot(array()) is special
    if (t.isArray()) {
        if (ast.apiLevel() <= AST.JLS4) {
            final T componentT = t.getComponentT();
            assert componentT != null;
            return ast.newArrayType(newType(componentT, context));
        }
        final T elementT = t.getElementT();
        assert elementT != null;
        for (T checkT = t; checkT != null && checkT.isArray(); checkT = checkT.getComponentT()) {
            if (checkT.isAnnotated()) {
                final ArrayType arrayType = ast.newArrayType(newType(elementT, context));
                final List<Dimension> dimensions = arrayType.dimensions();
                dimensions.clear();
                for (T componentT = t; componentT != null
                        && componentT.isArray(); componentT = componentT.getComponentT()) {
                    final Dimension dimension = ast.newDimension();
                    final List<IExtendedModifier> annotations = dimension.annotations();
                    assert annotations != null;
                    if (componentT.isAnnotated()) {
                        Annotations.decompileAnnotations(componentT, annotations, context);
                    }
                    dimensions.add(dimension);
                }
                return arrayType;
            }
        }
        return ast.newArrayType(newType(elementT, context), t.getDimensions());
    }
    if (t.isAnnotated()) {
        Type type = newType(t.getRawT(), context);
        if (ast.apiLevel() <= AST.JLS4) {
            log.warn("Cannot decompile type annotations for type '" + t + "' in Eclipse AST JLS4!");
            return type;
        }
        // parameterized type is not directly annotateable in Eclipse; but DecoJer thinks the
        // whole type is meant, not just the generic type, hence translate here
        AnnotatableType annotatableType = (AnnotatableType) (type instanceof ParameterizedType
                ? ((ParameterizedType) type).getType()
                : type);
        qualified: if (annotatableType instanceof SimpleType) {
            // direct annotation of qualified types adds the annotations as first element,
            // strange Java spec doesn't allow "@A package.Name" but wants "package.@A Name"
            final Name typeName = ((SimpleType) annotatableType).getName();
            if (!(typeName instanceof QualifiedName)) {
                break qualified;
            }
            final Name qualifier = ((QualifiedName) typeName).getQualifier();
            final SimpleName name = ((QualifiedName) typeName).getName();
            // cannot delete mandory childs, copy them
            annotatableType = ast.newNameQualifiedType((Name) ASTNode.copySubtree(ast, qualifier),
                    (SimpleName) ASTNode.copySubtree(ast, name));
            if (type instanceof ParameterizedType) {
                ((ParameterizedType) type).setType(annotatableType);
            } else {
                type = annotatableType;
            }
        }
        final List<IExtendedModifier> annotations = annotatableType.annotations();
        assert annotations != null;
        Annotations.decompileAnnotations(t, annotations, context);
        return type;
    }
    // doesn't work, now with Dimension (see above): if (t.isArray()) { return
    // ast.newArrayType(newType(t.getComponentT(), contextT)); }
    if (t.isParameterized()) {
        final T genericT = t.getGenericT();
        assert genericT != null;
        final ParameterizedType parameterizedType = ast.newParameterizedType(newType(genericT, context));
        for (final T typeArg : t.getTypeArgs()) {
            assert typeArg != null;
            parameterizedType.typeArguments().add(newType(typeArg, context));
        }
        return parameterizedType;
    }
    if (t.isWildcard()) {
        final T boundT = t.getBoundT();
        if (boundT == null) {
            return ast.newWildcardType();
        }
        if (t.isSubclassOf()) {
            final WildcardType wildcardType = ast.newWildcardType();
            // default...newWildcardType.setUpperBound(true);
            wildcardType.setBound(newType(boundT, context));
            return wildcardType;
        }
        final WildcardType wildcardType = ast.newWildcardType();
        wildcardType.setUpperBound(false);
        wildcardType.setBound(newType(boundT, context));
        return wildcardType;
    }
    if (t.isMulti()) {
        log.warn("Convert type for multi-type '" + t + "'!");
        // prefer boolean for multi-type with 0 or 1, synchronous to newLiteral()!
        // prefer byte before char if no explicit char type given
    }
    if (t.is(T.BOOLEAN)) {
        return ast.newPrimitiveType(PrimitiveType.BOOLEAN);
    }
    if (t.is(T.BYTE)) {
        return ast.newPrimitiveType(PrimitiveType.BYTE);
    }
    if (t.is(T.CHAR)) {
        return ast.newPrimitiveType(PrimitiveType.CHAR);
    }
    if (t.is(T.SHORT)) {
        return ast.newPrimitiveType(PrimitiveType.SHORT);
    }
    if (t.is(T.INT)) {
        return ast.newPrimitiveType(PrimitiveType.INT);
    }
    if (t.is(T.FLOAT)) {
        return ast.newPrimitiveType(PrimitiveType.FLOAT);
    }
    if (t.is(T.LONG)) {
        return ast.newPrimitiveType(PrimitiveType.LONG);
    }
    if (t.is(T.DOUBLE)) {
        return ast.newPrimitiveType(PrimitiveType.DOUBLE);
    }
    if (t.is(T.VOID)) {
        return ast.newPrimitiveType(PrimitiveType.VOID);
    }
    if (t.isQualified()) {
        final T qualifierT = t.getQualifierT();
        assert qualifierT != null : "cannot be null for qualified";
        // could be ParamT etc., not decompileable with name as target;
        // restrict qualifications to really necessary enclosings:
        // t = Outer.Inner.InnerInner, t = Outer.Inner ==> Inner
        final T contextT = context.getT();
        assert contextT != null;
        if (contextT.getFullName().startsWith(qualifierT.getFullName())) {
            // TODO full name has too much info yet (like annotations)
            return ast.newSimpleType(newSimpleName(t.getSimpleIdentifier(), ast));
        }
        return ast.newQualifiedType(newType(qualifierT, context), newSimpleName(t.getSimpleIdentifier(), ast));
    }
    // else fall through...
    return ast.newSimpleType(newTypeName(t, context));
}