Appends a less than test to the condition.

@param trigger the trigger field.
@param compare the value to use in the compare.
@return this ExpressionBuilder.
160285
public ExpressionBuilder lessThan(final SubordinateTrigger trigger, final Object compare) {
		BooleanExpression exp = new CompareExpression(CompareType.LESS_THAN, trigger, compare);
		appendExpression(exp);

		return this;
	}
1255503
private static void validateTrigger(String targetType, BoxWebHook.Trigger trigger) {
        for (String type : trigger.getTypes()) {
            if (targetType.equals(type)) {
                return;
            }
        }
        throw new IllegalArgumentException(String.format(
                "Provided trigger '%s' is not supported on provided target '%s'.", trigger.name(), targetType));
    }
496955
public ExpressionBuilder not(final ExpressionBuilder exp) {
		// Note - NOT Expressions are not added to the stack (like the other group expressions AND and OR) and are
		// treated the same as a "compare" expression.
		// It is expected a NOT Expression is used by itself or with an AND or NOT.
		GroupExpression not = new GroupExpression(Type.NOT);
		not.add(exp.expression.getExpression());

		appendExpression(not);

		return this;
	}
1322817
public SqlBuilder where(final Condition... cons) {
    if (isNotEmpty(statement)) throw new RuntimeException("cannot add condition to a exists statement");
    return where(Arrays.asList(cons));
  }
125882
@Override
    public Predicate ge(Expression<? extends Number> arg0, Number arg1)
    {
        // TODO Auto-generated method stub
        return new ComparisonPredicate(arg0, arg1, ConditionalOperator.GTE);
    }
129386
private ReqlFunction1 parseAndBuildFilters(EntityType entityType, Expression whereExp)
    {
        if (whereExp instanceof ComparisonExpression)
        {
            String left = ((ComparisonExpression) whereExp).getLeftExpression().toActualText();

            String right = ((ComparisonExpression) whereExp).getRightExpression().toActualText();
            right = right.replaceAll("['\"]", "");
            if (right.startsWith(POSITIONAL_PREFIX) || right.startsWith(PARAMETERIZED_PREFIX))
            {
                right = kunderaQuery.getParametersMap().get(right) + "";
            }
            Attribute attribute = entityType.getAttribute(left.split(DOT_REGEX)[1]);
            boolean isId = ((Field) attribute.getJavaMember()).isAnnotationPresent(Id.class);
          
            return buildFunction(isId ? ID : ((AbstractAttribute) attribute).getJPAColumnName(),
                    ConvertUtils.convert(right, attribute.getJavaType()),
                    ((ComparisonExpression) whereExp).getActualIdentifier());
        }
        else
        {
            logger.error("Operation not supported");
            throw new KunderaException("Operation not supported");
        }
    }
571297
public static OtherwiseBuilder getBuilder( ConditionCol52 c ) {

        if ( c.getOperator().equals( "==" ) ) {
            return new EqualsOtherwiseBuilder();
        } else if ( c.getOperator().equals( "!=" ) ) {
            return new NotEqualsOtherwiseBuilder();
        }
        throw new IllegalArgumentException( "ConditionCol operator does not support Otherwise values" );
    }
444951
public static ExpressionComparator compareTo(List<String> properties) {
		ExpressionComparator comparator = ExpressionComparator.create();
		for (String property : properties) {
			comparator.with(thisProperty(property), thatProperty(property), true);
		}
		return comparator;
	}
379589
private void hookToTrigger(final T trigger) {
        // Hook to trigger only if not already done (the same trigger adatper will be used if it was already hooked)
        if (!triggersToTriggerAdapters.containsKey(trigger)) {
            final TriggerListener triggerAdapter = new TriggerAdapter(trigger);
            triggersToTriggerAdapters.put(trigger, triggerAdapter);
            trigger.addTriggerListener(triggerAdapter);
        }
    }
561514
protected function replaceSingleHavingClause(Query\Expr\Comparison $comparison, ColumnCollection $columns, QueryBuilder $queryBuilder)
    {
        $source     = $columns->get($comparison->getLeftExpr())->getPaginatorSource();
        $param      = $comparison->getRightExpr();
        $operator   = $this->getOperator($comparison->getOperator());
        $expression = $queryBuilder->expr()->{$operator}($source, $param);
        $queryBuilder->andWhere($expression);
    }
1352711
protected void addEqualsCondition(final Expression<String> property, final String value) {
        fieldConditions.add(getCriteriaBuilder().equal(property, value));
    }
623342
function execTrigger(trigger) {
    if (!trigger) {
      return true;
    }
    // "trigger1[,trigger2]*"
    if (/^([\w-_]+)(,[\w-_]+)*$/.test(trigger)) {
      var a1 = String(getArgument('trigger')).split(',');
      var a2 = trigger.split(',');
      var flag = false;
      a1.every(function (item) {
        if (a2.indexOf(item) >= 0) {
          flag = true;
        }
        return !flag;
      });
      return flag;
    }
    // "@trigger === 'debug'"
    // "#variant === 'debug'"
    // ":environment === 'debug'"
    /*jslint evil: true */
    return new Function('return (' +
      trigger.replace(/(@|#|:)([\w-_]+)/g, function (all, flag, name) {
        if (flag === '@') {
          return JSON.stringify(getArgument(name));
        }
        else if (flag === ':') {
          return JSON.stringify(getEnvironment(name));
        }
        else {
          return JSON.stringify(getVariant(name));
        }
      }) +
      ')'
    )();
  }
1171366
public ConditionalBuilder when(Object value, Matcher expression) {
        action.setConditionExpression(new HamcrestConditionExpression(expression, value));
        return this;
    }
59240
public Filter<T> lessThan(T value) {
		return new ComparableFilter<T>(this, value, Operator.LESS_THAN);
	}
655532
@SuppressWarnings("unchecked")
	@Override
	public T lessEqual(final String col, final Object value) {
		context().param(CaseFormat.CAMEL_CASE.convert(col), new LessEqual(col, value));
		this.useOperator = true;
		return (T) this;
	}
1011798
@Override
  public int compareTo(RuleMatch other) {
    Objects.requireNonNull(other);
    return Integer.compare(getFromPos(), other.getFromPos());
  }
181913
protected void fireTrigger(final ReplicationTrigger trigger) {
        Log.d(Log.TAG_SYNC, "%s [fireTrigger()] => " + trigger, this);
        // All state machine triggers need to happen on the replicator thread
        synchronized (executor) {
            if (!executor.isShutdown()) {
                executor.submit(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Log.d(Log.TAG_SYNC, "firing trigger: %s", trigger);
                            stateMachine.fire(trigger);
                        } catch (Exception e) {
                            Log.i(Log.TAG_SYNC, "Error in StateMachine.fire(trigger): %s", e.getMessage());
                            throw new RuntimeException(e);
                        }
                    }
                });
            }
        }
    }