/*

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

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.rowset;

import java.io.*;

import java.util.*;

import java.sql.*;

import javax.sql.*;

import java.math.*;

import javax.sql.rowset.*;

import javax.sql.rowset.spi.*;

import javax.sql.rowset.serial.*;

import com.sun.rowset.providers.*;

import com.sun.rowset.internal.*;

/**

 * The standard implementation of the <code>FilteredRowSet</code> interface. See the interface

 *

 * @see javax.sql.rowset.Predicate

 * @author Jonathan Bruce, Amit Handa

 */

public class FilteredRowSetImpl extends WebRowSetImpl implements Serializable, Cloneable, FilteredRowSet {

    private Predicate p;

    private boolean onInsertRow = false;

    /**

     * Construct a <code>FilteredRowSet</code>

     */

    public FilteredRowSetImpl() throws SQLException {

        super();

    }

    /**

     * Construct a <code>FilteredRowSet</code> with a specified synchronization

     * provider.

     *

     * @param env a Hashtable containing a desired synchconizatation provider

     * name-value pair.

     */

    @SuppressWarnings("rawtypes")

    public FilteredRowSetImpl(Hashtable env) throws SQLException {

        super(env);

    }

    /**

     * Apply the predicate for this filter

     *

     * @param p an implementation of the predicate interface

     */

    public void setFilter(Predicate p) throws SQLException {

        this.p = p;

    }

    /**

     * Retrieve the filter active for this <code>FilteredRowSet</code>

     *

     * @return a <code>Predicate</code> object instance

     */

    public Predicate getFilter() {

        return this.p;

    }

    /**

     * Over-riding <code>internalNext()</code> implementation. This method

     * applies the filter on the <code>RowSet</code> each time the cursor is advanced or

     * manipulated. It moves the cursor to the next row according to the set

     * predicate and returns <code>true</code> if the cursor is still within the rowset or

     * <code>false</code> if the cursor position is over the last row

     *

     * @return true if over the valid row in the rowset; false if over the last

     * row

     */

    protected boolean internalNext() throws SQLException {

        // CachedRowSetImpl.next() internally calls

        // this(crs).internalNext() NOTE: this holds crs object

        // So when frs.next() is called,

        // internally this(frs).internalNext() will be called

        // which will be nothing but this method.

        // because this holds frs object

        // keep on doing super.internalNext()

        // rather than doing it once.

         // p.evaluate will help us in changing the cursor

         // and checking the next value by returning true or false.

         // to fit the filter

         // So while() loop will have a "random combination" of

         // true and false returned depending upon the records

         // are in or out of filter.

         // We need to traverse from present cursorPos till end,

         // whether true or false and check each row for "filter"

         // "till we get a "true"

         boolean bool = false;

         for(int rows=this.getRow(); rows<=this.size();rows++) {

             bool = super.internalNext();

             if( !bool || p == null) {

               return bool;

             }

             if(p.evaluate(this)){

                   break;

             }

         }

       return bool;

    }

    /**

     * Over-riding <code>internalPrevious()</code> implementation. This method

     * applies the filter on the <code>RowSet</code> each time the cursor is moved backward or

     * manipulated. It moves the cursor to the previous row according to the set

     * predicate and returns <code>true</code> if the cursor is still within the rowset or

     * <code>false</code> if the cursor position is over the last row

     *

     * @return true if over the valid row in the rowset; false if over the last

     * row

     */

    protected boolean internalPrevious() throws SQLException {

         boolean bool = false;

         // with previous move backwards,

         // i.e. from any record towards first record

         for(int rows=this.getRow(); rows>0;rows--) {

             bool = super.internalPrevious();

             if( p == null) {

               return bool;

             }

             if(p.evaluate(this)){

                   break;

             }

         }

       return bool;

    }

    /**

     * Over-riding <code>internalFirst()</code> implementation. This method

     * applies the filter on the <code>RowSet</code> each time the cursor is moved to first

     * row. It moves the cursor to the first row according to the set

     * predicate and returns <code>true</code> if the cursor is still within the rowset or

     * <code>false</code> if the cursor position is over the last row

     *

     * @return true if over the valid row in the rowset; false if over the last

     * row

     */

    protected boolean internalFirst() throws SQLException {

        // from first till present cursor position(go forward),

        // find the actual first which matches the filter.

         boolean bool = super.internalFirst();

         if( p == null) {

               return bool;

             }

         while(bool) {

             if(p.evaluate(this)){

                   break;

             }

        bool = super.internalNext();

        }

     return bool;

    }

    /**

     * Over-riding <code>internalLast()</code> implementation. This method

     * applies the filter on the <code>RowSet</code> each time the cursor is moved to

     * last row. It moves the cursor to the last row according to the set

     * predicate and returns <code>true</code> if the cursor is still within the rowset or

     * <code>false</code> if the cursor position is over the last row

     *

     * @return true if over the valid row in the rowset; false if over the last

     * row

     */

    protected boolean internalLast() throws SQLException {

        // from last to the present cursor position(go backward),

        // find the actual last which matches the filter.

         boolean bool = super.internalLast();

         if( p == null) {

               return bool;

             }

         while(bool) {

             if(p.evaluate(this)){

                   break;

             }

        bool = super.internalPrevious();

        }

     return bool;

   } // end internalLast()

   /**

     * Moves the cursor the specified number of rows from the current

     * position, with a positive number moving it forward and a

     * negative number moving it backward.

     * <P>

     * If the number is positive, the cursor moves the specified number of

     * rows toward the end of the rowset, starting at the current row.

     * For example, the following command, in which

     * <code>crs</code> is a <code>CachedRowSetImpl</code> object with 100 rows,

     * moves the cursor forward four rows from the current row.  If the

     * current row is 50, the cursor would move to row 54.

     * <PRE><code>

     *

     *    crs.relative(4);

     *

     * </code> </PRE>

     * <P>

     * If the number is negative, the cursor moves back toward the beginning

     * the specified number of rows, starting at the current row.

     * For example, calling the method

     * <code>absolute(-1)</code> positions the cursor on the last row,

     * <code>absolute(-2)</code> moves it on the next-to-last row, and so on.

     * If the <code>CachedRowSetImpl</code> object <code>crs</code> has five rows,

     * the following command moves the cursor to the fourth-to-last row, which

     * in the case of a  rowset with five rows, is also the second row

     * from the beginning.

     * <PRE><code>

     *

     *    crs.absolute(-4);

     *

     * </code> </PRE>

     *

     * If the number specified is larger than the number of rows, the cursor

     * will move to the position after the last row. If the number specified

     * would move the cursor one or more rows before the first row, the cursor

     * moves to the position before the first row. In both cases, this method

     * throws an <code>SQLException</code>.

     * <P>

     * Note: Calling <code>absolute(1)</code> is the same as calling the

     * method <code>first()</code>.  Calling <code>absolute(-1)</code> is the

     * same as calling <code>last()</code>.  Calling <code>relative(0)</code>

     * is valid, but it does not change the cursor position.

     *

     * @param rows an <code>int</code> indicating the number of rows to move

     *             the cursor, starting at the current row; a positive number

     *             moves the cursor forward; a negative number moves the cursor

     *             backward; must not move the cursor past the valid

     *             rows

     * @return <code>true</code> if the cursor is on a row in this

     *         <code>CachedRowSetImpl</code> object; <code>false</code>

     *         otherwise

     * @throws SQLException if the rowset is type <code>ResultSet.TYPE_FORWARD_ONLY</code>

     */

   public boolean relative(int rows) throws SQLException {

      boolean retval;

      boolean bool = false;

      boolean boolval = false;

      if(getType() == ResultSet.TYPE_FORWARD_ONLY) {

         throw new SQLException(resBundle.handleGetObject("filteredrowsetimpl.relative").toString());

      }

      if( rows > 0 ) {

         int i = 0;

         while( i < (rows)) {

            if( isAfterLast() ) {

               return false;

            }

            bool = internalNext();

            i++;

         }

         retval = bool;

      } else {

         int j = rows;

         while( (j) < 0 ) {

           if( isBeforeFirst() ) {

              return false;

           }

           boolval = internalPrevious();

           j++;

         }

         retval = boolval;

      }

      if(rows != 0)

          notifyCursorMoved();

      return retval;

   }

   /**

     * Moves this <code>CachedRowSetImpl</code> object's cursor to the row number

     * specified.

     *

     * <p>If the number is positive, the cursor moves to an absolute row with

     * respect to the beginning of the rowset.  The first row is row 1, the second

     * is row 2, and so on.  For example, the following command, in which

     * <code>crs</code> is a <code>CachedRowSetImpl</code> object, moves the cursor

     * to the fourth row, starting from the beginning of the rowset.

     * <PRE><code>

     *

     *    crs.absolute(4);

     *

     * </code> </PRE>

     * <P>

     * If the number is negative, the cursor moves to an absolute row position

     * with respect to the end of the rowset.  For example, calling

     * <code>absolute(-1)</code> positions the cursor on the last row,

     * <code>absolute(-2)</code> moves it on the next-to-last row, and so on.

     * If the <code>CachedRowSetImpl</code> object <code>crs</code> has five rows,

     * the following command moves the cursor to the fourth-to-last row, which

     * in the case of a  rowset with five rows, is also the second row, counting

     * from the beginning.

     * <PRE><code>

     *

     *    crs.absolute(-4);

     *

     * </code> </PRE>

     *

     * If the number specified is larger than the number of rows, the cursor

     * will move to the position after the last row. If the number specified

     * would move the cursor one or more rows before the first row, the cursor

     * moves to the position before the first row.

     * <P>

     * Note: Calling <code>absolute(1)</code> is the same as calling the

     * method <code>first()</code>.  Calling <code>absolute(-1)</code> is the

     * same as calling <code>last()</code>.

     *

     * @param rows a positive number to indicate the row, starting row numbering from

     *        the first row, which is <code>1</code>; a negative number to indicate

     *        the row, starting row numbering from the last row, which is

     *        <code>-1</code>; it must not be <code>0</code>

     * @return <code>true</code> if the cursor is on the rowset; <code>false</code>

     *         otherwise

     * @throws SQLException if the given cursor position is <code>0</code> or the

     *            type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY</code>

     */

    public boolean absolute(int rows) throws SQLException {

      boolean retval;

      boolean bool = false;

      if(rows == 0 || getType() == ResultSet.TYPE_FORWARD_ONLY) {

         throw new SQLException(resBundle.handleGetObject("filteredrowsetimpl.absolute").toString());

      }

      if (rows > 0) {

         bool = internalFirst();

         int i = 0;

         while(i < (rows-1)) {

            if( isAfterLast() ) {

               return false;

            }

            bool = internalNext();

            i++;

         }

         retval = bool;

      } else {

         bool = internalLast();

         int j = rows;

         while((j+1) < 0 ) {

            if( isBeforeFirst() ) {

               return false;

            }

            bool = internalPrevious();

            j++;

         }

         retval = bool;

      }

      notifyCursorMoved();

      return retval;

   }

   /**

     * Moves the cursor for this <code>CachedRowSetImpl</code> object

     * to the insert row.  The current row in the rowset is remembered

     * while the cursor is on the insert row.

     * <P>

     * The insert row is a special row associated with an updatable

     * rowset.  It is essentially a buffer where a new row may

     * be constructed by calling the appropriate <code>updateXXX</code>

     * methods to assign a value to each column in the row.  A complete

     * row must be constructed; that is, every column that is not nullable

     * must be assigned a value.  In order for the new row to become part

     * of this rowset, the method <code>insertRow</code> must be called

     * before the cursor is moved back to the rowset.

     * <P>

     * Only certain methods may be invoked while the cursor is on the insert

     * row; many methods throw an exception if they are called while the

     * cursor is there.  In addition to the <code>updateXXX</code>

     * and <code>insertRow</code> methods, only the <code>getXXX</code> methods

     * may be called when the cursor is on the insert row.  A <code>getXXX</code>

     * method should be called on a column only after an <code>updateXXX</code>

     * method has been called on that column; otherwise, the value returned is

     * undetermined.

     *

     * @throws SQLException if this <code>CachedRowSetImpl</code> object is

     *            <code>ResultSet.CONCUR_READ_ONLY</code>

     */

   public void moveToInsertRow() throws SQLException {

      onInsertRow = true;

      super.moveToInsertRow();

   }

   /**

     * This is explanation for the overriding of the updateXXX functions.

     * These functions have been overriden to ensure that only correct

     * values that pass the criteria for the filter are actaully inserted.

     * The evaluation of whether a particular value passes the criteria

     * of the filter is done using the evaluate function in the Predicate

     * interface.

     *

     * The checking can will done in the evaluate function which is implemented

     * in the class that implements the Predicate interface. So the checking

     * can vary from one implementation to another.

     *

     * Some additional points here on the following:

     * 1. updateBytes()     - since the evaluate function takes Object as parameter

     *                        a String is constructed from the byte array and would

     *                        passed to the evaluate function.

     * 2. updateXXXstream() - here it would suffice to pass the stream handle

     *                        to the evaluate function and the implementation

     *                        of the evaluate function can do the comparision

     *                        based on the stream and also type of data.

     */

   /**

     * Sets the designated column in either the current row or the insert

     * row of this <code>CachedRowSetImpl</code> object with the given

     * <code>int</code> value.

     * <P>

     * This method updates a column value in the current row or the insert

     * row of this rowset, but it does not update the database.

     * If the cursor is on a row in the rowset, the

     * method {@link #updateRow} must be called to update the database.

     * If the cursor is on the insert row, the method {@link #insertRow}

     * must be called, which will insert the new row into both this rowset

     * and the database. Both of these methods must be called before the

     * cursor moves to another row.

     *

     * @param columnIndex the first column is <code>1</code>, the second

     *        is <code>2</code>, and so on; must be <code>1</code> or larger

     *        and equal to or less than the number of columns in this rowset

     * @param x the new column value

     * @throws SQLException if (1) the given column index is out of bounds,

     *            (2) the cursor is not on one of this rowset's rows or its

     *            insert row, or (3) this rowset is

     *            <code>ResultSet.CONCUR_READ_ONLY</code>

     */

   public void updateInt(int columnIndex , int x) throws SQLException {

     boolean bool;

     if(onInsertRow) {

        if(p != null) {

           bool = p.evaluate(Integer.valueOf(x),columnIndex);

           if(!bool) {

              throw new SQLException(resBundle.handleGetObject("filteredrowsetimpl.notallowed").toString());

           }

        }

     }

     super.updateInt(columnIndex,x);

   }

   /**

     * Sets the designated column in either the current row or the insert

     * row of this <code>CachedRowSetImpl</code> object with the given

     * <code>int</code> value.

     * <P>

     * This method updates a column value in the current row or the insert

     * row of this rowset, but it does not update the database.

     * If the cursor is on a row in the rowset, the

     * method {@link #updateRow} must be called to update the database.

     * If the cursor is on the insert row, the method {@link #insertRow}

     * must be called, which will insert the new row into both this rowset

     * and the database. Both of these methods must be called before the

     * cursor moves to another row.

     *