public ValueRecordsAggregate() 
{
           
    records = new CellValueRecordInterface[30][]; // We start with 30 Rows.
}

Creates a new instance of ValueRecordsAggregate

 public Object clone() 
{
      ValueRecordsAggregate rec = new ValueRecordsAggregate();
      for (Iterator valIter = getIterator(); valIter.hasNext();) {
        CellValueRecordInterface val = (CellValueRecordInterface)((CellValueRecordInterface)valIter.next()).clone();
        rec.insertCell(val);
      }
      return rec;
}

Performs a deep clone of the record

 public int construct(int offset,
    List records) 
{
        int k = 0;
        FormulaRecordAggregate lastFormulaAggregate = null;
        // First up, locate all the shared formulas for this sheet
        List sharedFormulas = new java.util.ArrayList();
        for (k = offset; k <  records.size(); k++)
        {
            Record rec = ( Record ) records.get(k);
            if (rec instanceof SharedFormulaRecord) {
            	sharedFormulas.add(rec);
            }
            if(rec instanceof EOFRecord) {
                // End of current sheet. Ignore all subsequent shared formula records (Bugzilla 44449)
                break;
            }
        }
        // Now do the main processing sweep
        for (k = offset; k <  records.size(); k++)
        {
            Record rec = ( Record ) records.get(k);
            if (rec instanceof StringRecord == false && !rec.isInValueSection() && !(rec instanceof UnknownRecord))
            {
                break;
            } else if (rec instanceof SharedFormulaRecord) {
            	// Already handled, not to worry
            } else if (rec instanceof FormulaRecord)
            {
              FormulaRecord formula = (FormulaRecord)rec;
              if (formula.isSharedFormula()) {
                // Traverse the list of shared formulas in
            	//  reverse order, and try to find the correct one
                //  for us
                boolean found = false;
                for (int i=sharedFormulas.size()-1;i >=0;i--) {
                    // TODO - there is no junit test case to justify this reversed loop
                    // perhaps it could just run in the normal direction?
                	SharedFormulaRecord shrd = (SharedFormulaRecord)sharedFormulas.get(i);
                	if (shrd.isFormulaInShared(formula)) {
                		shrd.convertSharedFormulaRecord(formula);
                		found = true;
                		break;
                	}
                }
                if (!found) {
                    handleMissingSharedFormulaRecord(formula);
                }
              }
              lastFormulaAggregate = new FormulaRecordAggregate((FormulaRecord)rec, null);
              insertCell( lastFormulaAggregate );
            }
            else if (rec instanceof StringRecord)
            {
                lastFormulaAggregate.setStringRecord((StringRecord)rec);
            }
            else if (rec.isValue())
            {
                insertCell(( CellValueRecordInterface ) rec);
            }
        }
        return k;
}

 protected  void fillFields(RecordInputStream in) 
{

}

You never fill an aggregate

 public int getFirstCellNum() 
{
        return firstcell;
}

 public Iterator getIterator() 
{
    return new MyIterator();
}

 public int getLastCellNum() 
{
        return lastcell;
}

 public int getPhysicalNumberOfCells() 
{
    int count=0;
    for(int r=0;r< records.length;r++) {
      CellValueRecordInterface[] rowCells=records[r];
      if (rowCells != null)
        for(short c=0;c< rowCells.length;c++) {
          if(rowCells[c]!=null) count++;
        }
    }
    return count;
}

 public int getRecordSize() 
{
    
        int size = 0;
    Iterator irecs = this.getIterator();
        while (irecs.hasNext()) {
                size += (( Record ) irecs.next()).getRecordSize();
        }
        return size;
}

 public int getRowCellBlockSize(int startRow,
    int endRow) 
{
      MyIterator itr = new MyIterator(startRow, endRow);
      int size = 0;
      while (itr.hasNext()) {
        CellValueRecordInterface cell = (CellValueRecordInterface)itr.next();
        int row = cell.getRow();
        if (row  > endRow)
          break;
        if ((row  >=startRow) && (row < = endRow))
          size += ((Record)cell).getRecordSize();
      }
      return size;
}

Tallies a count of the size of the cell records that are attached to the rows in the range specified.

 public short getSid() 
{
        return sid;
}

return the non static version of the id for this record.

 public  void insertCell(CellValueRecordInterface cell) 
{
    short column = cell.getColumn();
    int row = cell.getRow();
    if (row  >= records.length) {
      CellValueRecordInterface[][] oldRecords = records;
      int newSize = oldRecords.length * 2;
      if(newSize< row+1) newSize=row+1;
      records = new CellValueRecordInterface[newSize][];
      System.arraycopy(oldRecords, 0, records, 0, oldRecords.length);
    }
    CellValueRecordInterface[] rowCells = records[row];
    if (rowCells == null) {
      int newSize = column + 1;
      if(newSize< 10) newSize=10;
      rowCells = new CellValueRecordInterface[newSize];
      records[row] = rowCells;
    }
    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];
      System.arraycopy(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;
    }
}

 public  void removeCell(CellValueRecordInterface cell) 
{
    	if (cell != null) {
          short column = cell.getColumn();
          int row = cell.getRow();
          if(row >=records.length) return;
          CellValueRecordInterface[] rowCells=records[row];
          if(rowCells==null) return;
          if(column >=rowCells.length) return;
          rowCells[column]=null;
    	}
}

 public boolean rowHasCells(int row) 
{
    	if (row  > records.length-1) //previously this said row  > records.length which means if 
    		return false;  // if records.length == 60 and I pass "60" here I get array out of bounds
      CellValueRecordInterface[] rowCells=records[row]; //because a 60 length array has the last index = 59
      if(rowCells==null) return false;
      for(int col=0;col< rowCells.length;col++) {
        if(rowCells[col]!=null) return true;
      }
      return false;
}

Returns true if the row has cells attached to it

 public int serialize(int offset,
    byte[] data) 
{
      throw new RuntimeException("This method shouldnt be called. ValueRecordsAggregate.serializeCellRow() should be called from RowRecordsAggregate.");
}

called by the class that is responsible for writing this sucker. Subclasses should implement this so that their data is passed back in a byte array.

 public int serializeCellRow(int row,
    int offset,
    byte[] data) 
{
      MyIterator itr = new MyIterator(row, row);
        int      pos = offset;
        while (itr.hasNext())
        {
            CellValueRecordInterface cell = (CellValueRecordInterface)itr.next();
            if (cell.getRow() != row)
              break;
            pos += (( Record ) cell).serialize(pos, data);
        }
        return pos - offset;
}

Serializes the cells that are allocated to a certain row range

 protected  void validateSid(short id) 
{

}

called by constructor, should throw runtime exception in the event of a record passed with a differing ID.