poi-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From n...@apache.org
Subject svn commit: r1755068 - /poi/trunk/src/java/org/apache/poi/hssf/usermodel/HSSFFormulaEvaluator.java
Date Wed, 03 Aug 2016 11:15:13 GMT
Author: nick
Date: Wed Aug  3 11:15:13 2016
New Revision: 1755068

URL: http://svn.apache.org/viewvc?rev=1755068&view=rev
Log:
Whitespace / indents

Modified:
    poi/trunk/src/java/org/apache/poi/hssf/usermodel/HSSFFormulaEvaluator.java

Modified: poi/trunk/src/java/org/apache/poi/hssf/usermodel/HSSFFormulaEvaluator.java
URL: http://svn.apache.org/viewvc/poi/trunk/src/java/org/apache/poi/hssf/usermodel/HSSFFormulaEvaluator.java?rev=1755068&r1=1755067&r2=1755068&view=diff
==============================================================================
--- poi/trunk/src/java/org/apache/poi/hssf/usermodel/HSSFFormulaEvaluator.java (original)
+++ poi/trunk/src/java/org/apache/poi/hssf/usermodel/HSSFFormulaEvaluator.java Wed Aug  3
11:15:13 2016
@@ -46,333 +46,330 @@ import org.apache.poi.util.Internal;
  * calls to evaluate~ methods on this class.
  */
 public class HSSFFormulaEvaluator implements FormulaEvaluator, WorkbookEvaluatorProvider
{
+    private final WorkbookEvaluator _bookEvaluator;
+    private final HSSFWorkbook _book;
 
-	private final WorkbookEvaluator _bookEvaluator;
-	private final HSSFWorkbook _book;
+    public HSSFFormulaEvaluator(HSSFWorkbook workbook) {
+        this(workbook, null);
+    }
+    /**
+     * @param workbook  The workbook to perform the formula evaluations in
+     * @param stabilityClassifier used to optimise caching performance. Pass <code>null</code>
+     * for the (conservative) assumption that any cell may have its definition changed after
+     * evaluation begins.
+     */
+    public HSSFFormulaEvaluator(HSSFWorkbook workbook, IStabilityClassifier stabilityClassifier)
{
+        this(workbook, stabilityClassifier, null);
+    }
 
-	public HSSFFormulaEvaluator(HSSFWorkbook workbook) {
-		this(workbook, null);
-	}
-	/**
-	 * @param workbook  The workbook to perform the formula evaluations in
-	 * @param stabilityClassifier used to optimise caching performance. Pass <code>null</code>
-	 * for the (conservative) assumption that any cell may have its definition changed after
-	 * evaluation begins.
-	 */
-	public HSSFFormulaEvaluator(HSSFWorkbook workbook, IStabilityClassifier stabilityClassifier)
{
-		this(workbook, stabilityClassifier, null);
-	}
+    /**
+     * @param workbook  The workbook to perform the formula evaluations in
+     * @param stabilityClassifier used to optimise caching performance. Pass <code>null</code>
+     * for the (conservative) assumption that any cell may have its definition changed after
+     * evaluation begins.
+     * @param udfFinder pass <code>null</code> for default (AnalysisToolPak only)
+     */
+    private HSSFFormulaEvaluator(HSSFWorkbook workbook, IStabilityClassifier stabilityClassifier,
UDFFinder udfFinder) {
+        _book = workbook;
+        _bookEvaluator = new WorkbookEvaluator(HSSFEvaluationWorkbook.create(workbook), stabilityClassifier,
udfFinder);
+    }
 
-	/**
-	 * @param workbook  The workbook to perform the formula evaluations in
+    /**
+     * @param workbook  The workbook to perform the formula evaluations in
      * @param stabilityClassifier used to optimise caching performance. Pass <code>null</code>
      * for the (conservative) assumption that any cell may have its definition changed after
      * evaluation begins.
-	 * @param udfFinder pass <code>null</code> for default (AnalysisToolPak only)
-	 */
-	private HSSFFormulaEvaluator(HSSFWorkbook workbook, IStabilityClassifier stabilityClassifier,
UDFFinder udfFinder) {
-		_book = workbook;
-		_bookEvaluator = new WorkbookEvaluator(HSSFEvaluationWorkbook.create(workbook), stabilityClassifier,
udfFinder);
-	}
-
-	/**
-	 * @param workbook  The workbook to perform the formula evaluations in
-	 * @param stabilityClassifier used to optimise caching performance. Pass <code>null</code>
-	 * for the (conservative) assumption that any cell may have its definition changed after
-	 * evaluation begins.
-	 * @param udfFinder pass <code>null</code> for default (AnalysisToolPak only)
-	 */
-	public static HSSFFormulaEvaluator create(HSSFWorkbook workbook, IStabilityClassifier stabilityClassifier,
UDFFinder udfFinder) {
-		return new HSSFFormulaEvaluator(workbook, stabilityClassifier, udfFinder);
-	}
-
-
-	/**
-	 * Coordinates several formula evaluators together so that formulas that involve external
-	 * references can be evaluated.
-	 * @param workbookNames the simple file names used to identify the workbooks in formulas
-	 * with external links (for example "MyData.xls" as used in a formula "[MyData.xls]Sheet1!A1")
-	 * @param evaluators all evaluators for the full set of workbooks required by the formulas.
-	 */
-	public static void setupEnvironment(String[] workbookNames, HSSFFormulaEvaluator[] evaluators)
{
-		WorkbookEvaluator[] wbEvals = new WorkbookEvaluator[evaluators.length];
-		for (int i = 0; i < wbEvals.length; i++) {
-			wbEvals[i] = evaluators[i]._bookEvaluator;
-		}
-		CollaboratingWorkbooksEnvironment.setup(workbookNames, wbEvals);
-	}
+     * @param udfFinder pass <code>null</code> for default (AnalysisToolPak only)
+     */
+    public static HSSFFormulaEvaluator create(HSSFWorkbook workbook, IStabilityClassifier
stabilityClassifier, UDFFinder udfFinder) {
+        return new HSSFFormulaEvaluator(workbook, stabilityClassifier, udfFinder);
+    }
+
 
-	@Override
+    /**
+     * Coordinates several formula evaluators together so that formulas that involve external
+     * references can be evaluated.
+     * @param workbookNames the simple file names used to identify the workbooks in formulas
+     * with external links (for example "MyData.xls" as used in a formula "[MyData.xls]Sheet1!A1")
+     * @param evaluators all evaluators for the full set of workbooks required by the formulas.
+     */
+    public static void setupEnvironment(String[] workbookNames, HSSFFormulaEvaluator[] evaluators)
{
+        WorkbookEvaluator[] wbEvals = new WorkbookEvaluator[evaluators.length];
+        for (int i = 0; i < wbEvals.length; i++) {
+            wbEvals[i] = evaluators[i]._bookEvaluator;
+        }
+        CollaboratingWorkbooksEnvironment.setup(workbookNames, wbEvals);
+    }
+
+    @Override
     public void setupReferencedWorkbooks(Map<String, FormulaEvaluator> evaluators)
{
         CollaboratingWorkbooksEnvironment.setupFormulaEvaluator(evaluators);
     }
-	
+
     @Override
     public WorkbookEvaluator _getWorkbookEvaluator() {
         return _bookEvaluator;
     }
-    
-	/**
-	 * Should be called whenever there are major changes (e.g. moving sheets) to input cells
-	 * in the evaluated workbook.  If performance is not critical, a single call to this method
-	 * may be used instead of many specific calls to the notify~ methods.
-	 *
-	 * Failure to call this method after changing cell values will cause incorrect behaviour
-	 * of the evaluate~ methods of this class
-	 */
-	@Override
+
+    /**
+     * Should be called whenever there are major changes (e.g. moving sheets) to input cells
+     * in the evaluated workbook.  If performance is not critical, a single call to this
method
+     * may be used instead of many specific calls to the notify~ methods.
+     *
+     * Failure to call this method after changing cell values will cause incorrect behaviour
+     * of the evaluate~ methods of this class
+     */
+    @Override
     public void clearAllCachedResultValues() {
-		_bookEvaluator.clearAllCachedResultValues();
-	}
-	/**
-	 * Should be called to tell the cell value cache that the specified (value or formula) cell
-	 * has changed.
-	 * Failure to call this method after changing cell values will cause incorrect behaviour
-	 * of the evaluate~ methods of this class
-	 */
-	public void notifyUpdateCell(HSSFCell cell) {
-		_bookEvaluator.notifyUpdateCell(new HSSFEvaluationCell(cell));
-	}
+        _bookEvaluator.clearAllCachedResultValues();
+    }
+    /**
+     * Should be called to tell the cell value cache that the specified (value or formula)
cell
+     * has changed.
+     * Failure to call this method after changing cell values will cause incorrect behaviour
+     * of the evaluate~ methods of this class
+     */
+    public void notifyUpdateCell(HSSFCell cell) {
+        _bookEvaluator.notifyUpdateCell(new HSSFEvaluationCell(cell));
+    }
     @Override
     public void notifyUpdateCell(Cell cell) {
         _bookEvaluator.notifyUpdateCell(new HSSFEvaluationCell((HSSFCell)cell));
     }
-	/**
-	 * Should be called to tell the cell value cache that the specified cell has just been
-	 * deleted.
-	 * Failure to call this method after changing cell values will cause incorrect behaviour
-	 * of the evaluate~ methods of this class
-	 */
-	public void notifyDeleteCell(HSSFCell cell) {
-		_bookEvaluator.notifyDeleteCell(new HSSFEvaluationCell(cell));
-	}
-	@Override
+    /**
+     * Should be called to tell the cell value cache that the specified cell has just been
+     * deleted.
+     * Failure to call this method after changing cell values will cause incorrect behaviour
+     * of the evaluate~ methods of this class
+     */
+    public void notifyDeleteCell(HSSFCell cell) {
+        _bookEvaluator.notifyDeleteCell(new HSSFEvaluationCell(cell));
+    }
+    @Override
     public void notifyDeleteCell(Cell cell) {
-		_bookEvaluator.notifyDeleteCell(new HSSFEvaluationCell((HSSFCell)cell));
-	}
+        _bookEvaluator.notifyDeleteCell(new HSSFEvaluationCell((HSSFCell)cell));
+    }
 
-	/**
-	 * Should be called to tell the cell value cache that the specified (value or formula) cell
-	 * has changed.
-	 * Failure to call this method after changing cell values will cause incorrect behaviour
-	 * of the evaluate~ methods of this class
-	 */
-	@Override
+    /**
+     * Should be called to tell the cell value cache that the specified (value or formula)
cell
+     * has changed.
+     * Failure to call this method after changing cell values will cause incorrect behaviour
+     * of the evaluate~ methods of this class
+     */
+    @Override
     public void notifySetFormula(Cell cell) {
-		_bookEvaluator.notifyUpdateCell(new HSSFEvaluationCell((HSSFCell)cell));
-	}
+        _bookEvaluator.notifyUpdateCell(new HSSFEvaluationCell((HSSFCell)cell));
+    }
+
+    /**
+     * If cell contains a formula, the formula is evaluated and returned,
+     * else the CellValue simply copies the appropriate cell value from
+     * the cell and also its cell type. This method should be preferred over
+     * evaluateInCell() when the call should not modify the contents of the
+     * original cell.
+     *
+     * @param cell may be <code>null</code> signifying that the cell is not present
(or blank)
+     * @return <code>null</code> if the supplied cell is <code>null</code>
or blank
+     */
+    @Override
+    public CellValue evaluate(Cell cell) {
+        if (cell == null) {
+            return null;
+        }
+
+        switch (cell.getCellTypeEnum()) {
+            case BOOLEAN:
+                return CellValue.valueOf(cell.getBooleanCellValue());
+            case ERROR:
+                return CellValue.getError(cell.getErrorCellValue());
+            case FORMULA:
+                return evaluateFormulaCellValue(cell);
+            case NUMERIC:
+                return new CellValue(cell.getNumericCellValue());
+            case STRING:
+                return new CellValue(cell.getRichStringCellValue().getString());
+            case BLANK:
+                return null;
+            default:
+                throw new IllegalStateException("Bad cell type (" + cell.getCellTypeEnum()
+ ")");
+        }
+    }
+
+
+    /**
+     * If cell contains formula, it evaluates the formula, and saves the result of the formula.
The
+     * cell remains as a formula cell. If the cell does not contain formula, this method
returns -1
+     * and leaves the cell unchanged.
+     *
+     * Note that the type of the <em>formula result</em> is returned, so you
know what kind of
+     * cached formula result is also stored with  the formula.
+     * <pre>
+     * int evaluatedCellType = evaluator.evaluateFormulaCell(cell);
+     * </pre>
+     * Be aware that your cell will hold both the formula, and the result. If you want the
cell
+     * replaced with the result of the formula, use {@link #evaluateInCell(org.apache.poi.ss.usermodel.Cell)}
+     * @param cell The cell to evaluate
+     * @return -1 for non-formula cells, or the type of the <em>formula result</em>
+     */
+    @Override
+    public int evaluateFormulaCell(Cell cell) {
+        return evaluateFormulaCellEnum(cell).getCode();
+    }
+
+    /**
+     * If cell contains formula, it evaluates the formula, and saves the result of the formula.
The
+     * cell remains as a formula cell. If the cell does not contain formula, rather than
throwing an
+     * exception, this method returns {@link CellType#_NONE} and leaves the cell unchanged.
+     *
+     * Note that the type of the <em>formula result</em> is returned, so you
know what kind of
+     * cached formula result is also stored with  the formula.
+     * <pre>
+     * CellType evaluatedCellType = evaluator.evaluateFormulaCell(cell);
+     * </pre>
+     * Be aware that your cell will hold both the formula, and the result. If you want the
cell
+     * replaced with the result of the formula, use {@link #evaluateInCell(org.apache.poi.ss.usermodel.Cell)}
+     * @param cell The cell to evaluate
+     * @return {@link CellType#_NONE} for non-formula cells, or the type of the <em>formula
result</em>
+     * @since POI 3.15 beta 3
+     * @deprecated POI 3.15 beta 3. Will be deleted when we make the CellType enum transition.
See bug 59791.
+     */
+    @Internal
+    @Override
+    public CellType evaluateFormulaCellEnum(Cell cell) {
+        if (cell == null || cell.getCellTypeEnum() != CellType.FORMULA) {
+            return CellType._NONE;
+        }
+        CellValue cv = evaluateFormulaCellValue(cell);
+        // cell remains a formula cell, but the cached value is changed
+        setCellValue(cell, cv);
+        return cv.getCellType();
+    }
+
+    /**
+     * If cell contains formula, it evaluates the formula, and
+     *  puts the formula result back into the cell, in place
+     *  of the old formula.
+     * Else if cell does not contain formula, this method leaves
+     *  the cell unchanged.
+     * Note that the same instance of HSSFCell is returned to
+     * allow chained calls like:
+     * <pre>
+     * int evaluatedCellType = evaluator.evaluateInCell(cell).getCellType();
+     * </pre>
+     * Be aware that your cell value will be changed to hold the
+     *  result of the formula. If you simply want the formula
+     *  value computed for you, use {@link #evaluateFormulaCellEnum(Cell)}}
+     */
+    @Override
+    public HSSFCell evaluateInCell(Cell cell) {
+        if (cell == null) {
+            return null;
+        }
+        HSSFCell result = (HSSFCell) cell;
+        if (cell.getCellTypeEnum() == CellType.FORMULA) {
+            CellValue cv = evaluateFormulaCellValue(cell);
+            setCellValue(cell, cv);
+            setCellType(cell, cv); // cell will no longer be a formula cell
+        }
+        return result;
+    }
+    private static void setCellType(Cell cell, CellValue cv) {
+        CellType cellType = cv.getCellType();
+        switch (cellType) {
+            case BOOLEAN:
+            case ERROR:
+            case NUMERIC:
+            case STRING:
+                cell.setCellType(cellType);
+                return;
+            case BLANK:
+                // never happens - blanks eventually get translated to zero
+            case FORMULA:
+                // this will never happen, we have already evaluated the formula
+            default:
+                throw new IllegalStateException("Unexpected cell value type (" + cellType
+ ")");
+        }
+    }
 
-	/**
-	 * If cell contains a formula, the formula is evaluated and returned,
-	 * else the CellValue simply copies the appropriate cell value from
-	 * the cell and also its cell type. This method should be preferred over
-	 * evaluateInCell() when the call should not modify the contents of the
-	 * original cell.
-	 *
-	 * @param cell may be <code>null</code> signifying that the cell is not present
(or blank)
-	 * @return <code>null</code> if the supplied cell is <code>null</code>
or blank
-	 */
-	@Override
-	public CellValue evaluate(Cell cell) {
-		if (cell == null) {
-			return null;
-		}
-
-		switch (cell.getCellTypeEnum()) {
-			case BOOLEAN:
-				return CellValue.valueOf(cell.getBooleanCellValue());
-			case ERROR:
-				return CellValue.getError(cell.getErrorCellValue());
-			case FORMULA:
-				return evaluateFormulaCellValue(cell);
-			case NUMERIC:
-				return new CellValue(cell.getNumericCellValue());
-			case STRING:
-				return new CellValue(cell.getRichStringCellValue().getString());
-			case BLANK:
-				return null;
-			default:
-				throw new IllegalStateException("Bad cell type (" + cell.getCellTypeEnum() + ")");
-		}
-		
-	}
-
-
-	/**
-	 * If cell contains formula, it evaluates the formula, and saves the result of the formula.
The
-	 * cell remains as a formula cell. If the cell does not contain formula, this method returns
-1
-	 * and leaves the cell unchanged.
-	 *
-	 * Note that the type of the <em>formula result</em> is returned, so you know
what kind of
-	 * cached formula result is also stored with  the formula.
-	 * <pre>
-	 * int evaluatedCellType = evaluator.evaluateFormulaCell(cell);
-	 * </pre>
-	 * Be aware that your cell will hold both the formula, and the result. If you want the cell
-	 * replaced with the result of the formula, use {@link #evaluateInCell(org.apache.poi.ss.usermodel.Cell)}
-	 * @param cell The cell to evaluate
-	 * @return -1 for non-formula cells, or the type of the <em>formula result</em>
-	 */
-	@Override
-	public int evaluateFormulaCell(Cell cell) {
-		return evaluateFormulaCellEnum(cell).getCode();
-	}
-	
-	/**
-	 * If cell contains formula, it evaluates the formula, and saves the result of the formula.
The
-	 * cell remains as a formula cell. If the cell does not contain formula, rather than throwing
an
-	 * exception, this method returns {@link CellType#_NONE} and leaves the cell unchanged.
-	 *
-	 * Note that the type of the <em>formula result</em> is returned, so you know
what kind of
-	 * cached formula result is also stored with  the formula.
-	 * <pre>
-	 * CellType evaluatedCellType = evaluator.evaluateFormulaCell(cell);
-	 * </pre>
-	 * Be aware that your cell will hold both the formula, and the result. If you want the cell
-	 * replaced with the result of the formula, use {@link #evaluateInCell(org.apache.poi.ss.usermodel.Cell)}
-	 * @param cell The cell to evaluate
-	 * @return {@link CellType#_NONE} for non-formula cells, or the type of the <em>formula
result</em>
-	 * @since POI 3.15 beta 3
-	 * @deprecated POI 3.15 beta 3. Will be deleted when we make the CellType enum transition.
See bug 59791.
-	 */
-	@Internal
-	@Override
-	public CellType evaluateFormulaCellEnum(Cell cell) {
-		if (cell == null || cell.getCellTypeEnum() != CellType.FORMULA) {
-			return CellType._NONE;
-		}
-		CellValue cv = evaluateFormulaCellValue(cell);
-		// cell remains a formula cell, but the cached value is changed
-		setCellValue(cell, cv);
-		return cv.getCellType();
-	}
-
-	/**
-	 * If cell contains formula, it evaluates the formula, and
-	 *  puts the formula result back into the cell, in place
-	 *  of the old formula.
-	 * Else if cell does not contain formula, this method leaves
-	 *  the cell unchanged.
-	 * Note that the same instance of HSSFCell is returned to
-	 * allow chained calls like:
-	 * <pre>
-	 * int evaluatedCellType = evaluator.evaluateInCell(cell).getCellType();
-	 * </pre>
-	 * Be aware that your cell value will be changed to hold the
-	 *  result of the formula. If you simply want the formula
-	 *  value computed for you, use {@link #evaluateFormulaCellEnum(Cell)}}
-	 */
-	@Override
-	public HSSFCell evaluateInCell(Cell cell) {
-		if (cell == null) {
-			return null;
-		}
-		HSSFCell result = (HSSFCell) cell;
-		if (cell.getCellTypeEnum() == CellType.FORMULA) {
-			CellValue cv = evaluateFormulaCellValue(cell);
-			setCellValue(cell, cv);
-			setCellType(cell, cv); // cell will no longer be a formula cell
-		}
-		return result;
-	}
-	private static void setCellType(Cell cell, CellValue cv) {
-		CellType cellType = cv.getCellType();
-		switch (cellType) {
-			case BOOLEAN:
-			case ERROR:
-			case NUMERIC:
-			case STRING:
-				cell.setCellType(cellType);
-				return;
-			case BLANK:
-				// never happens - blanks eventually get translated to zero
-			case FORMULA:
-				// this will never happen, we have already evaluated the formula
-			default:
-				throw new IllegalStateException("Unexpected cell value type (" + cellType + ")");
-		}
-		
-	}
-
-	private static void setCellValue(Cell cell, CellValue cv) {
-		CellType cellType = cv.getCellType();
-		switch (cellType) {
-			case BOOLEAN:
-				cell.setCellValue(cv.getBooleanValue());
-				break;
-			case ERROR:
-				cell.setCellErrorValue(cv.getErrorValue());
-				break;
-			case NUMERIC:
-				cell.setCellValue(cv.getNumberValue());
-				break;
-			case STRING:
-				cell.setCellValue(new HSSFRichTextString(cv.getStringValue()));
-				break;
-			case BLANK:
-				// never happens - blanks eventually get translated to zero
-			case FORMULA:
-				// this will never happen, we have already evaluated the formula
-			default:
-				throw new IllegalStateException("Unexpected cell value type (" + cellType + ")");
-		}
-	}
-
-	/**
-	 * Loops over all cells in all sheets of the supplied
-	 *  workbook.
-	 * For cells that contain formulas, their formulas are
-	 *  evaluated, and the results are saved. These cells
-	 *  remain as formula cells.
-	 * For cells that do not contain formulas, no changes
-	 *  are made.
-	 * This is a helpful wrapper around looping over all
-	 *  cells, and calling evaluateFormulaCell on each one.
-	 */
-	public static void evaluateAllFormulaCells(HSSFWorkbook wb) {
-	   evaluateAllFormulaCells(wb, new HSSFFormulaEvaluator(wb));
-	}
-	
-   /**
-    * Loops over all cells in all sheets of the supplied
-    *  workbook.
-    * For cells that contain formulas, their formulas are
-    *  evaluated, and the results are saved. These cells
-    *  remain as formula cells.
-    * For cells that do not contain formulas, no changes
-    *  are made.
-    * This is a helpful wrapper around looping over all
-    *  cells, and calling evaluateFormulaCell on each one.
-    */
-	public static void evaluateAllFormulaCells(Workbook wb) {
-      FormulaEvaluator evaluator = wb.getCreationHelper().createFormulaEvaluator();
-      evaluateAllFormulaCells(wb, evaluator);
-	}
-	private static void evaluateAllFormulaCells(Workbook wb, FormulaEvaluator evaluator) {
-      for(int i=0; i<wb.getNumberOfSheets(); i++) {
-         Sheet sheet = wb.getSheetAt(i);
-
-         for(Row r : sheet) {
-            for (Cell c : r) {
-               if (c.getCellTypeEnum() == CellType.FORMULA) {
-                  evaluator.evaluateFormulaCellEnum(c);
-               }
+    private static void setCellValue(Cell cell, CellValue cv) {
+        CellType cellType = cv.getCellType();
+        switch (cellType) {
+            case BOOLEAN:
+                cell.setCellValue(cv.getBooleanValue());
+                break;
+            case ERROR:
+                cell.setCellErrorValue(cv.getErrorValue());
+                break;
+            case NUMERIC:
+                cell.setCellValue(cv.getNumberValue());
+                break;
+            case STRING:
+                cell.setCellValue(new HSSFRichTextString(cv.getStringValue()));
+                break;
+            case BLANK:
+                // never happens - blanks eventually get translated to zero
+            case FORMULA:
+                // this will never happen, we have already evaluated the formula
+            default:
+                throw new IllegalStateException("Unexpected cell value type (" + cellType
+ ")");
+        }
+    }
+
+    /**
+     * Loops over all cells in all sheets of the supplied
+     *  workbook.
+     * For cells that contain formulas, their formulas are
+     *  evaluated, and the results are saved. These cells
+     *  remain as formula cells.
+     * For cells that do not contain formulas, no changes
+     *  are made.
+     * This is a helpful wrapper around looping over all
+     *  cells, and calling evaluateFormulaCell on each one.
+     */
+    public static void evaluateAllFormulaCells(HSSFWorkbook wb) {
+        evaluateAllFormulaCells(wb, new HSSFFormulaEvaluator(wb));
+    }
+
+    /**
+     * Loops over all cells in all sheets of the supplied
+     *  workbook.
+     * For cells that contain formulas, their formulas are
+     *  evaluated, and the results are saved. These cells
+     *  remain as formula cells.
+     * For cells that do not contain formulas, no changes
+     *  are made.
+     * This is a helpful wrapper around looping over all
+     *  cells, and calling evaluateFormulaCell on each one.
+     */
+    public static void evaluateAllFormulaCells(Workbook wb) {
+        FormulaEvaluator evaluator = wb.getCreationHelper().createFormulaEvaluator();
+        evaluateAllFormulaCells(wb, evaluator);
+    }
+    private static void evaluateAllFormulaCells(Workbook wb, FormulaEvaluator evaluator)
{
+        for(int i=0; i<wb.getNumberOfSheets(); i++) {
+            Sheet sheet = wb.getSheetAt(i);
+
+            for(Row r : sheet) {
+                for (Cell c : r) {
+                    if (c.getCellTypeEnum() == CellType.FORMULA) {
+                        evaluator.evaluateFormulaCellEnum(c);
+                    }
+                }
             }
-         }
-      }
-	}
-	
-   /**
-    * Loops over all cells in all sheets of the supplied
-    *  workbook.
-    * For cells that contain formulas, their formulas are
-    *  evaluated, and the results are saved. These cells
-    *  remain as formula cells.
-    * For cells that do not contain formulas, no changes
-    *  are made.
-    * This is a helpful wrapper around looping over all
-    *  cells, and calling evaluateFormulaCell on each one.
-    */
+        }
+    }
+
+    /**
+     * Loops over all cells in all sheets of the supplied
+     *  workbook.
+     * For cells that contain formulas, their formulas are
+     *  evaluated, and the results are saved. These cells
+     *  remain as formula cells.
+     * For cells that do not contain formulas, no changes
+     *  are made.
+     * This is a helpful wrapper around looping over all
+     *  cells, and calling evaluateFormulaCell on each one.
+     */
     @Override
     public void evaluateAll() {
         evaluateAllFormulaCells(_book, this);
@@ -383,24 +380,24 @@ public class HSSFFormulaEvaluator implem
      * @param cell
      */
     private CellValue evaluateFormulaCellValue(Cell cell) {
-		ValueEval eval = _bookEvaluator.evaluate(new HSSFEvaluationCell((HSSFCell)cell));
-		if (eval instanceof BoolEval) {
-			BoolEval be = (BoolEval) eval;
-			return CellValue.valueOf(be.getBooleanValue());
-		}
-		if (eval instanceof NumericValueEval) {
-			NumericValueEval ne = (NumericValueEval) eval;
-			return new CellValue(ne.getNumberValue());
-		}
-		if (eval instanceof StringValueEval) {
-			StringValueEval ne = (StringValueEval) eval;
-			return new CellValue(ne.getStringValue());
-		}
-		if (eval instanceof ErrorEval) {
-			return CellValue.getError(((ErrorEval)eval).getErrorCode());
-		}
-		throw new RuntimeException("Unexpected eval class (" + eval.getClass().getName() + ")");
-	}
+        ValueEval eval = _bookEvaluator.evaluate(new HSSFEvaluationCell((HSSFCell)cell));
+        if (eval instanceof BoolEval) {
+            BoolEval be = (BoolEval) eval;
+            return CellValue.valueOf(be.getBooleanValue());
+        }
+        if (eval instanceof NumericValueEval) {
+            NumericValueEval ne = (NumericValueEval) eval;
+            return new CellValue(ne.getNumberValue());
+        }
+        if (eval instanceof StringValueEval) {
+            StringValueEval ne = (StringValueEval) eval;
+            return new CellValue(ne.getStringValue());
+        }
+        if (eval instanceof ErrorEval) {
+            return CellValue.getError(((ErrorEval)eval).getErrorCode());
+        }
+        throw new RuntimeException("Unexpected eval class (" + eval.getClass().getName()
+ ")");
+    }
 
     /** {@inheritDoc} */
     @Override



---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@poi.apache.org
For additional commands, e-mail: commits-help@poi.apache.org


Mime
View raw message