Returns a new condition that applies if {@code this} OR the given {@code condition} apply.

@return new condition
@throws IllegalArgumentException if {@code condition} is null
427629
public Condition<S, D> or(Condition<S, D> condition) {
    Assert.notNull(condition, "condition");
    return Conditions.or(this, condition);
  }
853771
@Override
    public boolean condition(Object input) {
        return op.apply(input.toString(), value, set);
    }
1361270
public static Condition not(final Condition condition) {
    return new Condition("not " + condition.name, !condition.nullIsAllowed) {
      @Override
      public boolean apply(Driver driver, WebElement element) {
        return !condition.apply(driver, element);
      }

      @Override
      public String actualValue(Driver driver, WebElement element) {
        return condition.actualValue(driver, element);
      }
    };
  }
703188
public static <T> Choice<T> condition(boolean condition, T t) {
    return condition ? of(t) : Choice.<T>none();
  }
75665
public Optional<NrqlAlertCondition> update(NrqlAlertCondition condition)
    {
        return HTTP.PUT(String.format("/v2/alerts_nrql_conditions/%d.json", condition.getId()), condition, NRQL_ALERT_CONDITION);
    }
1246261
public static Rule conditionsRule(final Set<Condition> conditions, StateObj results) {
        if (null == conditions) {
            throw new NullPointerException("conditions must not be null");
        }
        final StateObj newstate = States.state(results);
        return new Rule() {
            @Override
            public boolean test(final StateObj input) {
                return applyConditions(input, conditions, true);
            }

            @Override
            public StateObj evaluate(final StateObj stateObj) {
                if (test(stateObj)) {
                    return newstate;
                }
                return null;
            }

            @Override
            public String toString() {
                return "Rule: Conditions(" + conditions + ") => " + newstate;
            }
        };
    }
535649
public Condition<S, D> and(Condition<S, D> condition) {
    Assert.notNull(condition, "condition");
    return Conditions.and(this, condition);
  }
527710
public Expression asNonNullable() {
    if (isNonNullable()) {
      return this;
    }
    return new Expression(resultType, features.plus(Feature.NON_NULLABLE)) {
      @Override
      protected void doGen(CodeBuilder adapter) {
        Expression.this.gen(adapter);
      }
    };
  }
1002477
public function condition($callback = null)
        {
            if ($callback !== null) {
                if (!is_callable($callback)) {
                    throw new InvalidArgumentException(
                        sprintf(
                            "Condition provided is not a valid callback. Given (%s)",
                            gettype($callback)
                        )
                    );
                }

                $this->conditionCallback = $callback;

                return $this;
            }

            return $this->conditionCallback;
        }
888888
public static ProductCanonicalCondition createCanonicalCondition(
      @Nullable ProductCanonicalConditionCondition condition) {
    ProductCanonicalCondition productCanonicalCondition = new ProductCanonicalCondition();
    productCanonicalCondition.setCondition(condition);
    return productCanonicalCondition;
  }
647200
public Optional<AlertCondition> update(AlertCondition condition)
    {
        return HTTP.PUT(String.format("/v2/alerts_conditions/%d.json", condition.getId()), condition, ALERT_CONDITION);
    }
1243984
public WaitMessageConditionBuilder message() {
        MessageCondition condition = new MessageCondition();
        container.setCondition(condition);
        return new WaitMessageConditionBuilder(condition, this);
    }
941970
private static TerminalBindingCondition createWithCode(
            final String condition,
            final String message,
            final Integer code) {
        if (condition == null) {
            throw(new IllegalArgumentException(
                    "condition may not be null"));
        }
        if (message == null) {
            throw(new IllegalArgumentException(
                    "message may not be null"));
        }
        if (COND_TO_INSTANCE.get(condition) != null) {
            throw(new IllegalStateException(
                    "Multiple definitions of condition: " + condition));
        }
        TerminalBindingCondition result =
                new TerminalBindingCondition(condition, message);
        COND_TO_INSTANCE.put(condition, result);
        if (code != null) {
            if (CODE_TO_INSTANCE.get(code) != null) {
                throw(new IllegalStateException(
                        "Multiple definitions of code: " + code));
            }
            CODE_TO_INSTANCE.put(code, result);
        }
        return result;
    }
832848
public Where<T, ID> or() {
		ManyClause clause = new ManyClause(pop("OR"), ManyClause.OR_OPERATION);
		push(clause);
		addNeedsFuture(clause);
		return this;
	}
371233
public static boolean and(final INDArray n, final Condition cond) {
        if (cond instanceof BaseCondition) {
            long val = (long) Nd4j.getExecutioner().exec(new MatchCondition(n, cond)).getDouble(0);

            if (val == n.length())
                return true;
            else
                return false;

        } else {
            throw new RuntimeException("Can only execute BaseCondition conditions using this method");
        }
    }
693124
public static <S, D> Condition<S, D> not(Condition<S, D> condition) {
    Assert.notNull(condition, "condition");
    return new Not<S, D>(condition);
  }
189698
public void addCondition(final Condition condition) {
        if (conditions_ == null) {
            conditions_ = new ArrayList<>();
        }
        conditions_.add(condition);
    }