public OperationConst(int index1, Number arg2, Operator operator, boolean asString) { this.index1 = index1; this.arg2 = arg2; this.expr2 = Expressions.constant(arg2); this.operator = operator; this.asString = asString; }
private static Expression<?> asExpression(Object arg) { if (arg instanceof Expression) { return ExpressionUtils.extract((Expression<?>) arg); } else { return Expressions.constant(arg); } }
/** * Create a new BooleanExpression * * @param value boolean * @return new BooleanExpression */ public static BooleanExpression asBoolean(boolean value) { return asBoolean(constant(value)); }
/** * Create a new EnumExpression * * @param value enum * @return new EnumExpression */ public static <T extends Enum<T>> EnumExpression<T> asEnum(T value) { return asEnum(constant(value)); }
/** * Create a new NumberExpression * * @param value Number * @return new NumberExpression */ public static <T extends Number & Comparable<?>> NumberExpression<T> asNumber(T value) { return asNumber(constant(value)); }
/** * Create a new StringExpression * * @param value String * @return new StringExpression */ public static StringExpression asString(String value) { return asString(constant(value)); }
/** * Create a new JTSGeometryExpression * * @param value Geometry * @return new JTSGeometryExpression */ public static <T extends Geometry> JTSGeometryExpression<T> asJTSGeometry(T value) { return asJTSGeometry(Expressions.constant(value)); }
/** * Create a new DateExpression * * @param value the date * @return new DateExpression */ public static <T extends Comparable<?>> DateExpression<T> asDate(T value) { return asDate(constant(value)); }
/** * Create a new TimeExpression * * @param value the time * @return new TimeExpression */ public static <T extends Comparable<?>> TimeExpression<T> asTime(T value) { return asTime(constant(value)); }
/** * Create a new GeometryExpression * * @param value Geometry * @return new GeometryExpression */ public static <T extends Geometry> GeometryExpression<T> asGeometry(T value) { return asGeometry(Expressions.constant(value)); }
/** * Create a new DateTimeExpression * * @param value the date time * @return new DateTimeExpression */ public static <T extends Comparable<?>> DateTimeExpression<T> asDateTime(T value) { return asDateTime(constant(value)); }
/** * Create a new SimpleExpression * * @param value constant * @return new SimpleExpression */ public static <T> SimpleExpression<T> asSimple(T value) { return asSimple(constant(value)); }
@Override public BooleanExpression eq(T constant) { return eq(Expressions.constant(constant)); }
@Override public BooleanExpression ne(T constant) { return ne(Expressions.constant(constant)); }
@Override public BooleanExpression contains(T constant) { return contains(Expressions.constant(constant)); }
@Override public BooleanExpression lt(T constant) { return lt(Expressions.constant(constant)); }
@Test public void asDate_returns_a_corresponding_DateExpression_for_a_given_Expression() { assertEquals("year(Thu Jan 01 00:00:00 UTC 1970)", Expressions.asDate(Expressions.constant(new Date(1L))).year().toString()); }
@Test public void asTime_returns_a_corresponding_TimeExpression_for_a_given_Expression() { assertEquals("hour(Thu Jan 01 00:00:00 UTC 1970)", Expressions.asTime(Expressions.constant(new Date(1L))).hour().toString()); }
@Test public void asDateTime_returns_a_corresponding_DateTimeExpression_for_a_given_Expression() { assertEquals("min(Thu Jan 01 00:00:00 UTC 1970)", Expressions.asDateTime(Expressions.constant(new Date(1L))).min().toString()); }