Gets greater.

@param target the target
@return the greater
188273
public static Predicate<Number> getGreater(Number target) {
		return number -> number.doubleValue() > target.doubleValue();
	}
99614
public boolean greaterThanOrEqual(Object left, Object right) {
    if (left == right) {
      return true;
    }
    else if (left == null || right == null) {
      return false;
    }
    else {
      return compare(left, right, ">=") >= 0;
    }
  }
594685
public String unCapitalize(final Object target) {
        if (target == null) {
            return null;
        }
        return StringUtils.unCapitalize(target);
    }
963657
public static <T> Level0ArrayOperator<BigDecimal[],BigDecimal> on(final BigDecimal[] target) {
        return onArrayOf(Types.BIG_DECIMAL, target);
    }
153373
static float getRelativeY (NativeEvent e, Element target) {
    return (e.getClientY() - target.getAbsoluteTop() + target.getScrollTop() +
            target.getOwnerDocument().getScrollTop()) / HtmlGraphics.experimentalScale;
  }
146789
public static <T> Level0ArrayOperator<String[],String> on(final String[] target) {
        return onArrayOf(Types.STRING, target);
    }
243261
public Betner reset(String target) {
		this.rebuild = !target4Betn.equals(target);
		this.target4Betn = target;
		return this;
	}
379532
public static long get(String target) {
		if (DEFAULT_SCALE62_VALS.getR() == target) {
			return DEFAULT_SCALE62_VALS.getL();
		}

		return toL(target);
	}
802063
public static <T> Level0ArrayOperator<String[],String> onArray(final String[] target) {
        return onArrayOf(Types.STRING, target);
    }
72387
public java.lang.String getTarget() {
        return (java.lang.String) getStateHelper().eval(PropertyKeys.target);

    }
822192
@Override
  public IVersion getMaximum()
  {
    switch (operator) {
      case "<":
        return version.getPrevVersion();
      case "<=":
        return version;
      case ">":
        return version.getNextVersion();
      case ">=":
        return null;
      default:
        throw new IllegalArgumentException("Invalid operator: " + operator);
    }
  }
749361
public static <T extends Comparable<? super T>> boolean greaterThan(final T object,
            final T other) {

        return JudgeUtils.greaterThan(object, other);
    }
910638
public static int indexAny(String target, String... indexWith) {
		return indexAny(target, 0, Arrays.asList(indexWith));
	}
789384
public static final int compareUnsigned(int source, int target)
    {
        source += MAGIC_UNSIGNED;
        target += MAGIC_UNSIGNED;
        if (source < target) {
            return -1;
        }
        else if (source > target) {
            return 1;
        }
        return 0;
    }
890436
public static String unCapitalize(final Object target) {

        if (target == null) {
            return null;
        }
        final StringBuilder result = new StringBuilder(target.toString());

        if (result.length() > 0) {
            result.setCharAt(0, Character.toLowerCase(result.charAt(0)));
        }

        return result.toString();
    }
1942
public static <T> T getFieldValue(final Object target, final String name) {
		Field field = FieldUtils.getDeclaredField(target.getClass(), name, true);

		if (field == null) {
			throw new IllegalArgumentException("Could not find field [" + name + "] on target [" + target + ']');
		}

		T result = null;
		try {
			result = (T) field.get(target);
		} catch (IllegalAccessException e) {
			throw new ImpossibleException(e);
		}
		return result;
	}
1049758
public final QueryParser.greater_return greater() throws RecognitionException {
        QueryParser.greater_return retval = new QueryParser.greater_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token WS56=null;
        Token GREATER57=null;
        Token WS58=null;
        QueryParser.field_return field55 = null;

        QueryParser.value_return value59 = null;


        CommonTree WS56_tree=null;
        CommonTree GREATER57_tree=null;
        CommonTree WS58_tree=null;

        try {
            // src/riemann/Query.g:60:9: ( field ( WS )* GREATER ( WS )* value )
            // src/riemann/Query.g:60:11: field ( WS )* GREATER ( WS )* value
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_field_in_greater431);
            field55=field();

            state._fsp--;

            adaptor.addChild(root_0, field55.getTree());
            // src/riemann/Query.g:60:17: ( WS )*
            loop21:
            do {
                int alt21=2;
                int LA21_0 = input.LA(1);

                if ( (LA21_0==WS) ) {
                    alt21=1;
                }


                switch (alt21) {
            	case 1 :
            	    // src/riemann/Query.g:60:17: WS
            	    {
            	    WS56=(Token)match(input,WS,FOLLOW_WS_in_greater433); 
            	    WS56_tree = (CommonTree)adaptor.create(WS56);
            	    adaptor.addChild(root_0, WS56_tree);


            	    }
            	    break;

            	default :
            	    break loop21;
                }
            } while (true);

            GREATER57=(Token)match(input,GREATER,FOLLOW_GREATER_in_greater436); 
            GREATER57_tree = (CommonTree)adaptor.create(GREATER57);
            root_0 = (CommonTree)adaptor.becomeRoot(GREATER57_tree, root_0);

            // src/riemann/Query.g:60:30: ( WS )*
            loop22:
            do {
                int alt22=2;
                int LA22_0 = input.LA(1);

                if ( (LA22_0==WS) ) {
                    alt22=1;
                }


                switch (alt22) {
            	case 1 :
            	    // src/riemann/Query.g:60:30: WS
            	    {
            	    WS58=(Token)match(input,WS,FOLLOW_WS_in_greater439); 
            	    WS58_tree = (CommonTree)adaptor.create(WS58);
            	    adaptor.addChild(root_0, WS58_tree);


            	    }
            	    break;

            	default :
            	    break loop22;
                }
            } while (true);

            pushFollow(FOLLOW_value_in_greater442);
            value59=value();

            state._fsp--;

            adaptor.addChild(root_0, value59.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }