diff options
Diffstat (limited to 'javaparser-symbol-solver-testing/src/test/test_sourcecode/javaparser_new_src/javaparser-core/com/github/javaparser/ast/type/ArrayType.java')
-rw-r--r-- | javaparser-symbol-solver-testing/src/test/test_sourcecode/javaparser_new_src/javaparser-core/com/github/javaparser/ast/type/ArrayType.java | 86 |
1 files changed, 86 insertions, 0 deletions
diff --git a/javaparser-symbol-solver-testing/src/test/test_sourcecode/javaparser_new_src/javaparser-core/com/github/javaparser/ast/type/ArrayType.java b/javaparser-symbol-solver-testing/src/test/test_sourcecode/javaparser_new_src/javaparser-core/com/github/javaparser/ast/type/ArrayType.java new file mode 100644 index 000000000..babf2a5d7 --- /dev/null +++ b/javaparser-symbol-solver-testing/src/test/test_sourcecode/javaparser_new_src/javaparser-core/com/github/javaparser/ast/type/ArrayType.java @@ -0,0 +1,86 @@ +package com.github.javaparser.ast.type; + +import com.github.javaparser.Range; +import com.github.javaparser.ast.ArrayBracketPair; +import com.github.javaparser.ast.expr.AnnotationExpr; +import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import com.github.javaparser.utils.Pair; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +/** + * To indicate that a type is an array, it gets wrapped in an ArrayType for every array level it has. + * So, int[][] becomes ArrayType(ArrayType(int)). + */ +public class ArrayType extends ReferenceType<ArrayType> implements NodeWithAnnotations<ArrayType> { + private Type componentType; + + public ArrayType(Type componentType, List<AnnotationExpr> annotations) { + setComponentType(componentType); + setAnnotations(annotations); + } + + public ArrayType(Range range, Type componentType, List<AnnotationExpr> annotations) { + super(range); + setComponentType(componentType); + setAnnotations(annotations); + } + + @Override public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + public Type getComponentType() { + return componentType; + } + + public ArrayType setComponentType(final Type type) { + this.componentType = type; + setAsParentNodeOf(this.componentType); + return this; + } + + /** + * Takes lists of arrayBracketPairs, assumes the lists are ordered left to right and the pairs are ordered left to right, mirroring the actual code. + * The type gets wrapped in ArrayTypes so that the outermost ArrayType corresponds to the rightmost ArrayBracketPair. + */ + @SafeVarargs + public static Type wrapInArrayTypes(Type type, List<ArrayBracketPair>... arrayBracketPairLists) { + for (int i = arrayBracketPairLists.length - 1; i >= 0; i--) { + final List<ArrayBracketPair> arrayBracketPairList = arrayBracketPairLists[i]; + if (arrayBracketPairList != null) { + for (int j = arrayBracketPairList.size() - 1; j >= 0; j--) { + type = new ArrayType(type, arrayBracketPairList.get(j).getAnnotations()); + } + } + } + return type; + } + + /** + * Takes a type that may be an ArrayType. Unwraps ArrayTypes until the element type is found. + * + * @return a pair of the element type, and the unwrapped ArrayTypes, if any. + */ + public static Pair<Type, List<ArrayBracketPair>> unwrapArrayTypes(Type type) { + final List<ArrayBracketPair> arrayBracketPairs = new ArrayList<>(); + while (type instanceof ArrayType) { + ArrayType arrayType = (ArrayType) type; + arrayBracketPairs.add(new ArrayBracketPair(Range.UNKNOWN, arrayType.getAnnotations())); + type = arrayType.getComponentType(); + } + return new Pair<>(type, arrayBracketPairs); + } + + public static ArrayType arrayOf(Type type, AnnotationExpr... annotations) { + return new ArrayType(type, Arrays.asList(annotations)); + } +} |