Examples of Expression

• PolynomialExpressionGenerator.Expression
  @author Nicholson.Bill
• aQute.bnd.osgi.resource.FilterParser.Expression
• aQute.library.capreq.FilterParser.Expression
• adipe.translate.sql.Expression
  Represents an SQL expression (of non-boolean type), as it can appear in a select list, condition, etc.
• anvil.script.expression.Expression
  class Expression @author : Jani Lehtim�ki
• ariba.util.fieldvalue.Expression
  Abstract representation of an expression in an unspecified expression language.

  @aribaapi ariba

• caltrop.interpreter.ast.Expression
• cambridge.model.Expression
  User: erdinc Date: Oct 31, 2009 Time: 12:34:28 AM
• cascading.flow.planner.iso.expression.Expression
• cc.redberry.core.tensor.Expression
  Representation of mathematical expression A = B. {@code Expression} also implements{@link Transformation} and represents substitutions. @author Dmitry Bolotin @author Stanislav Poslavsky @see ExpressionBuilder @see ExpressionFactory @since 1.0
• client.net.sf.saxon.ce.expr.Expression
  Interface supported by an XPath expression. This includes both compile-time and run-time methods.

  Two expressions are considered equal if they return the same result when evaluated in the same context.

• com.airhacks.enhydrator.transform.Expression
  @author airhacks.com
• com.alibaba.antx.config.generator.expr.Expression
  ����һ�����ʽ�� @author Michael Zhou
• com.alibaba.citrus.expr.Expression
  代表一个表达式。 @author Michael Zhou
• com.asakusafw.utils.java.model.syntax.Expression
  式を表現する基底インターフェース。

  • Specified In:
    • {@code [JLS3:15] Expressions}
• com.avaje.ebean.Expression
  An expression that is part of a WHERE or HAVING clause.
• com.bacoder.parser.java.api.Expression
• com.bpodgursky.jbool_expressions.Expression
• com.cburch.logisim.analyze.model.Expression
• com.damnhandy.uri.template.Expression
  xample.com/foo{?query,number} \___________/ ^ | | The expression

  This class models this representation and adds helper functions for replacement and reverse matching.

  @author Ryan J. McDonough @version $Revision: 1.1 $ @see ExpressionImpl @since 2.0
• com.draagon.meta.manager.exp.Expression
• com.dragome.compiler.ast.Expression
  Copyright by Wolfgang Kuehn 2005 Created on Feb 17, 2005
• com.exigen.ie.constrainer.Expression
• com.facebook.presto.sql.tree.Expression
• com.founder.fix.bpmn2extensions.fixflow.Expression
  A representation of the model object 'Expression'. 表达式

  The following features are supported:

  • {@link com.founder.fix.bpmn2extensions.fixflow.Expression#getValue Value}
  • {@link com.founder.fix.bpmn2extensions.fixflow.Expression#getId Id}
  • {@link com.founder.fix.bpmn2extensions.fixflow.Expression#getName Name}

  @see com.founder.fix.bpmn2extensions.fixflow.FixFlowPackage#getExpression() @model extendedMetaData="name='Expression' kind='simple'" @generated
• com.gentics.api.lib.expressionparser.Expression
• com.github.antlrjavaparser.api.expr.Expression
• com.github.sommeri.less4j.core.ast.Expression
• com.google.caja.parser.js.Expression
  @author mikesamuel@gmail.com
• com.google.dart.engine.ast.Expression
  Instances of the class {@code Expression} defines the behavior common to nodes that represent anexpression.

   expression ::= {@link AssignmentExpression assignmentExpression}|  {@link ConditionalExpression conditionalExpression} cascadeSection|  {@link ThrowExpression throwExpression}

  @coverage dart.engine.ast
• com.google.devtools.moe.client.parser.Expression
  An interface for objects describing a {@link Codebase}. A Codebase is described lazily by editing or translating a given expression. Then {@link Expression#createCodebase(ProjectContext)}is called to create the Codebase in a given ProjectContext. Different Expression implementations may offer different transformations, e.g. {@link RepositoryExpression#createWriter(ProjectContext)}. Expressions should be immutable, and all implementations of the transformations below should return new Expressions leaving the given ones (this) unchanged.
• com.google.gxp.compiler.base.Expression
  A node that can (eventually) be evaluated.
• com.google.minijoe.compiler.ast.Expression
  Abstract superclass for all expression nodes. @author Andy Hayward
• com.google.test.metric.cpp.dom.Expression
• com.googlecode.aviator.Expression
  A expression @author dennis
• com.googlecode.openbeans.Expression
• com.graphbuilder.math.Expression
• com.hpctoday.fada.Expression
• com.icl.saxon.expr.Expression
• com.icona.tree.nodes.Expression
• com.intellij.codeInsight.template.Expression
• com.marakana.calculator.expressions.Expression
• com.meidusa.amoeba.parser.expression.Expression
  表达式基类 @author Struct chen
• com.mysema.query.types.Expression
  Expression defines a general typed expression in a Query instance. The generic type parameter is a reference to the type the expression is bound to.

  The central Expression subinterfaces are

  • {@link Constant} - for constants such as Strings, numbers and entity instances
  • {@link FactoryExpression} - for row based result processing
  • {@link Operation} - for common supported operations and function calls
  • {@link ParamExpression} - for bindable query parameters
  • {@link Path} - for variables, properties and collection member access
  • {@link SubQueryExpression} - for subqueries
  • {@link TemplateExpression} - for custom syntax

  @author tiwe @param < T> expression type
• com.neemsoft.jmep.Expression
• com.objfac.prebop.Expression
  @author Bob Foster
• com.opensymphony.workflow.query.Expression
• com.pogofish.jadt.ast.Expression
• com.puppetlabs.geppetto.pp.Expression
  A representation of the model object 'Expression'. @see com.puppetlabs.geppetto.pp.PPPackage#getExpression() @model @generated
• com.redhat.ceylon.compiler.typechecker.tree.Tree.Expression
• com.redspr.redquerybuilder.core.client.expression.Expression
• com.salesforce.phoenix.expression.Expression
  Interface for general expression evaluation @author jtaylor @since 0.1
• com.sk89q.worldedit.internal.expression.Expression
  Compiles and evaluates expressions.

  Supported operators:

  • Logical: &&, ||, ! (unary)
  • Bitwise: ~ (unary), >>, <<
  • Arithmetic: +, -, *, /, % (modulo), ^ (power), - (unary), --, ++ (prefix only)
  • Comparison: <=, >=, >, <, ==, !=, ~= (near)

  Supported functions: abs, acos, asin, atan, atan2, cbrt, ceil, cos, cosh, exp, floor, ln, log, log10, max, max, min, min, rint, round, sin, sinh, sqrt, tan, tanh and more. (See the Functions class or the wiki)

  Constants: e, pi

  To compile an equation, run {@code Expression.compile("expression here", "var1", "var2"...)}. If you wish to run the equation multiple times, you can then optimize it, by calling {@link #optimize()}. You can then run the equation as many times as you want by calling {@link #evaluate(double)}. You do not need to pass values for all variables specified while compiling. To query variables after evaluation, you can use {@link #getVariable(String,boolean)}. To get a value out of these, use {@link Variable#getValue()}.

  Variables are also supported and can be set either by passing values to {@link #evaluate(double)}.

• com.strobel.decompiler.ast.Expression
• com.strobel.decompiler.languages.java.ast.Expression
• com.strobel.expressions.Expression
  The base type for all nodes in Expression Trees. @author Mike Strobel
• com.stuffwithstuff.bantam.expressions.Expression
  Interface for all expression AST node classes.
• com.sun.msv.grammar.Expression
  Primitive of the tree regular expression. most of the derived class is immutable (except ReferenceExp, ElementExp and OtherExp).

  By making it immutable, it becomes possible to share subexpressions among expressions. This is very important for regular-expression-derivation based validation algorithm, as well as for smaller memory footprint. This sharing is automatically achieved by ExpressionPool.

  ReferebceExp, ElementExp, and OtherExp are also placed in the pool, but these are not unified. Since they are not unified, application can derive classes from these expressions and mix them into AGM. This technique is heavily used to introduce schema language specific primitives into AGM. See various sub-packages of this package for examples.

  The equals method must be implemented by the derived type. equals method will be used to unify the expressions. equals method can safely assume that its children are already unified (therefore == can be used to test the equality, rather than equals method).

  To achieve unification, we overload the equals method so that o1.equals(o2) is true if o1 and o2 are identical. There, those two objects must return the same hash code. For this purpose, the hash code is calculated statically and cached internally. @author Kohsuke KAWAGUCHI

• com.sun.org.apache.xpath.internal.Expression
  This abstract class serves as the base for all expression objects. An Expression can be executed to return a {@link com.sun.org.apache.xpath.internal.objects.XObject}, normally has a location within a document or DOM, can send error and warning events, and normally do not hold state and are meant to be immutable once construction has completed. An exception to the immutibility rule is iterators and walkers, which must be cloned in order to be used -- the original must still be immutable.
• com.sun.tools.corba.se.idl.constExpr.Expression
• com.sun.tools.internal.xjc.reader.gbind.Expression
  This builds content models. @author Kohsuke Kawaguchi
• com.sun.tools.xjc.reader.gbind.Expression
  This builds content models. @author Kohsuke Kawaguchi
• com.tulskiy.musique.playlist.formatting.tokens.Expression
  @Author : Denis Tulskiy @Date : Feb 6, 2010
• com.volantis.xml.expression.Expression
  A parsed expression.

  Warning: This is a facade provided for use by user code, not for implementation in user code. User implementations of this interface are highly likely to be incompatible with future releases of the product at both binary and source levels.

  Implementations of this interface must be thread safe and must not maintain any evaluation specific state as they may be evaluated simultaneously by multiple threads.

  Expressions must have no context specific information in them. Where it is necessary to refer to named items the names must be stored as QNames which are expanded at evaluation time. This means that a given string will always result in the same Expression expression no matter where it is used.

  @volantis-api-include-in PublicAPI @volantis-api-include-in ProfessionalServicesAPI @volantis-api-include-in InternalAPI
• cs227b.teamIago.resolver.Expression
  @author NickTODO To change the template for this generated type comment go to Window - Preferences - Java - Code Style - Code Templates
• cz.jirutka.rsql.parser.model.Expression
• de.fuberlin.wiwiss.d2rq.expr.Expression
  A SQL expression. @author Richard Cyganiak (richard@cyganiak.de)
• de.halirutan.mathematica.parsing.psi.api.Expression
  Created with IntelliJ IDEA. User: patrick Date: 1/3/13 Time: 11:41 AM Purpose:
• de.sebastianbenz.task.query.Expression
  A representation of the model object 'Expression'. @see de.sebastianbenz.task.query.QueryPackage#getExpression() @model @generated
• dtool.ast.expressions.Expression
• edu.cmu.cs.stage3.alice.core.Expression
• edu.mit.simile.backstage.model.data.Expression
• edu.stanford.nlp.ling.tokensregex.types.Expression
  This interfaces represents an expression that can be evaluated to obtain a value @author Angel Chang
• eu.admire.dispel.expressions.Expression
  A representation of the model object 'Expression'. @see eu.admire.dispel.expressions.ExpressionsPackage#getExpression() @model abstract="true" @generated
• eu.admire.dispel.parser.expression.Expression
• expression.Expression
  interface for expressions To build expressions in a concrete CSP solver syntax, need to implement ExpressionVisitor @author Hélène Collavizza @date June 2008
• fitnesse.util.Expression
• freemarker.core.ast.Expression
  An abstract class for nodes in the parse tree that represent a FreeMarker expression.
• games.stendhal.common.parser.Expression
  An Expression is part of a Sentence. It encapsulates the original, white space trimmed text, the expression type, a normalized lower case text string and the integer amount. @author Martin Fuchs
• heart.alsvfd.Expression
• httl.ast.Expression
  Expression. (API, Prototype, Immutable, ThreadSafe) @see httl.spi.parsers.ExpressionParser#parse(String,int) @author Liang Fei (liangfei0201 AT gmail DOT com)
• io.crate.sql.tree.Expression
• ivory.smrf.model.builder.Expression
• japa.parser.ast.expr.Expression
  @author Julio Vilmar Gesser
• jaque.expressions.Expression
  streaming@googlegroups.com">KonstantinTriger
• java.beans.Expression
  An Expression object represents a primitive expression in which a single method is applied to a target and a set of arguments to return a result - as in "a.getFoo()".

  In addition to the properties of the super class, the Expression object provides a value which is the object returned when this expression is evaluated. The return value is typically not provided by the caller and is instead computed by dynamically finding the method and invoking it when the first call to getValue is made. @see #getValue @see #setValue @since 1.4 @version 1.3 11/15/00 @author Philip Milne

• javarepl.expressions.Expression
• javax.el.Expression
  Base class for the expression subclasses {@link ValueExpression} and{@link MethodExpression}, implementing characterstics common to both.

  All expressions must implement the equals() and hashCode() methods so that two expressions can be compared for equality. They are redefined abstract in this class to force their implementation in subclasses.

  All expressions must also be Serializable so that they can be saved and restored.

  Expressions are also designed to be immutable so that only one instance needs to be created for any given expression String / {@link FunctionMapper}. This allows a container to pre-create expressions and not have to re-parse them each time they are evaluated.

  @since JSP 2.1
• javax.persistence.criteria.Expression
  Criteria expression. @since JPA 2.0
• javax.servlet.jsp.el.Expression
  Allows evaluation of JSP EL.
• jmathexpr.Expression
  An arbitrary mathematical expression. @author Elemér Furka
• kiss.lang.Expression
  Abstract base class for immutable Kiss Expression nodes Design intent: - Represent Kiss AST - Can be optimised - Can be evaluated / interpreted given an execution environment - Can be compiled, given satisfaction of all external dependencies - Immutable @author Mike
• kodkod.ast.Expression
  A relational expression. Unless otherwise noted, all methods in this class throw a NullPointerException when given null arguments. @specfield arity: int @invariant arity > 0 @author Emina Torlak
• lombok.ast.Expression
• mil.nga.giat.geowave.analytics.mapreduce.kde.parser.Expression
• net.hydromatic.linq4j.expressions.Expression

  Analogous to LINQ's System.Linq.Expression.

• net.mitza.odata.parser.Expression
  @author Mihai Cadariu
• net.sf.jsqlparser.expression.Expression
• net.sf.jxls.parser.Expression
• net.sf.saxon.expr.Expression
  Interface supported by an XPath expression. This includes both compile-time and run-time methods.

  Two expressions are considered equal if they return the same result when evaluated in the same context.

• oracle.olapi.syntax.Expression
• oracle.toplink.essentials.expressions.Expression

  Purpose: Define an object-level representation of a database query where clause.

  Description: An expression is a tree-like structure that defines the selection criteria for a query against objects in the database. The expression has the advantage over SQL by being at the object-level, i.e. the object model attributes and relationships can be used to be query on instead of the database field names. Because it is an object, not a string the expression has the advantage that is can be easily manipulated through code to easily build complex selection criterias.

  Responsibilities:

  • Store the selection criteria in a tree-like structure.
  • Support public manipulation protocols for all comparison and function opperators.
  • Use opperator overloading to support all primitive types as well as objects.

• org.activemq.filter.Expression
  Represents an expression @version $Revision: 1.1.1.1 $
• org.activiti.engine.delegate.Expression
  @author Frederik Heremans
• org.andromda.core.translation.Expression
  Stores the translated expression, @author Chad Brandon
• org.apache.activemq.apollo.filter.Expression
  Represents an expression @version $Revision: 1.2 $
• org.apache.activemq.filter.Expression
  Represents an expression @version $Revision: 1.2 $
• org.apache.ambari.server.api.predicate.expressions.Expression
  Expression representation. There are two types of expressions, relational and logical. Each expression has an operator and either 2 operands for binary expressions or 1 operand for unary expressions.
• org.apache.beehive.netui.script.Expression
  This class implements an abstraction atop an Expression object. It provides access to metadata about the parsed expression including the data binding context and tokens that constitute the expression.
• org.apache.camel.Expression
  emq.apache.org/camel/expression.html">expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. @version $Revision: $
• org.apache.cayenne.exp.Expression
  Superclass of Cayenne expressions that defines basic API for expressions use.
• org.apache.clerezza.rdf.core.sparql.query.Expression
  org/TR/rdf-sparql-query/#modOrderBy"> SPARQL Query Language: 9.1 ORDER BY @see SPARQL Query Language: 3 RDF Term Constraints (Informative) @see SPARQL Query Language: 11.2 Filter Evaluation @author hasan
• org.apache.cocoon.el.Expression
  @version $Id: Expression.java 605958 2007-12-20 15:13:11Z vgritsenko $
• org.apache.commons.betwixt.expression.Expression

  Expression represents an arbitrary expression on a bean.

  @author James Strachan
• org.apache.commons.el.Expression

  The abstract class from which all expression types derive. @author Nathan Abramson - Art Technology Group @author Shawn Bayern @version $Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author: luehe $

• org.apache.commons.jelly.expression.Expression

  Expression represents an arbitrary expression using some pluggable expression language.

  @author James Strachan @version $Revision: 1.4 $
• org.apache.commons.jexl.Expression

  Represents a single JEXL expression. This simple interface provides access to the underlying expression through getExpression(), and it provides hooks to add a pre- and post- expression resolver.

  An expression is different than a script - it is simply a reference of an expression.

  @since 1.0 @author Geir Magnusson Jr. @version $Id: Expression.java 397092 2006-04-26 05:11:28Z dion $
• org.apache.commons.jexl2.Expression
  Represents a single JEXL expression.

  This simple interface provides access to the underlying expression through {@link Expression#getExpression()}.

  An expression is different than a script - it is simply a reference of an expression.

  @since 1.0 @author Geir Magnusson Jr. @version $Id: Expression.java 884175 2009-11-25 16:23:41Z henrib $
• org.apache.commons.jxpath.ri.compiler.Expression
  Common superclass for several types of nodes in the parse tree. Provides APIs for optimization of evaluation of expressions. Specifically, an expression only needs to executed once during the evaluation of an xpath if that expression is context-independent. Expression.isContextDependent() provides that hint. @author Dmitri Plotnikov @version $Revision: 1.6 $ $Date: 2003/03/11 00:59:22 $
• org.apache.felix.gogo.runtime.Expression
  rns 212.34
  

  Add Custom Functions

  Adding custom functions is as easy as adding custom operators. Create an instance of `Expression.Function`and add it to the expression. Parameters are the function name and the count of required parameters. The functions `eval()` method will be called with a list of the BigDecimal parameters. All existing functions can also be overridden.
  For example, add a function `average(a,b,c)`, that will calculate the average value of a, b and c:
  

   Expression e = new Expression("2 * average(12,4,8)"); e.addFunction(e.new Function("average", 3) { {@literal @}Override public BigDecimal eval(List parameters) { BigDecimal sum = parameters.get(0).add(parameters.get(1)).add(parameters.get(2)); return sum.divide(new BigDecimal(3)); } }); e.eval(); // returns 16 

  The software is licensed under the MIT Open Source license (see LICENSE file).
  

  • The *power of* operator (^) implementation was copied from [Stack Overflow](http://stackoverflow.com/questions/3579779/how-to-do-a-fractional-power-on-bigdecimal-in-java) Thanks to Gene Marin
  • The SQRT() function implementation was taken from the book [The Java Programmers Guide To numerical Computing](http://www.amazon.de/Java-Number-Cruncher-Programmers-Numerical/dp/0130460419) (Ronald Mak, 2002)

  @author Udo Klimaschewski (http://about.me/udo.klimaschewski)
• org.apache.garbage.tree.Expression
  @author Pier Fumagalli, February 2003 @version CVS $Id: Expression.java,v 1.2 2004/03/05 10:07:24 bdelacretaz Exp $
• org.apache.hadoop.fs.shell.find.Expression
  Interface describing an expression to be used in the {@link org.apache.hadoop.fs.shell.find.Find} command.
• org.apache.hadoop.hbase.client.idx.exp.Expression
  Class representing an expression.
• org.apache.imperius.spl.core.Expression
• org.apache.lucene.expressions.Expression
  ile an expression: Expression expr = JavascriptCompiler.compile("sqrt(_score) + ln(popularity)"); // SimpleBindings just maps variables to SortField instances SimpleBindings bindings = new SimpleBindings(); bindings.add(new SortField("_score", SortField.Type.SCORE)); bindings.add(new SortField("popularity", SortField.Type.INT)); // create a sort field and sort by it (reverse order) Sort sort = new Sort(expr.getSortField(bindings, true)); Query query = new TermQuery(new Term("body", "contents")); searcher.search(query, null, 10, sort); @see JavascriptCompiler#compile @lucene.experimental
• org.apache.maven.usability.plugin.Expression
  A plugin parameter expression supported by Maven. @version $Revision$ $Date$
• org.apache.ode.bpel.compiler.bom.Expression
  BOM representation of a BPEL expression language expression.
• org.apache.oodt.xmlps.queryparser.Expression
  The abstract interface for our expression tree.
• org.apache.openjpa.kernel.exps.Expression
  Interface for a set of conditions that must be met for the query to be true. @author Abe White
• org.apache.openjpa.persistence.query.Expression
  Instances of this interface can be used either as select list items or as predicate operands.
• org.apache.phoenix.expression.Expression
  Interface for general expression evaluation @since 0.1
• org.apache.pig.Expression
  A class to communicate Filter expressions to LoadFuncs. @since Pig 0.7
• org.apache.qpid.filter.Expression
  Represents an expression
• org.apache.qpid.server.filter.Expression
  Represents an expression
• org.apache.servicemix.expression.Expression
  An expression strategy for extracting or calculating some value from a message. @version $Revision: 564374 $
• org.apache.slide.projector.expression.Expression
  The Expression interface
• org.apache.taglibs.standard.lang.jstl.Expression

  The abstract class from which all expression types derive. @author Nathan Abramson - Art Technology Group @author Shawn Bayern

• org.apache.tiles.Expression
  It is an expression, along with the expression language (e.g. EL, MVEL, OGNL) it is expressed with. @version $Rev: 788032 $ $Date: 2009-06-24 10:08:32 -0400 (Wed, 24 Jun 2009) $ @since 2.2.0
• org.apache.ws.jaxme.sqls.Expression
  Interface of an arithmetic expression.
• org.apache.xpath.Expression
  This abstract class serves as the base for all expression objects. An Expression can be executed to return a {@link org.apache.xpath.objects.XObject}, normally has a location within a document or DOM, can send error and warning events, and normally do not hold state and are meant to be immutable once construction has completed. An exception to the immutibility rule is iterators and walkers, which must be cloned in order to be used -- the original must still be immutable.
• org.applause.lang.applauseDsl.Expression
  A representation of the model object 'Expression'. @see org.applause.lang.applauseDsl.ApplauseDslPackage#getExpression() @model @generated
• org.araneaframework.backend.list.memorybased.Expression
  Expression that returns an Object when it is evaluated.
• org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression
• org.auraframework.expression.Expression
  An expression that can be evaluated on the server or the client.
• org.bitbucket.rehei.sparqljava.model.Expression
• org.broadleafcommerce.openadmin.web.rulebuilder.statement.Expression
  @author jfischer @author Elbert Bautista (elbertbautista)
• org.camunda.bpm.engine.delegate.Expression
  @author Frederik Heremans
• org.candle.decompiler.intermediate.expression.Expression
• org.codehaus.activemq.filter.Expression
  Represents an expression @version $Revision: 1.1 $
• org.codehaus.aspectwerkz.definition.expression.Expression
  Base abstract class for the expressions.

  An expression is wether an ExpressionExpression (algebra) wether a LeafExpression

  Evaluates nested pointcut patterns with unlimited depth.

  Uses the composite pattern. @author Jonas Bon�r @author Alexandre Vasseur @TODO : implement readObject() for the subclasses @TODO : add serialVersionUID field to the subclasses

• org.codehaus.groovy.ast.expr.Expression
  Represents a base class for expressions which evaluate as an object @author James Strachan @version $Revision: 17114 $
• org.csu.idl.idlmm.Expression
  A representation of the model object 'Expression'. @see org.csu.idl.idlmm.IdlmmPackage#getExpression() @model abstract="true" @generated
• org.datanucleus.query.expression.Expression
  A Scalar expression in a Query. Used to compute values with a resulting type.
• org.datanucleus.query.typesafe.Expression
• org.drools.core.rule.constraint.ConditionAnalyzer.Expression
• org.drools.runtime.pipeline.Expression

  This api is experimental and thus the classes and the interfaces returned are subject to change.

• org.eclipse.bpel.model.Expression
  A representation of the model object 'Expression'.

  The following features are supported:

  • {@link org.eclipse.bpel.model.Expression#getBody Body}
  • {@link org.eclipse.bpel.model.Expression#getExpressionLanguage Expression Language}
  • {@link org.eclipse.bpel.model.Expression#getOpaque Opaque}

  @see org.eclipse.bpel.model.BPELPackage#getExpression() @model @generated
• org.eclipse.bpmn2.Expression
  A representation of the model object 'Expression'. @see org.eclipse.bpmn2.Bpmn2Package#getExpression() @model extendedMetaData="name='tExpression' kind='mixed'" @generated
• org.eclipse.core.expressions.Expression
  Abstract base class for all expressions provided by the common expression language.

  An expression is evaluated by calling {@link #evaluate(IEvaluationContext)}.

  This class may be subclassed to provide specific expressions.

  @since 3.0
• org.eclipse.dltk.ast.expressions.Expression
• org.eclipse.jdt.core.dom.Expression
  Abstract base class of AST nodes that represent expressions. There are several kinds of expressions.

   Expression: {@link Annotation}, {@link ArrayAccess}, {@link ArrayCreation}, {@link ArrayInitializer}, {@link Assignment}, {@link BooleanLiteral}, {@link CastExpression}, {@link CharacterLiteral}, {@link ClassInstanceCreation}, {@link ConditionalExpression}, {@link CreationReference}, {@link ExpressionMethodReference}, {@link FieldAccess}, {@link InfixExpression}, {@link InstanceofExpression}, {@link LambdaExpression}, {@link MethodInvocation}, {@link MethodReference}, {@link Name}, {@link NullLiteral}, {@link NumberLiteral}, {@link ParenthesizedExpression}, {@link PostfixExpression}, {@link PrefixExpression}, {@link StringLiteral}, {@link SuperFieldAccess}, {@link SuperMethodInvocation}, {@link SuperMethodReference}, {@link ThisExpression}, {@link TypeLiteral}, {@link TypeMethodReference}, {@link VariableDeclarationExpression}

  @since 2.0
• org.eclipse.jdt.internal.compiler.ast.Expression
• org.eclipse.persistence.expressions.Expression

  Purpose: Define an object-level representation of a database query where clause.

  Description: An expression is a tree-like structure that defines the selection criteria for a query against objects in the database. The expression has the advantage over SQL by being at the object-level, i.e. the object model attributes and relationships can be used to be query on instead of the database field names. Because it is an object, not a string the expression has the advantage that is can be easily manipulated through code to easily build complex selection criterias.

  Responsibilities:

  • Store the selection criteria in a tree-like structure.
  • Support public manipulation protocols for all comparison and function operators.
  • Use opperator overloading to support all primitive types as well as objects.

• org.eclipse.persistence.jpa.internal.jpql.parser.Expression
  rg/en/jsr/detail?id=317">JSR 317: Java™ Persistence 2.0

  The BNF for the Java Persistence query language, version 2.0:

   QL_statement ::= select_statement | update_statement | delete_statement select_statement ::= select_clause from_clause [where_clause] [groupby_clause] [having_clause] [orderby_clause] update_statement ::= update_clause [where_clause] delete_statement ::= delete_clause [where_clause] from_clause ::= FROM identification_variable_declaration {, {identification_variable_declaration | collection_member_declaration}} identification_variable_declaration ::= range_variable_declaration { join | fetch_join } range_variable_declaration ::= entity_name [AS] identification_variable join ::= join_spec join_association_path_expression [AS] identification_variable fetch_join ::= join_spec FETCH join_association_path_expression join_spec ::= [ LEFT [OUTER] | INNER ] JOIN join_association_path_expression ::= join_collection_valued_path_expression | join_single_valued_path_expression join_collection_valued_path_expression ::= identification_variable.{single_valued_embeddable_object_field.}*collection_valued_field join_single_valued_path_expression ::= identification_variable.{single_valued_embeddable_object_field.}*single_valued_object_field collection_member_declaration ::= IN (collection_valued_path_expression) [AS] identification_variable qualified_identification_variable ::= KEY(identification_variable) | VALUE(identification_variable) | ENTRY(identification_variable) single_valued_path_expression ::= qualified_identification_variable | state_field_path_expression | single_valued_object_path_expression general_identification_variable ::= identification_variable | KEY(identification_variable) | VALUE(identification_variable) state_field_path_expression ::= general_identification_variable.{single_valued_object_field.}*state_field single_valued_object_path_expression ::= general_identification_variable.{single_valued_object_field.}*single_valued_object_field collection_valued_path_expression ::= general_identification_variable.{single_valued_object_field.}*collection_valued_field update_clause ::= UPDATE entity_name [[AS] identification_variable] SET update_item {, update_item} update_item ::= [identification_variable.]{state_field | single_valued_object_field} = new_value new_value ::= scalar_expression | simple_entity_expression | NULL delete_clause ::= DELETE FROM entity_name [[AS] identification_variable] select_clause ::= SELECT [DISTINCT] select_item {, select_item} select_item ::= select_expression [[AS] result_variable] select_expression ::= single_valued_path_expression | scalar_expression | aggregate_expression | identification_variable | OBJECT(identification_variable) | constructor_expression constructor_expression ::= NEW constructor_name ( constructor_item {, constructor_item}* ) constructor_item ::= single_valued_path_expression | scalar_expression | aggregate_expression | identification_variable aggregate_expression ::= { AVG | MAX | MIN | SUM } ([DISTINCT] state_field_path_expression) | COUNT ([DISTINCT] identification_variable | state_field_path_expression | single_valued_object_path_expression) where_clause ::= WHERE conditional_expression groupby_clause ::= GROUP BY groupby_item {, groupby_item} groupby_item ::= single_valued_path_expression | identification_variable having_clause ::= HAVING conditional_expression orderby_clause ::= ORDER BY orderby_item {, orderby_item} orderby_item ::= state_field_path_expression | result_variable [ ASC | DESC ] subquery ::= simple_select_clause subquery_from_clause [where_clause] [groupby_clause] [having_clause] subquery_from_clause ::= FROM subselect_identification_variable_declaration {, subselect_identification_variable_declaration | collection_member_declaration} subselect_identification_variable_declaration ::= identification_variable_declaration | derived_path_expression [AS] identification_variable {join}* | derived_collection_member_declaration derived_path_expression ::= superquery_identification_variable.{single_valued_object_field.}*collection_valued_field | superquery_identification_variable.{single_valued_object_field.}*single_valued_object_field derived_collection_member_declaration ::= IN superquery_identification_variable.{single_valued_object_field.}*collection_valued_field simple_select_clause ::= SELECT [DISTINCT] simple_select_expression simple_select_expression ::= single_valued_path_expression | scalar_expression | aggregate_expression | identification_variable scalar_expression ::= simple_arithmetic_expression | string_primary | enum_primary | datetime_primary | boolean_primary | case_expression | entity_type_expression conditional_expression ::= conditional_term | conditional_expression OR conditional_term conditional_term ::= conditional_factor | conditional_term AND conditional_factor conditional_factor ::= [ NOT ] conditional_primary conditional_primary ::= simple_cond_expression | (conditional_expression) simple_cond_expression ::= comparison_expression | between_expression | in_expression | like_expression | null_comparison_expression | empty_collection_comparison_expression | collection_member_expression | exists_expression between_expression ::= arithmetic_expression [NOT] BETWEEN arithmetic_expression AND arithmetic_expression | string_expression [NOT] BETWEEN string_expression AND string_expression | datetime_expression [NOT] BETWEEN datetime_expression AND datetime_expression in_expression ::= {state_field_path_expression | type_discriminator} [NOT] IN { ( in_item {, in_item}* ) | (subquery) | collection_valued_input_parameter } in_item ::= literal | single_valued_input_parameter like_expression ::= string_expression [NOT] LIKE pattern_value [ESCAPE escape_character] null_comparison_expression ::= {single_valued_path_expression | input_parameter} IS [NOT] NULL empty_collection_comparison_expression ::= collection_valued_path_expression IS [NOT] EMPTY collection_member_expression ::= entity_or_value_expression [NOT] MEMBER [OF] collection_valued_path_expression entity_or_value_expression ::= single_valued_object_path_expression | state_field_path_expression | simple_entity_or_value_expression simple_entity_or_value_expression ::= identification_variable | input_parameter | literal exists_expression ::= [NOT] EXISTS (subquery) all_or_any_expression ::= { ALL | ANY | SOME} (subquery) comparison_expression ::= string_expression comparison_operator {string_expression | all_or_any_expression} | boolean_expression { = | <> } {boolean_expression | all_or_any_expression} | enum_expression { =|<> } {enum_expression | all_or_any_expression} | datetime_expression comparison_operator {datetime_expression | all_or_any_expression} | entity_expression { = | <> } {entity_expression | all_or_any_expression} | arithmetic_expression comparison_operator {arithmetic_expression | all_or_any_expression} | entity_type_expression { = | <> } entity_type_expression} comparison_operator ::= = | > | >= | < | <= | <> arithmetic_expression ::= simple_arithmetic_expression | (subquery) simple_arithmetic_expression ::= arithmetic_term | simple_arithmetic_expression { + | - } arithmetic_term arithmetic_term ::= arithmetic_factor | arithmetic_term { * | / } arithmetic_factor arithmetic_factor ::= [{ + | - }] arithmetic_primary arithmetic_primary ::= state_field_path_expression | numeric_literal | (simple_arithmetic_expression) | input_parameter | functions_returning_numerics | aggregate_expression | case_expression string_expression ::= string_primary | (subquery) string_primary ::= state_field_path_expression | string_literal | input_parameter | functions_returning_strings | aggregate_expression | case_expression datetime_primary ::= state_field_path_expression | input_parameter | functions_returning_datetime | aggregate_expression | case_expression | date_time_timestamp_literal datetime_expression ::= datetime_primary | (subquery) boolean_expression ::= boolean_primary | (subquery) boolean_primary ::= state_field_path_expression | boolean_literal | input_parameter | case_expression enum_expression ::= enum_primary | (subquery) enum_primary ::= state_field_path_expression | enum_literal | input_parameter | case_expression entity_expression ::= single_valued_object_path_expression | simple_entity_expression simple_entity_expression ::= identification_variable | input_parameter entity_type_expression ::= type_discriminator | entity_type_literal | input_parameter type_discriminator ::= TYPE(identification_variable | single_valued_object_path_expression | input_parameter) functions_returning_numerics ::= LENGTH(string_primary) | LOCATE(string_primary, string_primary[, simple_arithmetic_expression]) | ABS(simple_arithmetic_expression) | SQRT(simple_arithmetic_expression) | MOD(simple_arithmetic_expression, simple_arithmetic_expression) | SIZE(collection_valued_path_expression) | INDEX(identification_variable) functions_returning_datetime ::= CURRENT_DATE | CURRENT_TIME | CURRENT_TIMESTAMP | literalTemporal functions_returning_strings ::= CONCAT(string_primary, string_primary {, string_primary}*) | SUBSTRING(string_primary, simple_arithmetic_expression [, simple_arithmetic_expression]) | TRIM([[trim_specification] [trim_character] FROM] string_primary) | LOWER(string_primary) | UPPER(string_primary) trim_specification ::= LEADING | TRAILING | BOTH trim_character ::= string_literal | input_parameter case_expression ::= general_case_expression | simple_case_expression | coalesce_expression | nullif_expression general_case_expression ::= CASE when_clause {when_clause}* ELSE scalar_expression END when_clause ::= WHEN conditional_expression THEN scalar_expression simple_case_expression ::= CASE case_operand simple_when_clause {simple_when_clause}* ELSE scalar_expression END case_operand ::= state_field_path_expression | type_discriminator simple_when_clause ::= WHEN scalar_expression THEN scalar_expression coalesce_expression ::= COALESCE(scalar_expression {, scalar_expression}+) nullif_expression ::= NULLIF(scalar_expression, scalar_expression) boolean_literal ::= TRUE | FALSE string_literal ::= 'string' enum_literal ::= {package_name.}*EnumType.CONSTANT literalTemporal ::= date_literal | TIME_LITERAL | TIMESTAMP_LITERAL date_literal ::= "{" "'d'" (' ' | '\t')+ '\'' DATE_STRING '\'' (' ' | '\t')* "}" TIME_LITERAL ::= "{" "'t'" (' ' | '\t')+ '\'' TIME_STRING '\'' (' ' | '\t')* "}" TIMESTAMP_LITERAL ::= "{" ('ts') (' ' | '\t')+ '\'' DATE_STRING ' ' TIME_STRING '\'' (' ' | '\t')* "}" DATE_STRING ::= '0'..'9' '0'..'9' '0'..'9' '0'..'9' '-' '0'..'9' '0'..'9' '-' '0'..'9' '0'..'9' TIME_STRING ::= '0'..'9' ('0'..'9')? ':' '0'..'9' '0'..'9' ':' '0'..'9' '0'..'9' '.' '0'..'9' 

  The following BNFs is the EclipseLink's extension over the standard JPQL BNF.

  join ::= join_spec { join_association_path_expression | join_treat_association_path_expression } [AS] identification_variable join_treat_association_path_expression ::= TREAT(join_association_path_expression AS entity_type_literal) functions_returning_strings ::= ... | func_expression functions_returning_numerics ::= ... | func_expression functions_returning_datetime ::= ... | func_expression func_expression ::= FUNC (func_name {, func_item}*) func_item ::= scalar_expression (NOT SURE) orderby_item ::= state_field_path_expression | result_variable | scalar_expression [ ASC | DESC ] groupby_item ::= single_valued_path_expression | identification_variable | scalar_expression aggregate_expression ::= { AVG | MAX | MIN | SUM | COUNT } ([DISTINCT] scalar_expression) in_item ::= literal | single_valued_input_parameter | scalar_expression 

  @version 2.3 @since 2.3 @author Pascal Filion
• org.eclipse.persistence.jpa.jpql.parser.Expression
  This is the root interface of the parsed tree representation of a JPQL query. The way a JPQL query is parsed is based on the {@link JPQLGrammar JPQL grammar} used.

  Provisional API: This interface is part of an interim API that is still under development and expected to change significantly before reaching stability. It is available at this early stage to solicit feedback from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken (repeatedly) as the API evolves. @see JPQLGrammar @version 2.4.2 @since 2.3 @author Pascal Filion

• org.eclipse.php.internal.core.ast.nodes.Expression
  Base class for all expression in PHP
• org.eclipse.php.internal.debug.core.zend.debugger.Expression
• org.eclipse.xtend.lib.macro.expression.Expression
  @author Sven Efftinge @noimplement This interface is not intended to be implemented by clients.
• org.eclipselabs.emodeling.query.Expression
• org.elegant.aash.comparator.parsing.expr.Expression
• org.exist.xquery.Expression
  Base interface implemented by all classes which are part of an XQuery/XPath expression. The main method is {@link #eval(Sequence,Item)}. Please read the description there.
• org.gdbms.engine.instruction.Expression
  Interfaz a implementar sobre los nodos @author Fernando Gonz�lez Cort�s
• org.geotools.filter.Expression
• org.h2.expression.Expression
  An expression is a operation, a value, or a function in a query.
• org.hsqldb.Expression
  Expression class. @author Campbell Boucher-Burnett (boucherb@users dot sourceforge.net) @author Fred Toussi (fredt@users dot sourceforge.net) @version 1.9.0 @since 1.9.0
• org.hsqldb_voltpatches.Expression
  Expression class. @author Campbell Boucher-Burnett (boucherb@users dot sourceforge.net) @author Fred Toussi (fredt@users dot sourceforge.net) @version 1.9.0 @since 1.9.0
• org.jboss.aspects.dbc.condition.parser.Expression
  @author Kabir Khan @version $Revision: 37406 $
• org.jboss.byteman.rule.expression.Expression
  abstract class representing an evaluable expression. this is used in all 3 elements of ECA rules: as the value part of each of the event bindings in the binding list comprising an ECA rule event; as the condition expression of an ECA rule condition;and as an element of the actions list in an ECA rule action.
• org.jbpm.jpdl.el.Expression

  The abstract class for a prepared expression.

  An instance of an Expression can be obtained via from an ExpressionEvaluator instance.

  An Expression may or not have done a syntactic parse of the expression. A client invoking the evaluate() method should be ready for the case where ELParseException exceptions are raised.

  @since 2.0
• org.jfree.report.expressions.Expression
  An expression is a lightweight computation that does not maintain a state. Expressions are used to calculate values within a single row of a report. Expressions can use a dataRow to access other fields, expressions or functions within the current row in the report. Statefull computations can be implemented using functions. @author Thomas Morgner @see Function
• org.jinq.jpa.jpqlquery.Expression
• org.jmanage.core.util.Expression
  Provides a mechanism to specify application name, mbean name and attribute or operation name as a single String expression. The expression looks like the following:
  <appName>/<mbeaName>/<attrName>

  The mbeanName could be the "configured" mbean name or the object name. This depends on the context in which Expression object is used.

  This object is widely used in the jManage application specifically in the command line UI and the access control system. Date: Feb 26, 2005 @author Rakesh Kalra

• org.jpox.query.expression.Expression
  A Scalar expression in a Query. Used to compute values with a resulting type @version $Revision: 1.34 $
• org.jquantlib.math.functions.Expression
  Processes a sequence of functions @author Richard Gomes
• org.jrdf.query.expression.Expression
  A pattern of triples applied to a graph to constrain the results of a query.

  Maps to a GraphPattern in the SPARQL grammar.

  @author Tom Adams @version $Revision: 2936 $
• org.jresearch.flexess.models.expression.Expression
  A representation of the model object 'Expression'.

  The following features are supported:

  • {@link org.jresearch.flexess.models.expression.Expression#getContainer Container}

  @see org.jresearch.flexess.models.expression.ExpressionPackage#getExpression() @model abstract="true" @generated
• org.jreversepro.ast.expression.Expression
  Represents the abstraction of the Java Language Syntax, Expression. @author akkumar
• org.lealone.expression.Expression
  An expression is a operation, a value, or a function in a query.
• org.librebiz.pureport.definition.Expression
• org.neo4j.cypherdsl.expression.Expression
  Common interface for all expressions
• org.netbeans.modules.php.editor.parser.astnodes.Expression
• org.nuxeo.ecm.automation.core.scripting.Expression
• org.objectweb.medor.expression.api.Expression
• org.omg.uml.foundation.datatypes.Expression
• org.opengis.filter.expression.Expression
  is.org/docs/02-059.pdf">Implementation specification 1.0 @author Chris Dillard (SYS Technologies) @author Justin Deoliveira (The Open Planning Project) @since GeoAPI 2.0
• org.openquark.cal.compiler.Expression
  Warning- this class should only be used by the CAL compiler implementation. It is not part of the external API of the CAL platform.

  Expressions are generated by the compiler after static analysis, typechecking, lambda lifting, overload resolution etc. They are an intermediate form used by machines to generate actual executable code. @author LWE

• org.outerj.expression.Expression
• org.pdf4j.saxon.expr.Expression
  Interface supported by an XPath expression. This includes both compile-time and run-time methods.
• org.pentaho.reporting.engine.classic.core.function.Expression
  An expression is a lightweight function that does not maintain a state. Expressions are used to calculate values within a single row of a report. Expressions can use a dataRow to access other fields, expressions or functions within the current row in the report. @author Thomas Morgner
• org.rascalmpl.ast.Expression
• org.renjin.compiler.ir.tac.expressions.Expression
• org.springframework.binding.expression.Expression
  An expression capable of evaluating itself against context objects. Encapsulates the details of a previously parsed expression string. Provides a common abstraction for expression evaluation independent of any language like OGNL or the Unified EL. @author Keith Donald
• org.springframework.expression.Expression
  An expression capable of evaluating itself against context objects. Encapsulates the details of a previously parsed expression string. Provides a common abstraction for expression evaluation independent of any language like OGNL or the Unified EL. @author Keith Donald @author Andy Clement @since 3.0
• org.springmodules.validation.bean.conf.loader.annotation.handler.Expression
• org.switchyard.component.common.knowledge.expression.Expression
  Expression. @author David Ward <dward@jboss.org> © 2012 Red Hat Inc.
• org.teiid.language.Expression
  Represents an expression in the language. Subinterfaces define specific types of expressions, such as literal values, element references, and functions.
• org.teiid.query.sql.symbol.Expression
  This is the interface for an expression in a SQL string. Expressions can be of several types (see subclasses), but all expressions have a type. These types are used for type checking.
• org.thymeleaf.standard.expression.Expression
  @author Daniel Fernández @since 1.1
• org.voltdb.benchmark.Verification.Expression
• org.wso2.carbon.cep.core.Expression
  This Class contains query text
• org.xvr.s3D.expression
  A representation of the model object 'expression'.

  The following features are supported:

  • {@link org.xvr.s3D.expression#getForEachStm For Each Stm}
  • {@link org.xvr.s3D.expression#getClStm Cl Stm}
  • {@link org.xvr.s3D.expression#getOCase OCase}
  • {@link org.xvr.s3D.expression#getBExpr BExpr}
  • {@link org.xvr.s3D.expression#getTExpr TExpr}
  • {@link org.xvr.s3D.expression#getFExpr FExpr}

  @see org.xvr.s3D.S3DPackage#getexpression() @model @generated
• org.zkoss.xel.Expression
  Represent a prepared (aka., compiled) expression. It can be retrieved by use of {@link ExpressionFactory}. @author tomyeh @since 3.0.0
• org.zkoss.zuss.metainfo.Expression
  Represents an expression.

  The children is a list of values and operators in the postfix expression. @author tomyeh

• our.apache.commons.jxpath.ri.compiler.Expression
• prefuse.data.expression.Expression
  rg">jeffrey heer
• ptolemy.actor.lib.Expression

  On each firing, evaluate an expression that may include references to the inputs, current time, and a count of the firing. The ports are referenced by the identifiers that have the same name as the port. To use this class, instantiate it, then add ports (instances of TypedIOPort). In vergil, you can add ports by right clicking on the icon and selecting "Configure Ports". In MoML you can add ports by just including ports of class TypedIOPort, set to be inputs, as in the following example:

   <entity name="exp" class="ptolemy.actor.lib.Expression"> <port name="in" class="ptolemy.actor.TypedIOPort"> <property name="input"/> </port> </entity> 

  This actor is type-polymorphic. The types of the inputs can be arbitrary and the types of the outputs are inferred from the expression based on the types inferred for the inputs.

  The expression parameter specifies an expression that can refer to the inputs by name. By default, the expression is empty, and attempting to execute the actor without setting it triggers an exception. This actor can be used instead of many of the arithmetic actors, such as AddSubtract, MultiplyDivide, and TrigFunction. However, those actors will be usually be more efficient, and sometimes more convenient to use.

  The expression language understood by this actor is the same as that used to set any parameter value, with the exception that the expressions evaluated by this actor can refer to the values of inputs, and to the current time by the identifier name "time", and to the current iteration count by the identifier named "iteration."

  This actor requires its all of its inputs to be present. If inputs are not all present, then an exception will be thrown.

  NOTE: There are a number of limitations in the current implementation. Primarily, multiports are not supported.

  @author Xiaojun Liu, Edward A. Lee, Steve Neuendorffer @version $Id: Expression.java,v 1.130 2007/12/07 06:25:26 cxh Exp $ @since Ptolemy II 0.2 @Pt.ProposedRating Green (neuendor) @Pt.AcceptedRating Green (neuendor)
• railo.runtime.sql.exp.Expression
• railo.transformer.bytecode.expression.Expression
  A Expression (Operation, Literal aso.)
• ru.aristar.jnuget.query.Expression
  Выражение,использующееся для поиска пакетов @author sviridov
• ru.snake.spritepacker.writer.expression.Expression
• ru.vassaev.core.Expression
• semestralka.Expression
  @author frantisek
• st.gravel.support.compiler.ast.Expression
• stanfordlogic.prover.Expression
  A logical sentence.
• steal.Expression
• steal.examples.expression.model.Expression
• supervision.Expression
• tools.Expression
• urban.kappa.Expression
  A representation of the model object 'Expression'.

  The following features are supported:

  • {@link urban.kappa.Expression#getAgents Agents}

  @see urban.kappa.KappaPackage#getExpression() @model @generated
• urban.urban.Expression
  A representation of the model object 'Expression'.

  The following features are supported:

  • {@link urban.urban.Expression#getAgents Agents}

  @see urban.urban.UrbanPackage#getExpression() @model @generated
• webit.script.core.ast.Expression
  @author Zqq
• wyvern.targets.Common.wyvernIL.IL.Expr.Expression

Examples of webit.script.core.ast.Expression

Examples of wyvern.targets.Common.wyvernIL.IL.Expr.Expression