/**
         * Formats the given numeric of date Cell's contents
         *  as a String, in as close as we can to the way
         *  that Excel would do so.
         * Uses the various format records to manage this.
         *
         * TODO - move this to a central class in such a
         *  way that hssf.usermodel can make use of it too
         */
        public String FormatNumberDateCell(CellValueRecordInterface cell)
        {
            double value;
            if (cell is NumberRecord)
            {
                value = ((NumberRecord)cell).Value;
            }
            else if (cell is FormulaRecord)
            {
                value = ((FormulaRecord)cell).Value;
            }
            else
            {
                throw new ArgumentException("Unsupported CellValue Record passed in " + cell);
            }

            // Get the built in format, if there is one
            int formatIndex = GetFormatIndex(cell);
            String formatString = GetFormatString(cell);

            if (formatString == null)
            {
                return value.ToString();
            }
            else
            {
                // Format, using the nice new
                //  HSSFDataFormatter to do the work for us
                return formatter.FormatRawCellContents(value, formatIndex, formatString);
            }
        }

        public void InsertCell(CellValueRecordInterface cell)
        {
            int column = cell.Column;
            int row = cell.Row;
            if (row >= records.Length)
            {
                CellValueRecordInterface[][] oldRecords = records;
                int newSize = oldRecords.Length * 2;
                if (newSize < row + 1) newSize = row + 1;
                records = new CellValueRecordInterface[newSize][];
                Array.Copy(oldRecords, 0, records, 0, oldRecords.Length);
            }
            object objRowCells = records[row];
            if (objRowCells == null)
            {
                int newSize = column + 1;
                if (newSize < 10) newSize = 10;
                objRowCells = new CellValueRecordInterface[newSize];
                records[row] = (CellValueRecordInterface[])objRowCells;
            }
            CellValueRecordInterface[] rowCells = (CellValueRecordInterface[])objRowCells;
            if (column >= rowCells.Length)
            {
                CellValueRecordInterface[] oldRowCells = rowCells;
                int newSize = oldRowCells.Length * 2;
                if (newSize < column + 1) newSize = column + 1;
                // if(newSize>257) newSize=257; // activate?
                rowCells = new CellValueRecordInterface[newSize];
                Array.Copy(oldRowCells, 0, rowCells, 0, oldRowCells.Length);
                records[row] = rowCells;
            }
            rowCells[column] = cell;

            if ((column < firstcell) || (firstcell == -1))
            {
                firstcell = column;
            }
            if ((column > lastcell) || (lastcell == -1))
            {
                lastcell = column;
            }
        }

 /// <summary>
 /// returns whether this cell represents the same cell (NOT VALUE)
 /// </summary>
 /// <param name="i"> record to Compare</param>
 /// <returns>true if the cells are the same cell (positionally), false if not.</returns>
 public bool IsEqual(CellValueRecordInterface i)
 {
     return _formulaRecord.IsEqual(i);
 }

 private ValueRecordsAggregate(int firstCellIx, int lastCellIx, CellValueRecordInterface[][] pRecords)
 {
     firstcell = firstCellIx;
     lastcell = lastCellIx;
     records = pRecords;
 }

 public MyEnumerator(ref CellValueRecordInterface[][] _records)
 {
     this.records = _records;
     this.nextRow = 0;
     this.lastRow = _records.Length - 1;
     //FindNext();
 }

 public void Construct(CellValueRecordInterface rec, RecordStream rs, SharedValueManager sfh)
 {
     if (rec is FormulaRecord)
     {
         FormulaRecord formulaRec = (FormulaRecord)rec;
         // read optional cached text value
         StringRecord cachedText=null;
         Type nextClass = rs.PeekNextClass();
         if (nextClass == typeof(StringRecord))
         {
             cachedText = (StringRecord)rs.GetNext();
         }
         else
         {
             cachedText = null;
         }
         InsertCell(new FormulaRecordAggregate(formulaRec, cachedText, sfh));
     }
     else
     {
         InsertCell(rec);
     }
 }

        public void RemoveCell(CellValueRecordInterface cell)
        {
            if (cell == null)
            {
                throw new ArgumentException("cell must not be null");
            }

            int row = cell.Row;
            if (row >= records.Length)
            {
                throw new Exception("cell row is out of range"); 
            }
            CellValueRecordInterface[] rowCells = records[row];
            if (rowCells == null)
            {
                throw new Exception("cell row is already empty");
            }
            int column = cell.Column;
            if (column >= rowCells.Length)
            {
                throw new Exception("cell column is out of range");
            }
            rowCells[column] = null;
            
        }

        /// <summary>
        /// Creates an Cell from a CellValueRecordInterface.  HSSFSheet uses this when
        /// reading in cells from an existing sheet.
        /// </summary>
        /// <param name="book">Workbook record of the workbook containing this cell</param>
        /// <param name="sheet">Sheet record of the sheet containing this cell</param>
        /// <param name="cval">the Cell Value Record we wish to represent</param>
        public HSSFCell(HSSFWorkbook book, HSSFSheet sheet, CellValueRecordInterface cval)
        {
            record = cval;
            cellType = DetermineType(cval);
            stringValue = null;
            this.book = book;
            this.sheet = sheet;
            switch (cellType)
            {
                case CellType.STRING:
                    stringValue = new HSSFRichTextString(book.Workbook, (LabelSSTRecord)cval);
                    break;

                case CellType.BLANK:
                    break;

                case CellType.FORMULA:
                    stringValue = new HSSFRichTextString(((FormulaRecordAggregate)cval).StringValue);
                    break;
            }
            //ExtendedFormatRecord xf = book.Workbook.GetExFormatAt(cval.XFIndex);

            //CellStyle = new HSSFCellStyle((short)cval.XFIndex, xf, book);
        }

        /**
         * used internally -- given a cell value record, figure out its type
         */
        private CellType DetermineType(CellValueRecordInterface cval)
        {
            if (cval is FormulaRecordAggregate)
            {
                return CellType.Formula;
            }

            Record record = (Record)cval;
            int sid = record.Sid;

            switch (sid)
            {

                case NumberRecord.sid:
                    return CellType.Numeric;


                case BlankRecord.sid:
                    return CellType.Blank;


                case LabelSSTRecord.sid:
                    return CellType.String;


                case FormulaRecordAggregate.sid:
                    return CellType.Formula;


                case BoolErrRecord.sid:
                    BoolErrRecord boolErrRecord = (BoolErrRecord)record;

                    return (boolErrRecord.IsBoolean)
                             ? CellType.Boolean
                             : CellType.Error;

            }
            throw new Exception("Bad cell value rec (" + cval.GetType().Name + ")");
        }

 public bool IsEqual(CellValueRecordInterface i)
 {
     return ((this.Row == i.Row)
             && (this.Column == i.Column));
 }

 public bool IsAfter(CellValueRecordInterface i)
 {
     if (this.Row < i.Row)
     {
         return false;
     }
     if ((this.Row == i.Row)
             && (this.Column < i.Column))
     {
         return false;
     }
     if ((this.Row == i.Row)
             && (this.Column == i.Column))
     {
         return false;
     }
     return true;
 }

 public bool IsBefore(CellValueRecordInterface i)
 {
     if (this.Row > i.Row)
     {
         return false;
     }
     if ((this.Row == i.Row)
             && (this.Column > i.Column))
     {
         return false;
     }
     if ((this.Row == i.Row)
             && (this.Column == i.Column))
     {
         return false;
     }
     return true;
 }

 /**
  * Returns the index of the format string, used by your cell,
  *  or -1 if none found
  */
 public int GetFormatIndex(CellValueRecordInterface cell)
 {
     ExtendedFormatRecord xfr = (ExtendedFormatRecord)
         xfRecords[cell.XFIndex];
     if (xfr == null)
     {
         logger.Log(POILogger.ERROR, "Cell " + cell.Row + "," + cell.Column + " uses XF with index " + cell.XFIndex + ", but we don't have that");
         return -1;
     }
     return xfr.FormatIndex;
 }

        /// <summary>
        /// Create a high level Cell object from an existing low level record.  Should
        /// only be called from HSSFSheet or HSSFRow itself.
        /// </summary>
        /// <param name="cell">The low level cell to Create the high level representation from</param>
        /// <returns> the low level record passed in</returns>
        public Cell CreateCellFromRecord(CellValueRecordInterface cell)
        {
            Cell hcell = new HSSFCell(book, sheet, cell);

            AddCell(hcell);
            int colIx = cell.Column;
            if (row.IsEmpty)
            {
                row.FirstCol=(colIx);
                row.LastCol=(colIx + 1);
            }
            else
            {
                if (colIx < row.FirstCol)
                {
                    row.FirstCol = (colIx);
                }
                else if (colIx > row.LastCol)
                {
                    row.LastCol = (colIx + 1);
                }
                else
                {
                    // added cell is within first and last cells
                }
            }
            return hcell;
        }

 /**
  * Returns the format string, eg $##.##, used
  *  by your cell 
  */
 public String GetFormatString(CellValueRecordInterface cell)
 {
     int formatIndex = GetFormatIndex(cell);
     if (formatIndex == -1)
     {
         // Not found
         return null;
     }
     return GetFormatString(formatIndex);
 }

 /**
  * Returns the index of the format string, used by your cell,
  *  or -1 if none found
  */
 public int GetFormatIndex(CellValueRecordInterface cell)
 {
     ExtendedFormatRecord xfr = (ExtendedFormatRecord)
         xfRecords[cell.XFIndex];
     if (xfr == null)
     {
         Console.Error.WriteLine("Cell " + cell.Row + "," + cell.Column + " uses XF with index " + cell.XFIndex + ", but we don't have that");
         return -1;
     }
     return xfr.FormatIndex;
 }

        /// <summary>
        /// Adds a value record to the sheet's contained binary records
        /// (i.e. LabelSSTRecord or NumberRecord).
        /// This method is "loc" sensitive.  Meaning you need to Set LOC to where you
        /// want it to start searching.  If you don't know do this: SetLoc(GetDimsLoc).
        /// When Adding several rows you can just start at the last one by leaving loc
        /// at what this Sets it to.
        /// </summary>
        /// <param name="row">the row to Add the cell value to</param>
        /// <param name="col">the cell value record itself.</param>
        public void AddValueRecord(int row, CellValueRecordInterface col)
        {
            //if (log.Check(POILogger.DEBUG))
            //{
            //    log.Log(POILogger.DEBUG, "Add value record  row" + row);
            //}
            DimensionsRecord d = _dimensions;

            if (col.Column >= d.LastCol)
            {
                d.LastCol = ((short)(col.Column + 1));
            }
            if (col.Column < d.FirstCol)
            {
                d.FirstCol = (col.Column);
            }
            _rowsAggregate.InsertCell(col);
        }

        /**
         * used internally -- given a cell value record, figure out its type
         */
        private CellType DetermineType(CellValueRecordInterface cval)
        {
            if (cval is FormulaRecordAggregate)
            {
                return CellType.FORMULA;
            }

            Record record = (Record)cval;
            int sid = record.Sid;

            switch (sid)
            {

                case NumberRecord.sid:
                    return CellType.NUMERIC;


                case BlankRecord.sid:
                    return CellType.BLANK;


                case LabelSSTRecord.sid:
                    return CellType.STRING;


                case FormulaRecordAggregate.sid:
                    return CellType.FORMULA;


                case BoolErrRecord.sid:
                    BoolErrRecord boolErrRecord = (BoolErrRecord)record;

                    return (boolErrRecord.IsBoolean)
                             ? CellType.BOOLEAN
                             : CellType.ERROR;

            }
            throw new Exception("Bad cell value rec (" + cval.GetType().Name + ")");
        }

 /// <summary>
 /// Remove a value record from the records array.
 /// This method is not loc sensitive, it Resets loc to = dimsloc so no worries.
 /// </summary>
 /// <param name="row">the row of the value record you wish to Remove</param>
 /// <param name="col">a record supporting the CellValueRecordInterface.</param>
 public void RemoveValueRecord(int row, CellValueRecordInterface col)
 {
     //log.LogFormatted(POILogger.DEBUG, "Remove value record row,dimsloc %,%",
     //                 new int[] { row, dimsloc });
     _rowsAggregate.RemoveCell(col);
 }

            /// <summary>
            /// Formats a number or date cell, be that a real number, or the
            /// answer to a formula
            /// </summary>
            /// <param name="cell">The cell.</param>
            /// <param name="value">The value.</param>
            /// <returns></returns>
            private String FormatNumberDateCell(CellValueRecordInterface cell, double value)
            {
                // Get the built in format, if there is one
                int formatIndex = ft.GetFormatIndex(cell);
                String formatString = ft.GetFormatString(cell);

                if (formatString == null)
                {
                    return value.ToString();
                }
                else
                {
                    // Is it a date?
                    if (HSSFDateUtil.IsADateFormat(formatIndex, formatString) &&
                            HSSFDateUtil.IsValidExcelDate(value))
                    {
                        // Java wants M not m for month
                        formatString = formatString.Replace('m', 'M');
                        // Change \- into -, if it's there
                        formatString = formatString.Replace("\\\\-", "-");

                        // Format as a date
                        DateTime d = HSSFDateUtil.GetJavaDate(value, false);
                        SimpleDateFormat df = new SimpleDateFormat(formatString);
                        return df.Format(d);
                    }
                    else
                    {
                        if (formatString == "General")
                        {
                            // Some sort of wierd default
                            return value.ToString();
                        }

                        // Format as a number
                        DecimalFormat df = new DecimalFormat(formatString);
                        return df.Format(value);
                    }
                }
            }