<p>fillArgs.</p>

@param operator a {@link java.lang.String} object.
@param args     an array of {@link ameba.db.dsl.QueryExprMeta.Val} objects.
@param et       a {@link io.ebean.ExpressionList} object.
357010
public static void fillArgs(String operator, Val<Expression>[] args, ExpressionList<?> et) {
        for (Val<Expression> val : args) {
            if (val.object() instanceof Expression) {
                et.add(val.expr());
            } else {
                throw new QuerySyntaxException(Messages.get("dsl.arguments.error3", operator));
            }
        }
    }
242220
public static PointExpression<Point> pointOperation(Operator op, Expression<?>... args) {
        return new PointOperation<Point>(Point.class, op, args);
    }
912720
public static PolygonExpression<Polygon> polygonOperation(Operator op, Expression<?>... args) {
        return new PolygonOperation<Polygon>(Polygon.class, op, args);
    }
1178268
private void oneArg(String[] args, int index) {
        if ((index + 1) < args.length) {
            setOption(args[index], args[index+1]);
        } else {
            usageError("main.requires_argument", args[index]);
        }
    }
39334
public boolean matches(Operator<?> operator) {
        final Type expectedType = TypeUtils.unrollVariables(
            TypeUtils.getTypeArguments(operator.getClass(), Operator.class), Operator.class.getTypeParameters()[0]);

        if (!TypeUtils.isInstance(this, expectedType)) {
            return false;
        }
        final Map<TypeVariable<?>, Type> typeArguments = TypeUtils.getTypeArguments(expectedType, Operation.class);
        for (Class<?> c : ClassUtils.hierarchy(TypeUtils.getRawType(expectedType, operator.getClass()))) {
            if (c.equals(Operation.class)) {
                break;
            }
            for (TypeVariable<?> var : c.getTypeParameters()) {
                Type type = Types.resolveAt(this, var, typeArguments);
                if (type == null || typeArguments == null) {
                    continue;
                }
                if (type instanceof Class<?> && ((Class<?>) type).isPrimitive()) {
                    type = ClassUtils.primitiveToWrapper((Class<?>) type);
                }
                if (!TypeUtils.isAssignable(type, TypeUtils.unrollVariables(typeArguments, var))) {
                    return false;
                }
            }
        }
        return true;
    }
145863
public final void arguments() throws RecognitionException {
		int arguments_StartIndex = input.index();

		try {
			if ( state.backtracking>0 && alreadyParsedRule(input, 140) ) { return; }

			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1297:5: ( '(' ( expressionList )? ')' )
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1297:7: '(' ( expressionList )? ')'
			{
			match(input,36,FOLLOW_36_in_arguments6395); if (state.failed) return;
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1297:11: ( expressionList )?
			int alt192=2;
			int LA192_0 = input.LA(1);
			if ( ((LA192_0 >= CharacterLiteral && LA192_0 <= DecimalLiteral)||LA192_0==FloatingPointLiteral||(LA192_0 >= HexLiteral && LA192_0 <= Identifier)||(LA192_0 >= OctalLiteral && LA192_0 <= StringLiteral)||LA192_0==29||LA192_0==36||(LA192_0 >= 40 && LA192_0 <= 41)||(LA192_0 >= 44 && LA192_0 <= 45)||LA192_0==53||LA192_0==65||LA192_0==67||(LA192_0 >= 70 && LA192_0 <= 71)||LA192_0==77||(LA192_0 >= 79 && LA192_0 <= 80)||LA192_0==82||LA192_0==85||LA192_0==92||LA192_0==94||(LA192_0 >= 97 && LA192_0 <= 98)||LA192_0==105||LA192_0==108||LA192_0==111||LA192_0==115||LA192_0==118||LA192_0==126) ) {
				alt192=1;
			}
			switch (alt192) {
				case 1 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1297:11: expressionList
					{
					pushFollow(FOLLOW_expressionList_in_arguments6397);
					expressionList();
					state._fsp--;
					if (state.failed) return;
					}
					break;

			}

			match(input,37,FOLLOW_37_in_arguments6400); if (state.failed) return;
			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
			if ( state.backtracking>0 ) { memoize(input, 140, arguments_StartIndex); }

		}
	}
1178927
def InsertArg(self, string="", **_):
    """"""
    if self.state == "LIST_ARG":
      self.list_args.append(string)
    elif self.current_expression.AddArg(string):
      # This expression is complete
      self.stack.append(self.current_expression)
      self.current_expression = self.expression_cls()
      # We go to the BINARY state, to find if there's an AND or OR operator
      return "BINARY"
1343339
public static <T> DslOperation<T> dslOperation(Class<? extends T> type, Operator operator,
            Expression<?>... args) {
        return new DslOperation<T>(type, operator, args);
    }
535435
Symbol resolveOperator(DiagnosticPosition pos, JCTree.Tag optag,
                           Env<AttrContext> env, List<Type> argtypes) {
        MethodResolutionContext prevResolutionContext = currentResolutionContext;
        try {
            currentResolutionContext = new MethodResolutionContext();
            Name name = treeinfo.operatorName(optag);
            return lookupMethod(env, pos, syms.predefClass, currentResolutionContext,
                    new BasicLookupHelper(name, syms.predefClass.type, argtypes, null, BOX) {
                @Override
                Symbol doLookup(Env<AttrContext> env, MethodResolutionPhase phase) {
                    return findMethod(env, site, name, argtypes, typeargtypes,
                            phase.isBoxingRequired(),
                            phase.isVarargsRequired(), true);
                }
                @Override
                Symbol access(Env<AttrContext> env, DiagnosticPosition pos, Symbol location, Symbol sym) {
                    return accessMethod(sym, pos, env.enclClass.sym.type, name,
                          false, argtypes, null);
                }
            });
        } finally {
            currentResolutionContext = prevResolutionContext;
        }
    }
336810
@Override
    public List<? extends SatConstraint> buildConstraint(BtrPlaceTree t, List<BtrpOperand> args) {

        if (!checkConformance(t, args)) {
            return Collections.emptyList();
        }

        // Get the first parameter
        @SuppressWarnings("unchecked")
        List<VM> s = (List<VM>) params[0].transform(this, t, args.get(0));
        if (s == null) {
            return Collections.emptyList();
        }

        // Get param 'OneOf'
        Object obj = params[1].transform(this, t, args.get(1));
        if (obj == null) {
            return Collections.emptyList();
        }
        if (obj instanceof List) {
            @SuppressWarnings("unchecked")
            List<VM> s2 = (List<VM>) obj;
            if (s2.isEmpty()) {
                t.ignoreError("Parameter '" + params[1].getName() + "' expects a non-empty list of VMs");
                return Collections.emptyList();
            }
            return Precedence.newPrecedence(s, s2);
        } else if (obj instanceof String) {
            String timestamp = (String) obj;
            if ("".equals(timestamp)) {
                t.ignoreError("Parameter '" + params[1].getName() + "' expects a non-empty string");
                return Collections.emptyList();
            }
            return Deadline.newDeadline(s, timestamp);
        } else {
            return Collections.emptyList();
        }
    }
1275602
public static <T extends Comparable<?>> DateTimeOperation<T> dateTimeOperation(Class<? extends T> type,
            Operator operator, Expression<?>... args) {
        return new DateTimeOperation<T>(type, operator, args);
    }
699405
@Nonnull
  public IMPLTYPE arg (@Nonnull final IJSExpression aExpr)
  {
    ValueEnforcer.notNull (aExpr, "Argument");
    m_aArgs.add (aExpr);
    return _thisAsT ();
  }
569715
public Operator operator(final Token tok) throws Exception
    {
        final String token = tok.getValue().toString();
        final Constructor<?> constructor = operatorMap.get(token);
        if (constructor == null)
            return null;
        try
        {
            return (Operator) constructor.newInstance(new Object[] {
                    tok
            });
        } catch (final Exception e)
        {
            throw new Exception("operator construction", e);
        }
    }
521434
protected Element[] calculateArgs(Context context)
			throws EvaluationException {

		Element[] results = new Element[ops.length];
		for (int i = 0; i < ops.length; i++) {
			results[i] = ops[i].execute(context);
		}

		return results;
	}
192048
function (item, expression) {
            var ret = 1,
                operator = expression.operator;

            if (expression instanceof Query.Where) {
                if (operator === "or") {
                    ret = 0;
                }
                var tmp;
                for (var i = 0; i < expression.expressions.length; i++) {
                    tmp = this._filterItem(item, expression.expressions[i]);
                    if (operator === "and") {
                        ret = ret * tmp;
                    } else if (operator === "or" && tmp) {
                        return 1;
                    } else if (operator === "not") {
                        return tmp ? 0 : 1;
                    }
                }
            } else if (expression instanceof Query.Comparator) {
                // TODO: add type check
                var value = expression.value,
                    field = expression.field,
                    itemValue = this._getValueForItemField(item, field);

                if (typeof(itemValue) === "undefined") {
                    return 0;
                }

                switch (operator) {
                    case "eql":
                        return itemValue == value;
                    case "gt":
                        return itemValue > value;
                    case "lt":
                        return itemValue < value;
                    case "gte":
                        return itemValue >= value;
                    case "lte":
                        return itemValue <= value;
                    case "in":
                        if (!(itemValue instanceof Array)) {
                            itemValue = [itemValue];
                        }
                        for (var j = 0; j < itemValue.length; j++) {
                            for (var k in value) {
                                if (value.hasOwnProperty(k)) {
                                    if (itemValue[j] == value[k]) {
                                        return 1;
                                    }
                                }
                            }
                        }
                        return 0;
                    case "between":
                        return itemValue >= value[0] && itemValue <= value[1];
                    case "like":
                        return new RegExp(value, "i").test(itemValue);
                    case "ne":
                        return itemValue != value;
                    default :
                        return 1;
                }

            }

            return ret;
        }
1053830
protected QueryExprMeta arguments(Val<?>... arguments) {
        if (this.arguments == null) this.arguments = Lists.newArrayList();
        Collections.addAll(this.arguments, arguments);
        return this;
    }
181940
public ExpressionBuilder operator(Operator operator) {
        this.checkOperatorSymbol(operator);
        this.userOperators.put(operator.getSymbol(), operator);
        return this;
    }