Class AbstractEncapsulatedExpression

java.lang.Object
org.eclipse.persistence.jpa.jpql.parser.AbstractExpression
org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression
All Implemented Interfaces:
Expression
Direct Known Subclasses:
AbstractDoubleEncapsulatedExpression, AbstractSingleEncapsulatedExpression, AbstractTripleEncapsulatedExpression, TreatExpression

public abstract class AbstractEncapsulatedExpression extends AbstractExpression
This expression handles parsing the identifier followed by an expression encapsulated within parenthesis.
BNF: expression ::= <identifier>(expression)
Since:
2.3
Version:
2.5
  • Constructor Details

    • AbstractEncapsulatedExpression

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

    • addOrderedChildrenTo

      protected final void addOrderedChildrenTo(List<Expression> children)
      Description copied from class: AbstractExpression
      Adds the children of this AbstractExpression to the given list.
      Overrides:
      addOrderedChildrenTo in class AbstractExpression
      Parameters:
      children - The list used to store the string representation of this AbstractExpression
    • addOrderedEncapsulatedExpressionTo

      protected abstract void addOrderedEncapsulatedExpressionTo(List<Expression> children)
      Adds the Expressions representing the encapsulated Expression.
      Parameters:
      children - The list used to store the string representation of the encapsulated Expression
    • areLogicalIdentifiersSupported

      protected boolean areLogicalIdentifiersSupported()
    • getActualIdentifier

      public final String getActualIdentifier()
      Returns the actual identifier found in the string representation of the JPQL query, which has the actual case that was used.
      Returns:
      The JPQL identifier that was actually parsed
    • getIdentifier

      public final String getIdentifier()
      Returns the JPQL identifier of this expression.
      Returns:
      The JPQL identifier
    • hasEncapsulatedExpression

      public abstract boolean hasEncapsulatedExpression()
      Determines whether something was parsed after the left parenthesis.
      Returns:
      true if something was parsed; false otherwise
    • hasLeftParenthesis

      public final boolean hasLeftParenthesis()
      Determines whether the open parenthesis was parsed or not.
      Returns:
      true if the open parenthesis was present in the string version of the query; false otherwise
    • hasRightParenthesis

      public final boolean hasRightParenthesis()
      Determines whether the close parenthesis was parsed or not.
      Returns:
      true if the close parenthesis was present in the string version of the query; false otherwise
    • hasSpaceAfterIdentifier

      public boolean hasSpaceAfterIdentifier()
      Determines whether a whitespace was parsed after the identifier rather than the left parenthesis. This can happen in incomplete query of this form: ABS 4 + 5).
      Returns:
      true if a whitespace was parsed after the identifier; false otherwise
    • 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 AbstractExpression
      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
    • parse

      protected void parse(WordParser wordParser, boolean tolerant)
      Description copied from class: AbstractExpression
      Parses the query by starting at the current position, which is part of the given WordParser.
      Specified by:
      parse in class AbstractExpression
      Parameters:
      wordParser - The text to parse based on the current position of the cursor
      tolerant - Determines whether the parsing system should be tolerant, meaning if it should try to parse invalid or incomplete queries
    • parseEncapsulatedExpression

      protected abstract 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.
      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 abstract void 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 ')'.
    • shouldParseRightParenthesis

      protected boolean shouldParseRightParenthesis(WordParser wordParser, boolean tolerant)
      Determines whether the right parenthesis should be parsed or not by this expression. There is a possible case where this expression should have optional left and right parenthesis. If there is no left parenthesis, then it would most likely mean the right parenthesis does not belong to this expression.
      Parameters:
      wordParser - The text to parse based on the current position of the cursor
      tolerant - Determines whether the parsing system should be tolerant, meaning if it should try to parse invalid or incomplete queries
      Returns:
      true if the right parenthesis should be owned by this expression if it is the next character to scan; false otherwise
    • toParsedText

      protected final void toParsedText(StringBuilder writer, boolean actual)
      Description copied from class: AbstractExpression
      Generates a string representation of this Expression, including its children, if it has any.
      Specified by:
      toParsedText in class AbstractExpression
      Parameters:
      writer - The buffer used to append this Expression's string representation
      actual - Determines whether the string representation should represent what was parsed, i.e. include any "virtual" whitespace (such as ending whitespace) and the actual case of the JPQL identifiers
    • toParsedTextEncapsulatedExpression

      protected abstract void toParsedTextEncapsulatedExpression(StringBuilder writer, boolean actual)
      Generates a string representation of the encapsulated Expression.
      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