////////////////////////////////////////////////////////////////////////////////
   // MillScript-Excel: an Open Spice interpreter and batch website creation tool
   // Copyright (C) 2006 Open World Ltd, Kevin Rogers
   //
   // This file is part of MillScript-Excel.
   //
   // MillScript-Excel is free software; you can redistribute it and/or modify it under
   // the terms of the GNU General Public License as published by the Free
   // Software Foundation; either version 2 of the License, or (at your option)
  // any later version.
  //
  // MillScript-Excel 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 for
  // more details.
  //
  // You should have received a copy of the GNU General Public License along with
  // MillScript-Excel; if not, write to the Free Software Foundation, Inc., 59 Temple
  // Place, Suite 330, Boston, MA  02111-1307  USA
  ////////////////////////////////////////////////////////////////////////////////
  package org.millscript.office.spreadsheet.rows;
  
  import org.millscript.commons.alert.alerts.Unimplemented;
  import org.millscript.commons.util.IList;
  import org.millscript.commons.util.ListIterator;
  import org.millscript.commons.util.alerts.ListIndexOutOfBoundsAlert;
  import org.millscript.commons.util.iterator.NullListIterator;
  import org.millscript.commons.util.list.AbstractIList;
  import org.millscript.office.spreadsheet.Cell;
  import org.millscript.office.spreadsheet.Row;
  
  /**
   * 
   */
  public class ISharedRowList extends AbstractIList< Row > {
  
      /**
       * The index of the first element of this list in the backing store.
       */
      private final int firstIndex;
  
      /**
       * The index of the last element of this list in the backing store.
       */
      private final int lastIndex;
      
      /**
       * The backing data store for this worksheet, a two dimensional array,
       * an array of array of cells. A null entry indicates the row is empty.
       */
      private Cell[][] rowData;
  
      /**
       * Constructs a new shared store worksheet with a slice of the specified
       * backing row array.
       *
       * @param rows   the backing object array(only kept if start &lt;= end )
       * @param start the index(one based, inclusive) of the first element in the
       * slice
       * @param end   the index(one based, inclusive) of the last element in the
       * slice. If end &lt; start, the new list will be empty
       */
      public ISharedRowList( final Cell[][] rows, final int start, final int end ) {
          if ( start > end ) {
              this.rowData = null;
          } else if ( start < 1 || start > rows.length ) {
              throw new ListIndexOutOfBoundsAlert(
                  "First index in slice must be between 1 and the number of rows"
              ).culprit(
                  "index",
                  start
              ).decorate( rows ).mishap();
          } else if ( end > rows.length ) {
              throw new ListIndexOutOfBoundsAlert(
                  "Last index in slice must not be greater than the number of rows"
              ).culprit(
                  "index",
                  end
              ).decorate( rows ).mishap();
          } else {
              this.rowData = rows;
          }
          this.firstIndex = start;
          this.lastIndex = end;
      }
  
      /**
       * @see org.millscript.commons.util.list.AbstractIList#doGet(int)
       */
      @Override
      protected Row doGet( final int pos ) {
          // NOTE - We subtract two here as both firstElementIndex and pos use
          // one based indexing, so we have to subtract one from both
          final Cell[] row = this.rowData[ this.firstIndex - 2 + pos ];
          if ( row == null ) {
              return new RowImpl();
          } else {
              return new RowImpl( row, true );
          }
     }
 
     /**
      * @see org.millscript.commons.util.list.AbstractIList#doSlice(int, int, boolean)
      */
     @Override
     protected IList< Row > doSlice( int first, int last, boolean share ) {
         // The off by one adjustment is required as the indicies are inclusive,
         // so if first is one we must use the value of firstIndex.
         if ( share ) {
             return new ISharedRowList(
                 this.rowData,
                 this.firstIndex + first - 1,
                 this.firstIndex + last - 1
             );
         } else {
             return new IRowList(
                 this.rowData,
                 this.firstIndex + first - 1,
                 this.firstIndex + last - 1
             );
         }
     }
 
     /**
      * @see org.millscript.commons.util.IList#indexOf(V)
      */
     public int indexOf( Row value ) {
         // TODO Auto-generated method stub
         throw new Unimplemented(
             "A indexOf operation was required"
         ).culprit( "class", this.getClass() );
     }
 
     /**
      * @see org.millscript.commons.util.IList#iterator(boolean)
      */
     public ListIterator< Row > iterator( boolean share ) {
         if ( share ) {
             return new SharedRowListIterator(
                 this.rowData,
                 this.firstIndex,
                 this.lastIndex
             );
         } else if ( this.size() == 0 ) {
             return new NullListIterator< Row >();
         } else {
             final Cell[][] objects = new Cell[ this.size() ][];
             System.arraycopy( this.rowData, this.firstIndex - 1, objects, 0, objects.length );
             return new RowListIterator( objects, true );
         }
     }
 
     /**
      * @see org.millscript.commons.util.IMap#size()
      */
     public int size() {
         return this.lastIndex < this.firstIndex ? 0
                                                 : this.lastIndex - this.firstIndex + 1;
     }
 
 }