Package io.sundr.model

Class SynchronizedFluent<A extends SynchronizedFluent<A>>

java.lang.Object

io.sundr.builder.BaseFluent<A>

io.sundr.model.SynchronizedFluent<A>

Direct Known Subclasses:

BlockFluent.SynchronizedStatementsNested, DoFluent.SynchronizedStatementNested, ForeachFluent.SynchronizedBodyNested, ForFluent.SynchronizedBodyNested, IfDslThenStepFluent.SynchronizedStatementsNested, IfFluent.SynchronizedElseStatementNested, IfFluent.SynchronizedStatementNested, LambdaFluent.SynchronizedStatementNested, SynchronizedBuilder, SynchronizedFluent.SynchronizedBodyNested, WhileFluent.SynchronizedStatementNested

public class SynchronizedFluent<A extends SynchronizedFluent<A>>
extends BaseFluent<A>

Generated

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	SynchronizedFluent.AssignBodyNested<N>
class	SynchronizedFluent.AssignLockExpressionNested<N>
class	SynchronizedFluent.BinaryExpressionBodyNested<N>
class	SynchronizedFluent.BinaryExpressionLockNested<N>
class	SynchronizedFluent.BitwiseAndBodyNested<N>
class	SynchronizedFluent.BitwiseAndLockExpressionNested<N>
class	SynchronizedFluent.BitwiseOrBodyNested<N>
class	SynchronizedFluent.BitwiseOrLockExpressionNested<N>
class	SynchronizedFluent.BlockBodyNested<N>
class	SynchronizedFluent.BreakBodyNested<N>
class	SynchronizedFluent.CastLockExpressionNested<N>
class	SynchronizedFluent.ClassRefLockExpressionNested<N>
class	SynchronizedFluent.ConstructBodyNested<N>
class	SynchronizedFluent.ConstructLockExpressionNested<N>
class	SynchronizedFluent.ContextRefLockExpressionNested<N>
class	SynchronizedFluent.ContinueBodyNested<N>
class	SynchronizedFluent.DeclareBodyNested<N>
class	SynchronizedFluent.DeclareLockExpressionNested<N>
class	SynchronizedFluent.DivideBodyNested<N>
class	SynchronizedFluent.DivideLockExpressionNested<N>
class	SynchronizedFluent.DoBodyNested<N>
class	SynchronizedFluent.DotClassLockExpressionNested<N>
class	SynchronizedFluent.EmptyBodyNested<N>
class	SynchronizedFluent.EmptyLockExpressionNested<N>
class	SynchronizedFluent.EnclosedLockExpressionNested<N>
class	SynchronizedFluent.EqualsBodyNested<N>
class	SynchronizedFluent.EqualsLockExpressionNested<N>
class	SynchronizedFluent.ForBodyNested<N>
class	SynchronizedFluent.ForeachBodyNested<N>
class	SynchronizedFluent.GreaterThanBodyNested<N>
class	SynchronizedFluent.GreaterThanLockExpressionNested<N>
class	SynchronizedFluent.GreaterThanOrEqualBodyNested<N>
class	SynchronizedFluent.GreaterThanOrEqualLockExpressionNested<N>
class	SynchronizedFluent.IfBodyNested<N>
class	SynchronizedFluent.IfDslThenStepBodyNested<N>
class	SynchronizedFluent.IndexLockExpressionNested<N>
class	SynchronizedFluent.InstanceOfLockExpressionNested<N>
class	SynchronizedFluent.InverseLockExpressionNested<N>
class	SynchronizedFluent.LambdaBodyNested<N>
class	SynchronizedFluent.LambdaLockExpressionNested<N>
class	SynchronizedFluent.LeftShiftBodyNested<N>
class	SynchronizedFluent.LeftShiftLockExpressionNested<N>
class	SynchronizedFluent.LessThanBodyNested<N>
class	SynchronizedFluent.LessThanLockExpressionNested<N>
class	SynchronizedFluent.LessThanOrEqualBodyNested<N>
class	SynchronizedFluent.LessThanOrEqualLockExpressionNested<N>
class	SynchronizedFluent.LogicalAndBodyNested<N>
class	SynchronizedFluent.LogicalAndLockExpressionNested<N>
class	SynchronizedFluent.LogicalOrBodyNested<N>
class	SynchronizedFluent.LogicalOrLockExpressionNested<N>
class	SynchronizedFluent.MethodCallBodyNested<N>
class	SynchronizedFluent.MethodCallLockExpressionNested<N>
class	SynchronizedFluent.MinusBodyNested<N>
class	SynchronizedFluent.MinusLockExpressionNested<N>
class	SynchronizedFluent.ModuloBodyNested<N>
class	SynchronizedFluent.ModuloLockExpressionNested<N>
class	SynchronizedFluent.MultiplyBodyNested<N>
class	SynchronizedFluent.MultiplyLockExpressionNested<N>
class	SynchronizedFluent.NegativeLockExpressionNested<N>
class	SynchronizedFluent.NewArrayLockExpressionNested<N>
class	SynchronizedFluent.NotEqualsBodyNested<N>
class	SynchronizedFluent.NotEqualsLockExpressionNested<N>
class	SynchronizedFluent.NotLockExpressionNested<N>
class	SynchronizedFluent.PlusBodyNested<N>
class	SynchronizedFluent.PlusLockExpressionNested<N>
class	SynchronizedFluent.PositiveLockExpressionNested<N>
class	SynchronizedFluent.PostDecrementBodyNested<N>
class	SynchronizedFluent.PostDecrementLockExpressionNested<N>
class	SynchronizedFluent.PostIncrementBodyNested<N>
class	SynchronizedFluent.PostIncrementLockExpressionNested<N>
class	SynchronizedFluent.PreDecrementBodyNested<N>
class	SynchronizedFluent.PreDecrementLockExpressionNested<N>
class	SynchronizedFluent.PreIncrementBodyNested<N>
class	SynchronizedFluent.PreIncrementLockExpressionNested<N>
class	SynchronizedFluent.PropertyLockExpressionNested<N>
class	SynchronizedFluent.PropertyRefBodyNested<N>
class	SynchronizedFluent.PropertyRefLockExpressionNested<N>
class	SynchronizedFluent.ReturnBodyNested<N>
class	SynchronizedFluent.ReturnDslThisStepBodyNested<N>
class	SynchronizedFluent.ReturnDslVariableStepBodyNested<N>
class	SynchronizedFluent.RightShiftBodyNested<N>
class	SynchronizedFluent.RightShiftLockExpressionNested<N>
class	SynchronizedFluent.RightUnsignedShiftBodyNested<N>
class	SynchronizedFluent.RightUnsignedShiftLockExpressionNested<N>
class	SynchronizedFluent.StringStatementBodyNested<N>
class	SynchronizedFluent.SuperLockExpressionNested<N>
class	SynchronizedFluent.SwitchBodyNested<N>
class	SynchronizedFluent.SynchronizedBodyNested<N>
class	SynchronizedFluent.TernaryLockExpressionNested<N>
class	SynchronizedFluent.ThisLockExpressionNested<N>
class	SynchronizedFluent.ThrowBodyNested<N>
class	SynchronizedFluent.TryBodyNested<N>
class	SynchronizedFluent.ValueRefLockExpressionNested<N>
class	SynchronizedFluent.WhileBodyNested<N>
class	SynchronizedFluent.XorBodyNested<N>
class	SynchronizedFluent.XorLockExpressionNested<N>

Field Summary

Fields inherited from class io.sundr.builder.BaseFluent

_visitables

Constructor Summary

Constructors

Constructor	Description
SynchronizedFluent()
SynchronizedFluent(Synchronized instance)

Method Summary

Modifier and Type	Method	Description
Statement	buildBody()
protected static <T> VisitableBuilder<T,?>	builder(Object item)
Expression	buildLockExpression()
protected void	copyInstance(Synchronized instance)
boolean	equals(Object o)
boolean	hasBody()
int	hashCode()
boolean	hasLockExpression()
String	toString()
A	withBody(Statement body)
A	withLockExpression(Expression lockExpression)
SynchronizedFluent<A>.AssignBodyNested<A>	withNewAssignBody()
SynchronizedFluent<A>.AssignBodyNested<A>	withNewAssignBodyLike(Assign item)
SynchronizedFluent<A>.AssignLockExpressionNested<A>	withNewAssignLockExpression()
SynchronizedFluent<A>.AssignLockExpressionNested<A>	withNewAssignLockExpressionLike(Assign item)
SynchronizedFluent<A>.BinaryExpressionBodyNested<A>	withNewBinaryExpressionBody()
SynchronizedFluent<A>.BinaryExpressionBodyNested<A>	withNewBinaryExpressionBodyLike(BinaryExpression item)
SynchronizedFluent<A>.BinaryExpressionLockNested<A>	withNewBinaryExpressionLock()
SynchronizedFluent<A>.BinaryExpressionLockNested<A>	withNewBinaryExpressionLockLike(BinaryExpression item)
SynchronizedFluent<A>.BitwiseAndBodyNested<A>	withNewBitwiseAndBody()
A	withNewBitwiseAndBody(Object left, Object right)
SynchronizedFluent<A>.BitwiseAndBodyNested<A>	withNewBitwiseAndBodyLike(BitwiseAnd item)
SynchronizedFluent<A>.BitwiseAndLockExpressionNested<A>	withNewBitwiseAndLockExpression()
A	withNewBitwiseAndLockExpression(Object left, Object right)
SynchronizedFluent<A>.BitwiseAndLockExpressionNested<A>	withNewBitwiseAndLockExpressionLike(BitwiseAnd item)
SynchronizedFluent<A>.BitwiseOrBodyNested<A>	withNewBitwiseOrBody()
A	withNewBitwiseOrBody(Object left, Object right)
SynchronizedFluent<A>.BitwiseOrBodyNested<A>	withNewBitwiseOrBodyLike(BitwiseOr item)
SynchronizedFluent<A>.BitwiseOrLockExpressionNested<A>	withNewBitwiseOrLockExpression()
A	withNewBitwiseOrLockExpression(Object left, Object right)
SynchronizedFluent<A>.BitwiseOrLockExpressionNested<A>	withNewBitwiseOrLockExpressionLike(BitwiseOr item)
SynchronizedFluent<A>.BlockBodyNested<A>	withNewBlockBody()
SynchronizedFluent<A>.BlockBodyNested<A>	withNewBlockBodyLike(Block item)
SynchronizedFluent<A>.BreakBodyNested<A>	withNewBreakBody()
SynchronizedFluent<A>.BreakBodyNested<A>	withNewBreakBodyLike(Break item)
SynchronizedFluent<A>.CastLockExpressionNested<A>	withNewCastLockExpression()
SynchronizedFluent<A>.CastLockExpressionNested<A>	withNewCastLockExpressionLike(Cast item)
SynchronizedFluent<A>.ClassRefLockExpressionNested<A>	withNewClassRefLockExpression()
SynchronizedFluent<A>.ClassRefLockExpressionNested<A>	withNewClassRefLockExpressionLike(ClassRef item)
SynchronizedFluent<A>.ConstructBodyNested<A>	withNewConstructBody()
SynchronizedFluent<A>.ConstructBodyNested<A>	withNewConstructBodyLike(Construct item)
SynchronizedFluent<A>.ConstructLockExpressionNested<A>	withNewConstructLockExpression()
SynchronizedFluent<A>.ConstructLockExpressionNested<A>	withNewConstructLockExpressionLike(Construct item)
SynchronizedFluent<A>.ContextRefLockExpressionNested<A>	withNewContextRefLockExpression()
A	withNewContextRefLockExpression(String name)
SynchronizedFluent<A>.ContextRefLockExpressionNested<A>	withNewContextRefLockExpressionLike(ContextRef item)
SynchronizedFluent<A>.ContinueBodyNested<A>	withNewContinueBody()
SynchronizedFluent<A>.ContinueBodyNested<A>	withNewContinueBodyLike(Continue item)
SynchronizedFluent<A>.DeclareBodyNested<A>	withNewDeclareBody()
A	withNewDeclareBody(Class type, String name)
A	withNewDeclareBody(Class type, String name, Object value)
SynchronizedFluent<A>.DeclareBodyNested<A>	withNewDeclareBodyLike(Declare item)
SynchronizedFluent<A>.DeclareLockExpressionNested<A>	withNewDeclareLockExpression()
A	withNewDeclareLockExpression(Class type, String name)
A	withNewDeclareLockExpression(Class type, String name, Object value)
SynchronizedFluent<A>.DeclareLockExpressionNested<A>	withNewDeclareLockExpressionLike(Declare item)
SynchronizedFluent<A>.DivideBodyNested<A>	withNewDivideBody()
A	withNewDivideBody(Object left, Object right)
SynchronizedFluent<A>.DivideBodyNested<A>	withNewDivideBodyLike(Divide item)
SynchronizedFluent<A>.DivideLockExpressionNested<A>	withNewDivideLockExpression()
A	withNewDivideLockExpression(Object left, Object right)
SynchronizedFluent<A>.DivideLockExpressionNested<A>	withNewDivideLockExpressionLike(Divide item)
SynchronizedFluent<A>.DoBodyNested<A>	withNewDoBody()
SynchronizedFluent<A>.DoBodyNested<A>	withNewDoBodyLike(Do item)
SynchronizedFluent<A>.DotClassLockExpressionNested<A>	withNewDotClassLockExpression()
SynchronizedFluent<A>.DotClassLockExpressionNested<A>	withNewDotClassLockExpressionLike(DotClass item)
SynchronizedFluent<A>.EmptyBodyNested<A>	withNewEmptyBody()
SynchronizedFluent<A>.EmptyBodyNested<A>	withNewEmptyBodyLike(Empty item)
SynchronizedFluent<A>.EmptyLockExpressionNested<A>	withNewEmptyLockExpression()
SynchronizedFluent<A>.EmptyLockExpressionNested<A>	withNewEmptyLockExpressionLike(Empty item)
SynchronizedFluent<A>.EnclosedLockExpressionNested<A>	withNewEnclosedLockExpression()
SynchronizedFluent<A>.EnclosedLockExpressionNested<A>	withNewEnclosedLockExpressionLike(Enclosed item)
SynchronizedFluent<A>.EqualsBodyNested<A>	withNewEqualsBody()
A	withNewEqualsBody(Object left, Object right)
SynchronizedFluent<A>.EqualsBodyNested<A>	withNewEqualsBodyLike(Equals item)
SynchronizedFluent<A>.EqualsLockExpressionNested<A>	withNewEqualsLockExpression()
A	withNewEqualsLockExpression(Object left, Object right)
SynchronizedFluent<A>.EqualsLockExpressionNested<A>	withNewEqualsLockExpressionLike(Equals item)
SynchronizedFluent<A>.ForBodyNested<A>	withNewForBody()
SynchronizedFluent<A>.ForBodyNested<A>	withNewForBodyLike(For item)
SynchronizedFluent<A>.ForeachBodyNested<A>	withNewForeachBody()
SynchronizedFluent<A>.ForeachBodyNested<A>	withNewForeachBodyLike(Foreach item)
SynchronizedFluent<A>.GreaterThanBodyNested<A>	withNewGreaterThanBody()
A	withNewGreaterThanBody(Object left, Object right)
SynchronizedFluent<A>.GreaterThanBodyNested<A>	withNewGreaterThanBodyLike(GreaterThan item)
SynchronizedFluent<A>.GreaterThanLockExpressionNested<A>	withNewGreaterThanLockExpression()
A	withNewGreaterThanLockExpression(Object left, Object right)
SynchronizedFluent<A>.GreaterThanLockExpressionNested<A>	withNewGreaterThanLockExpressionLike(GreaterThan item)
SynchronizedFluent<A>.GreaterThanOrEqualBodyNested<A>	withNewGreaterThanOrEqualBody()
A	withNewGreaterThanOrEqualBody(Object left, Object right)
SynchronizedFluent<A>.GreaterThanOrEqualBodyNested<A>	withNewGreaterThanOrEqualBodyLike(GreaterThanOrEqual item)
SynchronizedFluent<A>.GreaterThanOrEqualLockExpressionNested<A>	withNewGreaterThanOrEqualLockExpression()
A	withNewGreaterThanOrEqualLockExpression(Object left, Object right)
SynchronizedFluent<A>.GreaterThanOrEqualLockExpressionNested<A>	withNewGreaterThanOrEqualLockExpressionLike(GreaterThanOrEqual item)
SynchronizedFluent<A>.IfBodyNested<A>	withNewIfBody()
SynchronizedFluent<A>.IfBodyNested<A>	withNewIfBodyLike(If item)
SynchronizedFluent<A>.IfDslThenStepBodyNested<A>	withNewIfDslThenStepBody()
SynchronizedFluent<A>.IfDslThenStepBodyNested<A>	withNewIfDslThenStepBodyLike(IfDslThenStep item)
SynchronizedFluent<A>.IndexLockExpressionNested<A>	withNewIndexLockExpression()
SynchronizedFluent<A>.IndexLockExpressionNested<A>	withNewIndexLockExpressionLike(Index item)
SynchronizedFluent<A>.InstanceOfLockExpressionNested<A>	withNewInstanceOfLockExpression()
SynchronizedFluent<A>.InstanceOfLockExpressionNested<A>	withNewInstanceOfLockExpressionLike(InstanceOf item)
SynchronizedFluent<A>.InverseLockExpressionNested<A>	withNewInverseLockExpression()
SynchronizedFluent<A>.InverseLockExpressionNested<A>	withNewInverseLockExpressionLike(Inverse item)
SynchronizedFluent<A>.LambdaBodyNested<A>	withNewLambdaBody()
SynchronizedFluent<A>.LambdaBodyNested<A>	withNewLambdaBodyLike(Lambda item)
SynchronizedFluent<A>.LambdaLockExpressionNested<A>	withNewLambdaLockExpression()
SynchronizedFluent<A>.LambdaLockExpressionNested<A>	withNewLambdaLockExpressionLike(Lambda item)
SynchronizedFluent<A>.LeftShiftBodyNested<A>	withNewLeftShiftBody()
A	withNewLeftShiftBody(Object left, Object right)
SynchronizedFluent<A>.LeftShiftBodyNested<A>	withNewLeftShiftBodyLike(LeftShift item)
SynchronizedFluent<A>.LeftShiftLockExpressionNested<A>	withNewLeftShiftLockExpression()
A	withNewLeftShiftLockExpression(Object left, Object right)
SynchronizedFluent<A>.LeftShiftLockExpressionNested<A>	withNewLeftShiftLockExpressionLike(LeftShift item)
SynchronizedFluent<A>.LessThanBodyNested<A>	withNewLessThanBody()
A	withNewLessThanBody(Object left, Object right)
SynchronizedFluent<A>.LessThanBodyNested<A>	withNewLessThanBodyLike(LessThan item)
SynchronizedFluent<A>.LessThanLockExpressionNested<A>	withNewLessThanLockExpression()
A	withNewLessThanLockExpression(Object left, Object right)
SynchronizedFluent<A>.LessThanLockExpressionNested<A>	withNewLessThanLockExpressionLike(LessThan item)
SynchronizedFluent<A>.LessThanOrEqualBodyNested<A>	withNewLessThanOrEqualBody()
A	withNewLessThanOrEqualBody(Object left, Object right)
SynchronizedFluent<A>.LessThanOrEqualBodyNested<A>	withNewLessThanOrEqualBodyLike(LessThanOrEqual item)
SynchronizedFluent<A>.LessThanOrEqualLockExpressionNested<A>	withNewLessThanOrEqualLockExpression()
A	withNewLessThanOrEqualLockExpression(Object left, Object right)
SynchronizedFluent<A>.LessThanOrEqualLockExpressionNested<A>	withNewLessThanOrEqualLockExpressionLike(LessThanOrEqual item)
SynchronizedFluent<A>.LogicalAndBodyNested<A>	withNewLogicalAndBody()
A	withNewLogicalAndBody(Object left, Object right)
SynchronizedFluent<A>.LogicalAndBodyNested<A>	withNewLogicalAndBodyLike(LogicalAnd item)
SynchronizedFluent<A>.LogicalAndLockExpressionNested<A>	withNewLogicalAndLockExpression()
A	withNewLogicalAndLockExpression(Object left, Object right)
SynchronizedFluent<A>.LogicalAndLockExpressionNested<A>	withNewLogicalAndLockExpressionLike(LogicalAnd item)
SynchronizedFluent<A>.LogicalOrBodyNested<A>	withNewLogicalOrBody()
A	withNewLogicalOrBody(Object left, Object right)
SynchronizedFluent<A>.LogicalOrBodyNested<A>	withNewLogicalOrBodyLike(LogicalOr item)
SynchronizedFluent<A>.LogicalOrLockExpressionNested<A>	withNewLogicalOrLockExpression()
A	withNewLogicalOrLockExpression(Object left, Object right)
SynchronizedFluent<A>.LogicalOrLockExpressionNested<A>	withNewLogicalOrLockExpressionLike(LogicalOr item)
SynchronizedFluent<A>.MethodCallBodyNested<A>	withNewMethodCallBody()
SynchronizedFluent<A>.MethodCallBodyNested<A>	withNewMethodCallBodyLike(MethodCall item)
SynchronizedFluent<A>.MethodCallLockExpressionNested<A>	withNewMethodCallLockExpression()
SynchronizedFluent<A>.MethodCallLockExpressionNested<A>	withNewMethodCallLockExpressionLike(MethodCall item)
SynchronizedFluent<A>.MinusBodyNested<A>	withNewMinusBody()
A	withNewMinusBody(Object left, Object right)
SynchronizedFluent<A>.MinusBodyNested<A>	withNewMinusBodyLike(Minus item)
SynchronizedFluent<A>.MinusLockExpressionNested<A>	withNewMinusLockExpression()
A	withNewMinusLockExpression(Object left, Object right)
SynchronizedFluent<A>.MinusLockExpressionNested<A>	withNewMinusLockExpressionLike(Minus item)
SynchronizedFluent<A>.ModuloBodyNested<A>	withNewModuloBody()
A	withNewModuloBody(Object left, Object right)
SynchronizedFluent<A>.ModuloBodyNested<A>	withNewModuloBodyLike(Modulo item)
SynchronizedFluent<A>.ModuloLockExpressionNested<A>	withNewModuloLockExpression()
A	withNewModuloLockExpression(Object left, Object right)
SynchronizedFluent<A>.ModuloLockExpressionNested<A>	withNewModuloLockExpressionLike(Modulo item)
SynchronizedFluent<A>.MultiplyBodyNested<A>	withNewMultiplyBody()
A	withNewMultiplyBody(Object left, Object right)
SynchronizedFluent<A>.MultiplyBodyNested<A>	withNewMultiplyBodyLike(Multiply item)
SynchronizedFluent<A>.MultiplyLockExpressionNested<A>	withNewMultiplyLockExpression()
A	withNewMultiplyLockExpression(Object left, Object right)
SynchronizedFluent<A>.MultiplyLockExpressionNested<A>	withNewMultiplyLockExpressionLike(Multiply item)
SynchronizedFluent<A>.NegativeLockExpressionNested<A>	withNewNegativeLockExpression()
SynchronizedFluent<A>.NegativeLockExpressionNested<A>	withNewNegativeLockExpressionLike(Negative item)
SynchronizedFluent<A>.NewArrayLockExpressionNested<A>	withNewNewArrayLockExpression()
A	withNewNewArrayLockExpression(Class type, Integer[] sizes)
SynchronizedFluent<A>.NewArrayLockExpressionNested<A>	withNewNewArrayLockExpressionLike(NewArray item)
SynchronizedFluent<A>.NotEqualsBodyNested<A>	withNewNotEqualsBody()
A	withNewNotEqualsBody(Object left, Object right)
SynchronizedFluent<A>.NotEqualsBodyNested<A>	withNewNotEqualsBodyLike(NotEquals item)
SynchronizedFluent<A>.NotEqualsLockExpressionNested<A>	withNewNotEqualsLockExpression()
A	withNewNotEqualsLockExpression(Object left, Object right)
SynchronizedFluent<A>.NotEqualsLockExpressionNested<A>	withNewNotEqualsLockExpressionLike(NotEquals item)
SynchronizedFluent<A>.NotLockExpressionNested<A>	withNewNotLockExpression()
SynchronizedFluent<A>.NotLockExpressionNested<A>	withNewNotLockExpressionLike(Not item)
SynchronizedFluent<A>.PlusBodyNested<A>	withNewPlusBody()
A	withNewPlusBody(Object left, Object right)
SynchronizedFluent<A>.PlusBodyNested<A>	withNewPlusBodyLike(Plus item)
SynchronizedFluent<A>.PlusLockExpressionNested<A>	withNewPlusLockExpression()
A	withNewPlusLockExpression(Object left, Object right)
SynchronizedFluent<A>.PlusLockExpressionNested<A>	withNewPlusLockExpressionLike(Plus item)
SynchronizedFluent<A>.PositiveLockExpressionNested<A>	withNewPositiveLockExpression()
SynchronizedFluent<A>.PositiveLockExpressionNested<A>	withNewPositiveLockExpressionLike(Positive item)
SynchronizedFluent<A>.PostDecrementBodyNested<A>	withNewPostDecrementBody()
SynchronizedFluent<A>.PostDecrementBodyNested<A>	withNewPostDecrementBodyLike(PostDecrement item)
SynchronizedFluent<A>.PostDecrementLockExpressionNested<A>	withNewPostDecrementLockExpression()
SynchronizedFluent<A>.PostDecrementLockExpressionNested<A>	withNewPostDecrementLockExpressionLike(PostDecrement item)
SynchronizedFluent<A>.PostIncrementBodyNested<A>	withNewPostIncrementBody()
SynchronizedFluent<A>.PostIncrementBodyNested<A>	withNewPostIncrementBodyLike(PostIncrement item)
SynchronizedFluent<A>.PostIncrementLockExpressionNested<A>	withNewPostIncrementLockExpression()
SynchronizedFluent<A>.PostIncrementLockExpressionNested<A>	withNewPostIncrementLockExpressionLike(PostIncrement item)
SynchronizedFluent<A>.PreDecrementBodyNested<A>	withNewPreDecrementBody()
SynchronizedFluent<A>.PreDecrementBodyNested<A>	withNewPreDecrementBodyLike(PreDecrement item)
SynchronizedFluent<A>.PreDecrementLockExpressionNested<A>	withNewPreDecrementLockExpression()
SynchronizedFluent<A>.PreDecrementLockExpressionNested<A>	withNewPreDecrementLockExpressionLike(PreDecrement item)
SynchronizedFluent<A>.PreIncrementBodyNested<A>	withNewPreIncrementBody()
SynchronizedFluent<A>.PreIncrementBodyNested<A>	withNewPreIncrementBodyLike(PreIncrement item)
SynchronizedFluent<A>.PreIncrementLockExpressionNested<A>	withNewPreIncrementLockExpression()
SynchronizedFluent<A>.PreIncrementLockExpressionNested<A>	withNewPreIncrementLockExpressionLike(PreIncrement item)
SynchronizedFluent<A>.PropertyLockExpressionNested<A>	withNewPropertyLockExpression()
SynchronizedFluent<A>.PropertyLockExpressionNested<A>	withNewPropertyLockExpressionLike(Property item)
SynchronizedFluent<A>.PropertyRefBodyNested<A>	withNewPropertyRefBody()
SynchronizedFluent<A>.PropertyRefBodyNested<A>	withNewPropertyRefBodyLike(PropertyRef item)
SynchronizedFluent<A>.PropertyRefLockExpressionNested<A>	withNewPropertyRefLockExpression()
SynchronizedFluent<A>.PropertyRefLockExpressionNested<A>	withNewPropertyRefLockExpressionLike(PropertyRef item)
SynchronizedFluent<A>.ReturnBodyNested<A>	withNewReturnBody()
A	withNewReturnBody(Object object)
SynchronizedFluent<A>.ReturnBodyNested<A>	withNewReturnBodyLike(Return item)
SynchronizedFluent<A>.ReturnDslThisStepBodyNested<A>	withNewReturnDslThisStepBody()
SynchronizedFluent<A>.ReturnDslThisStepBodyNested<A>	withNewReturnDslThisStepBodyLike(ReturnDslThisStep item)
SynchronizedFluent<A>.ReturnDslVariableStepBodyNested<A>	withNewReturnDslVariableStepBody()
A	withNewReturnDslVariableStepBody(String name)
SynchronizedFluent<A>.ReturnDslVariableStepBodyNested<A>	withNewReturnDslVariableStepBodyLike(ReturnDslVariableStep item)
SynchronizedFluent<A>.RightShiftBodyNested<A>	withNewRightShiftBody()
A	withNewRightShiftBody(Object left, Object right)
SynchronizedFluent<A>.RightShiftBodyNested<A>	withNewRightShiftBodyLike(RightShift item)
SynchronizedFluent<A>.RightShiftLockExpressionNested<A>	withNewRightShiftLockExpression()
A	withNewRightShiftLockExpression(Object left, Object right)
SynchronizedFluent<A>.RightShiftLockExpressionNested<A>	withNewRightShiftLockExpressionLike(RightShift item)
SynchronizedFluent<A>.RightUnsignedShiftBodyNested<A>	withNewRightUnsignedShiftBody()
A	withNewRightUnsignedShiftBody(Object left, Object right)
SynchronizedFluent<A>.RightUnsignedShiftBodyNested<A>	withNewRightUnsignedShiftBodyLike(RightUnsignedShift item)
SynchronizedFluent<A>.RightUnsignedShiftLockExpressionNested<A>	withNewRightUnsignedShiftLockExpression()
A	withNewRightUnsignedShiftLockExpression(Object left, Object right)
SynchronizedFluent<A>.RightUnsignedShiftLockExpressionNested<A>	withNewRightUnsignedShiftLockExpressionLike(RightUnsignedShift item)
SynchronizedFluent<A>.StringStatementBodyNested<A>	withNewStringStatementBody()
A	withNewStringStatementBody(String data)
A	withNewStringStatementBody(String data, Object[] parameters)
SynchronizedFluent<A>.StringStatementBodyNested<A>	withNewStringStatementBodyLike(StringStatement item)
SynchronizedFluent<A>.SuperLockExpressionNested<A>	withNewSuperLockExpression()
SynchronizedFluent<A>.SuperLockExpressionNested<A>	withNewSuperLockExpressionLike(Super item)
SynchronizedFluent<A>.SwitchBodyNested<A>	withNewSwitchBody()
SynchronizedFluent<A>.SwitchBodyNested<A>	withNewSwitchBodyLike(Switch item)
SynchronizedFluent<A>.SynchronizedBodyNested<A>	withNewSynchronizedBody()
SynchronizedFluent<A>.SynchronizedBodyNested<A>	withNewSynchronizedBodyLike(Synchronized item)
SynchronizedFluent<A>.TernaryLockExpressionNested<A>	withNewTernaryLockExpression()
SynchronizedFluent<A>.TernaryLockExpressionNested<A>	withNewTernaryLockExpressionLike(Ternary item)
SynchronizedFluent<A>.ThisLockExpressionNested<A>	withNewThisLockExpression()
SynchronizedFluent<A>.ThisLockExpressionNested<A>	withNewThisLockExpressionLike(This item)
SynchronizedFluent<A>.ThrowBodyNested<A>	withNewThrowBody()
SynchronizedFluent<A>.ThrowBodyNested<A>	withNewThrowBodyLike(Throw item)
SynchronizedFluent<A>.TryBodyNested<A>	withNewTryBody()
SynchronizedFluent<A>.TryBodyNested<A>	withNewTryBodyLike(Try item)
SynchronizedFluent<A>.ValueRefLockExpressionNested<A>	withNewValueRefLockExpression()
A	withNewValueRefLockExpression(Object value)
SynchronizedFluent<A>.ValueRefLockExpressionNested<A>	withNewValueRefLockExpressionLike(ValueRef item)
SynchronizedFluent<A>.WhileBodyNested<A>	withNewWhileBody()
SynchronizedFluent<A>.WhileBodyNested<A>	withNewWhileBodyLike(While item)
SynchronizedFluent<A>.XorBodyNested<A>	withNewXorBody()
A	withNewXorBody(Object left, Object right)
SynchronizedFluent<A>.XorBodyNested<A>	withNewXorBodyLike(Xor item)
SynchronizedFluent<A>.XorLockExpressionNested<A>	withNewXorLockExpression()
A	withNewXorLockExpression(Object left, Object right)
SynchronizedFluent<A>.XorLockExpressionNested<A>	withNewXorLockExpressionLike(Xor item)

Methods inherited from class io.sundr.builder.BaseFluent

aggregate, aggregate, build, build, builderOf, getVisitableMap

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Details

SynchronizedFluent

public SynchronizedFluent()

SynchronizedFluent

public SynchronizedFluent(Synchronized instance)

Method Details

buildBody

public Statement buildBody()

buildLockExpression

public Expression buildLockExpression()

builder

protected static <T> VisitableBuilder<T,?> builder(Object item)

copyInstance

protected void copyInstance(Synchronized instance)

equals

public boolean equals(Object o)

Overrides:

equals in class BaseFluent<A extends SynchronizedFluent<A>>

hasBody

public boolean hasBody()

hasLockExpression

public boolean hasLockExpression()

hashCode

public int hashCode()

Overrides:

hashCode in class BaseFluent<A extends SynchronizedFluent<A>>

toString

public String toString()

Overrides:

toString in class Object

withBody

public A withBody(Statement body)

withLockExpression

public A withLockExpression(Expression lockExpression)

withNewAssignBody

public SynchronizedFluent<A>.AssignBodyNested<A> withNewAssignBody()

withNewAssignBodyLike

public SynchronizedFluent<A>.AssignBodyNested<A> withNewAssignBodyLike(Assign item)

withNewAssignLockExpression

public SynchronizedFluent<A>.AssignLockExpressionNested<A> withNewAssignLockExpression()

withNewAssignLockExpressionLike

public SynchronizedFluent<A>.AssignLockExpressionNested<A> withNewAssignLockExpressionLike(Assign item)

withNewBinaryExpressionBody

public SynchronizedFluent<A>.BinaryExpressionBodyNested<A> withNewBinaryExpressionBody()

withNewBinaryExpressionBodyLike

public SynchronizedFluent<A>.BinaryExpressionBodyNested<A> withNewBinaryExpressionBodyLike(BinaryExpression item)

withNewBinaryExpressionLock

public SynchronizedFluent<A>.BinaryExpressionLockNested<A> withNewBinaryExpressionLock()

withNewBinaryExpressionLockLike

public SynchronizedFluent<A>.BinaryExpressionLockNested<A> withNewBinaryExpressionLockLike(BinaryExpression item)

withNewBitwiseAndBody

public SynchronizedFluent<A>.BitwiseAndBodyNested<A> withNewBitwiseAndBody()

withNewBitwiseAndBody

public A withNewBitwiseAndBody(Object left,
 Object right)

withNewBitwiseAndBodyLike

public SynchronizedFluent<A>.BitwiseAndBodyNested<A> withNewBitwiseAndBodyLike(BitwiseAnd item)

withNewBitwiseAndLockExpression

public SynchronizedFluent<A>.BitwiseAndLockExpressionNested<A> withNewBitwiseAndLockExpression()

withNewBitwiseAndLockExpression

public A withNewBitwiseAndLockExpression(Object left,
 Object right)

withNewBitwiseAndLockExpressionLike

public SynchronizedFluent<A>.BitwiseAndLockExpressionNested<A> withNewBitwiseAndLockExpressionLike(BitwiseAnd item)

withNewBitwiseOrBody

public SynchronizedFluent<A>.BitwiseOrBodyNested<A> withNewBitwiseOrBody()

withNewBitwiseOrBody

public A withNewBitwiseOrBody(Object left,
 Object right)

withNewBitwiseOrBodyLike

public SynchronizedFluent<A>.BitwiseOrBodyNested<A> withNewBitwiseOrBodyLike(BitwiseOr item)

withNewBitwiseOrLockExpression

public SynchronizedFluent<A>.BitwiseOrLockExpressionNested<A> withNewBitwiseOrLockExpression()

withNewBitwiseOrLockExpression

public A withNewBitwiseOrLockExpression(Object left,
 Object right)

withNewBitwiseOrLockExpressionLike

public SynchronizedFluent<A>.BitwiseOrLockExpressionNested<A> withNewBitwiseOrLockExpressionLike(BitwiseOr item)

withNewBlockBody

public SynchronizedFluent<A>.BlockBodyNested<A> withNewBlockBody()

withNewBlockBodyLike

public SynchronizedFluent<A>.BlockBodyNested<A> withNewBlockBodyLike(Block item)

withNewBreakBody

public SynchronizedFluent<A>.BreakBodyNested<A> withNewBreakBody()

withNewBreakBodyLike

public SynchronizedFluent<A>.BreakBodyNested<A> withNewBreakBodyLike(Break item)

withNewCastLockExpression

public SynchronizedFluent<A>.CastLockExpressionNested<A> withNewCastLockExpression()

withNewCastLockExpressionLike

public SynchronizedFluent<A>.CastLockExpressionNested<A> withNewCastLockExpressionLike(Cast item)

withNewClassRefLockExpression

public SynchronizedFluent<A>.ClassRefLockExpressionNested<A> withNewClassRefLockExpression()

withNewClassRefLockExpressionLike

public SynchronizedFluent<A>.ClassRefLockExpressionNested<A> withNewClassRefLockExpressionLike(ClassRef item)

withNewConstructBody

public SynchronizedFluent<A>.ConstructBodyNested<A> withNewConstructBody()

withNewConstructBodyLike

public SynchronizedFluent<A>.ConstructBodyNested<A> withNewConstructBodyLike(Construct item)

withNewConstructLockExpression

public SynchronizedFluent<A>.ConstructLockExpressionNested<A> withNewConstructLockExpression()

withNewConstructLockExpressionLike

public SynchronizedFluent<A>.ConstructLockExpressionNested<A> withNewConstructLockExpressionLike(Construct item)

withNewContextRefLockExpression

public SynchronizedFluent<A>.ContextRefLockExpressionNested<A> withNewContextRefLockExpression()

withNewContextRefLockExpression

public A withNewContextRefLockExpression(String name)

withNewContextRefLockExpressionLike

public SynchronizedFluent<A>.ContextRefLockExpressionNested<A> withNewContextRefLockExpressionLike(ContextRef item)

withNewContinueBody

public SynchronizedFluent<A>.ContinueBodyNested<A> withNewContinueBody()

withNewContinueBodyLike

public SynchronizedFluent<A>.ContinueBodyNested<A> withNewContinueBodyLike(Continue item)

withNewDeclareBody

public SynchronizedFluent<A>.DeclareBodyNested<A> withNewDeclareBody()

withNewDeclareBody

public A withNewDeclareBody(Class type,
 String name)

withNewDeclareBody

public A withNewDeclareBody(Class type,
 String name,
 Object value)

withNewDeclareBodyLike

public SynchronizedFluent<A>.DeclareBodyNested<A> withNewDeclareBodyLike(Declare item)

withNewDeclareLockExpression

public SynchronizedFluent<A>.DeclareLockExpressionNested<A> withNewDeclareLockExpression()

withNewDeclareLockExpression

public A withNewDeclareLockExpression(Class type,
 String name)

withNewDeclareLockExpression

public A withNewDeclareLockExpression(Class type,
 String name,
 Object value)

withNewDeclareLockExpressionLike

public SynchronizedFluent<A>.DeclareLockExpressionNested<A> withNewDeclareLockExpressionLike(Declare item)

withNewDivideBody

public SynchronizedFluent<A>.DivideBodyNested<A> withNewDivideBody()

withNewDivideBody

public A withNewDivideBody(Object left,
 Object right)

withNewDivideBodyLike

public SynchronizedFluent<A>.DivideBodyNested<A> withNewDivideBodyLike(Divide item)

withNewDivideLockExpression

public SynchronizedFluent<A>.DivideLockExpressionNested<A> withNewDivideLockExpression()

withNewDivideLockExpression

public A withNewDivideLockExpression(Object left,
 Object right)

withNewDivideLockExpressionLike

public SynchronizedFluent<A>.DivideLockExpressionNested<A> withNewDivideLockExpressionLike(Divide item)

withNewDoBody

public SynchronizedFluent<A>.DoBodyNested<A> withNewDoBody()

withNewDoBodyLike

public SynchronizedFluent<A>.DoBodyNested<A> withNewDoBodyLike(Do item)

withNewDotClassLockExpression

public SynchronizedFluent<A>.DotClassLockExpressionNested<A> withNewDotClassLockExpression()

withNewDotClassLockExpressionLike

public SynchronizedFluent<A>.DotClassLockExpressionNested<A> withNewDotClassLockExpressionLike(DotClass item)

withNewEmptyBody

public SynchronizedFluent<A>.EmptyBodyNested<A> withNewEmptyBody()

withNewEmptyBodyLike

public SynchronizedFluent<A>.EmptyBodyNested<A> withNewEmptyBodyLike(Empty item)

withNewEmptyLockExpression

public SynchronizedFluent<A>.EmptyLockExpressionNested<A> withNewEmptyLockExpression()

withNewEmptyLockExpressionLike

public SynchronizedFluent<A>.EmptyLockExpressionNested<A> withNewEmptyLockExpressionLike(Empty item)

withNewEnclosedLockExpression

public SynchronizedFluent<A>.EnclosedLockExpressionNested<A> withNewEnclosedLockExpression()

withNewEnclosedLockExpressionLike

public SynchronizedFluent<A>.EnclosedLockExpressionNested<A> withNewEnclosedLockExpressionLike(Enclosed item)

withNewEqualsBody

public SynchronizedFluent<A>.EqualsBodyNested<A> withNewEqualsBody()

withNewEqualsBody

public A withNewEqualsBody(Object left,
 Object right)

withNewEqualsBodyLike

public SynchronizedFluent<A>.EqualsBodyNested<A> withNewEqualsBodyLike(Equals item)

withNewEqualsLockExpression

public SynchronizedFluent<A>.EqualsLockExpressionNested<A> withNewEqualsLockExpression()

withNewEqualsLockExpression

public A withNewEqualsLockExpression(Object left,
 Object right)

withNewEqualsLockExpressionLike

public SynchronizedFluent<A>.EqualsLockExpressionNested<A> withNewEqualsLockExpressionLike(Equals item)

withNewForBody

public SynchronizedFluent<A>.ForBodyNested<A> withNewForBody()

withNewForBodyLike

public SynchronizedFluent<A>.ForBodyNested<A> withNewForBodyLike(For item)

withNewForeachBody

public SynchronizedFluent<A>.ForeachBodyNested<A> withNewForeachBody()

withNewForeachBodyLike

public SynchronizedFluent<A>.ForeachBodyNested<A> withNewForeachBodyLike(Foreach item)

withNewGreaterThanBody

public SynchronizedFluent<A>.GreaterThanBodyNested<A> withNewGreaterThanBody()

withNewGreaterThanBody

public A withNewGreaterThanBody(Object left,
 Object right)

withNewGreaterThanBodyLike

public SynchronizedFluent<A>.GreaterThanBodyNested<A> withNewGreaterThanBodyLike(GreaterThan item)

withNewGreaterThanLockExpression

public SynchronizedFluent<A>.GreaterThanLockExpressionNested<A> withNewGreaterThanLockExpression()

withNewGreaterThanLockExpression

public A withNewGreaterThanLockExpression(Object left,
 Object right)

withNewGreaterThanLockExpressionLike

public SynchronizedFluent<A>.GreaterThanLockExpressionNested<A> withNewGreaterThanLockExpressionLike(GreaterThan item)

withNewGreaterThanOrEqualBody

public SynchronizedFluent<A>.GreaterThanOrEqualBodyNested<A> withNewGreaterThanOrEqualBody()

withNewGreaterThanOrEqualBody

public A withNewGreaterThanOrEqualBody(Object left,
 Object right)

withNewGreaterThanOrEqualBodyLike

public SynchronizedFluent<A>.GreaterThanOrEqualBodyNested<A> withNewGreaterThanOrEqualBodyLike(GreaterThanOrEqual item)

withNewGreaterThanOrEqualLockExpression

public SynchronizedFluent<A>.GreaterThanOrEqualLockExpressionNested<A> withNewGreaterThanOrEqualLockExpression()

withNewGreaterThanOrEqualLockExpression

public A withNewGreaterThanOrEqualLockExpression(Object left,
 Object right)

withNewGreaterThanOrEqualLockExpressionLike

public SynchronizedFluent<A>.GreaterThanOrEqualLockExpressionNested<A> withNewGreaterThanOrEqualLockExpressionLike(GreaterThanOrEqual item)

withNewIfBody

public SynchronizedFluent<A>.IfBodyNested<A> withNewIfBody()

withNewIfBodyLike

public SynchronizedFluent<A>.IfBodyNested<A> withNewIfBodyLike(If item)

withNewIfDslThenStepBody

public SynchronizedFluent<A>.IfDslThenStepBodyNested<A> withNewIfDslThenStepBody()

withNewIfDslThenStepBodyLike

public SynchronizedFluent<A>.IfDslThenStepBodyNested<A> withNewIfDslThenStepBodyLike(IfDslThenStep item)

withNewIndexLockExpression

public SynchronizedFluent<A>.IndexLockExpressionNested<A> withNewIndexLockExpression()

withNewIndexLockExpressionLike

public SynchronizedFluent<A>.IndexLockExpressionNested<A> withNewIndexLockExpressionLike(Index item)

withNewInstanceOfLockExpression

public SynchronizedFluent<A>.InstanceOfLockExpressionNested<A> withNewInstanceOfLockExpression()

withNewInstanceOfLockExpressionLike

public SynchronizedFluent<A>.InstanceOfLockExpressionNested<A> withNewInstanceOfLockExpressionLike(InstanceOf item)

withNewInverseLockExpression

public SynchronizedFluent<A>.InverseLockExpressionNested<A> withNewInverseLockExpression()

withNewInverseLockExpressionLike

public SynchronizedFluent<A>.InverseLockExpressionNested<A> withNewInverseLockExpressionLike(Inverse item)

withNewLambdaBody

public SynchronizedFluent<A>.LambdaBodyNested<A> withNewLambdaBody()

withNewLambdaBodyLike

public SynchronizedFluent<A>.LambdaBodyNested<A> withNewLambdaBodyLike(Lambda item)

withNewLambdaLockExpression

public SynchronizedFluent<A>.LambdaLockExpressionNested<A> withNewLambdaLockExpression()

withNewLambdaLockExpressionLike

public SynchronizedFluent<A>.LambdaLockExpressionNested<A> withNewLambdaLockExpressionLike(Lambda item)

withNewLeftShiftBody

public SynchronizedFluent<A>.LeftShiftBodyNested<A> withNewLeftShiftBody()

withNewLeftShiftBody

public A withNewLeftShiftBody(Object left,
 Object right)

withNewLeftShiftBodyLike

public SynchronizedFluent<A>.LeftShiftBodyNested<A> withNewLeftShiftBodyLike(LeftShift item)

withNewLeftShiftLockExpression

public SynchronizedFluent<A>.LeftShiftLockExpressionNested<A> withNewLeftShiftLockExpression()

withNewLeftShiftLockExpression

public A withNewLeftShiftLockExpression(Object left,
 Object right)

withNewLeftShiftLockExpressionLike

public SynchronizedFluent<A>.LeftShiftLockExpressionNested<A> withNewLeftShiftLockExpressionLike(LeftShift item)

withNewLessThanBody

public SynchronizedFluent<A>.LessThanBodyNested<A> withNewLessThanBody()

withNewLessThanBody

public A withNewLessThanBody(Object left,
 Object right)

withNewLessThanBodyLike

public SynchronizedFluent<A>.LessThanBodyNested<A> withNewLessThanBodyLike(LessThan item)

withNewLessThanLockExpression

public SynchronizedFluent<A>.LessThanLockExpressionNested<A> withNewLessThanLockExpression()

withNewLessThanLockExpression

public A withNewLessThanLockExpression(Object left,
 Object right)

withNewLessThanLockExpressionLike

public SynchronizedFluent<A>.LessThanLockExpressionNested<A> withNewLessThanLockExpressionLike(LessThan item)

withNewLessThanOrEqualBody

public SynchronizedFluent<A>.LessThanOrEqualBodyNested<A> withNewLessThanOrEqualBody()

withNewLessThanOrEqualBody

public A withNewLessThanOrEqualBody(Object left,
 Object right)

withNewLessThanOrEqualBodyLike

public SynchronizedFluent<A>.LessThanOrEqualBodyNested<A> withNewLessThanOrEqualBodyLike(LessThanOrEqual item)

withNewLessThanOrEqualLockExpression

public SynchronizedFluent<A>.LessThanOrEqualLockExpressionNested<A> withNewLessThanOrEqualLockExpression()

withNewLessThanOrEqualLockExpression

public A withNewLessThanOrEqualLockExpression(Object left,
 Object right)

withNewLessThanOrEqualLockExpressionLike

public SynchronizedFluent<A>.LessThanOrEqualLockExpressionNested<A> withNewLessThanOrEqualLockExpressionLike(LessThanOrEqual item)

withNewLogicalAndBody

public SynchronizedFluent<A>.LogicalAndBodyNested<A> withNewLogicalAndBody()

withNewLogicalAndBody

public A withNewLogicalAndBody(Object left,
 Object right)

withNewLogicalAndBodyLike

public SynchronizedFluent<A>.LogicalAndBodyNested<A> withNewLogicalAndBodyLike(LogicalAnd item)

withNewLogicalAndLockExpression

public SynchronizedFluent<A>.LogicalAndLockExpressionNested<A> withNewLogicalAndLockExpression()

withNewLogicalAndLockExpression

public A withNewLogicalAndLockExpression(Object left,
 Object right)

withNewLogicalAndLockExpressionLike

public SynchronizedFluent<A>.LogicalAndLockExpressionNested<A> withNewLogicalAndLockExpressionLike(LogicalAnd item)

withNewLogicalOrBody

public SynchronizedFluent<A>.LogicalOrBodyNested<A> withNewLogicalOrBody()

withNewLogicalOrBody

public A withNewLogicalOrBody(Object left,
 Object right)

withNewLogicalOrBodyLike

public SynchronizedFluent<A>.LogicalOrBodyNested<A> withNewLogicalOrBodyLike(LogicalOr item)

withNewLogicalOrLockExpression

public SynchronizedFluent<A>.LogicalOrLockExpressionNested<A> withNewLogicalOrLockExpression()

withNewLogicalOrLockExpression

public A withNewLogicalOrLockExpression(Object left,
 Object right)

withNewLogicalOrLockExpressionLike

public SynchronizedFluent<A>.LogicalOrLockExpressionNested<A> withNewLogicalOrLockExpressionLike(LogicalOr item)

withNewMethodCallBody

public SynchronizedFluent<A>.MethodCallBodyNested<A> withNewMethodCallBody()

withNewMethodCallBodyLike

public SynchronizedFluent<A>.MethodCallBodyNested<A> withNewMethodCallBodyLike(MethodCall item)

withNewMethodCallLockExpression

public SynchronizedFluent<A>.MethodCallLockExpressionNested<A> withNewMethodCallLockExpression()

withNewMethodCallLockExpressionLike

public SynchronizedFluent<A>.MethodCallLockExpressionNested<A> withNewMethodCallLockExpressionLike(MethodCall item)

withNewMinusBody

public SynchronizedFluent<A>.MinusBodyNested<A> withNewMinusBody()

withNewMinusBody

public A withNewMinusBody(Object left,
 Object right)

withNewMinusBodyLike

public SynchronizedFluent<A>.MinusBodyNested<A> withNewMinusBodyLike(Minus item)

withNewMinusLockExpression

public SynchronizedFluent<A>.MinusLockExpressionNested<A> withNewMinusLockExpression()

withNewMinusLockExpression

public A withNewMinusLockExpression(Object left,
 Object right)

withNewMinusLockExpressionLike

public SynchronizedFluent<A>.MinusLockExpressionNested<A> withNewMinusLockExpressionLike(Minus item)

withNewModuloBody

public SynchronizedFluent<A>.ModuloBodyNested<A> withNewModuloBody()

withNewModuloBody

public A withNewModuloBody(Object left,
 Object right)

withNewModuloBodyLike

public SynchronizedFluent<A>.ModuloBodyNested<A> withNewModuloBodyLike(Modulo item)

withNewModuloLockExpression

public SynchronizedFluent<A>.ModuloLockExpressionNested<A> withNewModuloLockExpression()

withNewModuloLockExpression

public A withNewModuloLockExpression(Object left,
 Object right)

withNewModuloLockExpressionLike

public SynchronizedFluent<A>.ModuloLockExpressionNested<A> withNewModuloLockExpressionLike(Modulo item)

withNewMultiplyBody

public SynchronizedFluent<A>.MultiplyBodyNested<A> withNewMultiplyBody()

withNewMultiplyBody

public A withNewMultiplyBody(Object left,
 Object right)

withNewMultiplyBodyLike

public SynchronizedFluent<A>.MultiplyBodyNested<A> withNewMultiplyBodyLike(Multiply item)

withNewMultiplyLockExpression

public SynchronizedFluent<A>.MultiplyLockExpressionNested<A> withNewMultiplyLockExpression()

withNewMultiplyLockExpression

public A withNewMultiplyLockExpression(Object left,
 Object right)

withNewMultiplyLockExpressionLike

public SynchronizedFluent<A>.MultiplyLockExpressionNested<A> withNewMultiplyLockExpressionLike(Multiply item)

withNewNegativeLockExpression

public SynchronizedFluent<A>.NegativeLockExpressionNested<A> withNewNegativeLockExpression()

withNewNegativeLockExpressionLike

public SynchronizedFluent<A>.NegativeLockExpressionNested<A> withNewNegativeLockExpressionLike(Negative item)

withNewNewArrayLockExpression

public SynchronizedFluent<A>.NewArrayLockExpressionNested<A> withNewNewArrayLockExpression()

withNewNewArrayLockExpression

public A withNewNewArrayLockExpression(Class type,
 Integer[] sizes)

withNewNewArrayLockExpressionLike

public SynchronizedFluent<A>.NewArrayLockExpressionNested<A> withNewNewArrayLockExpressionLike(NewArray item)

withNewNotEqualsBody

public SynchronizedFluent<A>.NotEqualsBodyNested<A> withNewNotEqualsBody()

withNewNotEqualsBody

public A withNewNotEqualsBody(Object left,
 Object right)

withNewNotEqualsBodyLike

public SynchronizedFluent<A>.NotEqualsBodyNested<A> withNewNotEqualsBodyLike(NotEquals item)

withNewNotEqualsLockExpression

public SynchronizedFluent<A>.NotEqualsLockExpressionNested<A> withNewNotEqualsLockExpression()

withNewNotEqualsLockExpression

public A withNewNotEqualsLockExpression(Object left,
 Object right)

withNewNotEqualsLockExpressionLike

public SynchronizedFluent<A>.NotEqualsLockExpressionNested<A> withNewNotEqualsLockExpressionLike(NotEquals item)

withNewNotLockExpression

public SynchronizedFluent<A>.NotLockExpressionNested<A> withNewNotLockExpression()

withNewNotLockExpressionLike

public SynchronizedFluent<A>.NotLockExpressionNested<A> withNewNotLockExpressionLike(Not item)

withNewPlusBody

public SynchronizedFluent<A>.PlusBodyNested<A> withNewPlusBody()

withNewPlusBody

public A withNewPlusBody(Object left,
 Object right)

withNewPlusBodyLike

public SynchronizedFluent<A>.PlusBodyNested<A> withNewPlusBodyLike(Plus item)

withNewPlusLockExpression

public SynchronizedFluent<A>.PlusLockExpressionNested<A> withNewPlusLockExpression()

withNewPlusLockExpression

public A withNewPlusLockExpression(Object left,
 Object right)

withNewPlusLockExpressionLike

public SynchronizedFluent<A>.PlusLockExpressionNested<A> withNewPlusLockExpressionLike(Plus item)

withNewPositiveLockExpression

public SynchronizedFluent<A>.PositiveLockExpressionNested<A> withNewPositiveLockExpression()

withNewPositiveLockExpressionLike

public SynchronizedFluent<A>.PositiveLockExpressionNested<A> withNewPositiveLockExpressionLike(Positive item)

withNewPostDecrementBody

public SynchronizedFluent<A>.PostDecrementBodyNested<A> withNewPostDecrementBody()

withNewPostDecrementBodyLike

public SynchronizedFluent<A>.PostDecrementBodyNested<A> withNewPostDecrementBodyLike(PostDecrement item)

withNewPostDecrementLockExpression

public SynchronizedFluent<A>.PostDecrementLockExpressionNested<A> withNewPostDecrementLockExpression()

withNewPostDecrementLockExpressionLike

public SynchronizedFluent<A>.PostDecrementLockExpressionNested<A> withNewPostDecrementLockExpressionLike(PostDecrement item)

withNewPostIncrementBody

public SynchronizedFluent<A>.PostIncrementBodyNested<A> withNewPostIncrementBody()

withNewPostIncrementBodyLike

public SynchronizedFluent<A>.PostIncrementBodyNested<A> withNewPostIncrementBodyLike(PostIncrement item)

withNewPostIncrementLockExpression

public SynchronizedFluent<A>.PostIncrementLockExpressionNested<A> withNewPostIncrementLockExpression()

withNewPostIncrementLockExpressionLike

public SynchronizedFluent<A>.PostIncrementLockExpressionNested<A> withNewPostIncrementLockExpressionLike(PostIncrement item)

withNewPreDecrementBody

public SynchronizedFluent<A>.PreDecrementBodyNested<A> withNewPreDecrementBody()

withNewPreDecrementBodyLike

public SynchronizedFluent<A>.PreDecrementBodyNested<A> withNewPreDecrementBodyLike(PreDecrement item)

withNewPreDecrementLockExpression

public SynchronizedFluent<A>.PreDecrementLockExpressionNested<A> withNewPreDecrementLockExpression()

withNewPreDecrementLockExpressionLike

public SynchronizedFluent<A>.PreDecrementLockExpressionNested<A> withNewPreDecrementLockExpressionLike(PreDecrement item)

withNewPreIncrementBody

public SynchronizedFluent<A>.PreIncrementBodyNested<A> withNewPreIncrementBody()

withNewPreIncrementBodyLike

public SynchronizedFluent<A>.PreIncrementBodyNested<A> withNewPreIncrementBodyLike(PreIncrement item)

withNewPreIncrementLockExpression

public SynchronizedFluent<A>.PreIncrementLockExpressionNested<A> withNewPreIncrementLockExpression()

withNewPreIncrementLockExpressionLike

public SynchronizedFluent<A>.PreIncrementLockExpressionNested<A> withNewPreIncrementLockExpressionLike(PreIncrement item)

withNewPropertyLockExpression

public SynchronizedFluent<A>.PropertyLockExpressionNested<A> withNewPropertyLockExpression()

withNewPropertyLockExpressionLike

public SynchronizedFluent<A>.PropertyLockExpressionNested<A> withNewPropertyLockExpressionLike(Property item)

withNewPropertyRefBody

public SynchronizedFluent<A>.PropertyRefBodyNested<A> withNewPropertyRefBody()

withNewPropertyRefBodyLike

public SynchronizedFluent<A>.PropertyRefBodyNested<A> withNewPropertyRefBodyLike(PropertyRef item)

withNewPropertyRefLockExpression

public SynchronizedFluent<A>.PropertyRefLockExpressionNested<A> withNewPropertyRefLockExpression()

withNewPropertyRefLockExpressionLike

public SynchronizedFluent<A>.PropertyRefLockExpressionNested<A> withNewPropertyRefLockExpressionLike(PropertyRef item)

withNewReturnBody

public SynchronizedFluent<A>.ReturnBodyNested<A> withNewReturnBody()

withNewReturnBody

public A withNewReturnBody(Object object)

withNewReturnBodyLike

public SynchronizedFluent<A>.ReturnBodyNested<A> withNewReturnBodyLike(Return item)

withNewReturnDslThisStepBody

public SynchronizedFluent<A>.ReturnDslThisStepBodyNested<A> withNewReturnDslThisStepBody()

withNewReturnDslThisStepBodyLike

public SynchronizedFluent<A>.ReturnDslThisStepBodyNested<A> withNewReturnDslThisStepBodyLike(ReturnDslThisStep item)

withNewReturnDslVariableStepBody

public SynchronizedFluent<A>.ReturnDslVariableStepBodyNested<A> withNewReturnDslVariableStepBody()

withNewReturnDslVariableStepBody

public A withNewReturnDslVariableStepBody(String name)

withNewReturnDslVariableStepBodyLike

public SynchronizedFluent<A>.ReturnDslVariableStepBodyNested<A> withNewReturnDslVariableStepBodyLike(ReturnDslVariableStep item)

withNewRightShiftBody

public SynchronizedFluent<A>.RightShiftBodyNested<A> withNewRightShiftBody()

withNewRightShiftBody

public A withNewRightShiftBody(Object left,
 Object right)

withNewRightShiftBodyLike

public SynchronizedFluent<A>.RightShiftBodyNested<A> withNewRightShiftBodyLike(RightShift item)

withNewRightShiftLockExpression

public SynchronizedFluent<A>.RightShiftLockExpressionNested<A> withNewRightShiftLockExpression()

withNewRightShiftLockExpression

public A withNewRightShiftLockExpression(Object left,
 Object right)

withNewRightShiftLockExpressionLike

public SynchronizedFluent<A>.RightShiftLockExpressionNested<A> withNewRightShiftLockExpressionLike(RightShift item)

withNewRightUnsignedShiftBody

public SynchronizedFluent<A>.RightUnsignedShiftBodyNested<A> withNewRightUnsignedShiftBody()

withNewRightUnsignedShiftBody

public A withNewRightUnsignedShiftBody(Object left,
 Object right)

withNewRightUnsignedShiftBodyLike

public SynchronizedFluent<A>.RightUnsignedShiftBodyNested<A> withNewRightUnsignedShiftBodyLike(RightUnsignedShift item)

withNewRightUnsignedShiftLockExpression

public SynchronizedFluent<A>.RightUnsignedShiftLockExpressionNested<A> withNewRightUnsignedShiftLockExpression()

withNewRightUnsignedShiftLockExpression

public A withNewRightUnsignedShiftLockExpression(Object left,
 Object right)

withNewRightUnsignedShiftLockExpressionLike

public SynchronizedFluent<A>.RightUnsignedShiftLockExpressionNested<A> withNewRightUnsignedShiftLockExpressionLike(RightUnsignedShift item)

withNewStringStatementBody

public SynchronizedFluent<A>.StringStatementBodyNested<A> withNewStringStatementBody()

withNewStringStatementBody

public A withNewStringStatementBody(String data)

withNewStringStatementBody

public A withNewStringStatementBody(String data,
 Object[] parameters)

withNewStringStatementBodyLike

public SynchronizedFluent<A>.StringStatementBodyNested<A> withNewStringStatementBodyLike(StringStatement item)

withNewSuperLockExpression

public SynchronizedFluent<A>.SuperLockExpressionNested<A> withNewSuperLockExpression()

withNewSuperLockExpressionLike

public SynchronizedFluent<A>.SuperLockExpressionNested<A> withNewSuperLockExpressionLike(Super item)

withNewSwitchBody

public SynchronizedFluent<A>.SwitchBodyNested<A> withNewSwitchBody()

withNewSwitchBodyLike

public SynchronizedFluent<A>.SwitchBodyNested<A> withNewSwitchBodyLike(Switch item)

withNewSynchronizedBody

public SynchronizedFluent<A>.SynchronizedBodyNested<A> withNewSynchronizedBody()

withNewSynchronizedBodyLike

public SynchronizedFluent<A>.SynchronizedBodyNested<A> withNewSynchronizedBodyLike(Synchronized item)

withNewTernaryLockExpression

public SynchronizedFluent<A>.TernaryLockExpressionNested<A> withNewTernaryLockExpression()

withNewTernaryLockExpressionLike

public SynchronizedFluent<A>.TernaryLockExpressionNested<A> withNewTernaryLockExpressionLike(Ternary item)

withNewThisLockExpression

public SynchronizedFluent<A>.ThisLockExpressionNested<A> withNewThisLockExpression()

withNewThisLockExpressionLike

public SynchronizedFluent<A>.ThisLockExpressionNested<A> withNewThisLockExpressionLike(This item)

withNewThrowBody

public SynchronizedFluent<A>.ThrowBodyNested<A> withNewThrowBody()

withNewThrowBodyLike

public SynchronizedFluent<A>.ThrowBodyNested<A> withNewThrowBodyLike(Throw item)

withNewTryBody

public SynchronizedFluent<A>.TryBodyNested<A> withNewTryBody()

withNewTryBodyLike

public SynchronizedFluent<A>.TryBodyNested<A> withNewTryBodyLike(Try item)

withNewValueRefLockExpression

public SynchronizedFluent<A>.ValueRefLockExpressionNested<A> withNewValueRefLockExpression()

withNewValueRefLockExpression

public A withNewValueRefLockExpression(Object value)

withNewValueRefLockExpressionLike

public SynchronizedFluent<A>.ValueRefLockExpressionNested<A> withNewValueRefLockExpressionLike(ValueRef item)

withNewWhileBody

public SynchronizedFluent<A>.WhileBodyNested<A> withNewWhileBody()

withNewWhileBodyLike

public SynchronizedFluent<A>.WhileBodyNested<A> withNewWhileBodyLike(While item)

withNewXorBody

public SynchronizedFluent<A>.XorBodyNested<A> withNewXorBody()

withNewXorBody

public A withNewXorBody(Object left,
 Object right)

withNewXorBodyLike

public SynchronizedFluent<A>.XorBodyNested<A> withNewXorBodyLike(Xor item)

withNewXorLockExpression

public SynchronizedFluent<A>.XorLockExpressionNested<A> withNewXorLockExpression()

withNewXorLockExpression

public A withNewXorLockExpression(Object left,
 Object right)

withNewXorLockExpressionLike

public SynchronizedFluent<A>.XorLockExpressionNested<A> withNewXorLockExpressionLike(Xor item)