Module org.eclipse.persistence.jpa.jpql
Package 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)
Since:
2.3
Version:
2.5.1
See Also:

  • Field Details

    • parameterIndex

      protected int parameterIndex
      Determines which child expression is been currently parsed.

  • Constructor Details

    • AbstractTripleEncapsulatedExpression

      protected AbstractTripleEncapsulatedExpression(AbstractExpression parent, String identifier)
      Creates a new AbstractTripleEncapsulatedExpression.
      Parameters:
      parent - The parent of this expression
      identifier - The JPQL identifier that starts this expression

  • Method Details

    • acceptChildren

      public void acceptChildren(ExpressionVisitor visitor)
      Description copied from interface: Expression
      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(Collection<Expression> children)
      Description copied from class: AbstractExpression
      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(List<Expression> children)
      Description copied from class: AbstractEncapsulatedExpression
      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)
      Description copied from interface: 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

    • getParameterQueryBNFId

      public abstract String getParameterQueryBNFId(int index)
      Returns the unique identifier of the JPQLQueryBNF to be used to parse one of the encapsulated expression at the given position.
      Parameters:
      index - The position of the encapsulated Expression that needs to be parsed within the parenthesis, which starts at position 0
      Returns:
      The ID of the JPQLQueryBNF to be used to parse one of the encapsulated 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()
      Description copied from class: AbstractEncapsulatedExpression
      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, String word, Expression expression)
      Description copied from class: AbstractExpression
      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

    • parseEncapsulatedExpression

      protected void parseEncapsulatedExpression(WordParser wordParser, int whitespaceCount, boolean tolerant)
      Description copied from class: AbstractEncapsulatedExpression
      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()
      Description copied from class: AbstractEncapsulatedExpression
      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 ')'.
      Specified by:
      removeEncapsulatedExpression in class AbstractEncapsulatedExpression

    • toParsedTextEncapsulatedExpression

      protected final void toParsedTextEncapsulatedExpression(StringBuilder writer, boolean actual)
      Description copied from class: AbstractEncapsulatedExpression
      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