Creates a boolean "OR" expression.<p>

@param fragments the operands of the "OR"

@return the combined expressiong
488758
public static CmsSqlBooleanClause makeOr(I_CmsQueryFragment... fragments) {

        CmsSqlBooleanClause result = new CmsSqlBooleanClause("OR");
        for (I_CmsQueryFragment fragment : fragments) {
            result.addCondition(fragment);
        }
        return result;
    }
593642
public final <A extends Number & Comparable<?>> BooleanExpression between(@Nullable Expression<A> from, @Nullable Expression<A> to) {
        if (from == null) {
            if (to != null) {
                return Expressions.booleanOperation(Ops.LOE, mixin, to);
            } else {
                throw new IllegalArgumentException("Either from or to needs to be non-null");
            }
        } else if (to == null) {
            return Expressions.booleanOperation(Ops.GOE, mixin, from);
        } else {
            return Expressions.booleanOperation(Ops.BETWEEN, mixin, from, to);
        }
    }
1357477
public void setFragment(java.lang.String fragment) {
        getStateHelper().put(PropertyKeys.fragment, fragment);
    }
86970
public BooleanBuilder or(@Nullable Predicate right) {
        if (right != null) {
            if (predicate == null) {
                predicate = right;
            } else {
                predicate = ExpressionUtils.or(predicate, right);
            }
        }
        return this;
    }
836565
@Override
    public Predicate and(Expression<Boolean> arg0, Expression<Boolean> arg1)
    {
        if (arg0 != null && arg1 != null)
        {
           return new ConjuctionPredicate((Predicate)arg0, (Predicate)arg1);
        }
        return null;
    }
268420
def p_expression_Or(self, p):
        ''
        p[0] = Or(p[1], p[3], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
470557
public static BooleanExpression all(BooleanExpression expr) {
        return Expressions.booleanOperation(Ops.AggOps.BOOLEAN_ALL, expr);
    }
1238587
@Override
    protected Expression or(Expression base, Expression expression) {
        return Expr.or(base, expression);
    }
838145
public static <T> Predicate<T> OR(final Predicate<T> a, final Predicate<T> b) {
	return new Predicate<T>() {
	    public boolean check(T obj) {
		return a.check(obj) || b.check(obj);
	    }
	};
    }
547719
public static BlankFragment newInstance() {
        BlankFragment fragment = new BlankFragment();
        Bundle args = new Bundle();

        fragment.setArguments(args);
        return fragment;
    }
1069393
@Override
    protected boolean isValidFragment(String fragmentName) {

        Boolean knownFrag = false;

        for (Class<?> cls : INNER_CLASSES) {

            if ( cls.getName().equals(fragmentName) ){

                knownFrag = true;

                break;
            }
        }

        return knownFrag;
    }
1275766
public static <F extends Fragment> FragmentBundler<F> create(F fragment) {
    return new FragmentBundler<F>(fragment);
  }
218778
public void setFragment( String fragment )
    {
        _fragment = null;
        if ( fragment != null && fragment.length() > 0 )
        {
            _fragment = fragment;
        }
    }
207425
static TokenMap<String> fromFragment(final Object... tags) {
    return new TokenMap<String>() {
      @Override public String map(final Token token) {
        final Object val = token.value();
        if (val instanceof Fragment) {
          Fragment c = (Fragment) val;
          if (!Objects.in(c.tag(), tags)) return null;
          return c.text();
        }
        else return null;
      }
      @Override public String toString() {
        if (tags.length == 0) return "";
        if (tags.length == 1) return String.valueOf(tags[0]);
        return "[" + Strings.join(", ", tags) + "]";
      }
    };
  }
283065
public static Boolean asBoolean(String expression, Node node, XPath xpath)
            throws XPathExpressionException {
        String booleanString = evaluateAsString(expression, node, xpath);
        return (isEmptyString(booleanString)) ? null : Boolean.parseBoolean(booleanString);
    }
7321
public static Optional<Condition> createCompareCondition(final PredicateCompareRightValue compareRightValue, final Column column) {
        return compareRightValue.getExpression() instanceof SimpleExpressionSegment
                ? Optional.of(new Condition(column, ((SimpleExpressionSegment) compareRightValue.getExpression()).getSQLExpression())) : Optional.<Condition>absent();
    }
8082
public static Boolean or(Boolean a,Boolean b) 
  {
  	return orTable[ttIndex(a)][ttIndex(b)];
  }