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)); }