Uses of Interface
com.mysema.query.types.Expression

Packages that use Expression

com.mysema.query	Contains basic Query elements
com.mysema.query.alias	Alias functionality
com.mysema.query.dml	DML interfaces
com.mysema.query.group
com.mysema.query.support	Various support classes
com.mysema.query.types	Contains Querydsl grammar types
com.mysema.query.types.expr	Operations represent typed operations with operator and arguments
com.mysema.query.types.path	Paths represent typed property paths, variables and list-map-array access
com.mysema.query.types.query	Subquery implementations
com.mysema.query.types.template	Custom types are comparable to operations but contain the serialization templates instead of operator patterns.

Uses of Expression in com.mysema.query

Classes in com.mysema.query that implement Expression

class

BooleanBuilder BooleanBuilder is a cascading builder for Predicate expressions.

Methods in com.mysema.query that return Expression

Expression<?>	BooleanBuilder.getArg(int index)
Expression<?>	QueryFlag.getFlag()
Expression<?>	JoinFlag.getFlag()
Expression<?>	JoinExpression.getTarget()

Methods in com.mysema.query that return types with arguments of type Expression

List<Expression<?>>	BooleanBuilder.getArgs()
List<Expression<?>>	QueryMetadata.getGroupBy() Get the group by expressions
List<Expression<?>>	EmptyMetadata.getGroupBy()
List<Expression<?>>	DefaultQueryMetadata.getGroupBy()
List<Expression<?>>	QueryMetadata.getProjection() Get the projection
List<Expression<?>>	EmptyMetadata.getProjection()
List<Expression<?>>	DefaultQueryMetadata.getProjection()

Methods in com.mysema.query with parameters of type Expression

void	QueryMetadata.addGroupBy(Expression<?>... o) Add the given group by expressions
void	EmptyMetadata.addGroupBy(Expression<?>... o)
void	DefaultQueryMetadata.addGroupBy(Expression<?>... o)
void	QueryMetadata.addJoin(JoinType joinType, Expression<?> expr) Add the given query join
void	EmptyMetadata.addJoin(JoinType joinType, Expression<?> expr)
void	DefaultQueryMetadata.addJoin(JoinType joinType, Expression<?> expr)
void	QueryMetadata.addProjection(Expression<?>... o) Add the given projections
void	EmptyMetadata.addProjection(Expression<?>... o)
void	DefaultQueryMetadata.addProjection(Expression<?>... o)
<T> T	Tuple.get(Expression<T> expr) Get a tuple element by expression
Q	Query.groupBy(Expression<?>... o) Defines the grouping/aggregation expressions
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterate(Expression<?>[] args) iterate over the results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest) iterate over the results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest) iterate over the results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest) iterate over the results for the given projection
<RT> com.mysema.commons.lang.CloseableIterator<RT>	Projectable.iterate(Expression<RT> projection) iterate over the results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterateDistinct(Expression<?>[] args) iterate over the distinct results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest) iterate over the distinct results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest) iterate over the distinct results for the given projection
com.mysema.commons.lang.CloseableIterator<Object[]>	Projectable.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest) iterate over the distinct results for the given projection
<RT> com.mysema.commons.lang.CloseableIterator<RT>	Projectable.iterateDistinct(Expression<RT> projection) iterate over the distinct results for the given projection
List<Object[]>	Projectable.list(Expression<?>[] args) list the results for the given projection An empty list is returned for no results.
List<Object[]>	Projectable.list(Expression<?> first, Expression<?> second, Expression<?>... rest) list the results for the given projection An empty list is returned for no results.
List<Object[]>	Projectable.list(Expression<?> first, Expression<?> second, Expression<?>... rest) list the results for the given projection An empty list is returned for no results.
List<Object[]>	Projectable.list(Expression<?> first, Expression<?> second, Expression<?>... rest) list the results for the given projection An empty list is returned for no results.
<RT> List<RT>	Projectable.list(Expression<RT> projection) list the results for the given projection An empty list is returned for no results.
List<Object[]>	Projectable.listDistinct(Expression<?>[] args) list the distinct results for the given projection An empty list is returned for no results.
List<Object[]>	Projectable.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest) list the distinct results for the given projection An empty list is returned for no results.
List<Object[]>	Projectable.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest) list the distinct results for the given projection An empty list is returned for no results.
List<Object[]>	Projectable.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest) list the distinct results for the given projection An empty list is returned for no results.
<RT> List<RT>	Projectable.listDistinct(Expression<RT> projection) list the distinct results for the given projection An empty list is returned for no results.
<RT> SearchResults<RT>	Projectable.listDistinctResults(Expression<RT> projection) list the distinct results for the given projection
<RT> SearchResults<RT>	Projectable.listResults(Expression<RT> projection) list the results for the given projection
<K,V> Map<K,V>	Projectable.map(Expression<K> key, Expression<V> value) return the given projection as a Map instance using key and value for Map population An empty map is returned for no results.
<K,V> Map<K,V>	Projectable.map(Expression<K> key, Expression<V> value) return the given projection as a Map instance using key and value for Map population An empty map is returned for no results.
Object[]	Projectable.singleResult(Expression<?>[] args) return a single result for the given projection or null if no result is found
Object[]	Projectable.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest) return a single result for the given projection or null if no result is found
Object[]	Projectable.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest) return a single result for the given projection or null if no result is found
Object[]	Projectable.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest) return a single result for the given projection or null if no result is found
<RT> RT	Projectable.singleResult(Expression<RT> projection) return a single result for the given projection or null if no result is found
Object[]	Projectable.uniqueResult(Expression<?>[] args) return a unique result for the given projection or null if no result is found
Object[]	Projectable.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest) return a unique result for the given projection or null if no result is found
Object[]	Projectable.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest) return a unique result for the given projection or null if no result is found
Object[]	Projectable.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest) return a unique result for the given projection or null if no result is found
<RT> RT	Projectable.uniqueResult(Expression<RT> projection) return a unique result for the given projection or null if no result is found

Constructors in com.mysema.query with parameters of type Expression

JoinExpression(JoinType type, Expression<?> target)
Create a new JoinExpression instance

JoinFlag(Expression<?> flag)

JoinFlag(Expression<?> flag, JoinFlag.Position position)

QueryFlag(QueryFlag.Position position, Expression<?> flag)

Uses of Expression in com.mysema.query.alias

Methods in com.mysema.query.alias with type parameters of type Expression

static <D extends Expression<?>> D	Alias.$() Convert the given alias to an expression
<A extends Expression<?>> A	AliasFactory.getCurrent() Get the current thread bound expression without reseting it
<A extends Expression<?>> A	AliasFactory.getCurrentAndReset() Get the current thread bound expression and reset it

Methods in com.mysema.query.alias that return Expression

static <D> Expression<D>

Alias.getAny(D arg) Convert the given alias to an expression

Methods in com.mysema.query.alias with parameters of type Expression

static <A> A	Alias.alias(Class<A> cl, Expression<? extends A> expr) Create a new alias proxy of the given type for the given expression
<A> A	AliasFactory.createAliasForExpr(Class<A> cl, Expression<? extends A> expr) Create an alias instance for the given class and Expression
<A> A	AliasFactory.createAliasForProperty(Class<A> cl, Object parent, Expression<?> path) Create an alias instance for the given class, parent and path
protected <A> A	AliasFactory.createProxy(Class<A> cl, Expression<?> path) Create a proxy instance for the given class and path
void	AliasFactory.setCurrent(Expression<?> expr) Set the thread bound expression to the given value

Constructors in com.mysema.query.alias with parameters of type Expression

PropertyAccessInvocationHandler(Expression<?> host, AliasFactory aliasFactory, PathFactory pathFactory, TypeSystem typeSystem)

Uses of Expression in com.mysema.query.dml

Methods in com.mysema.query.dml with parameters of type Expression

<T> C

StoreClause.set(Path<T> path, Expression<? extends T> expression) Add an expression binding

Uses of Expression in com.mysema.query.group

Subinterfaces of Expression in com.mysema.query.group

interface

GroupExpression<T,R> Defines the way results of a given expression are grouped.

Classes in com.mysema.query.group that implement Expression

class	AbstractGroupExpression<T,R> A base class for GroupExpressions
class	QPair<K,V> A pair of (Map) key and value

Fields in com.mysema.query.group declared as Expression

protected Expression<?>[]

GroupBy.expressions

Methods in com.mysema.query.group that return Expression

Expression<T>	GroupExpression.getExpression()
Expression<T>	AbstractGroupExpression.getExpression()
static <K,V> Expression<Map<K,V>>	GroupBy.map(Expression<K> key, Expression<V> value) Create a new aggregating map expression

Methods in com.mysema.query.group with parameters of type Expression

ResultTransformer<Map<K,Group>>	GroupByBuilder.as(Expression<?>... expressions)
<V> ResultTransformer<Map<K,V>>	GroupByBuilder.as(Expression<V> expression)
static <K,V> QPair<K,V>	QPair.create(Expression<K> key, Expression<V> value)
static <K,V> QPair<K,V>	QPair.create(Expression<K> key, Expression<V> value)
boolean	QPair.equals(Expression<?> keyExpr, Class<?> valueType)
boolean	QPair.equals(Expression<?> keyExpr, Expression<?> valueExpr)
boolean	QPair.equals(Expression<?> keyExpr, Expression<?> valueExpr)
<T> List<T>	Group.getList(Expression<T> expr) Returns a List of values in this group.
<K,V> Map<K,V>	Group.getMap(Expression<K> key, Expression<V> value) Returns a Map of values in this group
<K,V> Map<K,V>	Group.getMap(Expression<K> key, Expression<V> value) Returns a Map of values in this group
<T> T	Group.getOne(Expression<T> expr) Returns the value of the given single valued expression.
<T> Set<T>	Group.getSet(Expression<T> expr) Returns a Set of values in this group.
static <K> GroupByBuilder<K>	GroupBy.groupBy(Expression<K> key) Create a new GroupByBuilder for the given key expression
static <E> AbstractGroupExpression<?,List<E>>	GroupBy.list(Expression<E> expression) Create a new aggregating list expression
static <K,V> Expression<Map<K,V>>	GroupBy.map(Expression<K> key, Expression<V> value) Create a new aggregating map expression
static <K,V> Expression<Map<K,V>>	GroupBy.map(Expression<K> key, Expression<V> value) Create a new aggregating map expression
static <E extends Comparable<E>> AbstractGroupExpression<?,E>	GroupBy.max(Expression<E> expression) Create a new aggregating max expression
static <E extends Comparable<E>> AbstractGroupExpression<?,E>	GroupBy.min(Expression<E> expression) Create a new aggregating min expression
static <E> AbstractGroupExpression<?,Set<E>>	GroupBy.set(Expression<E> expression) Create a new aggregating set expression

Constructors in com.mysema.query.group with parameters of type Expression

AbstractGroupExpression(Class<? super R> type, Expression<T> expr)

GroupByBuilder(Expression<K> key)
Create a new GroupByBuilder for the given key expression

QPair(Expression<K> key, Expression<V> value)

QPair(Expression<K> key, Expression<V> value)

Uses of Expression in com.mysema.query.support

Classes in com.mysema.query.support that implement Expression

class	NumberConversion<T> NumberConversion ensures that the results of a numeric projection confirm to the type of the projection expression
class	NumberConversions<T> NumberConversions ensures that the results of a projection involving numeric expressions confirm to the types of the numeric expressions

Methods in com.mysema.query.support that return Expression

static <T> Expression<T>	Expressions.constant(T value)
Expression<?>[]	QueryMixin.convert(Expression<?>[] exprs)
<RT> Expression<RT>	QueryMixin.convert(Expression<RT> expr)
protected <D> Expression<D>	QueryMixin.createAlias(Expression<D> path, Path<D> alias)
protected <D> Expression<D>	QueryMixin.createAlias(MapExpression<?,D> target, Path<D> alias)
protected <D> Expression<D>	QueryMixin.createAlias(Path<? extends Collection<D>> target, Path<D> alias)
protected <D> Expression<D>	QueryMixin.createAlias(SubQueryExpression<D> path, Path<D> alias)
Expression<?>	CollectionAnyVisitor.visit(Constant<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(Constant<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(FactoryExpression<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(FactoryExpression<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(Operation<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(Operation<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(ParamExpression<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(ParamExpression<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(Path<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(Path<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(SubQueryExpression<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(SubQueryExpression<?> expr, Context context)
Expression<?>	CollectionAnyVisitor.visit(TemplateExpression<?> expr, Context context)
Expression<?>	ListAccessVisitor.visit(TemplateExpression<?> expr, Context context)

Methods in com.mysema.query.support that return types with arguments of type Expression

List<Expression<?>>	NumberConversions.getArgs()
List<Expression<?>>	NumberConversion.getArgs()

Methods in com.mysema.query.support with parameters of type Expression

void	OrderedQueryMetadata.addJoin(JoinType joinType, Expression<?> expr)
T	QueryMixin.addToProjection(Expression<?>... o)
protected void	SerializerBase.appendAsString(Expression<?> expr)
static <D> SimpleExpression<D>	Expressions.as(Expression<D> source, Path<D> alias)
static <D> SimpleExpression<D>	Expressions.as(Expression<D> source, String alias)
static BooleanExpression	Expressions.booleanOperation(Operator<Boolean> operation, Expression<?>... args)
static BooleanExpression	Expressions.booleanTemplate(String template, Expression<?>... args)
static <T extends Comparable<?>> ComparableExpression<T>	Expressions.comparableOperation(Class<T> type, Operator<? super T> operator, Expression<?>... args)
static <T extends Comparable<?>> ComparableExpression<T>	Expressions.comparableTemplate(Class<T> cl, String template, Expression<?>... args)
Expression<?>[]	QueryMixin.convert(Expression<?>[] exprs)
<RT> Expression<RT>	QueryMixin.convert(Expression<RT> expr)
protected <D> Expression<D>	QueryMixin.createAlias(Expression<D> path, Path<D> alias)
static <T extends Comparable<?>> DateExpression<T>	Expressions.dateOperation(Class<T> type, Operator<? super T> operator, Expression<?>... args)
static <T extends Comparable<?>> DateTimeExpression<T>	Expressions.dateTimeOperation(Class<T> type, Operator<? super T> operator, Expression<?>... args)
static <T> DslExpression<T>	Expressions.dslOperation(Class<T> type, Operator<? super T> operator, Expression<?>... args)
static <T> DslExpression<T>	Expressions.dslTemplate(Class<T> cl, String template, Expression<?>... args)
T	QueryMixin.from(Expression<?>... args)
T	QueryMixin.groupBy(Expression<?>... o)
Q	QueryBase.groupBy(Expression<?>... o)
S	SerializerBase.handle(Expression<?> expr)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterate(Expression<?>[] args)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterate(Expression<?> first, Expression<?> second, Expression<?>... rest)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	ProjectableAdapter.iterate(Expression<RT> projection)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterateDistinct(Expression<?>[] args)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterateDistinct(Expression<?>[] args)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableAdapter.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
com.mysema.commons.lang.CloseableIterator<Object[]>	ProjectableQuery.iterateDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	ProjectableAdapter.iterateDistinct(Expression<RT> projection)
<RT> com.mysema.commons.lang.CloseableIterator<RT>	ProjectableQuery.iterateDistinct(Expression<RT> projection)
ListSubQuery<Object[]>	DetachableQuery.list(Expression<?>[] args)
List<Object[]>	ProjectableAdapter.list(Expression<?>[] args)
List<Object[]>	ProjectableQuery.list(Expression<?>[] args)
ListSubQuery<Object[]>	DetachableAdapter.list(Expression<?>[] args)
ListSubQuery<Object[]>	DetachableMixin.list(Expression<?>[] args)
ListSubQuery<Object[]>	DetachableQuery.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
ListSubQuery<Object[]>	DetachableQuery.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
ListSubQuery<Object[]>	DetachableQuery.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
List<Object[]>	ProjectableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
List<Object[]>	ProjectableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
List<Object[]>	ProjectableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
List<Object[]>	ProjectableQuery.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
List<Object[]>	ProjectableQuery.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
List<Object[]>	ProjectableQuery.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
ListSubQuery<Object[]>	DetachableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
ListSubQuery<Object[]>	DetachableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
ListSubQuery<Object[]>	DetachableAdapter.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
ListSubQuery<Object[]>	DetachableMixin.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
ListSubQuery<Object[]>	DetachableMixin.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
ListSubQuery<Object[]>	DetachableMixin.list(Expression<?> first, Expression<?> second, Expression<?>... rest)
<RT> ListSubQuery<RT>	DetachableQuery.list(Expression<RT> projection)
<RT> List<RT>	ProjectableAdapter.list(Expression<RT> projection)
<RT> List<RT>	ProjectableQuery.list(Expression<RT> projection)
<RT> ListSubQuery<RT>	DetachableAdapter.list(Expression<RT> projection)
<RT> ListSubQuery<RT>	DetachableMixin.list(Expression<RT> projection)
List<Object[]>	ProjectableAdapter.listDistinct(Expression<?>[] args)
List<Object[]>	ProjectableQuery.listDistinct(Expression<?>[] args)
List<Object[]>	ProjectableAdapter.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
List<Object[]>	ProjectableAdapter.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
List<Object[]>	ProjectableAdapter.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
List<Object[]>	ProjectableQuery.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
List<Object[]>	ProjectableQuery.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
List<Object[]>	ProjectableQuery.listDistinct(Expression<?> first, Expression<?> second, Expression<?>... rest)
<RT> List<RT>	ProjectableAdapter.listDistinct(Expression<RT> projection)
<RT> List<RT>	ProjectableQuery.listDistinct(Expression<RT> projection)
<RT> SearchResults<RT>	ProjectableAdapter.listDistinctResults(Expression<RT> expr)
<RT> SearchResults<RT>	ProjectableQuery.listDistinctResults(Expression<RT> projection)
<RT> SearchResults<RT>	ProjectableAdapter.listResults(Expression<RT> expr)
<K,V> Map<K,V>	ProjectableAdapter.map(Expression<K> key, Expression<V> value)
<K,V> Map<K,V>	ProjectableAdapter.map(Expression<K> key, Expression<V> value)
<K,V> Map<K,V>	ProjectableQuery.map(Expression<K> key, Expression<V> value)
<K,V> Map<K,V>	ProjectableQuery.map(Expression<K> key, Expression<V> value)
static <T extends Number & Comparable<?>> NumberExpression<T>	Expressions.numberOperation(Class<T> type, Operator<? super T> operator, Expression<?>... args)
static <T extends Number & Comparable<?>> NumberExpression<T>	Expressions.numberTemplate(Class<T> cl, String template, Expression<?>... args)
static <T> SimpleExpression<T>	Expressions.operation(Class<T> type, Operator<? super T> operator, Expression<?>... args)
static BooleanExpression	Expressions.predicate(Operator<Boolean> operation, Expression<?>... args)
Object[]	ProjectableAdapter.singleResult(Expression<?>[] args)
Object[]	ProjectableQuery.singleResult(Expression<?>[] args)
Object[]	ProjectableAdapter.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
Object[]	ProjectableAdapter.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
Object[]	ProjectableAdapter.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
Object[]	ProjectableQuery.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
Object[]	ProjectableQuery.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
Object[]	ProjectableQuery.singleResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
<RT> RT	ProjectableAdapter.singleResult(Expression<RT> expr)
<RT> RT	ProjectableQuery.singleResult(Expression<RT> expr)
static StringExpression	Expressions.stringOperation(Operator<? super String> operator, Expression<?>... args)
static StringExpression	Expressions.stringTemplate(String template, Expression<?>... args)
static <T> SimpleExpression<T>	Expressions.template(Class<T> cl, String template, Expression<?>... args)
static <T extends Comparable<?>> TimeExpression<T>	Expressions.timeOperation(Class<T> type, Operator<? super T> operator, Expression<?>... args)
SimpleSubQuery<Object[]>	DetachableQuery.unique(Expression<?>[] args)
SimpleSubQuery<Object[]>	DetachableAdapter.unique(Expression<?>[] args)
SimpleSubQuery<Object[]>	DetachableMixin.unique(Expression<?>[] args)
SimpleSubQuery<Object[]>	DetachableQuery.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
SimpleSubQuery<Object[]>	DetachableQuery.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
SimpleSubQuery<Object[]>	DetachableQuery.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
SimpleSubQuery<Object[]>	DetachableAdapter.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
SimpleSubQuery<Object[]>	DetachableAdapter.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
SimpleSubQuery<Object[]>	DetachableAdapter.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
SimpleSubQuery<Object[]>	DetachableMixin.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
SimpleSubQuery<Object[]>	DetachableMixin.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
SimpleSubQuery<Object[]>	DetachableMixin.unique(Expression<?> first, Expression<?> second, Expression<?>... rest)
<RT> SimpleSubQuery<RT>	DetachableQuery.unique(Expression<RT> projection)
<RT> SimpleSubQuery<RT>	DetachableAdapter.unique(Expression<RT> projection)
<RT> SimpleSubQuery<RT>	DetachableMixin.unique(Expression<RT> projection)
Object[]	ProjectableAdapter.uniqueResult(Expression<?>[] args)
Object[]	ProjectableAdapter.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
Object[]	ProjectableAdapter.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
Object[]	ProjectableAdapter.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
Object[]	ProjectableQuery.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
Object[]	ProjectableQuery.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
Object[]	ProjectableQuery.uniqueResult(Expression<?> first, Expression<?> second, Expression<?>... rest)
<RT> RT	ProjectableAdapter.uniqueResult(Expression<RT> expr)

Method parameters in com.mysema.query.support with type arguments of type Expression

protected void

SerializerBase.visitOperation(Class<?> type, Operator<?> operator, List<? extends Expression<?>> args)

Constructors in com.mysema.query.support with parameters of type Expression

NumberConversion(Expression<T> expr)

SimpleProjectableAdapter(Q query, Expression<T> projection)

SimpleProjectableAdapter(SimpleQuery<?> query, Projectable projectable, Expression<T> projection)

Uses of Expression in com.mysema.query.types

Subinterfaces of Expression in com.mysema.query.types

interface	CollectionExpression<T extends Collection<E>,E> CollectionExpression represents Collection typed expressions
interface	Constant<T> Constant represents a general constant expression.
interface	EntityPath<T> EntityPath is the common interface for entity path expressions
interface	FactoryExpression<T> FactoryExpression represents factory expressions such as JavaBean or Constructor projections
interface	MapExpression<K,V> MapExpression represents Map typed expressions
interface	Operation<T> Operation represents an operation with operator and arguments
interface	ParametrizedExpression<T> ParametrizedExpression is a common interface for expressions with generic type parameters
interface	ParamExpression<T> ParamExpression defines named and unnamed parameters in queries
interface	Path<T> Path represents a path expression.
interface	Predicate Predicate is the common interface for Boolean typed expressions
interface	ProjectionRole<T> Defines a custom projection for an Expression type.
interface	SubQueryExpression<T> SubQueryExpression represents a sub query.
interface	TemplateExpression<T> TemplateExpression provides base types for custom expressions with integrated serialization templates

Classes in com.mysema.query.types that implement Expression

class	ArrayConstructorExpression<T> ArrayConstructorExpression extends ExpressionBase to represent array initializers
class	ConstantImpl<T> ConstantImpl is the default implementation of the Constant interface
class	ConstructorExpression<T> ConstructorExpression represents a constructor invocation
class	ExpressionBase<T> ExpressionBase is the base class for immutable Expression implementations
static class	FactoryExpressionUtils.FactoryExpressionAdapter<T>
class	MappingProjection<T> Projection template that allows implementing arbitrary mapping of rows to result objects.
class	MutableExpressionBase<T> MutableExpressionBase is the base class for mutable Expression implementations
class	NullExpression<T> NullExpression defines a general null expression
class	OperationImpl<T> OperationImpl is the default implementation of the Operation interface
class	ParamExpressionImpl<T> ParamExpressionImpl defines a parameter in a query with an optional name
class	PathImpl<T> PathImpl defines a default implementation of the Path interface
class	PredicateOperation PredicateOperation provides a Boolean typed Operation implementation
class	PredicateTemplate PredicateTemplate provides a Boolean typed TemplateExpression implementation
class	QBean<T> QBean is a JavaBean populating projection type
class	QTuple QTuple represents a projection of type Tuple
class	SubQueryExpressionImpl<T> SubQueryExpressionImpl is the default implementation of the SubQueryExpression interface
class	TemplateExpressionImpl<T> Default implementation of the TemplateExpression interface

Fields in com.mysema.query.types with type parameters of type Expression

com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toContainsViaLike
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toContainsViaLike
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toContainsViaLikeLower
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toContainsViaLikeLower
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toEndsWithViaLike
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toEndsWithViaLike
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toEndsWithViaLikeLower
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toEndsWithViaLikeLower
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toLowerCase
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toLowerCase
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toStartsWithViaLike
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toStartsWithViaLike
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toStartsWithViaLikeLower
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toStartsWithViaLikeLower
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toUpperCase
com.google.common.base.Function<Expression<String>,Expression<String>>	Converters.toUpperCase

Methods in com.mysema.query.types that return Expression

static <T> Expression<T>	ExpressionUtils.all(CollectionExpression<?,? super T> col)
static <T> Expression<T>	ExpressionUtils.any(CollectionExpression<?,? super T> col)
static <D> Expression<D>	ExpressionUtils.as(Expression<D> source, Path<D> alias) Create an alias expression (source as alias) with the given source and alias
static <D> Expression<D>	ExpressionUtils.as(Expression<D> source, String alias) Create an alias expression (source as alias) with the given source and alias
Expression<T>	ConstructorExpression.as(Path<T> alias) Create an alias for the expression
Expression<T>	QBean.as(Path<T> alias) Create an alias for the expression
Expression<T>	ConstructorExpression.as(String alias) Create an alias for the expression
Expression<T>	QBean.as(String alias) Create an alias for the expression
Expression<?>	Template.Element.convert(Expression<?> source)
static Expression<Long>	ExpressionUtils.count(Expression<?> source)
static <C> Expression<C>	TemplateExpressionImpl.create(Class<C> cl, String template, Expression<?>... args) Create a new TemplateExpression with the given template in String form and template arguments
static <C> Expression<C>	TemplateExpressionImpl.create(Class<C> cl, Template template, Expression<?>... args) Create a new TemplateExpression with the given template and template arguments
Expression<?>	TemplateExpressionImpl.getArg(int index)
Expression<?>	OperationImpl.getArg(int i)
Expression<?>	TemplateExpression.getArg(int index) Get the argument with the given index
Expression<?>	Operation.getArg(int index) Get the argument with the given index
Expression<T>	PathMetadata.getExpression()
Expression<T>	ProjectionRole.getProjection() Return the custom projection
Expression<T>	OrderSpecifier.getTarget() Get the target expression of this OrderSpecifier
static Expression<String>	ExpressionUtils.likeToRegex(Expression<String> expr) Convert the given like pattern to a regex pattern
static Expression<String>	ExpressionUtils.likeToRegex(Expression<String> expr, boolean matchStartAndEnd)
static Expression<?>	ExpressionUtils.list(Expression<?>... exprs)
static Expression<?>	ExpressionUtils.list(List<? extends Expression<?>> exprs)
static Expression<?>	ExpressionUtils.merge(List<? extends Expression<?>> expressions)
static Expression<String>	ExpressionUtils.regexToLike(Expression<String> expr)
Expression<?>	ExtractorVisitor.visit(Constant<?> expr, Void context)
Expression<?>	ExtractorVisitor.visit(FactoryExpression<?> expr, Void context)
Expression<?>	ExtractorVisitor.visit(Operation<?> expr, Void context)
Expression<?>	ExtractorVisitor.visit(ParamExpression<?> expr, Void context)
Expression<?>	ExtractorVisitor.visit(Path<?> expr, Void context)
Expression<?>	ExtractorVisitor.visit(SubQueryExpression<?> expr, Void context)
Expression<?>	ExtractorVisitor.visit(TemplateExpression<?> expr, Void context)

Methods in com.mysema.query.types that return types with arguments of type Expression

List<Expression<?>>	ArrayConstructorExpression.getArgs()
List<Expression<?>>	TemplateExpressionImpl.getArgs()
List<Expression<?>>	FactoryExpression.getArgs() Get the invocation arguments
List<Expression<?>>	MappingProjection.getArgs()
List<Expression<?>>	OperationImpl.getArgs()
List<Expression<?>>	ConstructorExpression.getArgs()
List<Expression<?>>	QBean.getArgs()
List<Expression<?>>	FactoryExpressionUtils.FactoryExpressionAdapter.getArgs()
List<Expression<?>>	TemplateExpression.getArgs() Get the arguments of the custom expression
List<Expression<?>>	QTuple.getArgs()
List<Expression<?>>	Operation.getArgs() Get the arguments of this operation

Methods in com.mysema.query.types with parameters of type Expression

static <T> ArrayConstructorExpression<T>	Projections.array(Class<T[]> type, Expression<T>... exprs) Create a typed array projection for the given type and expressions
static <D> Expression<D>	ExpressionUtils.as(Expression<D> source, Path<D> alias) Create an alias expression (source as alias) with the given source and alias
static <D> Expression<D>	ExpressionUtils.as(Expression<D> source, String alias) Create an alias expression (source as alias) with the given source and alias
static <T> QBean<T>	Projections.bean(Class<T> type, Expression<?>... exprs) Create a Bean populating projection for the given type and expressions
static <T> QBean<T>	Projections.bean(Path<T> type, Expression<?>... exprs) Create a Bean populating projection for the given type and expressions
static <T> ConstructorExpression<T>	Projections.constructor(Class<T> type, Expression<?>... exprs) Create a constructor invocation projection for the given type and expressions
Expression<?>	Template.Element.convert(Expression<?> source)
static Expression<Long>	ExpressionUtils.count(Expression<?> source)
static <RT> Operation<RT>	OperationImpl.create(Class<? extends RT> type, Operator<? super RT> operator, Expression<?>... args)
static <C> Expression<C>	TemplateExpressionImpl.create(Class<C> cl, String template, Expression<?>... args) Create a new TemplateExpression with the given template in String form and template arguments
static <C> Expression<C>	TemplateExpressionImpl.create(Class<C> cl, Template template, Expression<?>... args) Create a new TemplateExpression with the given template and template arguments
static <D> ConstructorExpression<D>	ConstructorExpression.create(Class<D> type, Expression<?>... args)
static <D> Predicate	ExpressionUtils.eq(Expression<D> left, Expression<? extends D> right) Create an left equals right expression
static <D> Predicate	ExpressionUtils.eq(Expression<D> left, Expression<? extends D> right) Create an left equals right expression
static <D> Predicate	ExpressionUtils.eqConst(Expression<D> left, D constant) Create an left equals constant expression
static <T> QBean<T>	Projections.fields(Class<T> type, Expression<?>... exprs) Create a field access based Bean populating projection for the given type and expressions
static <T> QBean<T>	Projections.fields(Path<T> type, Expression<?>... exprs) Create a field access based Bean populating projection for the given type and expressions
static PathMetadata<Integer>	PathMetadataFactory.forArrayAccess(Path<?> parent, Expression<Integer> index) Create a new PathMetadata for indexed array access
static PathMetadata<Integer>	PathMetadataFactory.forListAccess(Path<?> parent, Expression<Integer> index) Create a new PathMetadata for indexed list access
static <KT> PathMetadata<KT>	PathMetadataFactory.forMapAccess(Path<?> parent, Expression<KT> key) Create a new PathMetadata for key based map access
static <D> Predicate	ExpressionUtils.in(Expression<D> left, Collection<? extends D> right) Create an left in right expression
static <D> Predicate	ExpressionUtils.in(Expression<D> left, CollectionExpression<?,? extends D> right) Create an left in right expression
static Predicate	ExpressionUtils.isNotNull(Expression<?> left) Create a left is not null expression
static Predicate	ExpressionUtils.isNull(Expression<?> left) Create a left is null expression
static Expression<String>	ExpressionUtils.likeToRegex(Expression<String> expr) Convert the given like pattern to a regex pattern
static Expression<String>	ExpressionUtils.likeToRegex(Expression<String> expr, boolean matchStartAndEnd)
static Expression<?>	ExpressionUtils.list(Expression<?>... exprs)
static <D> Predicate	ExpressionUtils.ne(Expression<D> left, Expression<? super D> right) Create a left not equals right expression
static <D> Predicate	ExpressionUtils.ne(Expression<D> left, Expression<? super D> right) Create a left not equals right expression
static <D> Predicate	ExpressionUtils.neConst(Expression<D> left, D constant) Create a left not equals constant expression
static Expression<String>	ExpressionUtils.regexToLike(Expression<String> expr)
static QTuple	Projections.tuple(Expression<?>... exprs) Create a Tuple typed projection for the given expressions

Method parameters in com.mysema.query.types with type arguments of type Expression

static Expression<?>	ExpressionUtils.list(List<? extends Expression<?>> exprs)
static Expression<?>	ExpressionUtils.merge(List<? extends Expression<?>> expressions)
static FactoryExpression<?>	FactoryExpressionUtils.wrap(List<? extends Expression<?>> projection)

Constructors in com.mysema.query.types with parameters of type Expression

ArrayConstructorExpression(Class<T[]> type, Expression<T>... args)

ArrayConstructorExpression(Expression<?>... args)

ConstructorExpression(Class<T> type, Class<?>[] paramTypes, Expression<?>... args)

MappingProjection(Class<? super T> type, Expression<?>... args)
Create a new MappingProjection instance

MappingProjection(Class<? super T> type, Expression<?>[]... args)
Create a new MappingProjection instance

OperationImpl(Class<? extends T> type, Operator<? super T> operator, Expression<?>... args)

OrderSpecifier(Order order, Expression<T> target)

PathMetadata(Path<?> parent, Expression<T> expression, PathType type)

PredicateOperation(Operator<Boolean> operator, Expression<?>... args)

PredicateTemplate(String template, Expression<?>... args)

PredicateTemplate(Template template, Expression<?>... args)

QBean(Class<T> type, boolean fieldAccess, Expression<?>... args)
Create a new QBean instance

QBean(Class<T> type, Expression<?>... args)
Create a new QBean instance

QBean(Path<T> type, boolean fieldAccess, Expression<?>... args)
Create a new QBean instance

QBean(Path<T> type, Expression<?>... args)
Create a new QBean instance

QTuple(Expression<?>... args)
Create a new QTuple instance

QTuple(Expression<?>[]... args)
Create a new QTuple instance

TemplateExpressionImpl(Class<? extends T> type, Template template, Expression<?>... args)

Constructor parameters in com.mysema.query.types with type arguments of type Expression

ConstructorExpression(Class<T> type, Class<?>[] paramTypes, List<Expression<?>> args)

OperationImpl(Class<? extends T> type, Operator<? super T> operator, List<Expression<?>> args)

PredicateOperation(Operator<Boolean> operator, List<Expression<?>> args)

PredicateTemplate(Template template, List<Expression<?>> args)

QBean(Class<T> type, boolean fieldAccess, Map<String,? extends Expression<?>> bindings)
Create a new QBean instance

QBean(Class<T> type, Map<String,? extends Expression<?>> bindings)
Create a new QBean instance

QBean(Path<T> type, boolean fieldAccess, Map<String,? extends Expression<?>> bindings)
Create a new QBean instance

QBean(Path<T> type, Map<String,? extends Expression<?>> bindings)
Create a new QBean instance

TemplateExpressionImpl(Class<? extends T> type, Template template, List<Expression<?>> args)

ValidatingVisitor(Collection<Expression<?>> known)

Uses of Expression in com.mysema.query.types.expr

Classes in com.mysema.query.types.expr with type parameters of type Expression

static class	CaseBuilder.Cases<A,Q extends Expression<A>> Cascading typesafe Case builder
static class	CaseBuilder.CaseWhen<A,Q extends Expression<A>> Intermediate When state
class	CaseForEqBuilder.Cases<T,Q extends Expression<T>>
class	CaseForEqBuilder.CaseWhen<T,Q extends Expression<T>>

Subinterfaces of Expression in com.mysema.query.types.expr

interface	ArrayExpression<T> ArrayExpression defines an interface for array typed expression
interface	ListExpression<E,Q extends SimpleExpression<? super E>> ListExpression represents List typed expressions

Classes in com.mysema.query.types.expr that implement Expression

class	BooleanExpression BooleanExpression represents Boolean expressions
class	BooleanOperation BooleanOperation represents boolean operations
class	Coalesce<T extends Comparable> Coalesce defines a coalesce function invocation.
class	CollectionExpressionBase<T extends Collection<E>,E> CollectionExpressionBase is an abstract base class for CollectionExpression implementations
class	ComparableExpression<T extends Comparable> ComparableExpression extends ComparableExpressionBase to provide comparison methods.
class	ComparableExpressionBase<T extends Comparable> ComparableExpressionBase represents comparable expressions
class	ComparableOperation<T extends Comparable<?>> ComparableOperation represents Comparable operations
class	DateExpression<T extends Comparable> DateExpression represents Date expressions The date representation is compatible with the Gregorian calendar.
class	DateOperation<T extends Comparable<?>> DateOperation represents Date operations
class	DateTimeExpression<T extends Comparable> DateTimeExpression represents Date / Time expressions The date representation is compatible with the Gregorian calendar.
class	DateTimeOperation<T extends Comparable<?>> DateTimeOperation represents DateTime operations
class	DslExpression<T> DslExpression is the base class for DSL expressions, but SimpleExpression is the base class for scalar Expressions
class	DslOperation<T> DslOperation represents a simple operation expression
class	EnumExpression<T extends Enum<T>> EnumExpression represents Enum typed expressions
class	EnumOperation<T extends Enum<T>> EnumOperation represents enum operations
class	MapExpressionBase<K,V,Q extends SimpleExpression<? super V>> MapExpressionBase is an abstract base class for MapExpression implementations
class	NumberExpression<T extends Number & Comparable<?>> NumberExpression represents a numeric expression
class	NumberOperation<T extends Number & Comparable<?>> NumberOperation represents numeric operations
class	Param<T> Param defines a parameter in a query with an optional name
class	SimpleExpression<T> SimpleExpression is the base class for Expression implementations.
class	SimpleOperation<T> SimpleOperation represents a simple operation expression
class	StringExpression StringExpression represents String expressions
class	StringOperation StringOperation represents a String typed operation
class	TemporalExpression<T extends Comparable> TemporalExpression is a supertype for Date/Time related types
class	TimeExpression<T extends Comparable> TimeExpression represents Time expressions
class	TimeOperation<T extends Comparable<?>> TimeOperation represents Time operations

Fields in com.mysema.query.types.expr declared as Expression

static Expression<Object[]>	Wildcard.all
protected Expression<T>	DslExpression.mixin

Methods in com.mysema.query.types.expr that return Expression

Expression<?>	DateOperation.getArg(int index)
Expression<?>	DateTimeOperation.getArg(int index)
Expression<?>	TimeOperation.getArg(int index)
Expression<?>	NumberOperation.getArg(int index)
Expression<?>	EnumOperation.getArg(int index)
Expression<?>	StringOperation.getArg(int index)
Expression<?>	BooleanOperation.getArg(int index)
Expression<?>	SimpleOperation.getArg(int index)
Expression<?>	ComparableOperation.getArg(int index)
Expression<?>	DslOperation.getArg(int index)

Methods in com.mysema.query.types.expr that return types with arguments of type Expression

List<Expression<?>>	DateOperation.getArgs()
List<Expression<?>>	DateTimeOperation.getArgs()
List<Expression<?>>	TimeOperation.getArgs()
List<Expression<?>>	NumberOperation.getArgs()
List<Expression<?>>	EnumOperation.getArgs()
List<Expression<?>>	StringOperation.getArgs()
List<Expression<?>>	BooleanOperation.getArgs()
List<Expression<?>>	SimpleOperation.getArgs()
List<Expression<?>>	ComparableOperation.getArgs()
List<Expression<?>>	DslOperation.getArgs()
<A> CaseBuilder.Cases<A,Expression<A>>	CaseBuilder.Initial.then(A constant)
<A> CaseBuilder.Cases<A,Expression<A>>	CaseBuilder.Initial.then(Expression<A> expr)
<T> CaseForEqBuilder.Cases<T,Expression<T>>	CaseForEqBuilder.then(Expression<T> then)
<T> CaseForEqBuilder.Cases<T,Expression<T>>	CaseForEqBuilder.then(T then)
<T> CaseForEqBuilder.Cases<T,Expression<T>>	CaseForEqBuilder.thenNull()

Methods in com.mysema.query.types.expr with parameters of type Expression

static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.acos(Expression<A> num)
<N extends Number & Comparable<?>> NumberExpression<T>	NumberExpression.add(Expression<N> right) Get the sum of this and right
Coalesce<T>	Coalesce.add(Expression<T> expr)
BooleanExpression	TemporalExpression.after(Expression<T> right) Get a this > right expression
StringExpression	StringExpression.append(Expression<String> str) Get the concatenation of this and str
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.asin(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.atan(Expression<A> num)
BooleanExpression	TemporalExpression.before(Expression<T> right) Get a this < right expression
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.between(Expression<A> from, Expression<A> to) Create a from < this < to expression
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.between(Expression<A> from, Expression<A> to) Create a from < this < to expression
BooleanExpression	ComparableExpression.between(Expression<T> from, Expression<T> to) Get a first <= this <= second expression
BooleanExpression	ComparableExpression.between(Expression<T> from, Expression<T> to) Get a first <= this <= second expression
SimpleExpression<Character>	StringExpression.charAt(Expression<Integer> i) Get the character at the given index
Coalesce<T>	ComparableExpressionBase.coalesce(Expression<?>... exprs)
StringExpression	StringExpression.concat(Expression<String> str) Get the concatenation of this and str
BooleanExpression	CollectionExpressionBase.contains(Expression<E> child)
BooleanExpression	MapExpressionBase.contains(Expression<K> key, Expression<V> value)
BooleanExpression	MapExpressionBase.contains(Expression<K> key, Expression<V> value)
BooleanExpression	StringExpression.contains(Expression<String> str) Returns true if the given String is contained
BooleanExpression	StringExpression.containsIgnoreCase(Expression<String> str)
BooleanExpression	MapExpressionBase.containsKey(Expression<K> key)
BooleanExpression	MapExpressionBase.containsValue(Expression<V> value)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.cos(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.cosh(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.cot(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.coth(Expression<A> num)
static <D extends Enum<D>> EnumExpression<D>	EnumOperation.create(Class<? extends D> type, Operator<? super D> op, Expression<?>... args) Factory method
static <D extends Number & Comparable<?>> NumberExpression<D>	NumberOperation.create(Class<? extends D> type, Operator<? super D> op, Expression<?>... args) Factory method
static <D> SimpleExpression<D>	SimpleOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args) Factory method
static <D> DslExpression<D>	DslOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args) Factory method
static <D extends Comparable<?>> DateExpression<D>	DateOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args) Factory method
static <D extends Comparable<?>> DateTimeExpression<D>	DateTimeOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args) Factory method
static <D extends Comparable<?>> TimeExpression<D>	TimeOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args) Factory method
static <D extends Comparable<?>> ComparableExpression<D>	ComparableOperation.create(Class<D> type, Operator<? super D> op, Expression<?>... args) Factory method
static BooleanExpression	BooleanOperation.create(Operator<? super Boolean> op, Expression<?>... args)
static StringExpression	StringOperation.create(Operator<? super String> op, Expression<?>... args)
protected abstract Q	CaseBuilder.Cases.createResult(Class<A> type, Expression<A> last)
protected abstract Q	CaseForEqBuilder.Cases.createResult(Class<T> type, Expression<T> last)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.degrees(Expression<A> num)
<N extends Number & Comparable<?>> NumberExpression<T>	NumberExpression.divide(Expression<N> right) Get the result of the operation this / right
BooleanExpression	StringExpression.endsWith(Expression<String> str) Returns true if this ends with str
BooleanExpression	StringExpression.endsWithIgnoreCase(Expression<String> str)
BooleanExpression	SimpleExpression.eq(Expression<? super T> right) Get a this == right expression
BooleanExpression	StringExpression.equalsIgnoreCase(Expression<String> str) Compares this StringExpression to another StringExpression, ignoring case considerations.
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.exp(Expression<A> num)
Q	ListExpression.get(Expression<Integer> index) Indexed access
SimpleExpression<T>	ArrayExpression.get(Expression<Integer> index) Get the element at the given index
abstract Q	MapExpressionBase.get(Expression<K> key)
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.goe(Expression<A> right) Create a this >= right expression
BooleanExpression	ComparableExpression.goe(Expression<T> right) Get a this >= right expression
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.gt(Expression<A> right) Create a this > right expression
BooleanExpression	ComparableExpression.gt(Expression<T> right) Get a this > right expression
NumberExpression<Integer>	StringExpression.indexOf(Expression<String> str) Get the index of the given substring in this String
NumberExpression<Integer>	StringExpression.indexOf(Expression<String> str, int i) Get the index of the given substring in this String, starting from the given index
BooleanExpression	StringExpression.like(Expression<String> str) Expr: this like str
BooleanExpression	StringExpression.like(Expression<String> str, char escape) Expr: this like str
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.ln(Expression<A> num)
NumberExpression<Integer>	StringExpression.locate(Expression<String> str) Get the position of the given String in this String, the first position is 1
NumberExpression<Integer>	StringExpression.locate(Expression<String> str, NumberExpression<Integer> start) Get the position of the given String in this String, the first position is 1
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.loe(Expression<A> right) Create a this <= right expression
BooleanExpression	ComparableExpression.loe(Expression<T> right) Get a this < right expression
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.log(Expression<A> num, int base)
static StringExpression	StringExpressions.lpad(Expression<String> in, Expression<Integer> length)
static StringExpression	StringExpressions.lpad(Expression<String> in, Expression<Integer> length)
static StringExpression	StringExpressions.lpad(Expression<String> in, int length)
static StringExpression	StringExpressions.lpad(Expression<String> in, int length, char c)
static StringExpression	StringExpressions.lpad(Expression<String> in, NumberExpression<Integer> length, char c)
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.lt(Expression<A> right) Create a this < right expression
BooleanExpression	ComparableExpression.lt(Expression<T> right) Get a this < right expression
static StringExpression	StringExpressions.ltrim(Expression<String> str)
BooleanExpression	StringExpression.matches(Expression<String> regex) Return true if this String matches the given regular expression
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.max(Expression<A> left, Expression<A> right) Return the greater of the given values
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.max(Expression<A> left, Expression<A> right) Return the greater of the given values
static <A extends Number & Comparable<?>> NumberExpression<A>	NumberExpression.max(Expression<A> left, Expression<A> right) Return the greater of the given values
static <A extends Number & Comparable<?>> NumberExpression<A>	NumberExpression.max(Expression<A> left, Expression<A> right) Return the greater of the given values
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.min(Expression<A> left, Expression<A> right) Return the smaller of the given values
static <A extends Number & Comparable<?>> NumberExpression<A>	MathExpressions.min(Expression<A> left, Expression<A> right) Return the smaller of the given values
static <A extends Number & Comparable<?>> NumberExpression<A>	NumberExpression.min(Expression<A> left, Expression<A> right) Return the smaller of the given values
static <A extends Number & Comparable<?>> NumberExpression<A>	NumberExpression.min(Expression<A> left, Expression<A> right) Return the smaller of the given values
NumberExpression<T>	NumberExpression.mod(Expression<T> num)
<N extends Number & Comparable<?>> NumberExpression<T>	NumberExpression.multiply(Expression<N> right) Get the result of the operation this * right
BooleanExpression	SimpleExpression.ne(Expression<? super T> right) Get a this <> right expression
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.notBetween(Expression<A> from, Expression<A> to)
<A extends Number & Comparable<?>> BooleanExpression	NumberExpression.notBetween(Expression<A> from, Expression<A> to)
BooleanExpression	ComparableExpression.notBetween(Expression<T> from, Expression<T> to) Get a this not between from and to expression
BooleanExpression	ComparableExpression.notBetween(Expression<T> from, Expression<T> to) Get a this not between from and to expression
BooleanExpression	StringExpression.notEqualsIgnoreCase(Expression<String> str) Compares this StringExpression to another StringExpression, ignoring case considerations.
BooleanExpression	StringExpression.notLike(Expression<String> str) Expr: this not like str
BooleanExpression	StringExpression.notLike(Expression<String> str, char escape) Expr: this not like str
Q	CaseBuilder.Cases.otherwise(Expression<A> expr)
Q	CaseForEqBuilder.Cases.otherwise(Expression<T> otherwise)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.power(Expression<A> num, int exponent)
StringExpression	StringExpression.prepend(Expression<String> str) Prepend the given String and return the result
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.radians(Expression<A> num)
static StringExpression	StringExpressions.rpad(Expression<String> in, Expression<Integer> length)
static StringExpression	StringExpressions.rpad(Expression<String> in, Expression<Integer> length)
static StringExpression	StringExpressions.rpad(Expression<String> in, int length)
static StringExpression	StringExpressions.rpad(Expression<String> in, int length, char c)
static StringExpression	StringExpressions.rpad(Expression<String> in, NumberExpression<Integer> length, char c)
static StringExpression	StringExpressions.rtrim(Expression<String> str)
static <A extends Number & Comparable<?>> NumberExpression<Integer>	MathExpressions.sign(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.sin(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.sinh(Expression<A> num)
BooleanExpression	StringExpression.startsWith(Expression<String> str) Return true if this starts with str
BooleanExpression	StringExpression.startsWithIgnoreCase(Expression<String> str)
StringExpression	StringExpression.substring(Expression<Integer> beginIndex) Get the given substring
StringExpression	StringExpression.substring(Expression<Integer> beginIndex, Expression<Integer> endIndex) Get the given substring
StringExpression	StringExpression.substring(Expression<Integer> beginIndex, Expression<Integer> endIndex) Get the given substring
StringExpression	StringExpression.substring(Expression<Integer> beginIndex, int endIndex) Get the given substring
StringExpression	StringExpression.substring(int beginIndex, Expression<Integer> endIndex) Get the given substring
<N extends Number & Comparable<?>> NumberExpression<T>	NumberExpression.subtract(Expression<N> right) Get the difference of this and right
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.tan(Expression<A> num)
static <A extends Number & Comparable<?>> NumberExpression<Double>	MathExpressions.tanh(Expression<A> num)
CaseBuilder.Cases<A,Q>	CaseBuilder.CaseWhen.then(Expression<A> expr)
<A> CaseBuilder.Cases<A,Expression<A>>	CaseBuilder.Initial.then(Expression<A> expr)
CaseForEqBuilder.Cases<T,Q>	CaseForEqBuilder.CaseWhen.then(Expression<T> then)
<T> CaseForEqBuilder.Cases<T,Expression<T>>	CaseForEqBuilder.then(Expression<T> then)
<T extends Number & Comparable<?>> CaseForEqBuilder.Cases<T,NumberExpression<T>>	CaseForEqBuilder.thenNumber(Expression<T> then)
CaseForEqBuilder.CaseWhen<T,Q>	CaseForEqBuilder.Cases.when(Expression<? extends D> when)
CaseForEqBuilder<T>	SimpleExpression.when(Expression<? extends T> other) Get a case expression builder

Constructors in com.mysema.query.types.expr with parameters of type Expression

BooleanExpression(Expression<Boolean> mixin)

BooleanOperation(Operator<? super Boolean> op, Expression<?>... args)

CaseForEqBuilder.CaseWhen(CaseForEqBuilder.Cases<T,Q> cases, Expression<? extends D> when)

CaseForEqBuilder(Expression<D> base, Expression<? extends D> other)

CaseForEqBuilder(Expression<D> base, Expression<? extends D> other)

Coalesce(Class<? extends T> type, Expression<?>... exprs)

Coalesce(Expression... exprs)

CollectionExpressionBase(Expression<T> mixin)

ComparableExpression(Expression<T> mixin)

ComparableExpressionBase(Expression<T> mixin)

ComparableOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)

DateExpression(Expression<T> mixin)

DateOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)

DateTimeExpression(Expression<T> mixin)

DateTimeOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)

DslExpression(Expression<T> mixin)

DslOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)

EnumExpression(Expression<T> mixin)

EnumOperation(Class<? extends T> type, Operator<? super T> op, Expression<?>... args)

MapExpressionBase(Expression<Map<K,V>> mixin)

NumberExpression(Expression<T> mixin)

NumberOperation(Class<? extends T> type, Operator<? super T> op, Expression<?>... args)

SimpleExpression(Expression<T> mixin)

SimpleOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)

StringExpression(Expression<String> mixin)

StringOperation(Operator<? super String> op, Expression<?>... args)

TemporalExpression(Expression<T> mixin)

TimeExpression(Expression<T> mixin)

TimeOperation(Class<T> type, Operator<? super T> op, Expression<?>... args)

Constructor parameters in com.mysema.query.types.expr with type arguments of type Expression

BooleanOperation(Operator<? super Boolean> op, List<Expression<?>> args)

ComparableOperation(Class<T> type, Operator<? super T> op, List<Expression<?>> args)

DateOperation(Class<T> type, Operator<? super T> op, List<Expression<?>> args)

DateTimeOperation(Class<T> type, Operator<? super T> op, List<Expression<?>> args)

DslOperation(Class<T> type, Operator<? super T> op, List<Expression<?>> args)

EnumOperation(Class<? extends T> type, Operator<? super T> op, List<Expression<?>> args)

NumberOperation(Class<? extends T> type, Operator<? super T> op, List<Expression<?>> args)

SimpleOperation(Class<T> type, Operator<? super T> op, List<Expression<?>> args)

StringOperation(Operator<? super String> op, List<Expression<?>> args)

TimeOperation(Class<T> type, Operator<? super T> op, List<Expression<?>> args)

Uses of Expression in com.mysema.query.types.path

Classes in com.mysema.query.types.path that implement Expression

class	ArrayPath<E> ArrayPath represents an array typed path
class	BeanPath<T> BeanPath represents bean paths
class	BooleanPath BooleanPath represents boolean path expressions
class	CollectionPath<E,Q extends SimpleExpression<? super E>> CollectionPath represents collection paths
class	CollectionPathBase<C extends Collection<E>,E,Q extends SimpleExpression<? super E>> CollectionPath is a base class for collection typed paths
class	ComparableEntityPath<T extends Comparable> ComparableEntityPath extends the ComparablePath class to implement the EntityPath interface
class	ComparablePath<T extends Comparable> ComparablePath represents Comparable paths
class	DatePath<T extends Comparable> DatePath presents Date paths
class	DateTimePath<T extends Comparable> DateTimePath presents DateTime typed paths
class	DslPath<T> DslPath represents simple paths
class	EntityPathBase<T> EntityPathBase provides a base class for EntityPath implementations
class	EnumPath<T extends Enum<T>> EnumPath represents enum paths
class	ListPath<E,Q extends SimpleExpression<? super E>> ListPath represents list paths
class	MapPath<K,V,E extends SimpleExpression<? super V>> MapPath represents map paths
class	NumberPath<T extends Number & Comparable<?>> NumberPath represents numeric paths
class	PathBuilder<T> PathBuilder is an extension to EntityPathBase for dynamic path construction
class	SetPath<E,Q extends SimpleExpression<? super E>> SetPath represents set paths
class	SimplePath<T> SimplePath represents simple paths
class	StringPath StringPath represents String typed paths
class	TimePath<T extends Comparable> TimePath represented Time paths

Methods in com.mysema.query.types.path with parameters of type Expression

protected PathMetadata<Integer>	ListPath.forListAccess(Expression<Integer> index)
protected PathMetadata<K>	MapPath.forMapAccess(Expression<K> key)
SimplePath<E>	ArrayPath.get(Expression<Integer> index) Create a expression for indexed access
Q	ListPath.get(Expression<Integer> index)
E	MapPath.get(Expression<K> key)

Uses of Expression in com.mysema.query.types.query

Subinterfaces of Expression in com.mysema.query.types.query

interface

ExtendedSubQueryExpression<T> Extensions to the SubQueryExpression interface

Classes in com.mysema.query.types.query that implement Expression

class	BooleanSubQuery Boolean typed single result subquery
class	ComparableSubQuery<T extends Comparable<?>> Comparable typed single result subquery
class	DateSubQuery<T extends Comparable<?>> Date typed single result subquery
class	DateTimeSubQuery<T extends Comparable<?>> DateTime typed single result subquery
class	ListSubQuery<T> List result subquery
class	NumberSubQuery<T extends Number & Comparable<?>> Number typed single result subquery
class	SimpleSubQuery<T> Object typed single result subquery
class	StringSubQuery String typed single result subquery
class	TimeSubQuery<T extends Comparable<?>> Time typed single result subquery

Methods in com.mysema.query.types.query with parameters of type Expression

SimpleExpression<?>	ListSubQuery.as(Expression<?> alias)
ListSubQuery<Object[]>	Detachable.list(Expression<?>[] args) Create a projection expression for the given projection
ListSubQuery<Object[]>	Detachable.list(Expression<?> first, Expression<?> second, Expression<?>... rest) Create a projection expression for the given projection
ListSubQuery<Object[]>	Detachable.list(Expression<?> first, Expression<?> second, Expression<?>... rest) Create a projection expression for the given projection
ListSubQuery<Object[]>	Detachable.list(Expression<?> first, Expression<?> second, Expression<?>... rest) Create a projection expression for the given projection
<RT> ListSubQuery<RT>	Detachable.list(Expression<RT> projection) Create a projection expression for the given projection
SimpleSubQuery<Object[]>	Detachable.unique(Expression<?>[] args) Create a projection expression for the given projection
SimpleSubQuery<Object[]>	Detachable.unique(Expression<?> first, Expression<?> second, Expression<?>... rest) Create a projection expression for the given projection
SimpleSubQuery<Object[]>	Detachable.unique(Expression<?> first, Expression<?> second, Expression<?>... rest) Create a projection expression for the given projection
SimpleSubQuery<Object[]>	Detachable.unique(Expression<?> first, Expression<?> second, Expression<?>... rest) Create a projection expression for the given projection
<RT> SimpleSubQuery<RT>	Detachable.unique(Expression<RT> projection) Create a subquery expression for the given projection

Uses of Expression in com.mysema.query.types.template

Classes in com.mysema.query.types.template that implement Expression

class	BooleanTemplate BooleanTemplate is a custom boolean expression
class	ComparableTemplate<T extends Comparable<?>> ComparableTemplate defines custom comparable expressions
class	DateTemplate<T extends Comparable<?>> DateTemplate defines custom date expressions
class	DateTimeTemplate<T extends Comparable<?>> DateTimeTemplate defines custom dateTime expressions
class	DslTemplate<T> DslTemplate defines custom simple expressions
class	EnumTemplate<T extends Enum<T>> EnumTemplate defines custom enum expressions
class	NumberTemplate<T extends Number & Comparable<?>> NumberTemplate defines custom numeric expressions
class	SimpleTemplate<T> SimpleTemplate defines custom simple expressions
class	StringTemplate StringTemplate defines custom String expressions
class	TimeTemplate<T extends Comparable<?>> TimeTemplate defines custom time expressions

Methods in com.mysema.query.types.template that return Expression

Expression<?>	TimeTemplate.getArg(int index)
Expression<?>	BooleanTemplate.getArg(int index)
Expression<?>	EnumTemplate.getArg(int index)
Expression<?>	DateTimeTemplate.getArg(int index)
Expression<?>	ComparableTemplate.getArg(int index)
Expression<?>	StringTemplate.getArg(int index)
Expression<?>	NumberTemplate.getArg(int index)
Expression<?>	DateTemplate.getArg(int index)
Expression<?>	DslTemplate.getArg(int index)
Expression<?>	SimpleTemplate.getArg(int index)

Methods in com.mysema.query.types.template that return types with arguments of type Expression

List<Expression<?>>	TimeTemplate.getArgs()
List<Expression<?>>	BooleanTemplate.getArgs()
List<Expression<?>>	EnumTemplate.getArgs()
List<Expression<?>>	DateTimeTemplate.getArgs()
List<Expression<?>>	ComparableTemplate.getArgs()
List<Expression<?>>	StringTemplate.getArgs()
List<Expression<?>>	NumberTemplate.getArgs()
List<Expression<?>>	DateTemplate.getArgs()
List<Expression<?>>	DslTemplate.getArgs()
List<Expression<?>>	SimpleTemplate.getArgs()

Methods in com.mysema.query.types.template with parameters of type Expression

static <T> DslExpression<T>	DslTemplate.create(Class<? extends T> type, String template, Expression<?>... args)
static <T> SimpleExpression<T>	SimpleTemplate.create(Class<? extends T> type, String template, Expression<?>... args)
static <T> DslExpression<T>	DslTemplate.create(Class<? extends T> type, Template template, Expression<?>... args)
static <T> SimpleExpression<T>	SimpleTemplate.create(Class<? extends T> type, Template template, Expression<?>... args)
static <T extends Comparable<?>> TimeTemplate<T>	TimeTemplate.create(Class<T> type, String template, Expression<?>... args)
static <T extends Comparable<?>> DateTimeExpression<T>	DateTimeTemplate.create(Class<T> type, String template, Expression<?>... args)
static <T extends Comparable<?>> ComparableExpression<T>	ComparableTemplate.create(Class<T> type, String template, Expression<?>... args)
static <T extends Comparable<?>> DateExpression<T>	DateTemplate.create(Class<T> type, String template, Expression<?>... args)
static <T extends Enum<T>> EnumExpression<T>	EnumTemplate.create(Class<T> type, String template, Expression<?>... args)
static <T extends Number & Comparable<?>> NumberExpression<T>	NumberTemplate.create(Class<T> type, String template, Expression<?>... args)
static <T extends Comparable<?>> TimeTemplate<T>	TimeTemplate.create(Class<T> type, Template template, Expression<?>... args)
static <T extends Comparable<?>> DateTimeExpression<T>	DateTimeTemplate.create(Class<T> type, Template template, Expression<?>... args)
static <T extends Comparable<?>> ComparableExpression<T>	ComparableTemplate.create(Class<T> type, Template template, Expression<?>... args)
static <T extends Comparable<?>> DateExpression<T>	DateTemplate.create(Class<T> type, Template template, Expression<?>... args)
static <T extends Enum<T>> EnumExpression<T>	EnumTemplate.create(Class<T> type, Template template, Expression<?>... args)
static <T extends Number & Comparable<?>> NumberExpression<T>	NumberTemplate.create(Class<T> type, Template template, Expression<?>... args)
static BooleanExpression	BooleanTemplate.create(String template, Expression<?>... args)
static StringExpression	StringTemplate.create(String template, Expression<?>... args)
static BooleanExpression	BooleanTemplate.create(Template template, Expression<?>... args)
static StringExpression	StringTemplate.create(Template template, Expression<?>... args)

Constructor parameters in com.mysema.query.types.template with type arguments of type Expression

BooleanTemplate(Template template, List<Expression<?>> args)

ComparableTemplate(Class<T> type, Template template, List<Expression<?>> args)

DateTemplate(Class<T> type, Template template, List<Expression<?>> args)

DateTimeTemplate(Class<T> type, Template template, List<Expression<?>> args)

DslTemplate(Class<? extends T> type, Template template, List<Expression<?>> args)

EnumTemplate(Class<T> type, Template template, List<Expression<?>> args)

NumberTemplate(Class<T> type, Template template, List<Expression<?>> args)

SimpleTemplate(Class<? extends T> type, Template template, List<Expression<?>> args)

StringTemplate(Template template, List<Expression<?>> args)

TimeTemplate(Class<T> type, Template template, List<Expression<?>> args)