/***
    *  The contents of this file are subject to the Mozilla Public
    *  License Version 1.1 (the "License"); you may not use this file
    *  except in compliance with the License. You may obtain a copy of
    *  the License at http://www.mozilla.org/MPL/
    *
    *  Software distributed under the License is distributed on an "AS
    *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
    *  implied. See the License for the specific language governing
   *  rights and limitations under the License.
   *
   *  The Original Code is pow2toolkit library.
   *
   *  The Initial Owner of the Original Code is
   *  Claudio Fratarcangeli
   *
   *  Portions created by Power Of Two S.R.L. are
   *  Copyright (C) Power Of Two S.R.L.
   *  All Rights Reserved.
   *
   * Contributor(s):
   */
  
  package com.pow2.dao.datalist;
  
  import java.sql.SQLException;
  
  import org.apache.log4j.*;
  
  
  
  /***
   *  ResultSetDataListChunk class.
   *
   * @author  Claudio Fratarcangeli
   * @created  5 dicembre 2002
   */
  public class ResultSetDataListChunk implements ResultSetDataList
  {
    /*** Log4J category. */
    protected static Category cat = Category.getInstance(ResultSetDataListChunk.class);
  
    private ResultSetDataList rsDataList;
    private int firstElementIndex;
    private int countOfElements;
    private int currIndex = -1;
  
  
    /***
     *  Constructor
     *
     * @param  rsDataList the resultSetDataList object
     * @param  firstElementIndex the index of the first element of the chunk
     * @param  countOfElements the number of the chunk elements
     */
    public ResultSetDataListChunk(ResultSetDataList rsDataList,
                                  int firstElementIndex,
                                  int countOfElements)
    {
      this.rsDataList = rsDataList;
      this.firstElementIndex = firstElementIndex;
      this.countOfElements = countOfElements;
    }
  
  
   /***
     *  Get the DataListIterator object.
     *
     * @return  the DataListIterator object
     * @exception Exception if any error occurs
     */
    public DataListIterator iterator() throws Exception
    {
      return new ResultSetDataListIterator(this);
    }
  
  
    /***
     *  Close the data list.
     *  <br>
     *  Implementation note: do not close this object !!
     *
     * @exception Exception if any error occurs
     */
    public void close() throws Exception
    {
       throw new Exception("ResultSetDataListChunkImpl: Invalid call to clear");
    }
  
  
    /***
     *  Put object state in item and return it.
     *  <br>
     *  Use rowMapper to map fields of ResultSet to instance variables of item.
     *  ResultSet index ranges from 1, while ResultSetDataList index
     *  ranges from 0.
     *
     * @param  index  the index value
     * @param  obj   the item object to fill
    * @return  the item object filled with values retrieved from the resultSet,
    *          or null if the input index is out of the bondaries of the chunk
    * @exception  Exception if any error occurs
    */
   public Object get(int index, Object obj) throws Exception
   {
     if (index >= countOfElements)
     {
       obj = null;
     }
     else
     {
       int chunkIndex = (firstElementIndex + index);
       cat.info("::get - getting element from index [" + index + " (" + chunkIndex + ")]");
       obj = rsDataList.get(chunkIndex, obj);
       currIndex = index;
     }
 
     return obj;
   }
 
 
   /***
    *  Check if the resultSet data list has got another element.
    *
    * @return  true  if the resultSet data list has got another record,
    *          false otherwise
    * @exception  Exception if any error occurs
    */
   public boolean hasNext() throws Exception
   {
     return ((currIndex + 1) < countOfElements) && rsDataList.hasNext();
   }
 
 
   /***
    *  Move the resultSetDataListChunk cursor before the first row of the list.
    *
    * @exception Exception if any error occurs
    */
   public void beforeFirst() throws Exception
   {
     if (firstElementIndex == 0)
       rsDataList.beforeFirst();
     else
       rsDataList.absolute(firstElementIndex - 1);
   }
 
 
   /***
    *  Move the resultSetDataListChunk cursor to a specific row number.
    *  Rows are numbered starting from 0.
    *
    * @param  index the cursor index value
    * @exception Exception if any error occurs
    */
   public boolean absolute(int index) throws Exception
   {
     if (index >= countOfElements)
       return false;
 
     boolean ret  = rsDataList.absolute(firstElementIndex + index);
 
     if (ret)
       currIndex = index;
 
     return ret;
   }
 
 
   /***
    *  Check if any element exist at the <code>index</code> poition.
    *
    * @param   index the index value
    * @return  true if any element exist at the <code>index</code> poition,
    *          false otherwise
    * @exception Exception if any error occurs
    */
   public boolean elementExists(int index) throws Exception
   {
     if (index >= countOfElements)
       return false;
 
     return rsDataList.elementExists(firstElementIndex + index);
   }
 
 
   /***
    *  Check if the resultSetDataListChunk is empty.
    *
    * @return  true if the resultSetDataListChunk is empty; false otherwise
    * @exception Exception if any error occurs
    */
   public boolean isEmpty() throws Exception
   {
     boolean isFull  = false;
 
     try
     {
       isFull = rsDataList.absolute(firstElementIndex);
 
       if (isFull && (currIndex != -1) && (currIndex != firstElementIndex))
         rsDataList.absolute(currIndex);
     }
     catch (SQLException e)
     {
       // log exception here;
       throw e;
     }
 
     return !isFull;
   }
 }