/// <summary>
/// Initializes a new instance of <see cref="ConditionalStatement" /> for the specified condition, true statement and false statement.
/// </summary>
/// <param name="parent">The parent condition in a chain of if-elseif conditions.</param>
/// <param name="condition">The condition that is tested.</param>
/// <param name="thenStatement">The statement that is run when the condition evaluates to anything else but falsy.</param>
/// <param name="elseStatement">The statement that is run when the condition evaluates to falsy.</param>
public ConditionalStatement(ConditionalStatement parent, Expression condition, Statement thenStatement, Statement elseStatement)
{
_parent = parent;
_condition = condition;
_thenStatement = thenStatement;
_elseStatement = elseStatement;
}
/// <summary>
/// Initializes a new instance of <see cref="LoopStatement" /> for the specified initializtion, condition, iteration and statement.
/// </summary>
/// <param name="initialization">The initialization of the loop.</param>
/// <param name="condition">The condition of the loop.</param>
/// <param name="iteration">The iteration of the loop.</param>
/// <param name="statement">The statement to run in the loop.</param>
/// <remarks>
/// The Statement property cannot be null. Use an <see cref="EmptyStatement"/> statement if necessary.
/// All of the other parameters are optional, leaving all of them out will result in an eternal loop.
/// </remarks>
public LoopStatement(Expression initialization, Expression condition, Expression iteration, Statement statement)
{
_initialization = initialization;
_condition = condition;
_iteration = iteration;
_statement = statement;
}
/// <summary>
/// Creates a new instance of <see cref="DoWhileStatement" /> and adds a condition.
/// </summary>
/// <param name="whileStatement">The existing instance of <see cref="DoWhileStatement" /> to copy the <see cref="DoWhileStatement.Statement" /> from.</param>
/// <param name="condition">The condition to add to the new instance.</param>
/// <returns>a new instance of <see cref="DoWhileStatement" />.</returns>
public static DoWhileStatement While(this DoWhileStatement whileStatement, Expression condition)
{
if (whileStatement == null)
{
throw new ArgumentNullException("whileStatement");
}
return new DoWhileStatement(condition, whileStatement.Statement);
}
/// <summary>
/// Creates a new instance of the CallOperationExpression class,
/// calling on the provided operand with the optionally supplied arguments.
/// </summary>
/// <param name="operand">The expression on which to apply the call operation.</param>
/// <param name="arguments">The arguments to pass in the call.</param>
public CallOperationExpression(Expression operand, IEnumerable<Expression> arguments)
{
_operand = operand;
if (arguments != null)
{
_arguments.AddRange(arguments);
}
}
/// <summary>
/// Initializes a new instance of <see cref="CaseStatement" />.
/// </summary>
/// <param name="value">The literal for which this case is used.</param>
/// <param name="statements">A sequence of statements that run in this case.</param>
public CaseStatement(Expression value, IEnumerable<Statement> statements)
{
_value = value;
if (statements != null)
{
_statements.AddRange(statements);
}
}
/// <summary>
/// Creates a new instance of <see cref="IndexOperationExpression" /> that performs an index operation.
/// </summary>
/// <param name="expression">An expression to perform an index operation on.</param>
/// <param name="operand">The index to retrieve.</param>
/// <returns></returns>
public static IndexOperationExpression Index(this Expression expression, Expression operand)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
return new IndexOperationExpression(expression, operand);
}
/// <summary>
/// Creates a new instance of <see cref="IteratorStatement" /> that iterates over the specified collection.
/// </summary>
/// <param name="statement">The statement to copy the properties from.</param>
/// <param name="collection">The expression to use as the collection.</param>
/// <returns>a new instance of <see cref="IteratorStatement" /></returns>
/// <remarks>
/// This helper method completes a <see cref="IteratorStatement" />.
/// It's used as in the following example:
/// <code>
/// var iteratorstatement = JS.For(id).In(collection);
/// </code>
/// </remarks>
public static IteratorStatement In(this IteratorStatement statement, Expression collection)
{
if (statement == null)
{
throw new ArgumentNullException("statement");
}
return new IteratorStatement(statement.Variable, collection, statement.Statement);
}
/// <summary>
/// Creates a new instance of <see cref="ConditionalStatement" /> that forms an else-if condition after the specified condition.
/// </summary>
/// <param name="statement">The conditional to which to add an else-if condition to.</param>
/// <param name="condition">The condition to test.</param>
/// <returns>a new instance of <see cref="ConditionalStatement" />.</returns>
/// <remarks>
/// This produces a new instance, and has no side effects on the existing statement (as all of the helpers are designed to) but
/// it does refer to the existing instance. Therefore, there may be undesired effects when the original is somehow modified.
/// However, in the typical use case (a fluent description of the conditional statement) there is no such problem.
/// </remarks>
public static ConditionalStatement ElseIf(this ConditionalStatement statement, Expression condition)
{
if (statement == null)
{
throw new ArgumentNullException("statement");
}
ConditionalStatement parent = new ConditionalStatement(statement.Parent, statement.Condition, statement.ThenStatement, null);
ConditionalStatement result = new ConditionalStatement(parent, condition, null, null);
parent.ElseStatement = result;
return result;
}
/// <summary>
/// Creates a new instance of <see cref="ObjectLiteralExpression" />, by copying the specified expression's properties, and adding the specified name and value to the properties.
/// </summary>
/// <param name="expression">The expression to copy the properties from.</param>
/// <param name="name">The name of the property to add.</param>
/// <param name="value">The value of the property to add.</param>
/// <returns>a new instance of <see cref="ObjectLiteralExpression" /></returns>
public static ObjectLiteralExpression WithProperty(this ObjectLiteralExpression expression, Expression name, Expression value)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
ObjectLiteralExpression result = new ObjectLiteralExpression(expression.Properties);
result.Properties[name] = value;
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="BinaryOperationExpression" /> with the specified operator and operands.
/// </summary>
/// <param name="operandLeft">The left side of the binary operation.</param>
/// <param name="operandRight">The right side of the binary operation.</param>
/// <param name="op">The binary operator</param>
public BinaryOperationExpression(Expression operandLeft, Expression operandRight, BinaryOperator op)
{
_operandLeft = operandLeft;
_operandRight = operandRight;
_operator = op;
}
/// <summary>
/// Initializes a new instance of <see cref="WhileStatement" /> for the specified condition and statement.
/// </summary>
/// <param name="condition">The condition to check in the loop.</param>
/// <param name="statement">The statement to run in the loop.</param>
public WhileStatement(Expression condition, Statement statement)
{
_condition = condition;
_statement = statement;
}
/// <summary>
/// Initializes a new instance of <see cref="SwitchStatement" /> for the specified expression.
/// </summary>
/// <param name="expression">The expression on which to switch.</param>
public SwitchStatement(Expression expression)
{
_expression = expression;
}
/// <summary>
/// Initializes a new instance of <see cref="SwitchStatement" /> for the specified expression and cases.
/// </summary>
/// <param name="expression">The expresson on which to switch.</param>
/// <param name="cases">A sequence of cases.</param>
public SwitchStatement(Expression expression, IEnumerable<CaseStatement> cases)
{
_expression = expression;
_cases.AddRange(cases);
}
/// <summary>
/// Creates a new instance of <see cref="UnaryOperationExpression" /> that represents the creation of a new object, using the specified arguments.
/// </summary>
/// <param name="expression">An expression that returns a constructor.</param>
/// <param name="arguments">An array of arguments to pass to the constructor.</param>
/// <returns>a new instance of <see cref="UnaryOperationExpression" />.</returns>
public static UnaryOperationExpression New(Expression expression, params Expression[] arguments)
{
return new UnaryOperationExpression(new CallOperationExpression(expression, arguments), UnaryOperator.New);
}
/// <summary>
/// Creates a new instance of <see cref="CallOperationExpression" /> that represents a call to the Microsoft AJAX global '$get' function.
/// </summary>
/// <param name="expression">The expression to use an argument to the call.</param>
/// <returns>a new instance of <see cref="CallOperationExpression" />.</returns>
public static CallOperationExpression Get(Expression expression)
{
return new CallOperationExpression(Id("$get"), expression);
}
/// <summary>
/// Creates a new instance of <see cref="ThrowStatement" /> that throws the specified expression as an exception.
/// </summary>
/// <param name="expression">The expression to throw.</param>
/// <returns>a new instance of <see cref="ThrowStatement" />.</returns>
public static ThrowStatement Throw(Expression expression)
{
return new ThrowStatement(expression);
}
/// <summary>
/// Initializes a new instance of <see cref="ConditionalStatement" /> for the specified condition, true statement and false statement.
/// </summary>
/// <param name="condition">The condition that is tested.</param>
/// <param name="thenStatement">The statement that is run when the condition evaluates to anything else but falsy.</param>
/// <param name="elseStatement">The statement that is run when the condition evaluates to falsy.</param>
public ConditionalStatement(Expression condition, Statement thenStatement, Statement elseStatement)
: this(null, condition, thenStatement, elseStatement)
{
}
/// <summary>
/// Creates a new instance of <see cref="UnaryOperationExpression" /> that surrounds the specified expression with parens.
/// </summary>
/// <param name="expression">The expression to surround by parens.</param>
/// <returns>a new instance of <see cref="UnaryOperationExpression" />.</returns>
public static UnaryOperationExpression Group(Expression expression)
{
return new UnaryOperationExpression(expression, UnaryOperator.Group);
}
/// <summary>
/// Returns an instance of <see cref="CallOperationExpression" /> containing a call to the alert() function with the specified message.
/// </summary>
public static CallOperationExpression Alert(Expression message)
{
return new CallOperationExpression(Id("alert"), message);
}
/// <summary>
/// Returns an instance of <see cref="CallOperationExpression" /> containing a call to the prompt() function with the specified message.
/// </summary>
public static CallOperationExpression Prompt(Expression message)
{
return new CallOperationExpression(Id("prompt"), message);
}
/// <summary>
/// Creates a new instance of <see cref="UnaryOperationExpression" /> that performs a logical not operator (!) on an expression.
/// </summary>
/// <param name="expression">The expression to perform the logical not operator on.</param>
/// <returns>A new instance of <see cref="UnaryOperationExpression" /></returns>
public static Expression Not(Expression expression)
{
return new UnaryOperationExpression(expression, UnaryOperator.LogicalNot);
}
public static UnaryOperationExpression New(Expression expression, IEnumerable<Expression> arguments = null)
{
return new UnaryOperationExpression(new CallOperationExpression(expression, arguments), UnaryOperator.New);
}
public static LoopStatement For(Expression initialization = null, Expression condition = null, Expression iteration = null)
{
return new LoopStatement(initialization, condition, iteration, Empty());
}
/// <summary>
/// Creates a new instance of <see cref="WhileStatement" /> that will loop while the specified condition returns true.
/// </summary>
/// <param name="condition">An expression that the loop will test for.</param>
/// <returns>a new instance of <see cref="WhileStatement" />.</returns>
public static WhileStatement While(Expression condition)
{
return new WhileStatement(condition, Empty());
}
/// <summary>
/// Creates a new instance of the CallOperationExpression class,
/// calling on the provided operand with the optionally supplied arguments.
/// </summary>
/// <param name="operand">The expression on which to apply the call operation.</param>
/// <param name="arguments">The arguments to pass in the call.</param>
public CallOperationExpression(Expression operand, params Expression[] arguments)
: this(operand, arguments.AsEnumerable())
{
}
/// <summary>
/// Creates a new instance of <see cref="WithStatement" />.
/// </summary>
/// <param name="expression">The expression that will be in the global scope.</param>
/// <returns>a new instance of <see cref="WithStatement" />.</returns>
public static WithStatement With(Expression expression)
{
return new WithStatement(expression, null);
}
public static ReturnStatement Return(Expression value = null)
{
return new ReturnStatement(value);
}
/// <summary>
/// Creates a new instance of <see cref="ConditionalStatement" /> for the specified condition.
/// </summary>
/// <param name="condition">The expression that specifies the condition.</param>
/// <returns>a new instance of <see cref="ConditionalStatement" />.</returns>
public static ConditionalStatement If(Expression condition)
{
return new ConditionalStatement(condition, null, null);
}
/// <summary>
/// Initializes a new instance of <see cref="IteratorStatement" /> for the specified variable, collection and statement.
/// </summary>
/// <param name="variable">The variable that holds the item for an iteration.</param>
/// <param name="collection">The collection on which to iterate.</param>
/// <param name="statement">The statement to run on each iteration.</param>
public IteratorStatement(Expression variable, Expression collection, Statement statement)
{
Variable = variable;
Collection = collection;
Statement = statement;
}
/// <summary>
/// Creates a new instance of <see cref="SwitchStatement" /> that switches on the provided expression.
/// </summary>
/// <param name="expression">An expression to switch on.</param>
/// <returns>a new instance of <see cref="SwitchStatement" />.</returns>
public static SwitchStatement Switch(Expression expression)
{
return new SwitchStatement(expression);
}
