lombok.ast.AST Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of lombok-pg Show documentation
lombok-pg is a collection of extensions to Project Lombok
The newest version!
/*
 * Copyright © 2011-2012 Philipp Eichhorn
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
package lombok.ast;

import lombok.*;

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class AST {
	public static Binary Add(final Expression left, final Expression right) {
		return new Binary(left, "+", right);
	}

	public static Binary And(final Expression left, final Expression right) {
		return new Binary(left, "&&", right);
	}

	public static Annotation Annotation(final TypeRef type) {
		return new Annotation(type);
	}

	public static Argument Arg(final TypeRef type, final String name) {
		return new Argument(type, name).makeFinal();
	}

	public static Assignment Assign(final Expression left, final Expression right) {
		return new Assignment(left, right);
	}

	public static Binary Binary(final Expression left, final String operator, final Expression right) {
		return new Binary(left, operator, right);
	}

	public static Block Block() {
		return new Block();
	}

	public static Break Break() {
		return new Break();
	}

	public static Break Break(final String label) {
		return new Break(label);
	}

	public static Call Call(final String name) {
		return new Call(name);
	}

	public static Call Call(final Expression receiver, final String name) {
		return new Call(receiver, name);
	}

	public static Cast Cast(final TypeRef type, final Expression expression) {
		return new Cast(type, expression);
	}

	public static Case Case(final Expression expression) {
		return new Case(expression);
	}

	public static Case Case() {
		return new Case();
	}

	public static CharLiteral Char(final String character) {
		return new CharLiteral(character);
	}

	public static ClassDecl ClassDecl(final String name) {
		return new ClassDecl(name);
	}

	public static ConstructorDecl ConstructorDecl(final String name) {
		return new ConstructorDecl(name);
	}

	public static Continue Continue() {
		return new Continue();
	}

	public static Continue Continue(final String label) {
		return new Continue(label);
	}

	public static DefaultValue DefaultValue(final TypeRef type) {
		return new DefaultValue(type);
	}

	public static DoWhile Do(final Statement action) {
		return new DoWhile(action);
	}

	public static EnumConstant EnumConstant(final String name) {
		return new EnumConstant(name);
	}

	public static Binary Equal(final Expression left, final Expression right) {
		return new Binary(left, "==", right);
	}

	public static Binary NotEqual(final Expression left, final Expression right) {
		return new Binary(left, "!=", right);
	}

	public static Expression Expr(final Object wrappedObject) {
		return new WrappedExpression(wrappedObject);
	}

	public static BooleanLiteral False() {
		return new BooleanLiteral(false);
	}

	public static FieldRef Field(final Expression receiver, final String name) {
		return new FieldRef(receiver, name);
	}

	public static FieldRef Field(final String name) {
		return new FieldRef(name);
	}

	public static FieldDecl FieldDecl(final TypeRef type, final String name) {
		return new FieldDecl(type, name);
	}

	public static Foreach Foreach(final LocalDecl elementVariable) {
		return new Foreach(elementVariable);
	}

	public static If If(final Expression condition) {
		return new If(condition);
	}

	public static Initializer Initializer() {
		return new Initializer();
	}

	public static JavaDoc JavaDoc() {
		return new JavaDoc();
	}

	public static JavaDoc JavaDoc(final String statement) {
		return new JavaDoc(statement);
	}

	public static InstanceOf InstanceOf(final Expression expression, final TypeRef type) {
		return new InstanceOf(expression, type);
	}

	public static ArrayRef ArrayRef(final Expression indexed, final Expression index) {
		return new ArrayRef(indexed, index);
	}

	public static ClassDecl InterfaceDecl(final String name) {
		return new ClassDecl(name).makeInterface();
	}

	public static LocalDecl LocalDecl(final TypeRef type, final String name) {
		return new LocalDecl(type, name);
	}

	public static NameRef Name(final String name) {
		return new NameRef(name);
	}

	public static NameRef Name(final Class clazz) {
		return new NameRef(clazz);
	}

	public static New New(final TypeRef type) {
		return new New(type);
	}

	public static NewArray NewArray(final TypeRef type) {
		return new NewArray(type);
	}

	public static NewArray NewArray(final TypeRef type, final int dimensions) {
		return new NewArray(type, dimensions);
	}

	public static Unary Not(final Expression condition) {
		return new Unary("!", condition);
	}

	public static NullLiteral Null() {
		return new NullLiteral();
	}

	public static MethodDecl MethodDecl(final TypeRef returnType, final String name) {
		return new MethodDecl(returnType, name);
	}

	public static MethodDecl MethodDecl(final Object wrappedObject) {
		return new WrappedMethodDecl(wrappedObject);
	}

	public static Argument NonFinalArg(final TypeRef type, final String name) {
		return new Argument(type, name);
	}

	public static NumberLiteral Number(final Number number) {
		return new NumberLiteral(number);
	}

	public static Binary Or(final Expression left, final Expression right) {
		return new Binary(left, "||", right);
	}

	public static Return Return() {
		return new Return();
	}

	public static Return Return(final Expression expression) {
		return new Return(expression);
	}

	public static ReturnDefault ReturnDefault() {
		return new ReturnDefault();
	}

	public static Statement Stat(final Object wrappedObject) {
		return new WrappedStatement(wrappedObject);
	}

	public static StringLiteral String(final String value) {
		return new StringLiteral(value);
	}

	public static Switch Switch(final Expression expression) {
		return new Switch(expression);
	}

	public static This This() {
		return new This();
	}

	public static This This(final TypeRef type) {
		return new This(type);
	}

	public static Throw Throw(final Expression init) {
		return new Throw(init);
	}

	public static BooleanLiteral True() {
		return new BooleanLiteral(true);
	}

	public static Synchronized Synchronized(final Expression lock) {
		return new Synchronized(lock);
	}

	public static Try Try(final Block tryBlock) {
		return new Try(tryBlock);
	}

	public static TypeRef Type(final Class clazz) {
		return new TypeRef(clazz);
	}

	public static TypeRef Type(final String typeName) {
		return new TypeRef(typeName);
	}

	public static TypeRef Type(final Object wrappedObject) {
		return new WrappedTypeRef(wrappedObject);
	}

	public static TypeParam TypeParam(final String name) {
		return new TypeParam(name);
	}

	public static While While(final Expression condition) {
		return new While(condition);
	}

	public static Wildcard Wildcard() {
		return new Wildcard();
	}

	public static Wildcard Wildcard(final Wildcard.Bound bound, final TypeRef type) {
		return new Wildcard(bound, type);
	}
}