C# CellValueRecordInterface类代码示例

        /**
         * 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);
 }