EclipseLink Hermes Parser 4.0.2 · org.eclipse.persistence.jpa.jpql.parser.AbstractDoubleEncapsulatedExpression

Modifier and Type	Field and Description
private AbstractExpression	firstExpression The `Expression` that represents the first expression.
private boolean	hasComma Determines whether the comma separating the first and second expression was parsed.
private boolean	hasSpaceAfterComma Determines whether a whitespace is following the comma.
private AbstractExpression	secondExpression The `Expression` that represents the second expression.

Access	Constructor and Description
protected	AbstractDoubleEncapsulatedExpression(AbstractExpression The parent of this expression parent, String The JPQL identifier that starts this expression identifier) Creates a new `AbstractDoubleEncapsulatedExpression`.

Method Summary

Modifier and Type	Method and Description
public void	acceptChildren(ExpressionVisitor The `visitor` to visit the children of this object. visitor) Implements org.eclipse.persistence.jpa.jpql.parser.Expression.acceptChildren. Visits the children of this `Expression`.
protected void	addChildrenTo(Collection<Expression> The collection used to store the children children) Overrides org.eclipse.persistence.jpa.jpql.parser.AbstractExpression.addChildrenTo. Adds the children of this `AbstractExpression` to the given collection.
protected void	addOrderedEncapsulatedExpressionTo(List<Expression> The list used to store the string representation of the encapsulated `Expression` children) Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.addOrderedEncapsulatedExpressionTo. Adds the `Expressions` representing the encapsulated `Expression`.
public final CollectionExpression	Returns: The first and second expressions wrapped by a temporary collection buildCollectionExpression() Creates a new `CollectionExpression` that will wrap the first and second expressions.
public JPQLQueryBNF	findQueryBNF(Expression The `Expression` that is a descendant of this one expression) Overrides org.eclipse.persistence.jpa.jpql.parser.AbstractExpression.findQueryBNF. Implements org.eclipse.persistence.jpa.jpql.parser.Expression.findQueryBNF. Retrieves the `JPQLQueryBNF` that represents the fragment of this `Expression` that was used when parsing the given `Expression`.
public final Expression	Returns: The expression that was parsed representing the first expression getFirstExpression() Returns the `Expression` that represents the first expression.
public final Expression	Returns: The expression that was parsed representing the second expression getSecondExpression() Returns the `Expression` that represents the second expression.
public final boolean	Returns: `true` if a comma was parsed after the first expression; `false` otherwise hasComma() Determines whether the comma was parsed after the first expression.
public boolean	hasEncapsulatedExpression() Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.hasEncapsulatedExpression. Determines whether something was parsed after the left parenthesis.
public final boolean	Returns: `true` if the first expression was parsed; `false` if it was not parsed hasFirstExpression() Determines whether the first expression of the query was parsed.
public final boolean	Returns: `true` if the second expression was parsed; `false` if it was not parsed hasSecondExpression() Determines whether the second expression of the query was parsed.
public final boolean	Returns: `true` if there was a whitespace after the comma; `false` otherwise hasSpaceAfterComma() Determines whether a whitespace was parsed after the comma.
protected boolean	isParsingComplete(WordParser The text to parse based on the current position of the cursor wordParser, String The word that was retrieved from the given text, which is the first word in the text word, Expression The `Expression` that has already been parsed expression) Overrides org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.isParsingComplete. Determines whether the parsing is complete based on what is left in the given text.
protected boolean	Returns: `true` if the second expression is optional; `false` if it is required isSecondExpressionOptional() Determines whether the second expression is optional or not.
public abstract String	Returns: The BNF to be used to parse one of the encapsulated expression parameterExpressionBNF(int The position of the encapsulated `Expression` that needs to be parsed within the parenthesis, which starts at position 0 index) Returns the BNF to be used to parse one of the encapsulated expression.
protected void	parseEncapsulatedExpression(WordParser The text to parse based on the current position of the cursor wordParser, int The number of whitespace characters that were parsed after '(' whitespaceCount, boolean Determines whether the parsing system should be tolerant, meaning if it should try to parse invalid or incomplete queries tolerant) Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.parseEncapsulatedExpression. Parses the encapsulated expression by starting at the current position, which is part of the given `WordParser`.
protected void	removeEncapsulatedExpression() Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.removeEncapsulatedExpression. Removes the encapsulated `Expression` that was parsed, it should not be part of this one.
protected void	toParsedTextEncapsulatedExpression(StringBuilder The buffer used to append the encapsulated `Expression`'s string representation writer, boolean 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 actual) Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.toParsedTextEncapsulatedExpression. Generates a string representation of the encapsulated `Expression`.

Inherited from org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression:: addOrderedChildrenTo areLogicalIdentifiersSupported getActualIdentifier getIdentifier hasLeftParenthesis hasRightParenthesis hasSpaceAfterIdentifier parse shouldParseRightParenthesis toParsedText

firstExpression	back to summary
private AbstractExpression firstExpression The `Expression` that represents the first expression.

hasComma	back to summary
private boolean hasComma Determines whether the comma separating the first and second expression was parsed.

hasSpaceAfterComma	back to summary
private boolean hasSpaceAfterComma Determines whether a whitespace is following the comma.

secondExpression	back to summary
private AbstractExpression secondExpression The `Expression` that represents the second expression.

AbstractDoubleEncapsulatedExpression	back to summary
protected AbstractDoubleEncapsulatedExpression(AbstractExpression parent, String identifier) Creates a new `AbstractDoubleEncapsulatedExpression`. Parameters parent:AbstractExpression The parent of this expression identifier:String The JPQL identifier that starts this expression

Method Detail

acceptChildren back to summary

acceptChildren	back to summary
public void acceptChildren(ExpressionVisitor visitor) Implements org.eclipse.persistence.jpa.jpql.parser.Expression.acceptChildren. Doc from org.eclipse.persistence.jpa.jpql.parser.Expression.acceptChildren. 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 `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:ExpressionVisitor The `visitor` to visit the children of this object. Annotations @Override

public void acceptChildren(ExpressionVisitor visitor)

Implements org.eclipse.persistence.jpa.jpql.parser.Expression.acceptChildren.

Doc from org.eclipse.persistence.jpa.jpql.parser.Expression.acceptChildren.

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 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:ExpressionVisitor: The visitor to visit the children of this object.

Annotations

@Override

addChildrenTo back to summary

addChildrenTo	back to summary
protected void addChildrenTo(Collection<Expression> children) Overrides org.eclipse.persistence.jpa.jpql.parser.AbstractExpression.addChildrenTo. Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractExpression.addChildrenTo. Adds the children of this `AbstractExpression` to the given collection. Parameters children:Collection<Expression> The collection used to store the children Annotations @Override

protected void addChildrenTo(Collection<Expression> children)

Overrides org.eclipse.persistence.jpa.jpql.parser.AbstractExpression.addChildrenTo.

Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractExpression.addChildrenTo.

Adds the children of this AbstractExpression to the given collection.

Parameters

children:Collection<Expression>: The collection used to store the children

Annotations

@Override

addOrderedEncapsulatedExpressionTo back to summary

addOrderedEncapsulatedExpressionTo	back to summary
protected void addOrderedEncapsulatedExpressionTo(List<Expression> children) Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.addOrderedEncapsulatedExpressionTo. Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.addOrderedEncapsulatedExpressionTo. Adds the `Expressions` representing the encapsulated `Expression`. Parameters children:List<Expression> The list used to store the string representation of the encapsulated `Expression` Annotations @Override

protected void addOrderedEncapsulatedExpressionTo(List<Expression> children)

Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.addOrderedEncapsulatedExpressionTo.

Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.addOrderedEncapsulatedExpressionTo.

Adds the Expressions representing the encapsulated Expression.

Parameters

children:List<Expression>: The list used to store the string representation of the encapsulated Expression

Annotations

@Override

buildCollectionExpression back to summary

buildCollectionExpression	back to summary
public final CollectionExpression buildCollectionExpression() Creates a new `CollectionExpression` that will wrap the first and second expressions. Returns:CollectionExpression The first and second expressions wrapped by a temporary collection

public final CollectionExpression buildCollectionExpression()

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

Returns:CollectionExpression: The first and second expressions wrapped by a temporary collection

findQueryBNF back to summary

findQueryBNF	back to summary
public JPQLQueryBNF findQueryBNF(Expression expression) Overrides org.eclipse.persistence.jpa.jpql.parser.AbstractExpression.findQueryBNF. Implements org.eclipse.persistence.jpa.jpql.parser.Expression.findQueryBNF. Doc from org.eclipse.persistence.jpa.jpql.parser.Expression.findQueryBNF. Retrieves the `JPQLQueryBNF` that represents the fragment of this `Expression` that was used when parsing the given `Expression`. Parameters expression:Expression The `Expression` that is a descendant of this one Returns:JPQLQueryBNF The `JPQLQueryBNF` that was used to parse the given expression Annotations @Override

public JPQLQueryBNF findQueryBNF(Expression expression)

Overrides org.eclipse.persistence.jpa.jpql.parser.AbstractExpression.findQueryBNF.

Implements org.eclipse.persistence.jpa.jpql.parser.Expression.findQueryBNF.

Doc from org.eclipse.persistence.jpa.jpql.parser.Expression.findQueryBNF.

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

Parameters

expression:Expression: The Expression that is a descendant of this one

Returns:JPQLQueryBNF

The JPQLQueryBNF that was used to parse the given expression

Annotations

@Override

getFirstExpression back to summary

getFirstExpression	back to summary
public final Expression getFirstExpression() Returns the `Expression` that represents the first expression. Returns:Expression The expression that was parsed representing the first expression

public final Expression getFirstExpression()

Returns the Expression that represents the first expression.

Returns:Expression: The expression that was parsed representing the first expression

getSecondExpression back to summary

getSecondExpression	back to summary
public final Expression getSecondExpression() Returns the `Expression` that represents the second expression. Returns:Expression The expression that was parsed representing the second expression

public final Expression getSecondExpression()

Returns the Expression that represents the second expression.

Returns:Expression: The expression that was parsed representing the second expression

hasComma back to summary

hasComma	back to summary
public final boolean hasComma() Determines whether the comma was parsed after the first expression. Returns:boolean `true` if a comma was parsed after the first expression; `false` otherwise

public final boolean hasComma()

Determines whether the comma was parsed after the first expression.

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

hasEncapsulatedExpression back to summary

hasEncapsulatedExpression	back to summary
public boolean hasEncapsulatedExpression() Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.hasEncapsulatedExpression. Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.hasEncapsulatedExpression. Determines whether something was parsed after the left parenthesis. Returns:boolean `true` if something was parsed; `false` otherwise Annotations @Override

public boolean hasEncapsulatedExpression()

Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.hasEncapsulatedExpression.

Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.hasEncapsulatedExpression.

Determines whether something was parsed after the left parenthesis.

Returns:boolean

true if something was parsed; false otherwise

Annotations

@Override

hasFirstExpression back to summary

hasFirstExpression	back to summary
public final boolean hasFirstExpression() Determines whether the first expression of the query was parsed. Returns:boolean `true` if the first expression was parsed; `false` if it was not parsed

public final boolean hasFirstExpression()

Determines whether the first expression of the query was parsed.

Returns:boolean: true if the first expression was parsed; false if it was not parsed

hasSecondExpression back to summary

hasSecondExpression	back to summary
public final boolean hasSecondExpression() Determines whether the second expression of the query was parsed. Returns:boolean `true` if the second expression was parsed; `false` if it was not parsed

public final boolean hasSecondExpression()

Determines whether the second expression of the query was parsed.

Returns:boolean: true if the second expression was parsed; false if it was not parsed

hasSpaceAfterComma back to summary

hasSpaceAfterComma	back to summary
public final boolean hasSpaceAfterComma() Determines whether a whitespace was parsed after the comma. Returns:boolean `true` if there was a whitespace after the comma; `false` otherwise

public final boolean hasSpaceAfterComma()

Determines whether a whitespace was parsed after the comma.

Returns:boolean: true if there was a whitespace after the comma; false otherwise

isParsingComplete back to summary

isParsingComplete	back to summary
protected boolean isParsingComplete(WordParser wordParser, String word, Expression expression) Overrides org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.isParsingComplete. Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractExpression.isParsingComplete. Determines whether the parsing is complete based on what is left in the given text. The text is never empty. Parameters wordParser:WordParser The text to parse based on the current position of the cursor word:String The word that was retrieved from the given text, which is the first word in the text expression:Expression The `Expression` that has already been parsed Returns:boolean `true` if the text no longer can't be parsed by the current expression; `false` if more can be parsed Annotations @Override

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

Overrides org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.isParsingComplete.

Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractExpression.isParsingComplete.

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

Parameters

wordParser:WordParser: The text to parse based on the current position of the cursor
word:String: The word that was retrieved from the given text, which is the first word in the text
expression:Expression: The Expression that has already been parsed

Returns:boolean

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

Annotations

@Override

isSecondExpressionOptional back to summary

isSecondExpressionOptional	back to summary
protected boolean isSecondExpressionOptional() Determines whether the second expression is optional or not. Returns:boolean `true` if the second expression is optional; `false` if it is required

protected boolean isSecondExpressionOptional()

Determines whether the second expression is optional or not.

Returns:boolean: true if the second expression is optional; false if it is required

parameterExpressionBNF back to summary

parameterExpressionBNF	back to summary
public abstract String parameterExpressionBNF(int index) Returns the BNF to be used to parse one of the encapsulated expression. Parameters index:int The position of the encapsulated `Expression` that needs to be parsed within the parenthesis, which starts at position 0 Returns:String The BNF to be used to parse one of the encapsulated expression

public abstract String parameterExpressionBNF(int index)

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

Parameters

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

Returns:String

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

parseEncapsulatedExpression back to summary

parseEncapsulatedExpression	back to summary
protected void parseEncapsulatedExpression(WordParser wordParser, int whitespaceCount, boolean tolerant) Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.parseEncapsulatedExpression. Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.parseEncapsulatedExpression. Parses the encapsulated expression by starting at the current position, which is part of the given `WordParser`. Parameters wordParser:WordParser The text to parse based on the current position of the cursor whitespaceCount:int The number of whitespace characters that were parsed after '(' tolerant:boolean Determines whether the parsing system should be tolerant, meaning if it should try to parse invalid or incomplete queries Annotations @Override

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

Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.parseEncapsulatedExpression.

Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.parseEncapsulatedExpression.

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

Parameters

wordParser:WordParser: The text to parse based on the current position of the cursor
whitespaceCount:int: The number of whitespace characters that were parsed after '('
tolerant:boolean: Determines whether the parsing system should be tolerant, meaning if it should try to parse invalid or incomplete queries

Annotations

@Override

removeEncapsulatedExpression back to summary

removeEncapsulatedExpression	back to summary
protected void removeEncapsulatedExpression() Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.removeEncapsulatedExpression. Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.removeEncapsulatedExpression. Removes the encapsulated `Expression` that was parsed, it should not be part of this one. This happens when the parsed information does not have both '(' and ')'. Annotations @Override

protected void removeEncapsulatedExpression()

Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.removeEncapsulatedExpression.

Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.removeEncapsulatedExpression.

Removes the encapsulated Expression that was parsed, it should not be part of this one. This happens when the parsed information does not have both '(' and ')'.

Annotations

@Override

toParsedTextEncapsulatedExpression back to summary

toParsedTextEncapsulatedExpression	back to summary
protected void toParsedTextEncapsulatedExpression(StringBuilder writer, boolean actual) Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.toParsedTextEncapsulatedExpression. Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.toParsedTextEncapsulatedExpression. Generates a string representation of the encapsulated `Expression`. Parameters writer:StringBuilder The buffer used to append the encapsulated `Expression`'s string representation actual:boolean 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 Annotations @Override

protected void toParsedTextEncapsulatedExpression(StringBuilder writer, boolean actual)

Implements abstract org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.toParsedTextEncapsulatedExpression.

Doc from org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression.toParsedTextEncapsulatedExpression.

Generates a string representation of the encapsulated Expression.

Parameters

writer:StringBuilder: The buffer used to append the encapsulated Expression's string representation
actual:boolean: 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

Annotations

@Override

public abstract Class AbstractDoubleEncapsulatedExpression

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail