* Copyright (c) 2006, 2013 Oracle and/or its affiliates. All rights reserved.

* This program and the accompanying materials are made available under the

* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0

* which accompanies this distribution.

* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html

* and the Eclipse Distribution License is available at

* http://www.eclipse.org/org/documents/edl-v10.php.

*

* Contributors:

*     Oracle - initial API and implementation

*

******************************************************************************/

* The default implementation of a {@link IBuilder}, which creates a {@link StateObject}

* representation of the {@link org.eclipse.persistence.jpa.jpql.parser.Expression Expression} being

* visited.

* <p>

* Provisional API: This interface is part of an interim API that is still under development and

* expected to change significantly before reaching stability. It is available at this early stage

* to solicit feedback from pioneering adopters on the understanding that any code that uses this

* API will almost certainly be broken (repeatedly) as the API evolves.

*

* @see Expression

* @see StateObject

*

* @version 2.4

* @since 2.4

* @author Pascal Filion

*/

  /**

   *

   */

  private IBuilder<CollectionMemberDeclarationStateObject, AbstractFromClauseStateObject> collectionDeclarationBuilder;

  /**

   *

   */

  private CollectionExpressionVisitor collectionExpressionVisitor;

  /**

   *

   */

  private IBuilder<DeleteStatementStateObject, JPQLQueryStateObject> deleteStatementBuilder;

  /**

   * This {@link IBuilder} is responsible to build an <code><b>DELETE</b></code> statement,

   * which populates the <code><b>DELETE</b></code> clause and the optional <code><b>WHERE</b></code>

   * clause by converting the information contained in the parsed JPQL query.

   */

  private IBuilder<JoinStateObject, AbstractIdentificationVariableDeclarationStateObject> joinBuilder;

  /**

   *

   */

  IJPQLQueryBuilder jpqlQueryBuilder;

  /**

   * This visitor is used to retrieve a variable name from various type of an {@link Expression}.

   */

  private LiteralVisitor literalVisitor;

  /**

   *

   */

  protected IManagedTypeProvider managedTypeProvider;

  /**

   * The parent {@link StateObject} of the {@link StateObject} to create.

   */

  protected JPQLQueryStateObject parent;

  /**

   *

   */

  private IBuilder<AbstractIdentificationVariableDeclarationStateObject, FromClauseStateObject> rangeDeclarationBuilder;

  /**

   *

   */

  private IBuilder<StateObject, SelectClauseStateObject> selectItemBuilder;

  /**

   * This {@link IBuilder} is responsible to build a top-level <code><b>SELECT</b></code> statement,

   * which populates the various clauses by converting the information contained in the parsed JPQL

   * query.

   */

  private IBuilder<SelectStatementStateObject, JPQLQueryStateObject> selectStatementBuilder;

  /**

   *

   */

  private IBuilder<AbstractIdentificationVariableDeclarationStateObject, SimpleFromClauseStateObject> simpleRangeDeclarationBuilder;

  /**

   * This {@link IBuilder} is responsible to build a subquery <code><b>SELECT</b></code> statement,

   * which populates the various clauses by converting the information contained in the parsed JPQL

   * query.

   */

  private IBuilder<SimpleSelectStatementStateObject, StateObject> simpleSelectStatementBuilder;

  /**

   * The {@link StateObject} that was created based on the visited {@link Expression}.

   */

  protected StateObject stateObject;

  /**

   * This {@link IBuilder} is responsible to build an <code><b>UPDATE</b></code> statement,

   * which populates the <code><b>UPDATE</b></code> clause and the optional <code><b>WHERE</b></code>

   * clause by converting the information contained in the parsed JPQL query.

   */

  private IBuilder<UpdateStatementStateObject, JPQLQueryStateObject> updateStatementBuilder;

  /**

   * This {@link IBuilder} is responsible to build a <code><b>WHEN</b></code> clause for the

   * <code><b>CASE</b></code> expression by converting the information contained in the parsed

   * JPQL query.

   */

  private IBuilder<CaseExpressionStateObject, CaseExpressionStateObject> whenClauseBuilder;

  /**

   * Creates a new <code>StateObjectBuilder</code>.

   */

  protected BasicStateObjectBuilder() {

    super();

  }

  @SuppressWarnings("unchecked")

  protected <T extends StateObject> List<T> buildChildren(Expression expression) {

    StateObject oldStateObject = stateObject;

    List<T> stateObjects = new ArrayList<T>();

    for (Expression child : children(expression)) {

      child.accept(this);

      stateObjects.add((T) stateObject);

      stateObject = oldStateObject;

    }

    return stateObjects;

  }

  protected IBuilder<CollectionMemberDeclarationStateObject, AbstractFromClauseStateObject> buildCollectionDeclarationBuilder() {

    return new CollectionMemberDeclarationBuilder();

  }

  protected IBuilder<DeleteStatementStateObject, JPQLQueryStateObject> buildDeleteStatementBuilder() {

    return new DeleteStatementBuilder();

  }

  protected IBuilder<JoinStateObject, AbstractIdentificationVariableDeclarationStateObject> buildJoinBuilder() {

    return new JoinBuilder();

  }

  /**

   * Creates the visitor that can retrieve the "literal" value from a given {@link Expression}

   * based on the desired {@link LiteralType}.

   *

   * @return A new concrete instance of {@link LiteralVisitor}

   */

  protected abstract LiteralVisitor buildLiteralVisitor();

  protected IBuilder<AbstractIdentificationVariableDeclarationStateObject, FromClauseStateObject> buildRangeDeclarationBuilder() {

    return new RangeDeclarationBuilder();

  }

  protected IBuilder<StateObject, SelectClauseStateObject> buildSelectItemBuilder() {

    return new SelectItemBuilder();

  }

  protected IBuilder<SelectStatementStateObject, JPQLQueryStateObject> buildSelectStatementBuilder() {

    return new SelectStatementBuilder();

  }

  protected IBuilder<AbstractIdentificationVariableDeclarationStateObject, SimpleFromClauseStateObject> buildSimpleRangeDeclarationBuilder() {

    return new SimpleRangeDeclarationBuilder();

  }

  protected IBuilder<SimpleSelectStatementStateObject, StateObject> buildSimpleSelectStatementBuilder() {

    return new SimpleSelectStatementBuilder();

  }

  /**

   * Visits the given {@link Expression} and returned its {@link StateObject}.

   *

   * @param expression The {@link Expression} to be visited by this builder

   * @return The {@link StateObject} representation of the given {@link Expression} or <code>null</code>

   * if nothing could be created

   */

  protected final StateObject buildStateObjectImp(Expression expression) {

    expression.accept(this);

    return stateObject;

  }

  protected IBuilder<UpdateStatementStateObject, JPQLQueryStateObject> buildUpdateStatementBuilder() {

    return new UpdateStatementBuilder();

  }

  protected IBuilder<CaseExpressionStateObject, CaseExpressionStateObject> buildWhenClauseBuilder() {

    return new WhenClauseBuilder();

  }

  @SuppressWarnings("unchecked")

  protected <T extends Expression> List<T> children(Expression expression) {

    CollectionExpressionVisitor visitor = getCollectionExpressionVisitor();

    try {

      expression.accept(visitor);

      return (List<T>) visitor.children;

    }

    finally {

      visitor.reset();

    }

  }

  protected IBuilder<CollectionMemberDeclarationStateObject, AbstractFromClauseStateObject> getCollectionDeclarationBuilder() {

    if (collectionDeclarationBuilder == null) {

      collectionDeclarationBuilder = buildCollectionDeclarationBuilder();

    }

    return collectionDeclarationBuilder;

  }

  protected CollectionExpressionVisitor getCollectionExpressionVisitor() {

    if (collectionExpressionVisitor == null) {

      collectionExpressionVisitor = new CollectionExpressionVisitor();

    }

    return collectionExpressionVisitor;

  }

  protected IBuilder<DeleteStatementStateObject, JPQLQueryStateObject> getDeleteStatementBuilder() {

    if (deleteStatementBuilder == null) {

      deleteStatementBuilder = buildDeleteStatementBuilder();

    }

    return deleteStatementBuilder;

  }

  protected IBuilder<JoinStateObject, AbstractIdentificationVariableDeclarationStateObject> getJoinBuilder() {

    if (joinBuilder == null) {

      joinBuilder = buildJoinBuilder();

    }

    return joinBuilder;

  }

  protected LiteralVisitor getLiteralVisitor() {

    if (literalVisitor == null) {

      literalVisitor = buildLiteralVisitor();

    }

    return literalVisitor;

  }

  protected IBuilder<AbstractIdentificationVariableDeclarationStateObject, FromClauseStateObject> getRangeDeclarationBuilder() {

    if (rangeDeclarationBuilder == null) {

      rangeDeclarationBuilder = buildRangeDeclarationBuilder();

    }

    return rangeDeclarationBuilder;

  }

  protected IBuilder<StateObject, SelectClauseStateObject> getSelectItemBuilder() {

    if (selectItemBuilder == null) {

      selectItemBuilder = buildSelectItemBuilder();

    }

    return selectItemBuilder;

  }

  protected IBuilder<SelectStatementStateObject, JPQLQueryStateObject> getSelectStatementBuilder() {

    if (selectStatementBuilder == null) {

      selectStatementBuilder = buildSelectStatementBuilder();

    }

    return selectStatementBuilder;

  }

  protected IBuilder<AbstractIdentificationVariableDeclarationStateObject, SimpleFromClauseStateObject> getSimpleRangeDeclarationBuilder() {

    if (simpleRangeDeclarationBuilder == null) {

      simpleRangeDeclarationBuilder = buildSimpleRangeDeclarationBuilder();

    }

    return simpleRangeDeclarationBuilder;

  }

  protected IBuilder<SimpleSelectStatementStateObject, StateObject> getSimpleSelectStatementBuilder() {

    if (simpleSelectStatementBuilder == null) {

      simpleSelectStatementBuilder = buildSimpleSelectStatementBuilder();

    }

    return simpleSelectStatementBuilder;

  }

  /**

   * Returns the {@link StateObject} that was created based on the visited {@link Expression}.

   *

   * @return The {@link StateObject} that was created based on the visited {@link Expression}

   */

  public StateObject getStateObject() {

    return stateObject;

  }

  protected IBuilder<UpdateStatementStateObject, JPQLQueryStateObject> getUpdateStatementBuilder() {

    if (updateStatementBuilder == null) {

      updateStatementBuilder = buildUpdateStatementBuilder();

    }

    return updateStatementBuilder;

  }

  /**

   * Retrieves the "literal" from the given {@link Expression}. The literal to retrieve depends on

   * the given {@link LiteralType type}. The literal is basically a string value like an

   * identification variable name, an input parameter, a path expression, an abstract schema name,

   * etc.

   *

   * @param expression The {@link Expression} to visit

   * @param type The {@link LiteralType} helps to determine what to retrieve from the visited

   * {@link Expression}

   * @return A value from the given {@link Expression} or an empty string if the given {@link

   * Expression} and the {@link LiteralType} do not match

   */

  protected String literal(Expression expression, LiteralType type) {

    LiteralVisitor visitor = getLiteralVisitor();

    try {

      visitor.setType(type);

      visitor.literal = null;

      expression.accept(visitor);

      return visitor.literal;

    }

    finally {

      visitor.literal = null;

    }

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(AbsExpression expression) {

    expression.getExpression().accept(this);

    AbsExpressionStateObject stateObject = new AbsExpressionStateObject(parent, this.stateObject);

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(AbstractSchemaName expression) {

    AbstractSchemaNameStateObject stateObject = new AbstractSchemaNameStateObject(

      parent,

      expression.getText()

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(AdditionExpression expression) {

    expression.getLeftExpression().accept(this);

    StateObject leftStateObject = stateObject;

    expression.getRightExpression().accept(this);

    StateObject rightStateObject = stateObject;

    AdditionExpressionStateObject stateObject = new AdditionExpressionStateObject(

      parent,

      leftStateObject,

      rightStateObject

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(AllOrAnyExpression expression) {

    expression.getExpression().accept(this);

    AllOrAnyExpressionStateObject stateObject = new AllOrAnyExpressionStateObject(

      parent,

      expression.getIdentifier(),

      this.stateObject

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(AndExpression expression) {

    expression.getLeftExpression().accept(this);

    StateObject leftStateObject = stateObject;

    expression.getRightExpression().accept(this);

    StateObject rightStateObject = stateObject;

    AndExpressionStateObject stateObject = new AndExpressionStateObject(

      parent,

      leftStateObject,

      rightStateObject

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(ArithmeticFactor expression) {

    expression.getExpression().accept(this);

    ArithmeticFactorStateObject stateObject = new ArithmeticFactorStateObject(

      parent,

      expression.isPlusSign(),

      this.stateObject

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(AvgFunction expression) {

    expression.getExpression().accept(this);

    AvgFunctionStateObject stateObject = new AvgFunctionStateObject(

      parent,

      expression.hasDistinct(),

      this.stateObject

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(BadExpression expression) {

    BadExpressionStateObject stateObject = new BadExpressionStateObject(

      parent,

      expression.getExpression().toActualText()

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(BetweenExpression expression) {

    expression.getExpression().accept(this);

    StateObject betweenStateObject = stateObject;

    expression.getLowerBoundExpression().accept(this);

    StateObject lowerBoundStateObject = stateObject;

    expression.getUpperBoundExpression().accept(this);

    StateObject upperBoundStateObject = stateObject;

    BetweenExpressionStateObject stateObject = new BetweenExpressionStateObject(

      parent,

      betweenStateObject,

      expression.hasNot(),

      lowerBoundStateObject,

      upperBoundStateObject

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(CaseExpression expression) {

    expression.getCaseOperand().accept(this);

    StateObject caseOperand = stateObject;

    expression.getElseExpression().accept(this);

    StateObject elseStateObject = stateObject;

    CaseExpressionStateObject caseExpressionStateObject = new CaseExpressionStateObject(

      parent,

      caseOperand,

      Collections.<WhenClauseStateObject>emptyList(),

      elseStateObject

    );

    whenClauseBuilder().buildStateObject(caseExpressionStateObject, expression);

    caseExpressionStateObject.setExpression(expression);

    this.stateObject = caseExpressionStateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(CoalesceExpression expression) {

    CoalesceExpressionStateObject stateObject = new CoalesceExpressionStateObject(

      parent,

      buildChildren(expression.getExpression())

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(CollectionExpression expression) {

    List<StateObject> stateObjects = buildChildren(expression);

    CollectionExpressionStateObject stateObject = new CollectionExpressionStateObject(

      parent,

      stateObjects

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(CollectionMemberDeclaration expression) {

    // Not done here

    stateObject = null;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(CollectionMemberExpression expression) {

    expression.getEntityExpression().accept(this);

    StateObject entityExpression = stateObject;

    CollectionMemberExpressionStateObject stateObject = new CollectionMemberExpressionStateObject(

      parent,

      entityExpression,

      expression.hasNot(),

      expression.hasOf(),

      literal(expression.getCollectionValuedPathExpression(), LiteralType.PATH_EXPRESSION_ALL_PATH)

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(CollectionValuedPathExpression expression) {

    CollectionValuedPathExpressionStateObject stateObject = new CollectionValuedPathExpressionStateObject(

      parent,

      expression.toActualText()

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(ComparisonExpression expression) {

    expression.getLeftExpression().accept(this);

    StateObject leftStateObject = stateObject;

    expression.getRightExpression().accept(this);

    StateObject rightStateObject = stateObject;

    ComparisonExpressionStateObject stateObject = new ComparisonExpressionStateObject(

      parent,

      leftStateObject,

      expression.getComparisonOperator(),

      rightStateObject

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(ConcatExpression expression) {

    ConcatExpressionStateObject stateObject = new ConcatExpressionStateObject(

      parent,

      buildChildren(expression.getExpression())

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(ConstructorExpression expression) {

    ConstructorExpressionStateObject stateObject = new ConstructorExpressionStateObject(

      parent,

      expression.getClassName(),

      buildChildren(expression.getConstructorItems())

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void visit(CountFunction expression) {

    expression.getExpression().accept(this);

    CountFunctionStateObject stateObject = new CountFunctionStateObject(

      parent,

      expression.hasDistinct(),

      this.stateObject

    );

    stateObject.setExpression(expression);

    this.stateObject = stateObject;

  }

  /**

   * {@inheritDoc}

   */