Class AbstractDoubleEncapsulatedExpression

All Implemented Interfaces:
Expression
Direct Known Subclasses:
DatabaseType, MathDoubleExpression, ModExpression, NullIfExpression

public abstract class AbstractDoubleEncapsulatedExpression extends AbstractEncapsulatedExpression
This Expression takes care of parsing an expression that encapsulates two expressions separated by a comma.
BNF: expression ::= <identifier>(first_expression, second_expression)
Since:
2.3
Version:
2.5.1
See Also:
  • Constructor Details

    • AbstractDoubleEncapsulatedExpression

      protected AbstractDoubleEncapsulatedExpression(AbstractExpression parent, String identifier)
      Creates a new AbstractDoubleEncapsulatedExpression.
      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 and second expressions.
      Returns:
      The first and second expressions wrapped 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
    • getSecondExpression

      public final Expression getSecondExpression()
      Returns the Expression that represents the second expression.
      Returns:
      The expression that was parsed representing the second expression
    • hasComma

      public final boolean hasComma()
      Determines whether the comma was parsed after the first expression.
      Returns:
      true if a comma was parsed after the first expression; false otherwise
    • 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
    • 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
    • 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
    • hasSpaceAfterComma

      public final boolean hasSpaceAfterComma()
      Determines whether a whitespace was parsed after the comma.
      Returns:
      true if there was a whitespace after the comma; 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 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
    • isSecondExpressionOptional

      protected boolean isSecondExpressionOptional()
      Determines whether the second expression is optional or not.
      Returns:
      true if the second expression is optional; false if it is required
    • parameterExpressionBNF

      public abstract 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)
      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 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