org.eclipse.persistence.jpa.jpql.parser
Class AbstractTripleEncapsulatedExpression

java.lang.Object
  org.eclipse.persistence.jpa.jpql.parser.AbstractExpression
      org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression
          org.eclipse.persistence.jpa.jpql.parser.AbstractTripleEncapsulatedExpression

All Implemented Interfaces:

Expression

Direct Known Subclasses:

LocateExpression, SubstringExpression

public abstract class AbstractTripleEncapsulatedExpression
extends AbstractEncapsulatedExpression

This Expression takes care of parsing an expression that encapsulates three expressions separated by a comma.

BNF: expression ::= <identifier>(first_expression, second_expression, third_expression)

Version:

2.4.2

See Also:

LocateExpression, SubstringExpression

Author:

Pascal Filion

Since:

2.3

Field Summary

protected int

parameterIndex Determines which child expression is been currently parsed.

Fields inherited from class org.eclipse.persistence.jpa.jpql.parser.AbstractExpression

COMMA, DOT, DOUBLE_QUOTE, LEFT_CURLY_BRACKET, LEFT_PARENTHESIS, NOT_DEFINED, RIGHT_CURLY_BRACKET, RIGHT_PARENTHESIS, SINGLE_QUOTE, SPACE, UNDERSCORE

Fields inherited from interface org.eclipse.persistence.jpa.jpql.parser.Expression

ABS, ALL, AND, ANY, AS, ASC, AVG, BETWEEN, BIT_LENGTH, BOTH, CASE, CAST, CHAR_LENGTH, CHARACTER_LENGTH, CLASS, COALESCE, COLUMN, CONCAT, COUNT, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP, DELETE, DELETE_FROM, DESC, DIFFERENT, DISTINCT, DIVISION, ELSE, EMPTY, END, ENTRY, EQUAL, ESCAPE, EXCEPT, EXISTS, EXTRACT, FALSE, FETCH, FROM, FUNC, FUNCTION, GREATER_THAN, GREATER_THAN_OR_EQUAL, GROUP_BY, HAVING, IN, INDEX, INNER, INNER_JOIN, INNER_JOIN_FETCH, INTERSECT, IS, IS_EMPTY, IS_NOT_EMPTY, IS_NOT_NULL, IS_NULL, JOIN, JOIN_FETCH, KEY, LEADING, LEFT, LEFT_JOIN, LEFT_JOIN_FETCH, LEFT_OUTER_JOIN, LEFT_OUTER_JOIN_FETCH, LENGTH, LIKE, LOCATE, LOWER, LOWER_THAN, LOWER_THAN_OR_EQUAL, MAX, MEMBER, MEMBER_OF, MIN, MINUS, MOD, MULTIPLICATION, NAMED_PARAMETER, NEW, NOT, NOT_BETWEEN, NOT_EQUAL, NOT_EXISTS, NOT_IN, NOT_LIKE, NOT_MEMBER, NOT_MEMBER_OF, NULL, NULLIF, NULLS_FIRST, NULLS_LAST, OBJECT, OF, ON, OPERATOR, OR, ORDER_BY, OUTER, PLUS, POSITION, POSITIONAL_PARAMETER, QUOTE, REGEXP, SELECT, SET, SIZE, SOME, SQL, SQRT, SUBSTRING, SUM, TABLE, THEN, TRAILING, TREAT, TRIM, TRUE, TYPE, UNION, UNKNOWN, UPDATE, UPPER, VALUE, WHEN, WHERE

Constructor Summary

protected

AbstractTripleEncapsulatedExpression(AbstractExpression parent) Creates a new AbstractTripleEncapsulatedExpression.

Method Summary

void	acceptChildren(ExpressionVisitor visitor) Visits the children of this Expression.
protected void	addChildrenTo(java.util.Collection<Expression> children) Adds the children of this AbstractExpression to the given collection.
protected void	addOrderedEncapsulatedExpressionTo(java.util.List<Expression> children) Adds the Expressions representing the encapsulated Expression.
CollectionExpression	buildCollectionExpression() Creates a new CollectionExpression that will wrap the first, second and third expressions.
JPQLQueryBNF	findQueryBNF(Expression expression) Retrieves the JPQLQueryBNF that represents the fragment of this Expression that was used when parsing the given Expression.
Expression	getFirstExpression() Returns the Expression that represents the first expression.
Expression	getSecondExpression() Returns the Expression that represents the second expression.
Expression	getThirdExpression() Returns the Expression that represents the first expression.
boolean	hasEncapsulatedExpression() Determines whether something was parsed after the left parenthesis.
boolean	hasFirstComma() Determines whether the comma was parsed after the first expression.
boolean	hasFirstExpression() Determines whether the first expression of the query was parsed.
boolean	hasSecondComma() Determines whether the comma was parsed after the second expression.
boolean	hasSecondExpression() Determines whether the second expression of the query was parsed.
boolean	hasSpaceAfterFirstComma() Determines whether a whitespace was parsed after the first comma.
boolean	hasSpaceAfterSecondComma() Determines whether a whitespace was parsed after the second comma.
boolean	hasThirdExpression() Determines whether the third expression of the query was parsed.
protected boolean	isParsingComplete(WordParser wordParser, java.lang.String word, Expression expression) Determines whether the parsing is complete based on what is left in the given text.
protected abstract boolean	isThirdExpressionOptional() Determines whether the third expression is an optional expression, which means a valid query can have it or not.
abstract java.lang.String	parameterExpressionBNF(int index) Returns the BNF to be used to parse one of the encapsulated expression.
protected void	parseEncapsulatedExpression(WordParser wordParser, int whitespaceCount, boolean tolerant) Parses the encapsulated expression by starting at the current position, which is part of the given WordParser.
protected void	removeEncapsulatedExpression()
protected void	toParsedTextEncapsulatedExpression(java.lang.StringBuilder writer, boolean actual) Generates a string representation of the encapsulated Expression.

Methods inherited from class org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression

addOrderedChildrenTo, areLogicalIdentifiersSupported, getActualIdentifier, getIdentifier, hasLeftParenthesis, hasRightParenthesis, hasSpaceAfterIdentifier, parse, parseIdentifier, shouldParseRightParenthesis, toParsedText

Methods inherited from class org.eclipse.persistence.jpa.jpql.parser.AbstractExpression

acceptUnknownVisitor, acceptUnknownVisitor, buildExpressionFromFallingBack, buildNullExpression, buildStringExpression, buildStringExpression, buildUnknownExpression, calculatePosition, children, findFallBackExpressionFactory, getExpressionFactory, getExpressionRegistry, getGrammar, getIdentifierVersion, getJPAVersion, getLength, getOffset, getParent, getQueryBNF, getRoot, getText, handleAggregate, handleCollection, isAncestor, isIdentifier, isNull, isTolerant, isUnknown, isVirtual, orderedChildren, parse, parseUsingExpressionFactory, populatePosition, rebuildActualText, rebuildParsedText, setParent, setText, shouldParseWithFactoryFirst, shouldSkipLiteral, toActualText, toParsedText, toString

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.eclipse.persistence.jpa.jpql.parser.Expression

accept, getQueryBNF

Field Detail

parameterIndex

protected int parameterIndex

Determines which child expression is been currently parsed.

Constructor Detail

AbstractTripleEncapsulatedExpression

protected AbstractTripleEncapsulatedExpression(AbstractExpression parent)

Creates a new AbstractTripleEncapsulatedExpression.

Parameters:

parent - The parent of this expression

Method Detail

acceptChildren

public void acceptChildren(ExpressionVisitor visitor)

Visits the children of this Expression. This method can be used to optimize traversing the children since a new list is not created every time Expression.children() is called.

This does not traverse the Expression sub-hierarchy, use a subclass of AbstractTraverseChildrenVisitor in order to traverse the entire sub-hierarchy.

Parameters:

visitor - The visitor to visit the children of this object.

addChildrenTo

protected void addChildrenTo(java.util.Collection<Expression> children)

Adds the children of this AbstractExpression to the given collection.

Overrides:

addChildrenTo in class AbstractExpression

Parameters:

children - The collection used to store the children

addOrderedEncapsulatedExpressionTo

protected void addOrderedEncapsulatedExpressionTo(java.util.List<Expression> children)

Adds the Expressions representing the encapsulated Expression.

Specified by:

addOrderedEncapsulatedExpressionTo in class AbstractEncapsulatedExpression

Parameters:

children - The list used to store the string representation of the encapsulated Expression

buildCollectionExpression

public final CollectionExpression buildCollectionExpression()

Creates a new CollectionExpression that will wrap the first, second and third expressions.

Returns:

The first, second and third expressions represented by a temporary collection

findQueryBNF

public JPQLQueryBNF findQueryBNF(Expression expression)

Retrieves the JPQLQueryBNF that represents the fragment of this Expression that was used when parsing the given Expression.

Specified by:

findQueryBNF in interface Expression

Overrides:

findQueryBNF in class AbstractExpression

Parameters:

expression - The Expression that is a descendant of this one

Returns:

The JPQLQueryBNF that was used to parse the given expression

getFirstExpression

public final Expression getFirstExpression()

Returns the Expression that represents the first expression.

Returns:

The expression that was parsed representing the first expression

getSecondExpression

public final Expression getSecondExpression()

Returns the Expression that represents the second expression.

Returns:

The expression that was parsed representing the second expression

getThirdExpression

public final Expression getThirdExpression()

Returns the Expression that represents the first expression.

Returns:

The expression that was parsed representing the first expression

hasEncapsulatedExpression

public boolean hasEncapsulatedExpression()

Determines whether something was parsed after the left parenthesis.

Specified by:

hasEncapsulatedExpression in class AbstractEncapsulatedExpression

Returns:

true if something was parsed; false otherwise

hasFirstComma

public final boolean hasFirstComma()

Determines whether the comma was parsed after the first expression.

Returns:

true if a comma was parsed after the first expression; false otherwise

hasFirstExpression

public final boolean hasFirstExpression()

Determines whether the first expression of the query was parsed.

Returns:

true if the first expression was parsed; false if it was not parsed

hasSecondComma

public final boolean hasSecondComma()

Determines whether the comma was parsed after the second expression.

Returns:

true if a comma was parsed after the second expression; false otherwise

hasSecondExpression

public final boolean hasSecondExpression()

Determines whether the second expression of the query was parsed.

Returns:

true if the second expression was parsed; false if it was not parsed

hasSpaceAfterFirstComma

public final boolean hasSpaceAfterFirstComma()

Determines whether a whitespace was parsed after the first comma.

Returns:

true if there was a whitespace after the first comma; false otherwise

hasSpaceAfterSecondComma

public final boolean hasSpaceAfterSecondComma()

Determines whether a whitespace was parsed after the second comma.

Returns:

true if there was a whitespace after the second comma; false otherwise

hasThirdExpression

public final boolean hasThirdExpression()

Determines whether the third expression of the query was parsed.

Returns:

true if the third expression was parsed; false if it was not parsed

isParsingComplete

protected boolean isParsingComplete(WordParser wordParser,
                                    java.lang.String word,
                                    Expression expression)

Determines whether the parsing is complete based on what is left in the given text. The text is never empty.

Overrides:

isParsingComplete in class AbstractEncapsulatedExpression

Parameters:

wordParser - The text to parse based on the current position of the cursor

word - The word that was retrieved from the given text, which is the first word in the text

expression - The Expression that has already been parsed

Returns:

true if the text no longer can't be parsed by the current expression; false if more can be parsed

isThirdExpressionOptional

protected abstract boolean isThirdExpressionOptional()

Determines whether the third expression is an optional expression, which means a valid query can have it or not.

Returns:

true if the third expression can either be present or not in a valid query; false if it's mandatory

parameterExpressionBNF

public abstract java.lang.String parameterExpressionBNF(int index)

Returns the BNF to be used to parse one of the encapsulated expression.

Parameters:

index - The position of the encapsulated Expression that needs to be parsed within the parenthesis, which starts at position 0

Returns:

The BNF to be used to parse one of the encapsulated expression

parseEncapsulatedExpression

protected void parseEncapsulatedExpression(WordParser wordParser,
                                           int whitespaceCount,
                                           boolean tolerant)

Parses the encapsulated expression by starting at the current position, which is part of the given WordParser.

Specified by:

parseEncapsulatedExpression in class AbstractEncapsulatedExpression

Parameters:

wordParser - The text to parse based on the current position of the cursor

whitespaceCount - The number of whitespace characters that were parsed after '('

tolerant - Determines whether the parsing system should be tolerant, meaning if it should try to parse invalid or incomplete queries

removeEncapsulatedExpression

protected void removeEncapsulatedExpression()

Specified by:

removeEncapsulatedExpression in class AbstractEncapsulatedExpression

toParsedTextEncapsulatedExpression

protected final void toParsedTextEncapsulatedExpression(java.lang.StringBuilder writer,
                                                        boolean actual)

Generates a string representation of the encapsulated Expression.

Specified by:

toParsedTextEncapsulatedExpression in class AbstractEncapsulatedExpression

Parameters:

writer - The buffer used to append the encapsulated Expression's string representation

actual - Determines whether to include any characters that are considered virtual, i.e. that was parsed when the query is incomplete and is needed for functionality like content assist