Returns a new condition based on the disjunction of the current condition
and the given condition.

@param that given condition.
517286
public OrCondition or(Condition that) {
        return new OrCondition(this, that.atomic() ? that : _(that));
    }
1278132
public BooleanExpression disjoint(Expression<? extends Geometry> geometry) {
        return Expressions.booleanOperation(SpatialOps.DISJOINT, mixin, geometry);
    }
69375
public static Condition createCondition(String expression) {
        try {
            return INSTANCE.ctorCondition.newInstance(expression);
        }
        catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
210869
public void waitFor(Condition condition) {
        boolean    intr=false;
        lock.lock();
        try {
            while(!condition.isMet()) {
                try {
                    cond.await();
                }
                catch(InterruptedException e) {
                    intr=true;
                }
            }
        }
        finally {
            lock.unlock();
            if(intr) Thread.currentThread().interrupt();
        }
    }
804287
public Resource getConflict(ResourceList that) {
        Resource r = _getConflict(this,that);
        if(r!=null)     return r;
        return _getConflict(that,this);
    }
86885
public static Rule conditionsRule(final Condition condition, String key, String value) {
        return conditionsRule(condition, States.state(key, value));
    }
748538
public function createCondition()
    {
        if ($this->nestedCondition !== null) {
            throw new BuildException("Only one nested condition is allowed.");
        }
        $this->nestedCondition = new NestedCondition();
        return $this->nestedCondition;
    }
863699
public MtasCQLParserSentenceCondition createFullSentence()
      throws ParseException {
    if (fullCondition == null) {
      if (secondSentencePart == null) {
        if (firstBasicSentence != null) {
          fullCondition = new MtasCQLParserSentenceCondition(firstBasicSentence,
              ignoreClause, maximumIgnoreLength);

        } else {
          fullCondition = firstSentence;
        }
        fullCondition.setOccurence(firstMinimumOccurence,
            firstMaximumOccurence);
        if (firstOptional) {
          fullCondition.setOptional(firstOptional);
        }
        return fullCondition;
      } else {
        if (!orOperator) {
          if (firstBasicSentence != null) {
            firstBasicSentence.setOccurence(firstMinimumOccurence,
                firstMaximumOccurence);
            firstBasicSentence.setOptional(firstOptional);
            fullCondition = new MtasCQLParserSentenceCondition(
                firstBasicSentence, ignoreClause, maximumIgnoreLength);
          } else {
            firstSentence.setOccurence(firstMinimumOccurence,
                firstMaximumOccurence);
            firstSentence.setOptional(firstOptional);
            fullCondition = new MtasCQLParserSentenceCondition(firstSentence,
                ignoreClause, maximumIgnoreLength);
          }
          fullCondition.addSentenceToEndLatestSequence(
              secondSentencePart.createFullSentence());
        } else {
          MtasCQLParserSentenceCondition sentence = secondSentencePart
              .createFullSentence();
          if (firstBasicSentence != null) {
            sentence.addSentenceAsFirstOption(
                new MtasCQLParserSentenceCondition(firstBasicSentence,
                    ignoreClause, maximumIgnoreLength));
          } else {
            sentence.addSentenceAsFirstOption(firstSentence);
          }
          fullCondition = sentence;
        }
        return fullCondition;
      }
    } else {
      return fullCondition;
    }
  }
329522
public OrCondition optimize() {
        for (AndCondition each : andConditions) {
            if (each.getConditions().get(0) instanceof NullCondition) {
                OrCondition result = new OrCondition();
                result.add(new NullCondition());
                return result;
            }
        }
        return this;
    }
1191734
public static <T extends Comparable<? super T>> Predicates<T> betweenInclusive(T from, T to)
    {
        Predicates.failIfDifferentTypes(from, to);
        return new BetweenInclusive<T>(from, to);
    }
1370586
@CheckResult
    @NonNull
    public final PowerAdapter showOnlyWhile(@NonNull Condition condition) {
        checkNotNull(condition, "condition");
        if (condition instanceof ConstantCondition) {
            if (condition.eval()) {
                return this;
            } else {
                return EMPTY;
            }
        }
        return new ConditionalAdapter(this, condition);
    }
741638
def iter_conditions(condition):
    """"""
    conditions = list()
    visited = set()
    # Has to be split out, since we don't want to visit the root (for cyclic conditions)
    # but we don't want to yield it (if it's non-cyclic) because this only yields inner conditions
    if condition.operation in {"and", "or"}:
        conditions.extend(reversed(condition.values))
    elif condition.operation == "not":
        conditions.append(condition.values[0])
    else:
        conditions.append(condition)
    while conditions:
        condition = conditions.pop()
        if condition in visited:
            continue
        visited.add(condition)
        yield condition
        if condition.operation in {"and", "or", "not"}:
            conditions.extend(reversed(condition.values))
345379
public boolean after(final Interval<C> that) {
        if(this.hasNone() || that.hasNone()) {
            return false;
        }
        return that.before(this);
    }
365595
public static Rule conditionsRule(final Condition condition, StateObj result) {
        HashSet<Condition> conditions = new HashSet<>();
        conditions.add(condition);
        return conditionsRule(conditions, result);
    }
488968
public static boolean satisfiesSome( IConjunct condition, PropertySet properties)
    {
    boolean satisfies;
    Iterator<IDisjunct> disjuncts;
    for( disjuncts = condition.getDisjuncts(),
           satisfies = !disjuncts.hasNext();
         
         !satisfies
           && disjuncts.hasNext();

         satisfies = disjuncts.next().satisfied( properties));

    return satisfies;
    }
1104121
@Override public int compareTo(Annotation that) {
    if (this == that) return 0;
    int byTimestamp = timestamp() < that.timestamp() ? -1 : timestamp() == that.timestamp() ? 0 : 1;
    if (byTimestamp != 0) return byTimestamp;
    return value().compareTo(that.value());
  }
73228
public final Condition ne(final V value) {
        return new Condition().withComparisonOperator(NE).withAttributeValueList(convert(value));
    }