diff options
Diffstat (limited to 'javaparser-core/src/main/java/com/github/javaparser/ast/expr')
38 files changed, 7681 insertions, 0 deletions
diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AnnotationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AnnotationExpr.java new file mode 100644 index 000000000..31c70fb5a --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AnnotationExpr.java @@ -0,0 +1,137 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.nodeTypes.NodeWithName; +import com.github.javaparser.ast.observer.ObservableProperty; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.AnnotationExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * A base class for the different types of annotations. + * + * @author Julio Vilmar Gesser + */ +public abstract class AnnotationExpr extends Expression implements NodeWithName<AnnotationExpr> { + + protected Name name; + + public AnnotationExpr() { + this(null, new Name()); + } + + @AllFieldsConstructor + public AnnotationExpr(Name name) { + this(null, name); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public AnnotationExpr(TokenRange tokenRange, Name name) { + super(tokenRange); + setName(name); + customInitialization(); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Name getName() { + return name; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public AnnotationExpr setName(final Name name) { + assertNotNull(name); + if (name == this.name) { + return (AnnotationExpr) this; + } + notifyPropertyChange(ObservableProperty.NAME, this.name, name); + if (this.name != null) + this.name.setParentNode(null); + this.name = name; + setAsParentNodeOf(name); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public AnnotationExpr clone() { + return (AnnotationExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public AnnotationExprMetaModel getMetaModel() { + return JavaParserMetaModel.annotationExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == name) { + setName((Name) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isAnnotationExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public AnnotationExpr asAnnotationExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifAnnotationExpr(Consumer<AnnotationExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<AnnotationExpr> toAnnotationExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayAccessExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayAccessExpr.java new file mode 100644 index 000000000..6945dd9ae --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayAccessExpr.java @@ -0,0 +1,177 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.ArrayAccessExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * Array brackets [] being used to get a value from an array. + * In <br/><code>getNames()[15*15]</code> the name expression is getNames() and the index expression is 15*15. + * + * @author Julio Vilmar Gesser + */ +public final class ArrayAccessExpr extends Expression { + + private Expression name; + + private Expression index; + + public ArrayAccessExpr() { + this(null, new NameExpr(), new IntegerLiteralExpr()); + } + + @AllFieldsConstructor + public ArrayAccessExpr(Expression name, Expression index) { + this(null, name, index); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public ArrayAccessExpr(TokenRange tokenRange, Expression name, Expression index) { + super(tokenRange); + setName(name); + setIndex(index); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getIndex() { + return index; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getName() { + return name; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ArrayAccessExpr setIndex(final Expression index) { + assertNotNull(index); + if (index == this.index) { + return (ArrayAccessExpr) this; + } + notifyPropertyChange(ObservableProperty.INDEX, this.index, index); + if (this.index != null) + this.index.setParentNode(null); + this.index = index; + setAsParentNodeOf(index); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ArrayAccessExpr setName(final Expression name) { + assertNotNull(name); + if (name == this.name) { + return (ArrayAccessExpr) this; + } + notifyPropertyChange(ObservableProperty.NAME, this.name, name); + if (this.name != null) + this.name.setParentNode(null); + this.name = name; + setAsParentNodeOf(name); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public ArrayAccessExpr clone() { + return (ArrayAccessExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public ArrayAccessExprMetaModel getMetaModel() { + return JavaParserMetaModel.arrayAccessExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == index) { + setIndex((Expression) replacementNode); + return true; + } + if (node == name) { + setName((Expression) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isArrayAccessExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ArrayAccessExpr asArrayAccessExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifArrayAccessExpr(Consumer<ArrayAccessExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ArrayAccessExpr> toArrayAccessExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayCreationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayCreationExpr.java new file mode 100644 index 000000000..509925803 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayCreationExpr.java @@ -0,0 +1,281 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.Range; +import com.github.javaparser.ast.*; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.type.ArrayType; +import com.github.javaparser.ast.type.ClassOrInterfaceType; +import com.github.javaparser.ast.type.Type; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import com.github.javaparser.metamodel.ArrayCreationExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import com.github.javaparser.metamodel.NonEmptyProperty; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import static com.github.javaparser.JavaParser.parseType; +import static com.github.javaparser.utils.Utils.assertNotNull; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import com.github.javaparser.ast.Node; +import com.github.javaparser.metamodel.OptionalProperty; +import java.util.function.Consumer; + +/** + * <code>new int[5][4][][]</code> or <code>new int[][]{{1},{2,3}}</code>. + * + * <br/>"int" is the element type. + * <br/>All the brackets are stored in the levels field, from left to right. + * + * @author Julio Vilmar Gesser + */ +public final class ArrayCreationExpr extends Expression { + + @NonEmptyProperty + private NodeList<ArrayCreationLevel> levels; + + private Type elementType; + + @OptionalProperty + private ArrayInitializerExpr initializer; + + public ArrayCreationExpr() { + this(null, new ClassOrInterfaceType(), new NodeList<>(), new ArrayInitializerExpr()); + } + + @AllFieldsConstructor + public ArrayCreationExpr(Type elementType, NodeList<ArrayCreationLevel> levels, ArrayInitializerExpr initializer) { + this(null, elementType, levels, initializer); + } + + public ArrayCreationExpr(Type elementType) { + this(null, elementType, new NodeList<>(), new ArrayInitializerExpr()); + } + + /** + * @deprecated range shouldn't be in utility constructors. + */ + @Deprecated + public ArrayCreationExpr(Range range, Type elementType) { + this(null, elementType, new NodeList<>(), new ArrayInitializerExpr()); + setRange(range); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public ArrayCreationExpr(TokenRange tokenRange, Type elementType, NodeList<ArrayCreationLevel> levels, ArrayInitializerExpr initializer) { + super(tokenRange); + setElementType(elementType); + setLevels(levels); + setInitializer(initializer); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Optional<ArrayInitializerExpr> getInitializer() { + return Optional.ofNullable(initializer); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Type getElementType() { + return elementType; + } + + /** + * Sets the initializer + * + * @param initializer the initializer, can be null + * @return this, the ArrayCreationExpr + */ + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ArrayCreationExpr setInitializer(final ArrayInitializerExpr initializer) { + if (initializer == this.initializer) { + return (ArrayCreationExpr) this; + } + notifyPropertyChange(ObservableProperty.INITIALIZER, this.initializer, initializer); + if (this.initializer != null) + this.initializer.setParentNode(null); + this.initializer = initializer; + setAsParentNodeOf(initializer); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ArrayCreationExpr setElementType(final Type elementType) { + assertNotNull(elementType); + if (elementType == this.elementType) { + return (ArrayCreationExpr) this; + } + notifyPropertyChange(ObservableProperty.ELEMENT_TYPE, this.elementType, elementType); + if (this.elementType != null) + this.elementType.setParentNode(null); + this.elementType = elementType; + setAsParentNodeOf(elementType); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public NodeList<ArrayCreationLevel> getLevels() { + return levels; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ArrayCreationExpr setLevels(final NodeList<ArrayCreationLevel> levels) { + assertNotNull(levels); + if (levels == this.levels) { + return (ArrayCreationExpr) this; + } + notifyPropertyChange(ObservableProperty.LEVELS, this.levels, levels); + if (this.levels != null) + this.levels.setParentNode(null); + this.levels = levels; + setAsParentNodeOf(levels); + return this; + } + + /** + * Takes the element type and wraps it in an ArrayType for every array creation level. + */ + public Type createdType() { + Type result = elementType; + for (int i = 0; i < levels.size(); i++) { + result = new ArrayType(result, ArrayType.Origin.TYPE, new NodeList<>()); + } + return result; + } + + /** + * Sets this type to this class and try to import it to the {@link CompilationUnit} if needed + * + * @param typeClass the type + * @return this + */ + public ArrayCreationExpr setElementType(Class<?> typeClass) { + tryAddImportToParentCompilationUnit(typeClass); + return setElementType(parseType(typeClass.getSimpleName())); + } + + public ArrayCreationExpr setElementType(final String type) { + return setElementType(parseType(type)); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + if (initializer != null) { + if (node == initializer) { + removeInitializer(); + return true; + } + } + for (int i = 0; i < levels.size(); i++) { + if (levels.get(i) == node) { + levels.remove(i); + return true; + } + } + return super.remove(node); + } + + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public ArrayCreationExpr removeInitializer() { + return setInitializer((ArrayInitializerExpr) null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public ArrayCreationExpr clone() { + return (ArrayCreationExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public ArrayCreationExprMetaModel getMetaModel() { + return JavaParserMetaModel.arrayCreationExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == elementType) { + setElementType((Type) replacementNode); + return true; + } + if (initializer != null) { + if (node == initializer) { + setInitializer((ArrayInitializerExpr) replacementNode); + return true; + } + } + for (int i = 0; i < levels.size(); i++) { + if (levels.get(i) == node) { + levels.set(i, (ArrayCreationLevel) replacementNode); + return true; + } + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isArrayCreationExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ArrayCreationExpr asArrayCreationExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifArrayCreationExpr(Consumer<ArrayCreationExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ArrayCreationExpr> toArrayCreationExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayInitializerExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayInitializerExpr.java new file mode 100644 index 000000000..d585a1833 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayInitializerExpr.java @@ -0,0 +1,164 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Arrays; +import java.util.List; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.ArrayInitializerExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * The initialization of an array. In the following sample, the outer { } is an ArrayInitializerExpr. + * It has two expressions inside: two ArrayInitializerExprs. + * These have two expressions each, one has 1 and 1, the other two and two. + * <br/><code>new int[][]{{1, 1}, {2, 2}};</code> + * + * @author Julio Vilmar Gesser + */ +public final class ArrayInitializerExpr extends Expression { + + private NodeList<Expression> values; + + public ArrayInitializerExpr() { + this(null, new NodeList<>()); + } + + @AllFieldsConstructor + public ArrayInitializerExpr(NodeList<Expression> values) { + this(null, values); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public ArrayInitializerExpr(TokenRange tokenRange, NodeList<Expression> values) { + super(tokenRange); + setValues(values); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public NodeList<Expression> getValues() { + return values; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ArrayInitializerExpr setValues(final NodeList<Expression> values) { + assertNotNull(values); + if (values == this.values) { + return (ArrayInitializerExpr) this; + } + notifyPropertyChange(ObservableProperty.VALUES, this.values, values); + if (this.values != null) + this.values.setParentNode(null); + this.values = values; + setAsParentNodeOf(values); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + for (int i = 0; i < values.size(); i++) { + if (values.get(i) == node) { + values.remove(i); + return true; + } + } + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public ArrayInitializerExpr clone() { + return (ArrayInitializerExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public ArrayInitializerExprMetaModel getMetaModel() { + return JavaParserMetaModel.arrayInitializerExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + for (int i = 0; i < values.size(); i++) { + if (values.get(i) == node) { + values.set(i, (Expression) replacementNode); + return true; + } + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isArrayInitializerExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ArrayInitializerExpr asArrayInitializerExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifArrayInitializerExpr(Consumer<ArrayInitializerExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ArrayInitializerExpr> toArrayInitializerExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AssignExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AssignExpr.java new file mode 100644 index 000000000..fbb46874d --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AssignExpr.java @@ -0,0 +1,256 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.AssignExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import com.github.javaparser.printer.Printable; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * An assignment expression. It supports the operators that are found the the AssignExpr.Operator enum. + * <br/><code>a=5</code> + * <br/><code>time+=500</code> + * <br/><code>watch.time+=500</code> + * <br/><code>(((time)))=100*60</code> + * <br/><code>peanut[a]=true</code> + * + * @author Julio Vilmar Gesser + */ +public final class AssignExpr extends Expression { + + public enum Operator implements Printable { + + ASSIGN("="), + PLUS("+="), + MINUS("-="), + MULTIPLY("*="), + DIVIDE("/="), + BINARY_AND("&="), + BINARY_OR("|="), + XOR("^="), + REMAINDER("%="), + LEFT_SHIFT("<<="), + SIGNED_RIGHT_SHIFT(">>="), + UNSIGNED_RIGHT_SHIFT(">>>="); + + private final String codeRepresentation; + + Operator(String codeRepresentation) { + this.codeRepresentation = codeRepresentation; + } + + public String asString() { + return codeRepresentation; + } + + public Optional<BinaryExpr.Operator> toBinaryOperator() { + switch(this) { + case PLUS: + return Optional.of(BinaryExpr.Operator.PLUS); + case MINUS: + return Optional.of(BinaryExpr.Operator.MINUS); + case MULTIPLY: + return Optional.of(BinaryExpr.Operator.MULTIPLY); + case DIVIDE: + return Optional.of(BinaryExpr.Operator.DIVIDE); + case BINARY_AND: + return Optional.of(BinaryExpr.Operator.BINARY_AND); + case BINARY_OR: + return Optional.of(BinaryExpr.Operator.BINARY_OR); + case XOR: + return Optional.of(BinaryExpr.Operator.XOR); + case REMAINDER: + return Optional.of(BinaryExpr.Operator.REMAINDER); + case LEFT_SHIFT: + return Optional.of(BinaryExpr.Operator.LEFT_SHIFT); + case SIGNED_RIGHT_SHIFT: + return Optional.of(BinaryExpr.Operator.SIGNED_RIGHT_SHIFT); + case UNSIGNED_RIGHT_SHIFT: + return Optional.of(BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT); + default: + return Optional.empty(); + } + } + } + + private Expression target; + + private Expression value; + + private Operator operator; + + public AssignExpr() { + this(null, new NameExpr(), new StringLiteralExpr(), Operator.ASSIGN); + } + + @AllFieldsConstructor + public AssignExpr(Expression target, Expression value, Operator operator) { + this(null, target, value, operator); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public AssignExpr(TokenRange tokenRange, Expression target, Expression value, Operator operator) { + super(tokenRange); + setTarget(target); + setValue(value); + setOperator(operator); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Operator getOperator() { + return operator; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getTarget() { + return target; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getValue() { + return value; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public AssignExpr setOperator(final Operator operator) { + assertNotNull(operator); + if (operator == this.operator) { + return (AssignExpr) this; + } + notifyPropertyChange(ObservableProperty.OPERATOR, this.operator, operator); + this.operator = operator; + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public AssignExpr setTarget(final Expression target) { + assertNotNull(target); + if (target == this.target) { + return (AssignExpr) this; + } + notifyPropertyChange(ObservableProperty.TARGET, this.target, target); + if (this.target != null) + this.target.setParentNode(null); + this.target = target; + setAsParentNodeOf(target); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public AssignExpr setValue(final Expression value) { + assertNotNull(value); + if (value == this.value) { + return (AssignExpr) this; + } + notifyPropertyChange(ObservableProperty.VALUE, this.value, value); + if (this.value != null) + this.value.setParentNode(null); + this.value = value; + setAsParentNodeOf(value); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public AssignExpr clone() { + return (AssignExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public AssignExprMetaModel getMetaModel() { + return JavaParserMetaModel.assignExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == target) { + setTarget((Expression) replacementNode); + return true; + } + if (node == value) { + setValue((Expression) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isAssignExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public AssignExpr asAssignExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifAssignExpr(Consumer<AssignExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<AssignExpr> toAssignExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BinaryExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BinaryExpr.java new file mode 100644 index 000000000..5ec79c0af --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BinaryExpr.java @@ -0,0 +1,261 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.BinaryExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import com.github.javaparser.printer.Printable; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * An expression with an expression on the left, an expression on the right, and an operator in the middle. + * It supports the operators that are found the the BinaryExpr.Operator enum. + * <br/><code>a && b</code> + * <br/><code>155 * 33</code> + * + * @author Julio Vilmar Gesser + */ +public final class BinaryExpr extends Expression { + + public enum Operator implements Printable { + + OR("||"), + AND("&&"), + BINARY_OR("|"), + BINARY_AND("&"), + XOR("^"), + EQUALS("=="), + NOT_EQUALS("!="), + LESS("<"), + GREATER(">"), + LESS_EQUALS("<="), + GREATER_EQUALS(">="), + LEFT_SHIFT("<<"), + SIGNED_RIGHT_SHIFT(">>"), + UNSIGNED_RIGHT_SHIFT(">>>"), + PLUS("+"), + MINUS("-"), + MULTIPLY("*"), + DIVIDE("/"), + REMAINDER("%"); + + private final String codeRepresentation; + + Operator(String codeRepresentation) { + this.codeRepresentation = codeRepresentation; + } + + public String asString() { + return codeRepresentation; + } + + public Optional<AssignExpr.Operator> toAssignOperator() { + switch(this) { + case BINARY_OR: + return Optional.of(AssignExpr.Operator.BINARY_OR); + case BINARY_AND: + return Optional.of(AssignExpr.Operator.BINARY_AND); + case XOR: + return Optional.of(AssignExpr.Operator.XOR); + case LEFT_SHIFT: + return Optional.of(AssignExpr.Operator.LEFT_SHIFT); + case SIGNED_RIGHT_SHIFT: + return Optional.of(AssignExpr.Operator.SIGNED_RIGHT_SHIFT); + case UNSIGNED_RIGHT_SHIFT: + return Optional.of(AssignExpr.Operator.UNSIGNED_RIGHT_SHIFT); + case PLUS: + return Optional.of(AssignExpr.Operator.PLUS); + case MINUS: + return Optional.of(AssignExpr.Operator.MINUS); + case MULTIPLY: + return Optional.of(AssignExpr.Operator.MULTIPLY); + case DIVIDE: + return Optional.of(AssignExpr.Operator.DIVIDE); + case REMAINDER: + return Optional.of(AssignExpr.Operator.REMAINDER); + default: + return Optional.empty(); + } + } + } + + private Expression left; + + private Expression right; + + private Operator operator; + + public BinaryExpr() { + this(null, new BooleanLiteralExpr(), new BooleanLiteralExpr(), Operator.EQUALS); + } + + @AllFieldsConstructor + public BinaryExpr(Expression left, Expression right, Operator operator) { + this(null, left, right, operator); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public BinaryExpr(TokenRange tokenRange, Expression left, Expression right, Operator operator) { + super(tokenRange); + setLeft(left); + setRight(right); + setOperator(operator); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getLeft() { + return left; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Operator getOperator() { + return operator; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getRight() { + return right; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public BinaryExpr setLeft(final Expression left) { + assertNotNull(left); + if (left == this.left) { + return (BinaryExpr) this; + } + notifyPropertyChange(ObservableProperty.LEFT, this.left, left); + if (this.left != null) + this.left.setParentNode(null); + this.left = left; + setAsParentNodeOf(left); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public BinaryExpr setOperator(final Operator operator) { + assertNotNull(operator); + if (operator == this.operator) { + return (BinaryExpr) this; + } + notifyPropertyChange(ObservableProperty.OPERATOR, this.operator, operator); + this.operator = operator; + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public BinaryExpr setRight(final Expression right) { + assertNotNull(right); + if (right == this.right) { + return (BinaryExpr) this; + } + notifyPropertyChange(ObservableProperty.RIGHT, this.right, right); + if (this.right != null) + this.right.setParentNode(null); + this.right = right; + setAsParentNodeOf(right); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public BinaryExpr clone() { + return (BinaryExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public BinaryExprMetaModel getMetaModel() { + return JavaParserMetaModel.binaryExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == left) { + setLeft((Expression) replacementNode); + return true; + } + if (node == right) { + setRight((Expression) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isBinaryExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public BinaryExpr asBinaryExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifBinaryExpr(Consumer<BinaryExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<BinaryExpr> toBinaryExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BooleanLiteralExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BooleanLiteralExpr.java new file mode 100644 index 000000000..4be43b298 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BooleanLiteralExpr.java @@ -0,0 +1,143 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.BooleanLiteralExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * The boolean literals. + * <br/><code>true</code> + * <br/><code>false</code> + * + * @author Julio Vilmar Gesser + */ +public final class BooleanLiteralExpr extends LiteralExpr { + + private boolean value; + + public BooleanLiteralExpr() { + this(null, false); + } + + @AllFieldsConstructor + public BooleanLiteralExpr(boolean value) { + this(null, value); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public BooleanLiteralExpr(TokenRange tokenRange, boolean value) { + super(tokenRange); + setValue(value); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public boolean getValue() { + return value; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public BooleanLiteralExpr setValue(final boolean value) { + if (value == this.value) { + return (BooleanLiteralExpr) this; + } + notifyPropertyChange(ObservableProperty.VALUE, this.value, value); + this.value = value; + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public BooleanLiteralExpr clone() { + return (BooleanLiteralExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public BooleanLiteralExprMetaModel getMetaModel() { + return JavaParserMetaModel.booleanLiteralExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isBooleanLiteralExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public BooleanLiteralExpr asBooleanLiteralExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifBooleanLiteralExpr(Consumer<BooleanLiteralExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<BooleanLiteralExpr> toBooleanLiteralExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/CastExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/CastExpr.java new file mode 100644 index 000000000..174d24cad --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/CastExpr.java @@ -0,0 +1,180 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.nodeTypes.NodeWithExpression; +import com.github.javaparser.ast.nodeTypes.NodeWithType; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.type.ClassOrInterfaceType; +import com.github.javaparser.ast.type.Type; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.CastExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * A typecast. The (long) in <code>(long)15</code> + * + * @author Julio Vilmar Gesser + */ +public final class CastExpr extends Expression implements NodeWithType<CastExpr, Type>, NodeWithExpression<CastExpr> { + + private Type type; + + private Expression expression; + + public CastExpr() { + this(null, new ClassOrInterfaceType(), new NameExpr()); + } + + @AllFieldsConstructor + public CastExpr(Type type, Expression expression) { + this(null, type, expression); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public CastExpr(TokenRange tokenRange, Type type, Expression expression) { + super(tokenRange); + setType(type); + setExpression(expression); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getExpression() { + return expression; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Type getType() { + return type; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public CastExpr setExpression(final Expression expression) { + assertNotNull(expression); + if (expression == this.expression) { + return (CastExpr) this; + } + notifyPropertyChange(ObservableProperty.EXPRESSION, this.expression, expression); + if (this.expression != null) + this.expression.setParentNode(null); + this.expression = expression; + setAsParentNodeOf(expression); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public CastExpr setType(final Type type) { + assertNotNull(type); + if (type == this.type) { + return (CastExpr) this; + } + notifyPropertyChange(ObservableProperty.TYPE, this.type, type); + if (this.type != null) + this.type.setParentNode(null); + this.type = type; + setAsParentNodeOf(type); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public CastExpr clone() { + return (CastExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public CastExprMetaModel getMetaModel() { + return JavaParserMetaModel.castExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == expression) { + setExpression((Expression) replacementNode); + return true; + } + if (node == type) { + setType((Type) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isCastExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public CastExpr asCastExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifCastExpr(Consumer<CastExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<CastExpr> toCastExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/CharLiteralExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/CharLiteralExpr.java new file mode 100644 index 000000000..bc2db0023 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/CharLiteralExpr.java @@ -0,0 +1,163 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import com.github.javaparser.metamodel.CharLiteralExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import com.github.javaparser.utils.StringEscapeUtils; +import com.github.javaparser.utils.Utils; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * A literal character. + * <br/><code>'a'</code> + * <br/><code>'\t'</code> + * <br/><code>'Ω'</code> + * <br/><code>'\177'</code> + * <br/><code>'💩'</code> + * + * @author Julio Vilmar Gesser + */ +public final class CharLiteralExpr extends LiteralStringValueExpr { + + public CharLiteralExpr() { + this(null, "?"); + } + + @AllFieldsConstructor + public CharLiteralExpr(String value) { + this(null, value); + } + + /** + * Constructs a CharLiteralExpr with given escaped character. + * + * @param value a char + */ + public CharLiteralExpr(char value) { + this(null, StringEscapeUtils.escapeJava(String.valueOf(value))); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public CharLiteralExpr(TokenRange tokenRange, String value) { + super(tokenRange, value); + customInitialization(); + } + + /** + * Utility method that creates a new StringLiteralExpr. Escapes EOL characters. + */ + public static CharLiteralExpr escape(String string) { + return new CharLiteralExpr(Utils.escapeEndOfLines(string)); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + /** + * @return the unescaped value character of this literal + */ + public char asChar() { + return StringEscapeUtils.unescapeJava(value).charAt(0); + } + + /** + * Sets the given char as the literal value + * + * @param value a char + * @return this expression + */ + public CharLiteralExpr setChar(char value) { + this.value = String.valueOf(value); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public CharLiteralExpr clone() { + return (CharLiteralExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public CharLiteralExprMetaModel getMetaModel() { + return JavaParserMetaModel.charLiteralExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isCharLiteralExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public CharLiteralExpr asCharLiteralExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifCharLiteralExpr(Consumer<CharLiteralExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<CharLiteralExpr> toCharLiteralExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ClassExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ClassExpr.java new file mode 100644 index 000000000..729bd4ff2 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ClassExpr.java @@ -0,0 +1,154 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.nodeTypes.NodeWithType; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.type.ClassOrInterfaceType; +import com.github.javaparser.ast.type.Type; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.ClassExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * Defines an expression that accesses the class of a type. + * <br/><code>Object.class</code> + * + * @author Julio Vilmar Gesser + */ +public final class ClassExpr extends Expression implements NodeWithType<ClassExpr, Type> { + + private Type type; + + public ClassExpr() { + this(null, new ClassOrInterfaceType()); + } + + @AllFieldsConstructor + public ClassExpr(Type type) { + this(null, type); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public ClassExpr(TokenRange tokenRange, Type type) { + super(tokenRange); + setType(type); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Type getType() { + return type; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ClassExpr setType(final Type type) { + assertNotNull(type); + if (type == this.type) { + return (ClassExpr) this; + } + notifyPropertyChange(ObservableProperty.TYPE, this.type, type); + if (this.type != null) + this.type.setParentNode(null); + this.type = type; + setAsParentNodeOf(type); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public ClassExpr clone() { + return (ClassExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public ClassExprMetaModel getMetaModel() { + return JavaParserMetaModel.classExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == type) { + setType((Type) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isClassExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ClassExpr asClassExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifClassExpr(Consumer<ClassExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ClassExpr> toClassExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ConditionalExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ConditionalExpr.java new file mode 100644 index 000000000..bdc50a061 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ConditionalExpr.java @@ -0,0 +1,204 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.nodeTypes.NodeWithCondition; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.ConditionalExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * The ternary conditional expression. + * In <code>b==0?x:y</code>, b==0 is the condition, x is thenExpr, and y is elseExpr. + * + * @author Julio Vilmar Gesser + */ +public final class ConditionalExpr extends Expression implements NodeWithCondition<ConditionalExpr> { + + private Expression condition; + + private Expression thenExpr; + + private Expression elseExpr; + + public ConditionalExpr() { + this(null, new BooleanLiteralExpr(), new StringLiteralExpr(), new StringLiteralExpr()); + } + + @AllFieldsConstructor + public ConditionalExpr(Expression condition, Expression thenExpr, Expression elseExpr) { + this(null, condition, thenExpr, elseExpr); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public ConditionalExpr(TokenRange tokenRange, Expression condition, Expression thenExpr, Expression elseExpr) { + super(tokenRange); + setCondition(condition); + setThenExpr(thenExpr); + setElseExpr(elseExpr); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getCondition() { + return condition; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getElseExpr() { + return elseExpr; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getThenExpr() { + return thenExpr; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ConditionalExpr setCondition(final Expression condition) { + assertNotNull(condition); + if (condition == this.condition) { + return (ConditionalExpr) this; + } + notifyPropertyChange(ObservableProperty.CONDITION, this.condition, condition); + if (this.condition != null) + this.condition.setParentNode(null); + this.condition = condition; + setAsParentNodeOf(condition); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ConditionalExpr setElseExpr(final Expression elseExpr) { + assertNotNull(elseExpr); + if (elseExpr == this.elseExpr) { + return (ConditionalExpr) this; + } + notifyPropertyChange(ObservableProperty.ELSE_EXPR, this.elseExpr, elseExpr); + if (this.elseExpr != null) + this.elseExpr.setParentNode(null); + this.elseExpr = elseExpr; + setAsParentNodeOf(elseExpr); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ConditionalExpr setThenExpr(final Expression thenExpr) { + assertNotNull(thenExpr); + if (thenExpr == this.thenExpr) { + return (ConditionalExpr) this; + } + notifyPropertyChange(ObservableProperty.THEN_EXPR, this.thenExpr, thenExpr); + if (this.thenExpr != null) + this.thenExpr.setParentNode(null); + this.thenExpr = thenExpr; + setAsParentNodeOf(thenExpr); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public ConditionalExpr clone() { + return (ConditionalExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public ConditionalExprMetaModel getMetaModel() { + return JavaParserMetaModel.conditionalExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == condition) { + setCondition((Expression) replacementNode); + return true; + } + if (node == elseExpr) { + setElseExpr((Expression) replacementNode); + return true; + } + if (node == thenExpr) { + setThenExpr((Expression) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isConditionalExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ConditionalExpr asConditionalExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifConditionalExpr(Consumer<ConditionalExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ConditionalExpr> toConditionalExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/DoubleLiteralExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/DoubleLiteralExpr.java new file mode 100644 index 000000000..007fdf320 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/DoubleLiteralExpr.java @@ -0,0 +1,141 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import com.github.javaparser.metamodel.DoubleLiteralExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * A float or a double constant. This value is stored exactly as found in the source. + * <br/><code>100.1f</code> + * <br/><code>23958D</code> + * <br/><code>0x4.5p1f</code> + * + * @author Julio Vilmar Gesser + */ +public final class DoubleLiteralExpr extends LiteralStringValueExpr { + + public DoubleLiteralExpr() { + this(null, "0"); + } + + @AllFieldsConstructor + public DoubleLiteralExpr(final String value) { + this(null, value); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public DoubleLiteralExpr(TokenRange tokenRange, String value) { + super(tokenRange, value); + customInitialization(); + } + + public DoubleLiteralExpr(final double value) { + this(null, String.valueOf(value)); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + /** + * @return the literal value as a double + */ + public double asDouble() { + return Double.parseDouble(value); + } + + public DoubleLiteralExpr setDouble(double value) { + this.value = String.valueOf(value); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public DoubleLiteralExpr clone() { + return (DoubleLiteralExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public DoubleLiteralExprMetaModel getMetaModel() { + return JavaParserMetaModel.doubleLiteralExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isDoubleLiteralExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public DoubleLiteralExpr asDoubleLiteralExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifDoubleLiteralExpr(Consumer<DoubleLiteralExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<DoubleLiteralExpr> toDoubleLiteralExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/EnclosedExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/EnclosedExpr.java new file mode 100644 index 000000000..c3d56d887 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/EnclosedExpr.java @@ -0,0 +1,162 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.EnclosedExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import static com.github.javaparser.utils.Utils.assertNotNull; +import java.util.function.Consumer; + +/** + * An expression between ( ). + * <br/><code>(1+1)</code> + * + * @author Julio Vilmar Gesser + */ +public final class EnclosedExpr extends Expression { + + private Expression inner; + + public EnclosedExpr() { + this(null, new StringLiteralExpr()); + } + + @AllFieldsConstructor + public EnclosedExpr(final Expression inner) { + this(null, inner); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public EnclosedExpr(TokenRange tokenRange, Expression inner) { + super(tokenRange); + setInner(inner); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getInner() { + return inner; + } + + /** + * Sets the inner expression + * + * @param inner the inner expression, can be null + * @return this, the EnclosedExpr + */ + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public EnclosedExpr setInner(final Expression inner) { + assertNotNull(inner); + if (inner == this.inner) { + return (EnclosedExpr) this; + } + notifyPropertyChange(ObservableProperty.INNER, this.inner, inner); + if (this.inner != null) + this.inner.setParentNode(null); + this.inner = inner; + setAsParentNodeOf(inner); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public EnclosedExpr removeInner() { + return setInner((Expression) null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public EnclosedExpr clone() { + return (EnclosedExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public EnclosedExprMetaModel getMetaModel() { + return JavaParserMetaModel.enclosedExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == inner) { + setInner((Expression) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isEnclosedExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public EnclosedExpr asEnclosedExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifEnclosedExpr(Consumer<EnclosedExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<EnclosedExpr> toEnclosedExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/Expression.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/Expression.java new file mode 100644 index 000000000..de9e52b4c --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/Expression.java @@ -0,0 +1,733 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.ExpressionMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import com.github.javaparser.resolution.types.ResolvedType; +import java.util.function.Consumer; +import static com.github.javaparser.utils.CodeGenerationUtils.f; +import java.util.Optional; + +/** + * A base class for all expressions. + * + * @author Julio Vilmar Gesser + */ +public abstract class Expression extends Node { + + @AllFieldsConstructor + public Expression() { + this(null); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public Expression(TokenRange tokenRange) { + super(tokenRange); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public Expression clone() { + return (Expression) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public ExpressionMetaModel getMetaModel() { + return JavaParserMetaModel.expressionMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + return super.replace(node, replacementNode); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isAnnotationExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public AnnotationExpr asAnnotationExpr() { + throw new IllegalStateException(f("%s is not an AnnotationExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isArrayAccessExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ArrayAccessExpr asArrayAccessExpr() { + throw new IllegalStateException(f("%s is not an ArrayAccessExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isArrayCreationExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ArrayCreationExpr asArrayCreationExpr() { + throw new IllegalStateException(f("%s is not an ArrayCreationExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isArrayInitializerExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ArrayInitializerExpr asArrayInitializerExpr() { + throw new IllegalStateException(f("%s is not an ArrayInitializerExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isAssignExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public AssignExpr asAssignExpr() { + throw new IllegalStateException(f("%s is not an AssignExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isBinaryExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public BinaryExpr asBinaryExpr() { + throw new IllegalStateException(f("%s is not an BinaryExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isBooleanLiteralExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public BooleanLiteralExpr asBooleanLiteralExpr() { + throw new IllegalStateException(f("%s is not an BooleanLiteralExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isCastExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public CastExpr asCastExpr() { + throw new IllegalStateException(f("%s is not an CastExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isCharLiteralExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public CharLiteralExpr asCharLiteralExpr() { + throw new IllegalStateException(f("%s is not an CharLiteralExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isClassExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ClassExpr asClassExpr() { + throw new IllegalStateException(f("%s is not an ClassExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isConditionalExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ConditionalExpr asConditionalExpr() { + throw new IllegalStateException(f("%s is not an ConditionalExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isDoubleLiteralExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public DoubleLiteralExpr asDoubleLiteralExpr() { + throw new IllegalStateException(f("%s is not an DoubleLiteralExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isEnclosedExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public EnclosedExpr asEnclosedExpr() { + throw new IllegalStateException(f("%s is not an EnclosedExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isFieldAccessExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public FieldAccessExpr asFieldAccessExpr() { + throw new IllegalStateException(f("%s is not an FieldAccessExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isInstanceOfExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public InstanceOfExpr asInstanceOfExpr() { + throw new IllegalStateException(f("%s is not an InstanceOfExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isIntegerLiteralExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public IntegerLiteralExpr asIntegerLiteralExpr() { + throw new IllegalStateException(f("%s is not an IntegerLiteralExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isLambdaExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public LambdaExpr asLambdaExpr() { + throw new IllegalStateException(f("%s is not an LambdaExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isLiteralExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public LiteralExpr asLiteralExpr() { + throw new IllegalStateException(f("%s is not an LiteralExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isLiteralStringValueExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public LiteralStringValueExpr asLiteralStringValueExpr() { + throw new IllegalStateException(f("%s is not an LiteralStringValueExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isLongLiteralExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public LongLiteralExpr asLongLiteralExpr() { + throw new IllegalStateException(f("%s is not an LongLiteralExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isMarkerAnnotationExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public MarkerAnnotationExpr asMarkerAnnotationExpr() { + throw new IllegalStateException(f("%s is not an MarkerAnnotationExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isMethodCallExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public MethodCallExpr asMethodCallExpr() { + throw new IllegalStateException(f("%s is not an MethodCallExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isMethodReferenceExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public MethodReferenceExpr asMethodReferenceExpr() { + throw new IllegalStateException(f("%s is not an MethodReferenceExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isNameExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public NameExpr asNameExpr() { + throw new IllegalStateException(f("%s is not an NameExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isNormalAnnotationExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public NormalAnnotationExpr asNormalAnnotationExpr() { + throw new IllegalStateException(f("%s is not an NormalAnnotationExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isNullLiteralExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public NullLiteralExpr asNullLiteralExpr() { + throw new IllegalStateException(f("%s is not an NullLiteralExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isObjectCreationExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ObjectCreationExpr asObjectCreationExpr() { + throw new IllegalStateException(f("%s is not an ObjectCreationExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isSingleMemberAnnotationExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public SingleMemberAnnotationExpr asSingleMemberAnnotationExpr() { + throw new IllegalStateException(f("%s is not an SingleMemberAnnotationExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isStringLiteralExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public StringLiteralExpr asStringLiteralExpr() { + throw new IllegalStateException(f("%s is not an StringLiteralExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isSuperExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public SuperExpr asSuperExpr() { + throw new IllegalStateException(f("%s is not an SuperExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isThisExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ThisExpr asThisExpr() { + throw new IllegalStateException(f("%s is not an ThisExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isTypeExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public TypeExpr asTypeExpr() { + throw new IllegalStateException(f("%s is not an TypeExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isUnaryExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public UnaryExpr asUnaryExpr() { + throw new IllegalStateException(f("%s is not an UnaryExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isVariableDeclarationExpr() { + return false; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public VariableDeclarationExpr asVariableDeclarationExpr() { + throw new IllegalStateException(f("%s is not an VariableDeclarationExpr", this)); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifAnnotationExpr(Consumer<AnnotationExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifArrayAccessExpr(Consumer<ArrayAccessExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifArrayCreationExpr(Consumer<ArrayCreationExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifArrayInitializerExpr(Consumer<ArrayInitializerExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifAssignExpr(Consumer<AssignExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifBinaryExpr(Consumer<BinaryExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifBooleanLiteralExpr(Consumer<BooleanLiteralExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifCastExpr(Consumer<CastExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifCharLiteralExpr(Consumer<CharLiteralExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifClassExpr(Consumer<ClassExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifConditionalExpr(Consumer<ConditionalExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifDoubleLiteralExpr(Consumer<DoubleLiteralExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifEnclosedExpr(Consumer<EnclosedExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifFieldAccessExpr(Consumer<FieldAccessExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifInstanceOfExpr(Consumer<InstanceOfExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifIntegerLiteralExpr(Consumer<IntegerLiteralExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifLambdaExpr(Consumer<LambdaExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifLiteralExpr(Consumer<LiteralExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifLiteralStringValueExpr(Consumer<LiteralStringValueExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifLongLiteralExpr(Consumer<LongLiteralExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifMarkerAnnotationExpr(Consumer<MarkerAnnotationExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifMethodCallExpr(Consumer<MethodCallExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifMethodReferenceExpr(Consumer<MethodReferenceExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifNameExpr(Consumer<NameExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifNormalAnnotationExpr(Consumer<NormalAnnotationExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifNullLiteralExpr(Consumer<NullLiteralExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifObjectCreationExpr(Consumer<ObjectCreationExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifSingleMemberAnnotationExpr(Consumer<SingleMemberAnnotationExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifStringLiteralExpr(Consumer<StringLiteralExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifSuperExpr(Consumer<SuperExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifThisExpr(Consumer<ThisExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifTypeExpr(Consumer<TypeExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifUnaryExpr(Consumer<UnaryExpr> action) { + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifVariableDeclarationExpr(Consumer<VariableDeclarationExpr> action) { + } + + public ResolvedType calculateResolvedType() { + return getSymbolResolver().calculateType(this); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<AnnotationExpr> toAnnotationExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ArrayAccessExpr> toArrayAccessExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ArrayCreationExpr> toArrayCreationExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ArrayInitializerExpr> toArrayInitializerExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<AssignExpr> toAssignExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<BinaryExpr> toBinaryExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<BooleanLiteralExpr> toBooleanLiteralExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<CastExpr> toCastExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<CharLiteralExpr> toCharLiteralExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ClassExpr> toClassExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ConditionalExpr> toConditionalExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<DoubleLiteralExpr> toDoubleLiteralExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<EnclosedExpr> toEnclosedExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<FieldAccessExpr> toFieldAccessExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<InstanceOfExpr> toInstanceOfExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<IntegerLiteralExpr> toIntegerLiteralExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<LambdaExpr> toLambdaExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<LiteralExpr> toLiteralExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<LiteralStringValueExpr> toLiteralStringValueExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<LongLiteralExpr> toLongLiteralExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<MarkerAnnotationExpr> toMarkerAnnotationExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<MethodCallExpr> toMethodCallExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<MethodReferenceExpr> toMethodReferenceExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<NameExpr> toNameExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<NormalAnnotationExpr> toNormalAnnotationExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<NullLiteralExpr> toNullLiteralExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ObjectCreationExpr> toObjectCreationExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<SingleMemberAnnotationExpr> toSingleMemberAnnotationExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<StringLiteralExpr> toStringLiteralExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<SuperExpr> toSuperExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ThisExpr> toThisExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<TypeExpr> toTypeExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<UnaryExpr> toUnaryExpr() { + return Optional.empty(); + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<VariableDeclarationExpr> toVariableDeclarationExpr() { + return Optional.empty(); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/FieldAccessExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/FieldAccessExpr.java new file mode 100644 index 000000000..c6b9e0a94 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/FieldAccessExpr.java @@ -0,0 +1,262 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.nodeTypes.NodeWithScope; +import com.github.javaparser.ast.nodeTypes.NodeWithSimpleName; +import com.github.javaparser.ast.nodeTypes.NodeWithTypeArguments; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.type.Type; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.FieldAccessExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import com.github.javaparser.metamodel.OptionalProperty; +import java.util.function.Consumer; + +/** + * Access of a field of an object. + * <br/>In <code>person.name</code> "name" is the name and "person" is the scope. + * + * @author Julio Vilmar Gesser + */ +public final class FieldAccessExpr extends Expression implements NodeWithSimpleName<FieldAccessExpr>, NodeWithTypeArguments<FieldAccessExpr>, NodeWithScope<FieldAccessExpr> { + + private Expression scope; + + @OptionalProperty + private NodeList<Type> typeArguments; + + private SimpleName name; + + public FieldAccessExpr() { + this(null, new ThisExpr(), new NodeList<>(), new SimpleName()); + } + + public FieldAccessExpr(final Expression scope, final String name) { + this(null, scope, new NodeList<>(), new SimpleName(name)); + } + + @AllFieldsConstructor + public FieldAccessExpr(final Expression scope, final NodeList<Type> typeArguments, final SimpleName name) { + this(null, scope, typeArguments, name); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public FieldAccessExpr(TokenRange tokenRange, Expression scope, NodeList<Type> typeArguments, SimpleName name) { + super(tokenRange); + setScope(scope); + setTypeArguments(typeArguments); + setName(name); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public SimpleName getName() { + return name; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public FieldAccessExpr setName(final SimpleName name) { + assertNotNull(name); + if (name == this.name) { + return (FieldAccessExpr) this; + } + notifyPropertyChange(ObservableProperty.NAME, this.name, name); + if (this.name != null) + this.name.setParentNode(null); + this.name = name; + setAsParentNodeOf(name); + return this; + } + + /** + * Use {@link #getName} instead. + */ + @Deprecated + public SimpleName getField() { + return name; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getScope() { + return scope; + } + + /** + * Use {@link #setName} with new SimpleName(field) instead. + */ + @Deprecated + public FieldAccessExpr setField(final String field) { + setName(new SimpleName(field)); + return this; + } + + /** + * Use {@link #setName} instead. + */ + @Deprecated + public FieldAccessExpr setFieldExpr(SimpleName inner) { + return setName(inner); + } + + /** + * Sets the scope + * + * @param scope the scope, can not be null + * @return this, the FieldAccessExpr + */ + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public FieldAccessExpr setScope(final Expression scope) { + assertNotNull(scope); + if (scope == this.scope) { + return (FieldAccessExpr) this; + } + notifyPropertyChange(ObservableProperty.SCOPE, this.scope, scope); + if (this.scope != null) + this.scope.setParentNode(null); + this.scope = scope; + setAsParentNodeOf(scope); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Optional<NodeList<Type>> getTypeArguments() { + return Optional.ofNullable(typeArguments); + } + + /** + * Sets the type arguments + * + * @param typeArguments the type arguments, can be null + * @return this, the FieldAccessExpr + */ + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public FieldAccessExpr setTypeArguments(final NodeList<Type> typeArguments) { + if (typeArguments == this.typeArguments) { + return (FieldAccessExpr) this; + } + notifyPropertyChange(ObservableProperty.TYPE_ARGUMENTS, this.typeArguments, typeArguments); + if (this.typeArguments != null) + this.typeArguments.setParentNode(null); + this.typeArguments = typeArguments; + setAsParentNodeOf(typeArguments); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public FieldAccessExpr clone() { + return (FieldAccessExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public FieldAccessExprMetaModel getMetaModel() { + return JavaParserMetaModel.fieldAccessExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + if (typeArguments != null) { + for (int i = 0; i < typeArguments.size(); i++) { + if (typeArguments.get(i) == node) { + typeArguments.remove(i); + return true; + } + } + } + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == name) { + setName((SimpleName) replacementNode); + return true; + } + if (node == scope) { + setScope((Expression) replacementNode); + return true; + } + if (typeArguments != null) { + for (int i = 0; i < typeArguments.size(); i++) { + if (typeArguments.get(i) == node) { + typeArguments.set(i, (Type) replacementNode); + return true; + } + } + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isFieldAccessExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public FieldAccessExpr asFieldAccessExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifFieldAccessExpr(Consumer<FieldAccessExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<FieldAccessExpr> toFieldAccessExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/InstanceOfExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/InstanceOfExpr.java new file mode 100644 index 000000000..69a505b7c --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/InstanceOfExpr.java @@ -0,0 +1,181 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.nodeTypes.NodeWithExpression; +import com.github.javaparser.ast.nodeTypes.NodeWithType; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.type.ClassOrInterfaceType; +import com.github.javaparser.ast.type.ReferenceType; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.InstanceOfExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * Usage of the instanceof operator. + * <br/><code>tool instanceof Drill</code> + * + * @author Julio Vilmar Gesser + */ +public final class InstanceOfExpr extends Expression implements NodeWithType<InstanceOfExpr, ReferenceType>, NodeWithExpression<InstanceOfExpr> { + + private Expression expression; + + private ReferenceType type; + + public InstanceOfExpr() { + this(null, new NameExpr(), new ClassOrInterfaceType()); + } + + @AllFieldsConstructor + public InstanceOfExpr(final Expression expression, final ReferenceType type) { + this(null, expression, type); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public InstanceOfExpr(TokenRange tokenRange, Expression expression, ReferenceType type) { + super(tokenRange); + setExpression(expression); + setType(type); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getExpression() { + return expression; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ReferenceType getType() { + return type; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public InstanceOfExpr setExpression(final Expression expression) { + assertNotNull(expression); + if (expression == this.expression) { + return (InstanceOfExpr) this; + } + notifyPropertyChange(ObservableProperty.EXPRESSION, this.expression, expression); + if (this.expression != null) + this.expression.setParentNode(null); + this.expression = expression; + setAsParentNodeOf(expression); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public InstanceOfExpr setType(final ReferenceType type) { + assertNotNull(type); + if (type == this.type) { + return (InstanceOfExpr) this; + } + notifyPropertyChange(ObservableProperty.TYPE, this.type, type); + if (this.type != null) + this.type.setParentNode(null); + this.type = type; + setAsParentNodeOf(type); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public InstanceOfExpr clone() { + return (InstanceOfExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public InstanceOfExprMetaModel getMetaModel() { + return JavaParserMetaModel.instanceOfExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == expression) { + setExpression((Expression) replacementNode); + return true; + } + if (node == type) { + setType((ReferenceType) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isInstanceOfExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public InstanceOfExpr asInstanceOfExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifInstanceOfExpr(Consumer<InstanceOfExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<InstanceOfExpr> toInstanceOfExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/IntegerLiteralExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/IntegerLiteralExpr.java new file mode 100644 index 000000000..a0d394986 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/IntegerLiteralExpr.java @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import com.github.javaparser.metamodel.IntegerLiteralExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * All ways to specify an int literal. + * <br/><code>8934</code> + * <br/><code>0x01</code> + * <br/><code>022</code> + * <br/><code>0B10101010</code> + * <br/><code>99999999L</code> + * + * @author Julio Vilmar Gesser + */ +public final class IntegerLiteralExpr extends LiteralStringValueExpr { + + public IntegerLiteralExpr() { + this(null, "0"); + } + + @AllFieldsConstructor + public IntegerLiteralExpr(final String value) { + this(null, value); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public IntegerLiteralExpr(TokenRange tokenRange, String value) { + super(tokenRange, value); + customInitialization(); + } + + public IntegerLiteralExpr(final int value) { + this(null, String.valueOf(value)); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + /** + * @return the literal value as an integer while respecting different number representations + */ + public int asInt() { + String result = value.replaceAll("_", ""); + if (result.startsWith("0x") || result.startsWith("0X")) { + return Integer.parseUnsignedInt(result.substring(2), 16); + } + if (result.startsWith("0b") || result.startsWith("0B")) { + return Integer.parseUnsignedInt(result.substring(2), 2); + } + if (result.length() > 1 && result.startsWith("0")) { + return Integer.parseUnsignedInt(result.substring(1), 8); + } + return Integer.parseInt(result); + } + + public IntegerLiteralExpr setInt(int value) { + this.value = String.valueOf(value); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public IntegerLiteralExpr clone() { + return (IntegerLiteralExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public IntegerLiteralExprMetaModel getMetaModel() { + return JavaParserMetaModel.integerLiteralExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isIntegerLiteralExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public IntegerLiteralExpr asIntegerLiteralExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifIntegerLiteralExpr(Consumer<IntegerLiteralExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<IntegerLiteralExpr> toIntegerLiteralExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LambdaExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LambdaExpr.java new file mode 100644 index 000000000..a69176f2a --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LambdaExpr.java @@ -0,0 +1,236 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.body.Parameter; +import com.github.javaparser.ast.nodeTypes.NodeWithParameters; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.stmt.ExpressionStmt; +import com.github.javaparser.ast.stmt.ReturnStmt; +import com.github.javaparser.ast.stmt.Statement; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.DerivedProperty; +import com.github.javaparser.metamodel.LambdaExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; + +/** + * <h1>A lambda expression</h1> + * <h2>Java 1-7</h2> + * Does not exist. + * <h2>Java 8+</h2> + * <code>(a, b) -> a + b</code> + * <br/><code>a -> ...</code> + * <br/><code>(Long a) -> { println(a); }</code> + * <p/>The parameters are on the left side of the ->. + * If a parameter uses type inference (it has no type specified) then its type is set to <code>UnknownType</code>. + * If they are in ( ), "isEnclosingParameters" is true. + * <br/>The body is to the right of the ->. + * The body is either a BlockStatement when it is in { } braces, or an ExpressionStatement when it is not in braces. + * + * @author Raquel Pau + */ +public final class LambdaExpr extends Expression implements NodeWithParameters<LambdaExpr> { + + private NodeList<Parameter> parameters; + + private boolean isEnclosingParameters; + + private Statement body; + + public LambdaExpr() { + this(null, new NodeList<>(), new ReturnStmt(), false); + } + + @AllFieldsConstructor + public LambdaExpr(NodeList<Parameter> parameters, Statement body, boolean isEnclosingParameters) { + this(null, parameters, body, isEnclosingParameters); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public LambdaExpr(TokenRange tokenRange, NodeList<Parameter> parameters, Statement body, boolean isEnclosingParameters) { + super(tokenRange); + setParameters(parameters); + setBody(body); + setEnclosingParameters(isEnclosingParameters); + customInitialization(); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public NodeList<Parameter> getParameters() { + return parameters; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public LambdaExpr setParameters(final NodeList<Parameter> parameters) { + assertNotNull(parameters); + if (parameters == this.parameters) { + return (LambdaExpr) this; + } + notifyPropertyChange(ObservableProperty.PARAMETERS, this.parameters, parameters); + if (this.parameters != null) + this.parameters.setParentNode(null); + this.parameters = parameters; + setAsParentNodeOf(parameters); + return this; + } + + /** + * @return a BlockStatement or an ExpressionStatement. See class Javadoc. + */ + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Statement getBody() { + return body; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public LambdaExpr setBody(final Statement body) { + assertNotNull(body); + if (body == this.body) { + return (LambdaExpr) this; + } + notifyPropertyChange(ObservableProperty.BODY, this.body, body); + if (this.body != null) + this.body.setParentNode(null); + this.body = body; + setAsParentNodeOf(body); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public boolean isEnclosingParameters() { + return isEnclosingParameters; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public LambdaExpr setEnclosingParameters(final boolean isEnclosingParameters) { + if (isEnclosingParameters == this.isEnclosingParameters) { + return (LambdaExpr) this; + } + notifyPropertyChange(ObservableProperty.ENCLOSING_PARAMETERS, this.isEnclosingParameters, isEnclosingParameters); + this.isEnclosingParameters = isEnclosingParameters; + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + for (int i = 0; i < parameters.size(); i++) { + if (parameters.get(i) == node) { + parameters.remove(i); + return true; + } + } + return super.remove(node); + } + + /** + * @return if the body of this lambda is a simple expression, return that expression. + * Otherwise (when the body is a block) return Optional.empty(). + */ + @DerivedProperty + public Optional<Expression> getExpressionBody() { + if (body.isExpressionStmt()) { + return Optional.of(body.asExpressionStmt().getExpression()); + } else { + return Optional.empty(); + } + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public LambdaExpr clone() { + return (LambdaExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public LambdaExprMetaModel getMetaModel() { + return JavaParserMetaModel.lambdaExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == body) { + setBody((Statement) replacementNode); + return true; + } + for (int i = 0; i < parameters.size(); i++) { + if (parameters.get(i) == node) { + parameters.set(i, (Parameter) replacementNode); + return true; + } + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isLambdaExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public LambdaExpr asLambdaExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifLambdaExpr(Consumer<LambdaExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<LambdaExpr> toLambdaExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LiteralExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LiteralExpr.java new file mode 100644 index 000000000..2c81560c6 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LiteralExpr.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import com.github.javaparser.metamodel.LiteralExprMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * A base class for all literal expressions. + * + * @author Julio Vilmar Gesser + */ +public abstract class LiteralExpr extends Expression { + + @AllFieldsConstructor + public LiteralExpr() { + this(null); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public LiteralExpr(TokenRange tokenRange) { + super(tokenRange); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public LiteralExpr clone() { + return (LiteralExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public LiteralExprMetaModel getMetaModel() { + return JavaParserMetaModel.literalExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isLiteralExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public LiteralExpr asLiteralExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifLiteralExpr(Consumer<LiteralExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<LiteralExpr> toLiteralExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LiteralStringValueExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LiteralStringValueExpr.java new file mode 100644 index 000000000..49561469e --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LiteralStringValueExpr.java @@ -0,0 +1,123 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import com.github.javaparser.metamodel.LiteralStringValueExprMetaModel; +import static com.github.javaparser.utils.Utils.assertNotNull; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * Any literal value that is stored internally as a String. + */ +public abstract class LiteralStringValueExpr extends LiteralExpr { + + protected String value; + + @AllFieldsConstructor + public LiteralStringValueExpr(final String value) { + this(null, value); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public LiteralStringValueExpr(TokenRange tokenRange, String value) { + super(tokenRange); + setValue(value); + customInitialization(); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public String getValue() { + return value; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public LiteralStringValueExpr setValue(final String value) { + assertNotNull(value); + if (value == this.value) { + return (LiteralStringValueExpr) this; + } + notifyPropertyChange(ObservableProperty.VALUE, this.value, value); + this.value = value; + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public LiteralStringValueExpr clone() { + return (LiteralStringValueExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public LiteralStringValueExprMetaModel getMetaModel() { + return JavaParserMetaModel.literalStringValueExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isLiteralStringValueExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public LiteralStringValueExpr asLiteralStringValueExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifLiteralStringValueExpr(Consumer<LiteralStringValueExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<LiteralStringValueExpr> toLiteralStringValueExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LongLiteralExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LongLiteralExpr.java new file mode 100644 index 000000000..d15442fbc --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LongLiteralExpr.java @@ -0,0 +1,157 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import com.github.javaparser.metamodel.LongLiteralExprMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * All ways to specify a long literal. + * <br/><code>8934l</code> + * <br/><code>0x01L</code> + * <br/><code>022l</code> + * <br/><code>0B10101010L</code> + * <br/><code>99999999L</code> + * + * @author Julio Vilmar Gesser + */ +public final class LongLiteralExpr extends LiteralStringValueExpr { + + public LongLiteralExpr() { + this(null, "0"); + } + + @AllFieldsConstructor + public LongLiteralExpr(final String value) { + this(null, value); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public LongLiteralExpr(TokenRange tokenRange, String value) { + super(tokenRange, value); + customInitialization(); + } + + public LongLiteralExpr(final long value) { + this(null, String.valueOf(value)); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + /** + * @return the literal value as an long while respecting different number representations + */ + public long asLong() { + String result = value.replaceAll("_", ""); + char lastChar = result.charAt(result.length() - 1); + if (lastChar == 'l' || lastChar == 'L') { + result = result.substring(0, result.length() - 1); + } + if (result.startsWith("0x") || result.startsWith("0X")) { + return Long.parseUnsignedLong(result.substring(2), 16); + } + if (result.startsWith("0b") || result.startsWith("0B")) { + return Long.parseUnsignedLong(result.substring(2), 2); + } + if (result.length() > 1 && result.startsWith("0")) { + return Long.parseUnsignedLong(result.substring(1), 8); + } + return Long.parseLong(result); + } + + public LongLiteralExpr setLong(long value) { + this.value = String.valueOf(value); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public LongLiteralExpr clone() { + return (LongLiteralExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public LongLiteralExprMetaModel getMetaModel() { + return JavaParserMetaModel.longLiteralExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isLongLiteralExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public LongLiteralExpr asLongLiteralExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifLongLiteralExpr(Consumer<LongLiteralExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<LongLiteralExpr> toLongLiteralExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MarkerAnnotationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MarkerAnnotationExpr.java new file mode 100644 index 000000000..e9ab8941d --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MarkerAnnotationExpr.java @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.MarkerAnnotationExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import static com.github.javaparser.JavaParser.parseName; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * An annotation that uses only the annotation type name. + * <br/><code>@Override</code> + * + * @author Julio Vilmar Gesser + */ +public final class MarkerAnnotationExpr extends AnnotationExpr { + + public MarkerAnnotationExpr() { + this(null, new Name()); + } + + public MarkerAnnotationExpr(final String name) { + this(null, parseName(name)); + } + + @AllFieldsConstructor + public MarkerAnnotationExpr(final Name name) { + this(null, name); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public MarkerAnnotationExpr(TokenRange tokenRange, Name name) { + super(tokenRange, name); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public MarkerAnnotationExpr clone() { + return (MarkerAnnotationExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public MarkerAnnotationExprMetaModel getMetaModel() { + return JavaParserMetaModel.markerAnnotationExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isMarkerAnnotationExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public MarkerAnnotationExpr asMarkerAnnotationExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifMarkerAnnotationExpr(Consumer<MarkerAnnotationExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<MarkerAnnotationExpr> toMarkerAnnotationExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MemberValuePair.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MemberValuePair.java new file mode 100644 index 000000000..8accb7b0f --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MemberValuePair.java @@ -0,0 +1,157 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.nodeTypes.NodeWithSimpleName; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.MemberValuePairMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; + +/** + * A value for a member of an annotation. + * In <code>@Counters(a=15)</code> a=15 is a MemberValuePair. Its name is a, and its value is 15. + * + * @author Julio Vilmar Gesser + */ +public final class MemberValuePair extends Node implements NodeWithSimpleName<MemberValuePair> { + + private SimpleName name; + + private Expression value; + + public MemberValuePair() { + this(null, new SimpleName(), new StringLiteralExpr()); + } + + public MemberValuePair(final String name, final Expression value) { + this(null, new SimpleName(name), value); + } + + @AllFieldsConstructor + public MemberValuePair(final SimpleName name, final Expression value) { + this(null, name, value); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public MemberValuePair(TokenRange tokenRange, SimpleName name, Expression value) { + super(tokenRange); + setName(name); + setValue(value); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public SimpleName getName() { + return name; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getValue() { + return value; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public MemberValuePair setName(final SimpleName name) { + assertNotNull(name); + if (name == this.name) { + return (MemberValuePair) this; + } + notifyPropertyChange(ObservableProperty.NAME, this.name, name); + if (this.name != null) + this.name.setParentNode(null); + this.name = name; + setAsParentNodeOf(name); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public MemberValuePair setValue(final Expression value) { + assertNotNull(value); + if (value == this.value) { + return (MemberValuePair) this; + } + notifyPropertyChange(ObservableProperty.VALUE, this.value, value); + if (this.value != null) + this.value.setParentNode(null); + this.value = value; + setAsParentNodeOf(value); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public MemberValuePair clone() { + return (MemberValuePair) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public MemberValuePairMetaModel getMetaModel() { + return JavaParserMetaModel.memberValuePairMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == name) { + setName((SimpleName) replacementNode); + return true; + } + if (node == value) { + setValue((Expression) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodCallExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodCallExpr.java new file mode 100644 index 000000000..dc914c9d4 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodCallExpr.java @@ -0,0 +1,301 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.nodeTypes.NodeWithArguments; +import com.github.javaparser.ast.nodeTypes.NodeWithOptionalScope; +import com.github.javaparser.ast.nodeTypes.NodeWithSimpleName; +import com.github.javaparser.ast.nodeTypes.NodeWithTypeArguments; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.type.Type; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.MethodCallExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import com.github.javaparser.metamodel.OptionalProperty; +import com.github.javaparser.resolution.SymbolResolver; +import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration; +import java.util.function.Consumer; + +/** + * A method call on an object. <br/><code>circle.circumference()</code> <br/>In <code>a.<String>bb(15);</code> a + * is the scope, String is a type argument, bb is the name and 15 is an argument. + * + * @author Julio Vilmar Gesser + */ +public final class MethodCallExpr extends Expression implements NodeWithTypeArguments<MethodCallExpr>, NodeWithArguments<MethodCallExpr>, NodeWithSimpleName<MethodCallExpr>, NodeWithOptionalScope<MethodCallExpr> { + + @OptionalProperty + private Expression scope; + + @OptionalProperty + private NodeList<Type> typeArguments; + + private SimpleName name; + + private NodeList<Expression> arguments; + + public MethodCallExpr() { + this(null, null, new NodeList<>(), new SimpleName(), new NodeList<>()); + } + + public MethodCallExpr(String name, Expression... arguments) { + this(null, null, new NodeList<>(), new SimpleName(name), new NodeList<>(arguments)); + } + + public MethodCallExpr(final Expression scope, final String name) { + this(null, scope, new NodeList<>(), new SimpleName(name), new NodeList<>()); + } + + public MethodCallExpr(final Expression scope, final SimpleName name) { + this(null, scope, new NodeList<>(), name, new NodeList<>()); + } + + public MethodCallExpr(final Expression scope, final String name, final NodeList<Expression> arguments) { + this(null, scope, new NodeList<>(), new SimpleName(name), arguments); + } + + public MethodCallExpr(final Expression scope, final SimpleName name, final NodeList<Expression> arguments) { + this(null, scope, new NodeList<>(), name, arguments); + } + + @AllFieldsConstructor + public MethodCallExpr(final Expression scope, final NodeList<Type> typeArguments, final SimpleName name, final NodeList<Expression> arguments) { + this(null, scope, typeArguments, name, arguments); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public MethodCallExpr(TokenRange tokenRange, Expression scope, NodeList<Type> typeArguments, SimpleName name, NodeList<Expression> arguments) { + super(tokenRange); + setScope(scope); + setTypeArguments(typeArguments); + setName(name); + setArguments(arguments); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public NodeList<Expression> getArguments() { + return arguments; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public SimpleName getName() { + return name; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Optional<Expression> getScope() { + return Optional.ofNullable(scope); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public MethodCallExpr setArguments(final NodeList<Expression> arguments) { + assertNotNull(arguments); + if (arguments == this.arguments) { + return (MethodCallExpr) this; + } + notifyPropertyChange(ObservableProperty.ARGUMENTS, this.arguments, arguments); + if (this.arguments != null) + this.arguments.setParentNode(null); + this.arguments = arguments; + setAsParentNodeOf(arguments); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public MethodCallExpr setName(final SimpleName name) { + assertNotNull(name); + if (name == this.name) { + return (MethodCallExpr) this; + } + notifyPropertyChange(ObservableProperty.NAME, this.name, name); + if (this.name != null) + this.name.setParentNode(null); + this.name = name; + setAsParentNodeOf(name); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public MethodCallExpr setScope(final Expression scope) { + if (scope == this.scope) { + return (MethodCallExpr) this; + } + notifyPropertyChange(ObservableProperty.SCOPE, this.scope, scope); + if (this.scope != null) + this.scope.setParentNode(null); + this.scope = scope; + setAsParentNodeOf(scope); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Optional<NodeList<Type>> getTypeArguments() { + return Optional.ofNullable(typeArguments); + } + + /** + * Sets the typeArguments + * + * @param typeArguments the typeArguments, can be null + * @return this, the MethodCallExpr + */ + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public MethodCallExpr setTypeArguments(final NodeList<Type> typeArguments) { + if (typeArguments == this.typeArguments) { + return (MethodCallExpr) this; + } + notifyPropertyChange(ObservableProperty.TYPE_ARGUMENTS, this.typeArguments, typeArguments); + if (this.typeArguments != null) + this.typeArguments.setParentNode(null); + this.typeArguments = typeArguments; + setAsParentNodeOf(typeArguments); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + for (int i = 0; i < arguments.size(); i++) { + if (arguments.get(i) == node) { + arguments.remove(i); + return true; + } + } + if (scope != null) { + if (node == scope) { + removeScope(); + return true; + } + } + if (typeArguments != null) { + for (int i = 0; i < typeArguments.size(); i++) { + if (typeArguments.get(i) == node) { + typeArguments.remove(i); + return true; + } + } + } + return super.remove(node); + } + + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public MethodCallExpr removeScope() { + return setScope((Expression) null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public MethodCallExpr clone() { + return (MethodCallExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public MethodCallExprMetaModel getMetaModel() { + return JavaParserMetaModel.methodCallExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + for (int i = 0; i < arguments.size(); i++) { + if (arguments.get(i) == node) { + arguments.set(i, (Expression) replacementNode); + return true; + } + } + if (node == name) { + setName((SimpleName) replacementNode); + return true; + } + if (scope != null) { + if (node == scope) { + setScope((Expression) replacementNode); + return true; + } + } + if (typeArguments != null) { + for (int i = 0; i < typeArguments.size(); i++) { + if (typeArguments.get(i) == node) { + typeArguments.set(i, (Type) replacementNode); + return true; + } + } + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isMethodCallExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public MethodCallExpr asMethodCallExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifMethodCallExpr(Consumer<MethodCallExpr> action) { + action.accept(this); + } + + public ResolvedMethodDeclaration resolveInvokedMethod() { + return getSymbolResolver().resolveDeclaration(this, ResolvedMethodDeclaration.class); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<MethodCallExpr> toMethodCallExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodReferenceExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodReferenceExpr.java new file mode 100644 index 000000000..8ddaac00d --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodReferenceExpr.java @@ -0,0 +1,229 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.nodeTypes.NodeWithIdentifier; +import com.github.javaparser.ast.nodeTypes.NodeWithTypeArguments; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.type.Type; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import static com.github.javaparser.utils.Utils.assertNonEmpty; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.MethodReferenceExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import com.github.javaparser.metamodel.NonEmptyProperty; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import com.github.javaparser.metamodel.OptionalProperty; +import java.util.function.Consumer; + +/** + * Method reference expressions introduced in Java 8 specifically designed to simplify lambda Expressions. + * Note that the field "identifier", indicating the word to the right of the ::, is not always a method name, + * it can be "new". + * <br/>In <code>System.out::println;</code> the scope is System.out and the identifier is "println" + * <br/><code>(test ? stream.map(String::trim) : stream)::toArray;</code> + * <br/>In <code>Bar<String>::<Integer>new</code> the String type argument is on the scope, + * and the Integer type argument is on this MethodReferenceExpr. + * + * @author Raquel Pau + */ +public final class MethodReferenceExpr extends Expression implements NodeWithTypeArguments<MethodReferenceExpr>, NodeWithIdentifier<MethodReferenceExpr> { + + private Expression scope; + + @OptionalProperty + private NodeList<Type> typeArguments; + + @NonEmptyProperty + private String identifier; + + public MethodReferenceExpr() { + this(null, new ClassExpr(), null, "empty"); + } + + @AllFieldsConstructor + public MethodReferenceExpr(Expression scope, NodeList<Type> typeArguments, String identifier) { + this(null, scope, typeArguments, identifier); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public MethodReferenceExpr(TokenRange tokenRange, Expression scope, NodeList<Type> typeArguments, String identifier) { + super(tokenRange); + setScope(scope); + setTypeArguments(typeArguments); + setIdentifier(identifier); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getScope() { + return scope; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public MethodReferenceExpr setScope(final Expression scope) { + assertNotNull(scope); + if (scope == this.scope) { + return (MethodReferenceExpr) this; + } + notifyPropertyChange(ObservableProperty.SCOPE, this.scope, scope); + if (this.scope != null) + this.scope.setParentNode(null); + this.scope = scope; + setAsParentNodeOf(scope); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Optional<NodeList<Type>> getTypeArguments() { + return Optional.ofNullable(typeArguments); + } + + /** + * Sets the typeArguments + * + * @param typeArguments the typeArguments, can be null + * @return this, the MethodReferenceExpr + */ + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public MethodReferenceExpr setTypeArguments(final NodeList<Type> typeArguments) { + if (typeArguments == this.typeArguments) { + return (MethodReferenceExpr) this; + } + notifyPropertyChange(ObservableProperty.TYPE_ARGUMENTS, this.typeArguments, typeArguments); + if (this.typeArguments != null) + this.typeArguments.setParentNode(null); + this.typeArguments = typeArguments; + setAsParentNodeOf(typeArguments); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public String getIdentifier() { + return identifier; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public MethodReferenceExpr setIdentifier(final String identifier) { + assertNonEmpty(identifier); + if (identifier == this.identifier) { + return (MethodReferenceExpr) this; + } + notifyPropertyChange(ObservableProperty.IDENTIFIER, this.identifier, identifier); + this.identifier = identifier; + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + if (typeArguments != null) { + for (int i = 0; i < typeArguments.size(); i++) { + if (typeArguments.get(i) == node) { + typeArguments.remove(i); + return true; + } + } + } + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public MethodReferenceExpr clone() { + return (MethodReferenceExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public MethodReferenceExprMetaModel getMetaModel() { + return JavaParserMetaModel.methodReferenceExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == scope) { + setScope((Expression) replacementNode); + return true; + } + if (typeArguments != null) { + for (int i = 0; i < typeArguments.size(); i++) { + if (typeArguments.get(i) == node) { + typeArguments.set(i, (Type) replacementNode); + return true; + } + } + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isMethodReferenceExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public MethodReferenceExpr asMethodReferenceExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifMethodReferenceExpr(Consumer<MethodReferenceExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<MethodReferenceExpr> toMethodReferenceExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/Name.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/Name.java new file mode 100644 index 000000000..0eeabd3ce --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/Name.java @@ -0,0 +1,241 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.JavaParser; +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; +import com.github.javaparser.ast.nodeTypes.NodeWithIdentifier; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import com.github.javaparser.metamodel.NameMetaModel; +import com.github.javaparser.metamodel.NonEmptyProperty; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import static com.github.javaparser.utils.Utils.assertNonEmpty; +import static com.github.javaparser.utils.Utils.assertNotNull; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import com.github.javaparser.metamodel.OptionalProperty; + +/** + * A name that may consist of multiple identifiers. + * In other words: it.may.contain.dots. + * <p> + * The rightmost identifier is "identifier", + * The one to the left of it is "qualifier.identifier", etc. + * <p> + * You can construct one from a String with the name(...) method. + * + * @author Julio Vilmar Gesser + * @see SimpleName + */ +public final class Name extends Node implements NodeWithIdentifier<Name>, NodeWithAnnotations<Name> { + + @NonEmptyProperty + private String identifier; + + @OptionalProperty + private Name qualifier; + + private NodeList<AnnotationExpr> annotations; + + public Name() { + this(null, null, "empty", new NodeList<>()); + } + + public Name(final String identifier) { + this(null, null, identifier, new NodeList<>()); + } + + public Name(Name qualifier, final String identifier) { + this(null, qualifier, identifier, new NodeList<>()); + } + + @AllFieldsConstructor + public Name(Name qualifier, final String identifier, NodeList<AnnotationExpr> annotations) { + this(null, qualifier, identifier, annotations); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public Name(TokenRange tokenRange, Name qualifier, String identifier, NodeList<AnnotationExpr> annotations) { + super(tokenRange); + setQualifier(qualifier); + setIdentifier(identifier); + setAnnotations(annotations); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public String getIdentifier() { + return identifier; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Name setIdentifier(final String identifier) { + assertNonEmpty(identifier); + if (identifier == this.identifier) { + return (Name) this; + } + notifyPropertyChange(ObservableProperty.IDENTIFIER, this.identifier, identifier); + this.identifier = identifier; + return this; + } + + /** + * Creates a new {@link Name} from a qualified name.<br> + * The qualified name can contains "." (dot) characters. + * + * @param qualifiedName qualified name + * @return instanceof {@link Name} + * @deprecated use JavaParser.parseName instead + */ + @Deprecated + public static Name parse(String qualifiedName) { + assertNonEmpty(qualifiedName); + return JavaParser.parseName(qualifiedName); + } + + /** + * @return the complete qualified name. Only the identifiers and the dots, so no comments or whitespace. + */ + public String asString() { + if (qualifier != null) { + return qualifier.asString() + "." + identifier; + } + return identifier; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Optional<Name> getQualifier() { + return Optional.ofNullable(qualifier); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Name setQualifier(final Name qualifier) { + if (qualifier == this.qualifier) { + return (Name) this; + } + notifyPropertyChange(ObservableProperty.QUALIFIER, this.qualifier, qualifier); + if (this.qualifier != null) + this.qualifier.setParentNode(null); + this.qualifier = qualifier; + setAsParentNodeOf(qualifier); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + for (int i = 0; i < annotations.size(); i++) { + if (annotations.get(i) == node) { + annotations.remove(i); + return true; + } + } + if (qualifier != null) { + if (node == qualifier) { + removeQualifier(); + return true; + } + } + return super.remove(node); + } + + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public Name removeQualifier() { + return setQualifier((Name) null); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public NodeList<AnnotationExpr> getAnnotations() { + return annotations; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Name setAnnotations(final NodeList<AnnotationExpr> annotations) { + assertNotNull(annotations); + if (annotations == this.annotations) { + return (Name) this; + } + notifyPropertyChange(ObservableProperty.ANNOTATIONS, this.annotations, annotations); + if (this.annotations != null) + this.annotations.setParentNode(null); + this.annotations = annotations; + setAsParentNodeOf(annotations); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public Name clone() { + return (Name) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public NameMetaModel getMetaModel() { + return JavaParserMetaModel.nameMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + for (int i = 0; i < annotations.size(); i++) { + if (annotations.get(i) == node) { + annotations.set(i, (AnnotationExpr) replacementNode); + return true; + } + } + if (qualifier != null) { + if (node == qualifier) { + setQualifier((Name) replacementNode); + return true; + } + } + return super.replace(node, replacementNode); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NameExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NameExpr.java new file mode 100644 index 000000000..d87158983 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NameExpr.java @@ -0,0 +1,165 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.nodeTypes.NodeWithSimpleName; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.NameExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import com.github.javaparser.resolution.Resolvable; +import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration; +import com.github.javaparser.resolution.types.ResolvedUnionType; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * Whenever a SimpleName is used in an expression, it is wrapped in NameExpr. + * <br/>In <code>int x = a + 3;</code> a is a SimpleName inside a NameExpr. + * + * @author Julio Vilmar Gesser + */ +public final class NameExpr extends Expression implements NodeWithSimpleName<NameExpr>, Resolvable<ResolvedValueDeclaration> { + + private SimpleName name; + + public NameExpr() { + this(null, new SimpleName()); + } + + public NameExpr(final String name) { + this(null, new SimpleName(name)); + } + + @AllFieldsConstructor + public NameExpr(final SimpleName name) { + this(name.getTokenRange().orElse(null), name); + setRange(name.getRange().orElse(null)); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public NameExpr(TokenRange tokenRange, SimpleName name) { + super(tokenRange); + setName(name); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public SimpleName getName() { + return name; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public NameExpr setName(final SimpleName name) { + assertNotNull(name); + if (name == this.name) { + return (NameExpr) this; + } + notifyPropertyChange(ObservableProperty.NAME, this.name, name); + if (this.name != null) + this.name.setParentNode(null); + this.name = name; + setAsParentNodeOf(name); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public NameExpr clone() { + return (NameExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public NameExprMetaModel getMetaModel() { + return JavaParserMetaModel.nameExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == name) { + setName((SimpleName) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isNameExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public NameExpr asNameExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifNameExpr(Consumer<NameExpr> action) { + action.accept(this); + } + + @Override + public ResolvedValueDeclaration resolve() { + return getSymbolResolver().resolveDeclaration(this, ResolvedValueDeclaration.class); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<NameExpr> toNameExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NormalAnnotationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NormalAnnotationExpr.java new file mode 100644 index 000000000..dd0fce54f --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NormalAnnotationExpr.java @@ -0,0 +1,180 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Arrays; +import java.util.List; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.NormalAnnotationExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * An annotation that has zero or more key-value pairs.<br/><code>@Mapping(a=5, d=10)</code> + * @author Julio Vilmar Gesser + */ +public final class NormalAnnotationExpr extends AnnotationExpr { + + private NodeList<MemberValuePair> pairs; + + public NormalAnnotationExpr() { + this(null, new Name(), new NodeList<>()); + } + + @AllFieldsConstructor + public NormalAnnotationExpr(final Name name, final NodeList<MemberValuePair> pairs) { + this(null, name, pairs); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public NormalAnnotationExpr(TokenRange tokenRange, Name name, NodeList<MemberValuePair> pairs) { + super(tokenRange, name); + setPairs(pairs); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public NodeList<MemberValuePair> getPairs() { + return pairs; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public NormalAnnotationExpr setPairs(final NodeList<MemberValuePair> pairs) { + assertNotNull(pairs); + if (pairs == this.pairs) { + return (NormalAnnotationExpr) this; + } + notifyPropertyChange(ObservableProperty.PAIRS, this.pairs, pairs); + if (this.pairs != null) + this.pairs.setParentNode(null); + this.pairs = pairs; + setAsParentNodeOf(pairs); + return this; + } + + /** + * adds a pair to this annotation + * + * @return this, the {@link NormalAnnotationExpr} + */ + public NormalAnnotationExpr addPair(String key, String value) { + return addPair(key, new NameExpr(value)); + } + + /** + * adds a pair to this annotation + * + * @return this, the {@link NormalAnnotationExpr} + */ + public NormalAnnotationExpr addPair(String key, NameExpr value) { + MemberValuePair memberValuePair = new MemberValuePair(key, value); + getPairs().add(memberValuePair); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + for (int i = 0; i < pairs.size(); i++) { + if (pairs.get(i) == node) { + pairs.remove(i); + return true; + } + } + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public NormalAnnotationExpr clone() { + return (NormalAnnotationExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public NormalAnnotationExprMetaModel getMetaModel() { + return JavaParserMetaModel.normalAnnotationExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + for (int i = 0; i < pairs.size(); i++) { + if (pairs.get(i) == node) { + pairs.set(i, (MemberValuePair) replacementNode); + return true; + } + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isNormalAnnotationExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public NormalAnnotationExpr asNormalAnnotationExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifNormalAnnotationExpr(Consumer<NormalAnnotationExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<NormalAnnotationExpr> toNormalAnnotationExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NullLiteralExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NullLiteralExpr.java new file mode 100644 index 000000000..b71ed5b80 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NullLiteralExpr.java @@ -0,0 +1,119 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.NullLiteralExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * A literal "null". + * <br/><code>null</code> + * + * @author Julio Vilmar Gesser + */ +public final class NullLiteralExpr extends LiteralExpr { + + @AllFieldsConstructor + public NullLiteralExpr() { + this(null); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public NullLiteralExpr(TokenRange tokenRange) { + super(tokenRange); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public NullLiteralExpr clone() { + return (NullLiteralExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public NullLiteralExprMetaModel getMetaModel() { + return JavaParserMetaModel.nullLiteralExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isNullLiteralExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public NullLiteralExpr asNullLiteralExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifNullLiteralExpr(Consumer<NullLiteralExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<NullLiteralExpr> toNullLiteralExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ObjectCreationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ObjectCreationExpr.java new file mode 100644 index 000000000..c4fe045b7 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ObjectCreationExpr.java @@ -0,0 +1,355 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.body.BodyDeclaration; +import com.github.javaparser.ast.nodeTypes.NodeWithArguments; +import com.github.javaparser.ast.nodeTypes.NodeWithOptionalScope; +import com.github.javaparser.ast.nodeTypes.NodeWithType; +import com.github.javaparser.ast.nodeTypes.NodeWithTypeArguments; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.type.ClassOrInterfaceType; +import com.github.javaparser.ast.type.Type; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.ObjectCreationExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import com.github.javaparser.metamodel.OptionalProperty; +import com.github.javaparser.resolution.declarations.ResolvedConstructorDeclaration; +import java.util.function.Consumer; + +/** + * A constructor call. + * <br/>In <code>new HashMap.Entry<String, Long>(15) {public String getKey() {return null;}};</code> + * HashMap.Entry is the type, String and Long are type arguments, 15 is an argument, and everything in { } + * is the anonymous class body. + * <p/>In <code>class B { class C { public void a() { new B().new C(); } } }</code> the scope is <code>new B()</code> + * of ObjectCreationExpr <code>new B().new C()</code> + * + * @author Julio Vilmar Gesser + */ +public final class ObjectCreationExpr extends Expression implements NodeWithTypeArguments<ObjectCreationExpr>, NodeWithType<ObjectCreationExpr, ClassOrInterfaceType>, NodeWithArguments<ObjectCreationExpr>, NodeWithOptionalScope<ObjectCreationExpr> { + + @OptionalProperty + private Expression scope; + + private ClassOrInterfaceType type; + + @OptionalProperty + private NodeList<Type> typeArguments; + + private NodeList<Expression> arguments; + + @OptionalProperty + private NodeList<BodyDeclaration<?>> anonymousClassBody; + + public ObjectCreationExpr() { + this(null, null, new ClassOrInterfaceType(), new NodeList<>(), new NodeList<>(), null); + } + + /** + * Defines a call to a constructor. + * + * @param scope may be null + * @param type this is the class that the constructor is being called for. + * @param arguments Any arguments to pass to the constructor + */ + public ObjectCreationExpr(final Expression scope, final ClassOrInterfaceType type, final NodeList<Expression> arguments) { + this(null, scope, type, new NodeList<>(), arguments, null); + } + + @AllFieldsConstructor + public ObjectCreationExpr(final Expression scope, final ClassOrInterfaceType type, final NodeList<Type> typeArguments, final NodeList<Expression> arguments, final NodeList<BodyDeclaration<?>> anonymousClassBody) { + this(null, scope, type, typeArguments, arguments, anonymousClassBody); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public ObjectCreationExpr(TokenRange tokenRange, Expression scope, ClassOrInterfaceType type, NodeList<Type> typeArguments, NodeList<Expression> arguments, NodeList<BodyDeclaration<?>> anonymousClassBody) { + super(tokenRange); + setScope(scope); + setType(type); + setTypeArguments(typeArguments); + setArguments(arguments); + setAnonymousClassBody(anonymousClassBody); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Optional<NodeList<BodyDeclaration<?>>> getAnonymousClassBody() { + return Optional.ofNullable(anonymousClassBody); + } + + public void addAnonymousClassBody(BodyDeclaration<?> body) { + if (anonymousClassBody == null) + anonymousClassBody = new NodeList<>(); + anonymousClassBody.add(body); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public NodeList<Expression> getArguments() { + return arguments; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Optional<Expression> getScope() { + return Optional.ofNullable(scope); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ClassOrInterfaceType getType() { + return type; + } + + /** + * Sets the anonymousClassBody<br> + * Null means no class body<br> + * Empty NodeList means new ClassName(){ } + * + * @param anonymousClassBody the anonymousClassBody, can be null or empty + * @return this, the ObjectCreationExpr + */ + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ObjectCreationExpr setAnonymousClassBody(final NodeList<BodyDeclaration<?>> anonymousClassBody) { + if (anonymousClassBody == this.anonymousClassBody) { + return (ObjectCreationExpr) this; + } + notifyPropertyChange(ObservableProperty.ANONYMOUS_CLASS_BODY, this.anonymousClassBody, anonymousClassBody); + if (this.anonymousClassBody != null) + this.anonymousClassBody.setParentNode(null); + this.anonymousClassBody = anonymousClassBody; + setAsParentNodeOf(anonymousClassBody); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ObjectCreationExpr setArguments(final NodeList<Expression> arguments) { + assertNotNull(arguments); + if (arguments == this.arguments) { + return (ObjectCreationExpr) this; + } + notifyPropertyChange(ObservableProperty.ARGUMENTS, this.arguments, arguments); + if (this.arguments != null) + this.arguments.setParentNode(null); + this.arguments = arguments; + setAsParentNodeOf(arguments); + return this; + } + + /** + * Sets the scope + * + * @param scope the scope, can be null + * @return this, the ObjectCreationExpr + */ + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ObjectCreationExpr setScope(final Expression scope) { + if (scope == this.scope) { + return (ObjectCreationExpr) this; + } + notifyPropertyChange(ObservableProperty.SCOPE, this.scope, scope); + if (this.scope != null) + this.scope.setParentNode(null); + this.scope = scope; + setAsParentNodeOf(scope); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ObjectCreationExpr setType(final ClassOrInterfaceType type) { + assertNotNull(type); + if (type == this.type) { + return (ObjectCreationExpr) this; + } + notifyPropertyChange(ObservableProperty.TYPE, this.type, type); + if (this.type != null) + this.type.setParentNode(null); + this.type = type; + setAsParentNodeOf(type); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Optional<NodeList<Type>> getTypeArguments() { + return Optional.ofNullable(typeArguments); + } + + /** + * Sets the typeArguments + * + * @param typeArguments the typeArguments, can be null + * @return this, the ObjectCreationExpr + */ + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ObjectCreationExpr setTypeArguments(final NodeList<Type> typeArguments) { + if (typeArguments == this.typeArguments) { + return (ObjectCreationExpr) this; + } + notifyPropertyChange(ObservableProperty.TYPE_ARGUMENTS, this.typeArguments, typeArguments); + if (this.typeArguments != null) + this.typeArguments.setParentNode(null); + this.typeArguments = typeArguments; + setAsParentNodeOf(typeArguments); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + if (anonymousClassBody != null) { + for (int i = 0; i < anonymousClassBody.size(); i++) { + if (anonymousClassBody.get(i) == node) { + anonymousClassBody.remove(i); + return true; + } + } + } + for (int i = 0; i < arguments.size(); i++) { + if (arguments.get(i) == node) { + arguments.remove(i); + return true; + } + } + if (scope != null) { + if (node == scope) { + removeScope(); + return true; + } + } + if (typeArguments != null) { + for (int i = 0; i < typeArguments.size(); i++) { + if (typeArguments.get(i) == node) { + typeArguments.remove(i); + return true; + } + } + } + return super.remove(node); + } + + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public ObjectCreationExpr removeScope() { + return setScope((Expression) null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public ObjectCreationExpr clone() { + return (ObjectCreationExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public ObjectCreationExprMetaModel getMetaModel() { + return JavaParserMetaModel.objectCreationExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (anonymousClassBody != null) { + for (int i = 0; i < anonymousClassBody.size(); i++) { + if (anonymousClassBody.get(i) == node) { + anonymousClassBody.set(i, (BodyDeclaration) replacementNode); + return true; + } + } + } + for (int i = 0; i < arguments.size(); i++) { + if (arguments.get(i) == node) { + arguments.set(i, (Expression) replacementNode); + return true; + } + } + if (scope != null) { + if (node == scope) { + setScope((Expression) replacementNode); + return true; + } + } + if (node == type) { + setType((ClassOrInterfaceType) replacementNode); + return true; + } + if (typeArguments != null) { + for (int i = 0; i < typeArguments.size(); i++) { + if (typeArguments.get(i) == node) { + typeArguments.set(i, (Type) replacementNode); + return true; + } + } + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isObjectCreationExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ObjectCreationExpr asObjectCreationExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifObjectCreationExpr(Consumer<ObjectCreationExpr> action) { + action.accept(this); + } + + public ResolvedConstructorDeclaration resolveInvokedConstructor() { + return getSymbolResolver().resolveDeclaration(this, ResolvedConstructorDeclaration.class); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ObjectCreationExpr> toObjectCreationExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SimpleName.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SimpleName.java new file mode 100644 index 000000000..faaa541cd --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SimpleName.java @@ -0,0 +1,126 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.nodeTypes.NodeWithIdentifier; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNonEmpty; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.NonEmptyProperty; +import com.github.javaparser.metamodel.SimpleNameMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; + +/** + * A name that consists of a single identifier. + * In other words: it.does.NOT.contain.dots. + * + * @see Name + */ +public final class SimpleName extends Node implements NodeWithIdentifier<SimpleName> { + + @NonEmptyProperty + private String identifier; + + public SimpleName() { + this(null, "empty"); + } + + @AllFieldsConstructor + public SimpleName(final String identifier) { + this(null, identifier); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public SimpleName(TokenRange tokenRange, String identifier) { + super(tokenRange); + setIdentifier(identifier); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public String getIdentifier() { + return identifier; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public SimpleName setIdentifier(final String identifier) { + assertNonEmpty(identifier); + if (identifier == this.identifier) { + return (SimpleName) this; + } + notifyPropertyChange(ObservableProperty.IDENTIFIER, this.identifier, identifier); + this.identifier = identifier; + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + public String asString() { + return identifier; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public SimpleName clone() { + return (SimpleName) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public SimpleNameMetaModel getMetaModel() { + return JavaParserMetaModel.simpleNameMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + return super.replace(node, replacementNode); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SingleMemberAnnotationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SingleMemberAnnotationExpr.java new file mode 100644 index 000000000..679c71475 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SingleMemberAnnotationExpr.java @@ -0,0 +1,150 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.SingleMemberAnnotationExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * An annotation that has a single value. <br/><code>@Count(15)</code> + * + * @author Julio Vilmar Gesser + */ +public final class SingleMemberAnnotationExpr extends AnnotationExpr { + + private Expression memberValue; + + public SingleMemberAnnotationExpr() { + this(null, new Name(), new StringLiteralExpr()); + } + + @AllFieldsConstructor + public SingleMemberAnnotationExpr(final Name name, final Expression memberValue) { + this(null, name, memberValue); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public SingleMemberAnnotationExpr(TokenRange tokenRange, Name name, Expression memberValue) { + super(tokenRange, name); + setMemberValue(memberValue); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getMemberValue() { + return memberValue; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public SingleMemberAnnotationExpr setMemberValue(final Expression memberValue) { + assertNotNull(memberValue); + if (memberValue == this.memberValue) { + return (SingleMemberAnnotationExpr) this; + } + notifyPropertyChange(ObservableProperty.MEMBER_VALUE, this.memberValue, memberValue); + if (this.memberValue != null) + this.memberValue.setParentNode(null); + this.memberValue = memberValue; + setAsParentNodeOf(memberValue); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public SingleMemberAnnotationExpr clone() { + return (SingleMemberAnnotationExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public SingleMemberAnnotationExprMetaModel getMetaModel() { + return JavaParserMetaModel.singleMemberAnnotationExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == memberValue) { + setMemberValue((Expression) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isSingleMemberAnnotationExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public SingleMemberAnnotationExpr asSingleMemberAnnotationExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifSingleMemberAnnotationExpr(Consumer<SingleMemberAnnotationExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<SingleMemberAnnotationExpr> toSingleMemberAnnotationExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/StringLiteralExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/StringLiteralExpr.java new file mode 100644 index 000000000..a7b4dd541 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/StringLiteralExpr.java @@ -0,0 +1,173 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import com.github.javaparser.metamodel.StringLiteralExprMetaModel; +import com.github.javaparser.utils.StringEscapeUtils; +import com.github.javaparser.utils.Utils; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * A literal string. + * <br/><code>"Hello World!"</code> + * <br/><code>"\"\n"</code> + * <br/><code>"\u2122"</code> + * <br/><code>"™"</code> + * <br/><code>"💩"</code> + * + * @author Julio Vilmar Gesser + */ +public final class StringLiteralExpr extends LiteralStringValueExpr { + + public StringLiteralExpr() { + this(null, "empty"); + } + + /** + * Creates a string literal expression from given string. Escapes EOL characters. + * + * @param value the value of the literal + */ + @AllFieldsConstructor + public StringLiteralExpr(final String value) { + this(null, Utils.escapeEndOfLines(value)); + } + + /** + * Utility method that creates a new StringLiteralExpr. Escapes EOL characters. + * + * @deprecated Use {@link #StringLiteralExpr(String)} instead. + */ + @Deprecated + public static StringLiteralExpr escape(String string) { + return new StringLiteralExpr(Utils.escapeEndOfLines(string)); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public StringLiteralExpr(TokenRange tokenRange, String value) { + super(tokenRange, value); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + /** + * Sets the content of this expressions to given value. Escapes EOL characters. + * + * @param value the new literal value + * @return self + */ + public StringLiteralExpr setEscapedValue(String value) { + this.value = Utils.escapeEndOfLines(value); + return this; + } + + /** + * @return the unescaped literal value + */ + public String asString() { + return StringEscapeUtils.unescapeJava(value); + } + + /** + * Escapes the given string from special characters and uses it as the literal value. + * + * @param value unescaped string + * @return this literal expression + */ + public StringLiteralExpr setString(String value) { + this.value = StringEscapeUtils.escapeJava(value); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public StringLiteralExpr clone() { + return (StringLiteralExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public StringLiteralExprMetaModel getMetaModel() { + return JavaParserMetaModel.stringLiteralExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isStringLiteralExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public StringLiteralExpr asStringLiteralExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifStringLiteralExpr(Consumer<StringLiteralExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<StringLiteralExpr> toStringLiteralExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SuperExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SuperExpr.java new file mode 100644 index 000000000..2de37fb25 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SuperExpr.java @@ -0,0 +1,173 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.OptionalProperty; +import com.github.javaparser.metamodel.SuperExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; + +/** + * An occurrence of the "super" keyword. <br/><code>World.super.greet()</code> is a MethodCallExpr of method name greet, + * and scope "World.super" which is a SuperExpr with classExpr "World". <br/><code>super.name</code> is a + * FieldAccessExpr of field greet, and a SuperExpr as its scope. The SuperExpr has no classExpr. + * + * @author Julio Vilmar Gesser + * @see com.github.javaparser.ast.stmt.ExplicitConstructorInvocationStmt + * @see ThisExpr + */ +public final class SuperExpr extends Expression { + + @OptionalProperty + private Expression classExpr; + + public SuperExpr() { + this(null, null); + } + + @AllFieldsConstructor + public SuperExpr(final Expression classExpr) { + this(null, classExpr); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public SuperExpr(TokenRange tokenRange, Expression classExpr) { + super(tokenRange); + setClassExpr(classExpr); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Optional<Expression> getClassExpr() { + return Optional.ofNullable(classExpr); + } + + /** + * Sets the classExpr + * + * @param classExpr the classExpr, can be null + * @return this, the SuperExpr + */ + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public SuperExpr setClassExpr(final Expression classExpr) { + if (classExpr == this.classExpr) { + return (SuperExpr) this; + } + notifyPropertyChange(ObservableProperty.CLASS_EXPR, this.classExpr, classExpr); + if (this.classExpr != null) + this.classExpr.setParentNode(null); + this.classExpr = classExpr; + setAsParentNodeOf(classExpr); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + if (classExpr != null) { + if (node == classExpr) { + removeClassExpr(); + return true; + } + } + return super.remove(node); + } + + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public SuperExpr removeClassExpr() { + return setClassExpr((Expression) null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public SuperExpr clone() { + return (SuperExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public SuperExprMetaModel getMetaModel() { + return JavaParserMetaModel.superExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (classExpr != null) { + if (node == classExpr) { + setClassExpr((Expression) replacementNode); + return true; + } + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isSuperExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public SuperExpr asSuperExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifSuperExpr(Consumer<SuperExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<SuperExpr> toSuperExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ThisExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ThisExpr.java new file mode 100644 index 000000000..dc9981d82 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ThisExpr.java @@ -0,0 +1,176 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.body.TypeDeclaration; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.OptionalProperty; +import com.github.javaparser.metamodel.ThisExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import com.github.javaparser.resolution.Resolvable; +import com.github.javaparser.resolution.declarations.ResolvedConstructorDeclaration; +import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration; +import java.util.function.Consumer; + +/** + * An occurrence of the "this" keyword. <br/><code>World.this.greet()</code> is a MethodCallExpr of method name greet, + * and scope "World.super" which is a ThisExpr with classExpr "World". <br/><code>this.name</code> is a + * FieldAccessExpr of field greet, and a ThisExpr as its scope. The ThisExpr has no classExpr. + * + * @author Julio Vilmar Gesser + * @see com.github.javaparser.ast.stmt.ExplicitConstructorInvocationStmt + * @see ThisExpr + */ +public final class ThisExpr extends Expression implements Resolvable<ResolvedTypeDeclaration> { + + @OptionalProperty + private Expression classExpr; + + public ThisExpr() { + this(null, null); + } + + @AllFieldsConstructor + public ThisExpr(final Expression classExpr) { + this(null, classExpr); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public ThisExpr(TokenRange tokenRange, Expression classExpr) { + super(tokenRange); + setClassExpr(classExpr); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Optional<Expression> getClassExpr() { + return Optional.ofNullable(classExpr); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public ThisExpr setClassExpr(final Expression classExpr) { + if (classExpr == this.classExpr) { + return (ThisExpr) this; + } + notifyPropertyChange(ObservableProperty.CLASS_EXPR, this.classExpr, classExpr); + if (this.classExpr != null) + this.classExpr.setParentNode(null); + this.classExpr = classExpr; + setAsParentNodeOf(classExpr); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + if (classExpr != null) { + if (node == classExpr) { + removeClassExpr(); + return true; + } + } + return super.remove(node); + } + + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public ThisExpr removeClassExpr() { + return setClassExpr((Expression) null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public ThisExpr clone() { + return (ThisExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public ThisExprMetaModel getMetaModel() { + return JavaParserMetaModel.thisExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (classExpr != null) { + if (node == classExpr) { + setClassExpr((Expression) replacementNode); + return true; + } + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isThisExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public ThisExpr asThisExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifThisExpr(Consumer<ThisExpr> action) { + action.accept(this); + } + + @Override + public ResolvedTypeDeclaration resolve() { + return getSymbolResolver().resolveDeclaration(this, ResolvedTypeDeclaration.class); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<ThisExpr> toThisExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/TypeExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/TypeExpr.java new file mode 100644 index 000000000..3d74b6eea --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/TypeExpr.java @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.nodeTypes.NodeWithType; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.type.ClassOrInterfaceType; +import com.github.javaparser.ast.type.Type; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.TypeExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * This class is just instantiated as scopes for MethodReferenceExpr nodes to encapsulate Types. + * <br/>In <code>World::greet</code> the ClassOrInterfaceType "World" is wrapped in a TypeExpr + * before it is set as the scope of the MethodReferenceExpr. + * + * @author Raquel Pau + */ +public final class TypeExpr extends Expression implements NodeWithType<TypeExpr, Type> { + + private Type type; + + public TypeExpr() { + this(null, new ClassOrInterfaceType()); + } + + @AllFieldsConstructor + public TypeExpr(Type type) { + this(null, type); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public TypeExpr(TokenRange tokenRange, Type type) { + super(tokenRange); + setType(type); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Type getType() { + return type; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public TypeExpr setType(final Type type) { + assertNotNull(type); + if (type == this.type) { + return (TypeExpr) this; + } + notifyPropertyChange(ObservableProperty.TYPE, this.type, type); + if (this.type != null) + this.type.setParentNode(null); + this.type = type; + setAsParentNodeOf(type); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public TypeExpr clone() { + return (TypeExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public TypeExprMetaModel getMetaModel() { + return JavaParserMetaModel.typeExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == type) { + setType((Type) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isTypeExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public TypeExpr asTypeExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifTypeExpr(Consumer<TypeExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<TypeExpr> toTypeExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/UnaryExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/UnaryExpr.java new file mode 100644 index 000000000..4008544d9 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/UnaryExpr.java @@ -0,0 +1,220 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.nodeTypes.NodeWithExpression; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.metamodel.DerivedProperty; +import com.github.javaparser.metamodel.UnaryExprMetaModel; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import com.github.javaparser.printer.Printable; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * An expression where an operator is applied to a single expression. + * It supports the operators that are found the the UnaryExpr.Operator enum. + * <br/><code>11++</code> + * <br/><code>++11</code> + * <br/><code>~1</code> + * <br/><code>-333</code> + * + * @author Julio Vilmar Gesser + */ +public final class UnaryExpr extends Expression implements NodeWithExpression<UnaryExpr> { + + public enum Operator implements Printable { + + PLUS("+", false), + MINUS("-", false), + PREFIX_INCREMENT("++", false), + PREFIX_DECREMENT("--", false), + LOGICAL_COMPLEMENT("!", false), + BITWISE_COMPLEMENT("~", false), + POSTFIX_INCREMENT("++", true), + POSTFIX_DECREMENT("--", true); + + private final String codeRepresentation; + + private final boolean isPostfix; + + Operator(String codeRepresentation, boolean isPostfix) { + this.codeRepresentation = codeRepresentation; + this.isPostfix = isPostfix; + } + + public String asString() { + return codeRepresentation; + } + + public boolean isPostfix() { + return isPostfix; + } + + public boolean isPrefix() { + return !isPostfix(); + } + } + + private Expression expression; + + private Operator operator; + + public UnaryExpr() { + this(null, new IntegerLiteralExpr(), Operator.POSTFIX_INCREMENT); + } + + @AllFieldsConstructor + public UnaryExpr(final Expression expression, final Operator operator) { + this(null, expression, operator); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public UnaryExpr(TokenRange tokenRange, Expression expression, Operator operator) { + super(tokenRange); + setExpression(expression); + setOperator(operator); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Expression getExpression() { + return expression; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public Operator getOperator() { + return operator; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public UnaryExpr setExpression(final Expression expression) { + assertNotNull(expression); + if (expression == this.expression) { + return (UnaryExpr) this; + } + notifyPropertyChange(ObservableProperty.EXPRESSION, this.expression, expression); + if (this.expression != null) + this.expression.setParentNode(null); + this.expression = expression; + setAsParentNodeOf(expression); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public UnaryExpr setOperator(final Operator operator) { + assertNotNull(operator); + if (operator == this.operator) { + return (UnaryExpr) this; + } + notifyPropertyChange(ObservableProperty.OPERATOR, this.operator, operator); + this.operator = operator; + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + return super.remove(node); + } + + @DerivedProperty + public boolean isPostfix() { + return operator.isPostfix(); + } + + @DerivedProperty + public boolean isPrefix() { + return !isPostfix(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public UnaryExpr clone() { + return (UnaryExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public UnaryExprMetaModel getMetaModel() { + return JavaParserMetaModel.unaryExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + if (node == expression) { + setExpression((Expression) replacementNode); + return true; + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isUnaryExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public UnaryExpr asUnaryExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifUnaryExpr(Consumer<UnaryExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<UnaryExpr> toUnaryExpr() { + return Optional.of(this); + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/VariableDeclarationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/VariableDeclarationExpr.java new file mode 100644 index 000000000..8745ce72b --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/VariableDeclarationExpr.java @@ -0,0 +1,261 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ +package com.github.javaparser.ast.expr; + +import com.github.javaparser.ast.AllFieldsConstructor; +import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.body.VariableDeclarator; +import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; +import com.github.javaparser.ast.nodeTypes.NodeWithVariables; +import com.github.javaparser.ast.nodeTypes.modifiers.NodeWithFinalModifier; +import com.github.javaparser.ast.observer.ObservableProperty; +import com.github.javaparser.ast.type.Type; +import com.github.javaparser.ast.visitor.CloneVisitor; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; +import com.github.javaparser.metamodel.JavaParserMetaModel; +import com.github.javaparser.metamodel.NonEmptyProperty; +import com.github.javaparser.metamodel.VariableDeclarationExprMetaModel; +import java.util.Arrays; +import java.util.EnumSet; +import java.util.List; +import java.util.stream.Collectors; +import static com.github.javaparser.ast.NodeList.nodeList; +import static com.github.javaparser.utils.Utils.assertNotNull; +import javax.annotation.Generated; +import com.github.javaparser.TokenRange; +import java.util.function.Consumer; +import java.util.Optional; + +/** + * A declaration of variables. + * It is an expression, so it can be put in places like the initializer of a for loop, + * or the resources part of the try statement. + * <br/><code>final int x=3, y=55</code> + * + * <br/>All annotations preceding the type will be set on this object, not on the type. + * JavaParser doesn't know if it they are applicable to the method or the type. + * + * @author Julio Vilmar Gesser + */ +public final class VariableDeclarationExpr extends Expression implements NodeWithFinalModifier<VariableDeclarationExpr>, NodeWithAnnotations<VariableDeclarationExpr>, NodeWithVariables<VariableDeclarationExpr> { + + private EnumSet<Modifier> modifiers; + + private NodeList<AnnotationExpr> annotations; + + @NonEmptyProperty + private NodeList<VariableDeclarator> variables; + + public VariableDeclarationExpr() { + this(null, EnumSet.noneOf(Modifier.class), new NodeList<>(), new NodeList<>()); + } + + public VariableDeclarationExpr(final Type type, String variableName) { + this(null, EnumSet.noneOf(Modifier.class), new NodeList<>(), nodeList(new VariableDeclarator(type, variableName))); + } + + public VariableDeclarationExpr(VariableDeclarator var) { + this(null, EnumSet.noneOf(Modifier.class), new NodeList<>(), nodeList(var)); + } + + public VariableDeclarationExpr(final Type type, String variableName, Modifier... modifiers) { + this(null, Arrays.stream(modifiers).collect(Collectors.toCollection(() -> EnumSet.noneOf(Modifier.class))), new NodeList<>(), nodeList(new VariableDeclarator(type, variableName))); + } + + public VariableDeclarationExpr(VariableDeclarator var, Modifier... modifiers) { + this(null, Arrays.stream(modifiers).collect(Collectors.toCollection(() -> EnumSet.noneOf(Modifier.class))), new NodeList<>(), nodeList(var)); + } + + public VariableDeclarationExpr(final NodeList<VariableDeclarator> variables) { + this(null, EnumSet.noneOf(Modifier.class), new NodeList<>(), variables); + } + + public VariableDeclarationExpr(final EnumSet<Modifier> modifiers, final NodeList<VariableDeclarator> variables) { + this(null, modifiers, new NodeList<>(), variables); + } + + @AllFieldsConstructor + public VariableDeclarationExpr(final EnumSet<Modifier> modifiers, final NodeList<AnnotationExpr> annotations, final NodeList<VariableDeclarator> variables) { + this(null, modifiers, annotations, variables); + } + + /** + * This constructor is used by the parser and is considered private. + */ + @Generated("com.github.javaparser.generator.core.node.MainConstructorGenerator") + public VariableDeclarationExpr(TokenRange tokenRange, EnumSet<Modifier> modifiers, NodeList<AnnotationExpr> annotations, NodeList<VariableDeclarator> variables) { + super(tokenRange); + setModifiers(modifiers); + setAnnotations(annotations); + setVariables(variables); + customInitialization(); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.AcceptGenerator") + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public NodeList<AnnotationExpr> getAnnotations() { + return annotations; + } + + /** + * Return the modifiers of this variable declaration. + * + * @return modifiers + * @see Modifier + */ + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public EnumSet<Modifier> getModifiers() { + return modifiers; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public NodeList<VariableDeclarator> getVariables() { + return variables; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public VariableDeclarationExpr setAnnotations(final NodeList<AnnotationExpr> annotations) { + assertNotNull(annotations); + if (annotations == this.annotations) { + return (VariableDeclarationExpr) this; + } + notifyPropertyChange(ObservableProperty.ANNOTATIONS, this.annotations, annotations); + if (this.annotations != null) + this.annotations.setParentNode(null); + this.annotations = annotations; + setAsParentNodeOf(annotations); + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public VariableDeclarationExpr setModifiers(final EnumSet<Modifier> modifiers) { + assertNotNull(modifiers); + if (modifiers == this.modifiers) { + return (VariableDeclarationExpr) this; + } + notifyPropertyChange(ObservableProperty.MODIFIERS, this.modifiers, modifiers); + this.modifiers = modifiers; + return this; + } + + @Generated("com.github.javaparser.generator.core.node.PropertyGenerator") + public VariableDeclarationExpr setVariables(final NodeList<VariableDeclarator> variables) { + assertNotNull(variables); + if (variables == this.variables) { + return (VariableDeclarationExpr) this; + } + notifyPropertyChange(ObservableProperty.VARIABLES, this.variables, variables); + if (this.variables != null) + this.variables.setParentNode(null); + this.variables = variables; + setAsParentNodeOf(variables); + return this; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.RemoveMethodGenerator") + public boolean remove(Node node) { + if (node == null) + return false; + for (int i = 0; i < annotations.size(); i++) { + if (annotations.get(i) == node) { + annotations.remove(i); + return true; + } + } + for (int i = 0; i < variables.size(); i++) { + if (variables.get(i) == node) { + variables.remove(i); + return true; + } + } + return super.remove(node); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.CloneGenerator") + public VariableDeclarationExpr clone() { + return (VariableDeclarationExpr) accept(new CloneVisitor(), null); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.GetMetaModelGenerator") + public VariableDeclarationExprMetaModel getMetaModel() { + return JavaParserMetaModel.variableDeclarationExprMetaModel; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.ReplaceMethodGenerator") + public boolean replace(Node node, Node replacementNode) { + if (node == null) + return false; + for (int i = 0; i < annotations.size(); i++) { + if (annotations.get(i) == node) { + annotations.set(i, (AnnotationExpr) replacementNode); + return true; + } + } + for (int i = 0; i < variables.size(); i++) { + if (variables.get(i) == node) { + variables.set(i, (VariableDeclarator) replacementNode); + return true; + } + } + return super.replace(node, replacementNode); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public boolean isVariableDeclarationExpr() { + return true; + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public VariableDeclarationExpr asVariableDeclarationExpr() { + return this; + } + + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public void ifVariableDeclarationExpr(Consumer<VariableDeclarationExpr> action) { + action.accept(this); + } + + @Override + @Generated("com.github.javaparser.generator.core.node.TypeCastingGenerator") + public Optional<VariableDeclarationExpr> toVariableDeclarationExpr() { + return Optional.of(this); + } +} |