public FormulaRecord() 
{
 //if formula support is not enabled then
                                        //we'll just store/reserialize
        field_8_parsed_expr = new Stack();
}

Creates new FormulaRecord

 public FormulaRecord(RecordInputStream in) 
{
        super(in);
}

Constructs a Formula record and sets its fields appropriately. Note - id must be 0x06 (NOT 0x406 see MSKB #Q184647 for an "explanation of this bug in the documentation) or an exception will be throw upon validation

Parameters:

in - the RecordInputstream to read the record from

 public Object clone() 
{
      FormulaRecord rec = new FormulaRecord();
      rec.field_1_row = field_1_row;
      rec.field_2_column = field_2_column;
      rec.field_3_xf = field_3_xf;
      rec.field_4_value = field_4_value;
      rec.field_5_options = field_5_options;
      rec.field_6_zero = field_6_zero;
      rec.field_7_expression_len = field_7_expression_len;
      rec.field_8_parsed_expr = new Stack();
      int size = 0;
      if (field_8_parsed_expr != null)
        size = field_8_parsed_expr.size();
      for (int i=0; i<  size; i++) {
        Ptg ptg = ((Ptg)field_8_parsed_expr.get(i)).copy();        
        rec.field_8_parsed_expr.add(i, ptg);
      }
      rec.value_data = value_data;
      rec.all_data = all_data;
      return rec;
}

 public int compareTo(Object obj) 
{
        CellValueRecordInterface loc = ( CellValueRecordInterface ) obj;
        if ((this.getRow() == loc.getRow())
                && (this.getColumn() == loc.getColumn()))
        {
            return 0;
        }
        if (this.getRow() <  loc.getRow())
        {
            return -1;
        }
        if (this.getRow()  > loc.getRow())
        {
            return 1;
        }
        if (this.getColumn() <  loc.getColumn())
        {
            return -1;
        }
        if (this.getColumn()  > loc.getColumn())
        {
            return 1;
        }
        return -1;
}

 public boolean equals(Object obj) 
{
        if (!(obj instanceof CellValueRecordInterface))
        {
            return false;
        }
        CellValueRecordInterface loc = ( CellValueRecordInterface ) obj;
        if ((this.getRow() == loc.getRow())
                && (this.getColumn() == loc.getColumn()))
        {
            return true;
        }
        return false;
}

 protected  void fillFields(RecordInputStream in) 
{
        try {
          field_1_row            = in.readUShort();
          field_2_column         = in.readShort();
          field_3_xf             = in.readShort();
          field_4_value          = in.readDouble();
          field_5_options        = in.readShort();
        if (Double.isNaN(field_4_value)) {
            value_data = in.getNANData();
        }
          field_6_zero           = in.readInt();
          field_7_expression_len = in.readShort();
          field_8_parsed_expr    = Ptg.createParsedExpressionTokens(field_7_expression_len, in);
        } catch (java.lang.UnsupportedOperationException uoe)  {
          throw new RecordFormatException(uoe);
        }
        if (in.remaining() == 10) {
            // TODO - this seems to occur when IntersectionPtg is present
            // 10 extra bytes are just 0x01 and 0x00
            // This causes POI stderr: "WARN. Unread 10 bytes of record 0x6"
        }
}

 public short getColumn() 
{
        return field_2_column;
}

 public short getExpressionLength() 
{
        return field_7_expression_len;
}

get the length (in number of tokens) of the expression

 public int getNumberOfExpressionTokens() 
{
        if (this.field_8_parsed_expr == null) {
            return 0;
        } else {
            return field_8_parsed_expr.size();
        }
}

get the size of the stack

 public short getOptions() 
{
        return field_5_options;
}

get the option flags

 public List getParsedExpression() 
{
        return field_8_parsed_expr;
}

get the stack as a list

 public int getRecordSize() 
{
        int retval =0;
        if (this.field_8_parsed_expr != null) {
            retval = getTotalPtgSize() + 26;
        } else {
            retval =all_data.length;
        }
        return retval;
        // return getTotalPtgSize() + 28;
}

 public int getRow() 
{
        return field_1_row;
}

 public short getSid() 
{
        return sid;
}

 public double getValue() 
{
        return field_4_value;
}

get the calculated value of the formula

 public short getXFIndex() 
{
        return field_3_xf;
}

 public boolean isAfter(CellValueRecordInterface i) 
{
        if (this.getRow() <  i.getRow())
        {
            return false;
        }
        if ((this.getRow() == i.getRow())
                && (this.getColumn() <  i.getColumn()))
        {
            return false;
        }
        if ((this.getRow() == i.getRow())
                && (this.getColumn() == i.getColumn()))
        {
            return false;
        }
        return true;
}

 public boolean isAlwaysCalc() 
{
    	return alwaysCalc.isSet(field_5_options);
}

 public boolean isBefore(CellValueRecordInterface i) 
{
        if (this.getRow()  > i.getRow())
        {
            return false;
        }
        if ((this.getRow() == i.getRow())
                && (this.getColumn()  > i.getColumn()))
        {
            return false;
        }
        if ((this.getRow() == i.getRow())
                && (this.getColumn() == i.getColumn()))
        {
            return false;
        }
        return true;
}

 public boolean isCalcOnLoad() 
{
    	return calcOnLoad.isSet(field_5_options);
}

 public boolean isEqual(CellValueRecordInterface i) 
{
        return ((this.getRow() == i.getRow())
                && (this.getColumn() == i.getColumn()));
}

 public boolean isInValueSection() 
{
        return true;
}

 public boolean isSharedFormula() 
{
        return sharedFormula.isSet(field_5_options);
}

 public boolean isValue() 
{
        return true;
}

 public Ptg peekExpressionToken() 
{
        return ( Ptg ) field_8_parsed_expr.peek();
}

peek at the token on the top of stack

 public Ptg popExpressionToken() 
{
        return ( Ptg ) field_8_parsed_expr.pop();
}

pop a token off of the stack

 public  void pushExpressionToken(Ptg ptg) 
{
        field_8_parsed_expr.push(ptg);
}

push a token onto the stack

 public int serialize(int offset,
    byte[] data) 
{
        if (this.field_8_parsed_expr != null) {
        int ptgSize = getTotalPtgSize();
        LittleEndian.putShort(data, 0 + offset, sid);
        LittleEndian.putShort(data, 2 + offset, ( short ) (22 + ptgSize));
        //LittleEndian.putShort(data, 4 + offset, getRow());
        LittleEndian.putShort(data, 4 + offset, ( short ) getRow());
        LittleEndian.putShort(data, 6 + offset, getColumn());
        LittleEndian.putShort(data, 8 + offset, getXFIndex());
        //only reserialize if the value is still NaN and we have old nan data
        if (Double.isNaN(this.getValue()) && value_data != null) {        	
			System.arraycopy(value_data,0,data,10 + offset,value_data.length);
        } else {
			LittleEndian.putDouble(data, 10 + offset, field_4_value);
        }
        LittleEndian.putShort(data, 18 + offset, getOptions());
        //when writing the chn field (offset 20), it's supposed to be 0 but ignored on read
        //Microsoft Excel Developer's Kit Page 318
        LittleEndian.putInt(data, 20 + offset, 0);
        LittleEndian.putShort(data, 24 + offset, getExpressionLength());
        Ptg.serializePtgStack(field_8_parsed_expr, data, 26+offset);
        } else {
            System.arraycopy(all_data,0,data,offset,all_data.length);
        }
        return getRecordSize();
}

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  void setAlwaysCalc(boolean flag) 
{
    	field_5_options =
    		alwaysCalc.setShortBoolean(field_5_options, flag);
}

 public  void setCalcOnLoad(boolean flag) 
{
    	field_5_options =
    		calcOnLoad.setShortBoolean(field_5_options, flag);
}

 public  void setColumn(short column) 
{
        field_2_column = column;
}

 public  void setExpressionLength(short len) 
{
        field_7_expression_len = len;
}

set the length (in number of tokens) of the expression

 public  void setOptions(short options) 
{
        field_5_options = options;
}

set the option flags

 public  void setParsedExpression(Stack ptgs) 
{
      field_8_parsed_expr = ptgs;
}

 public  void setRow(int row) 
{
        field_1_row = row;
}

 public  void setSharedFormula(boolean flag) 
{
    	field_5_options =
    		sharedFormula.setShortBoolean(field_5_options, flag);
}

 public  void setValue(double value) 
{
        field_4_value = value;
}

set the calculated value of the formula

 public  void setXFIndex(short xf) 
{
        field_3_xf = xf;
}

 public String toString() 
{
        StringBuffer buffer = new StringBuffer();
            buffer.append("[FORMULA]\n");
            buffer.append("    .row       = ")
                .append(Integer.toHexString(getRow())).append("\n");
            buffer.append("    .column    = ")
                .append(Integer.toHexString(getColumn()))
                .append("\n");
            buffer.append("    .xf              = ")
                .append(Integer.toHexString(getXFIndex())).append("\n");
            if (Double.isNaN(this.getValue()) && value_data != null)
              buffer.append("    .value (NaN)     = ")
                  .append(org.apache.poi.util.HexDump.dump(value_data,0,0))
                  .append("\n");
            else
              buffer.append("    .value           = ").append(getValue())
                  .append("\n");
            buffer.append("    .options         = ").append(getOptions())
                .append("\n");
            buffer.append("      .alwaysCalc         = ").append(alwaysCalc.isSet(getOptions()))
                .append("\n");
            buffer.append("      .calcOnLoad         = ").append(calcOnLoad.isSet(getOptions()))
                .append("\n");
            buffer.append("      .sharedFormula         = ").append(sharedFormula.isSet(getOptions()))
                .append("\n");
            buffer.append("    .zero            = ").append(field_6_zero)
                .append("\n");
            buffer.append("    .expressionlength= ").append(getExpressionLength())
                .append("\n");
            if (field_8_parsed_expr != null) {
                buffer.append("    .numptgsinarray  = ").append(field_8_parsed_expr.size())
                    .append("\n");
                for (int k = 0; k <  field_8_parsed_expr.size(); k++ ) {
                   buffer.append("     Ptg(")
                        .append(k)
                        .append(")=")
                        .append(field_8_parsed_expr.get(k).toString())
                        .append("\n")
                        .append(((Ptg)field_8_parsed_expr.get(k)).toDebugString())
                        .append("\n");
                }
            }else {
                buffer.append("Formula full data \n")
                    .append(org.apache.poi.util.HexDump.dump(this.all_data,0,0));
            }
            buffer.append("[/FORMULA]\n");
        return buffer.toString();
}

 protected  void validateSid(short id) 
{
        if (id != sid)
        {
            throw new RecordFormatException("NOT A FORMULA RECORD");
        }
}

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