Package org.eclipse.persistence.jpa.jpql.parser

Class CollectionExpression

java.lang.Object
org.eclipse.persistence.jpa.jpql.parser.AbstractExpression
org.eclipse.persistence.jpa.jpql.parser.CollectionExpression
All Implemented Interfaces:
Expression
public final class CollectionExpression extends AbstractExpression
A CollectionExpression wraps many expression which they are separated by spaces and/or commas.
BNF: expression ::= child_item {, child_item }*

or
BNF: expression ::= child_item { child_item }*

Version:
2.5
Author:
Pascal Filion

  • Constructor Details

    • CollectionExpression

      public CollectionExpression(AbstractExpression parent, List<AbstractExpression> children, List<Boolean> commas, List<Boolean> spaces)
      Creates a new CollectionExpression.
      Parameters:
      parent - The parent of this expression
      children - The list of children that are regrouped together
      spaces - The list of flags used to determine when to add a space after an Expression
      commas - The list of flags used to determine when to add a comma after an Expression

    • CollectionExpression

      public CollectionExpression(AbstractExpression parent, List<AbstractExpression> children, List<Boolean> commas, List<Boolean> spaces, boolean temporary)
      Creates a new CollectionExpression.
      Parameters:
      parent - The parent of this expression
      children - The list of children that are regrouped together
      commas - The list of flags used to determine when to add a comma after an Expression
      spaces - The list of flags used to determine when to add a space after an Expression
      temporary - Flag used to determine if this expression is temporarily used, which means the children will not be parented to this object

  • Method Details

    • accept

      public void accept(ExpressionVisitor visitor)
      Description copied from interface: Expression
      Visits this Expression by the given visitor.
      Parameters:
      visitor - The ExpressionVisitor to visit this object

    • accept

      public void accept(int index, ExpressionVisitor visitor)
      Visits the child Expression at the given position by the given visitor.
      Parameters:
      index - The index of the child to visit
      visitor - The ExpressionVisitor to visit a specific child

    • 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

    • addOrderedChildrenTo

      protected 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

    • childrenSize

      public int childrenSize()
      Returns the count of child expressions.
      Returns:
      The total count of expressions aggregated with spaces and/or commas

    • endsWithComma

      public boolean endsWithComma()
      Determines whether this CollectionExpression ends with a comma, which means the last Expression is a "null" expression.
      Returns:
      true if the string representation of this CollectionExpression ends with a comma (the ending space is not checked)

    • endsWithSpace

      public boolean endsWithSpace()
      Determines whether this CollectionExpression ends with a space, which means the last Expression is a "null" expression.
      Returns:
      true if the string representation of this CollectionExpression ends with a space (the ending comma is not checked)

    • 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

    • getChild

      public Expression getChild(int index)
      Retrieves the child Expression at the given position.
      Parameters:
      index - The position of the child Expression to retrieve
      Returns:
      The child Expression at the given position

    • getQueryBNF

      public JPQLQueryBNF getQueryBNF()
      Description copied from interface: Expression
      Returns the BNF of this Expression.
      Returns:
      The JPQLQueryBNF, which represents the grammar of this Expression

    • hasComma

      public boolean hasComma(int index)
      Determines whether a comma was parsed at the given position. The index is the position of the comma that is following the child at the same position.
      Parameters:
      index - The index of the child Expression to verify if there is a comma following it
      Returns:
      true if a comma is following the child Expression at the given index; false otherwise

    • hasSpace

      public boolean hasSpace(int index)
      Determines whether a space was parsed at the given position. The index is the position of the space that is following the child at the same position, which is after a comma, if one was also parsed at that location.
      Parameters:
      index - The index of the child Expression to verify if there is a space following it, which could be after a comma, if one was parsed
      Returns:
      true if a space is following the child Expression at the given index; false otherwise

    • indexOf

      public int indexOf(Expression expression)
      Retrieves the index of the given Expression.
      Parameters:
      expression - The Expression that might be a child of this expression
      Returns:
      The index in the collection of the given Expression or -1 if it is not a child

    • 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

    • toActualText

      public String toActualText(int endIndex)
      Returns a string representation of this Expression and its children. The expression should contain whitespace even if the beautified version would not have any. For instance, "SELECT e " should be returned where Expression.toParsedText() would return "SELECT e".
      Parameters:
      endIndex - The index used to determine when to create the string representation, which is exclusive
      Returns:
      The string representation of this Expression

    • toParsedText

      public String toParsedText(int endIndex)
      Generates a string representation of this CollectionExpression.
      Parameters:
      endIndex - The index used to determine when to create the string representation, which is exclusive
      Returns:
      The string representation of this Expression

    • toParsedText

      protected 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