public static ItemGroup Of(this ItemGroup itemGroup, long tenantId)
{
itemGroup.TenantId = tenantId;
itemGroup.Title = ConstantFactory.Text();
return(itemGroup);
}
public static OptionGroup To(this OptionGroup optionGroup, ItemGroup itemGroup)
{
optionGroup.TenantId = itemGroup.TenantId;
optionGroup.Title = ConstantFactory.Text();
optionGroup.ItemGroup = itemGroup;
return(optionGroup);
}
public static SaveOptionJson Build(this SaveOptionJson json, long groupId)
{
json.GroupId = groupId;
json.Name = ConstantFactory.Text();
json.Description = ConstantFactory.Text();
json.Price = 5;
json.IsAvailable = true;
return(json);
}
public static Option To(this Option option, OptionGroup optionGroup, bool available = true)
{
option.TenantId = optionGroup.TenantId;
option.Name = ConstantFactory.Text();
option.Description = ConstantFactory.Text(length: 50, wordCount: 6);
option.Price = 5;
option.IsAvailable = available;
option.OptionGroup = optionGroup;
return(option);
}
public static Item To(this Item item, ItemGroup itemGroup, bool available = true)
{
item.TenantId = itemGroup.TenantId;
item.Name = ConstantFactory.Text();
item.Description = ConstantFactory.Text(length: 50, wordCount: 6);
item.Price = 5;
item.IsAvailable = available;
item.ItemGroup = itemGroup;
return(item);
}
public Invoke(int function, int[] arguments)
{
this.function = function;
this.arguments = arguments;
var functions = new Functions();
int x = arguments[0];
var unwrappedX = (IntConstant)ConstantFactory.GetConstant(x);
int y = arguments[1];
var unwrappedY = (IntConstant)ConstantFactory.GetConstant(y);
var func = functions.IdToFunction[this.function];
var result = func.Invoke(unwrappedX.value, unwrappedY.value);
var constant = new ConstantFactory().CreateIntOrBool(result);
this.id = constant.id;
}
public static bool ResolveParameter(
Type parameterType, ref VisualTreeRunContext context,
[NotNullWhen(true)] out IFactory?result)
{
foreach (var candidate in context.AllParameterPossibilities())
{
if (candidate is IFactory fact && parameterType.IsAssignableFrom(fact.TargetType))
{
result = fact;
return(true);
}
if (parameterType.IsInstanceOfType(candidate))
{
result = new ConstantFactory(candidate);
return(true);
}
}
result = null;
return(false);
}
public static SaveOptionGroupJson Build(this SaveOptionGroupJson json)
{
json.Title = ConstantFactory.Text();
return(json);
}
protected virtual Expression <T> Unary(IEnumerator <Token> tokens, IDictionary <string, VariableExpression <T> > variables)
{
tokens.MoveNext();
switch (tokens.Current.TokenType)
{
case TokenType.Scalar:
ScalarExpression <T> subExpr = ParseScalarValue(tokens.Current.Value);
tokens.MoveNext();
return(subExpr);
case TokenType.Identifier:
string identifierName = tokens.Current.Value;
tokens.MoveNext();
ConstantExpression <T> consExpr = ConstantFactory.CreateConstant(identifierName);
if (consExpr != null)
{
return(consExpr);
}
VariableExpression <T> varExpr = null;
if (!variables.TryGetValue(identifierName, out varExpr))
{
varExpr = new VariableExpression <T>(identifierName);
variables.Add(identifierName, varExpr);
}
return(varExpr);
case TokenType.Operator:
Func <IEnumerator <Token>, IDictionary <string, VariableExpression <T> >, Expression <T> > func;
if (UnaryOperatorHandlers.TryGetValue(tokens.Current.Value, out func))
{
return(func(tokens, variables));
}
else
{
throw new SyntaxException(String.Format("Incorrect operator \"{0}\".", tokens.Current.Value));
}
case TokenType.Function:
string funcName = tokens.Current.Value;
IList <Expression <T> > args = new List <Expression <T> >();
tokens.MoveNext();
if (tokens.Current.Value != "(")
{
throw ThrowExpectedException("(");
}
args.Add(AddSub(tokens, variables));
while (tokens.Current.Value != ")" && tokens.Current.Value == ",")
{
args.Add(AddSub(tokens, variables));
}
if (tokens.Current.Value != ")")
{
throw ThrowExpectedException(")");
}
tokens.MoveNext();
return(FunctionFactory.CreateFunction(funcName, args.ToArray()));
default:
throw new SyntaxException();
}
}
/**
* Creates a Factory that will return the same object each time the factory
* is used. No check is made that the object is immutable. In general, only
* immutable objects should use the constant factory. Mutable objects should
* use the prototype factory.
*
* @see org.apache.commons.collections.functors.ConstantFactory
*
* @param constantToReturn the constant object to return each time in the factory
* @return the <code>constant</code> factory.
*/
public static Factory constantFactory(Object constantToReturn)
{
return(ConstantFactory.getInstance(constantToReturn));
}
