* @param format The format.
*/
public CellDateFormatter(String format) {
+ this(LocaleUtil.getUserLocale(), format);
+ }
+
+ /**
+ * Creates a new date formatter with the given specification.
+ *
+ * @param locale The locale.
+ * @param format The format.
+ */
+ public CellDateFormatter(Locale locale, String format) {
super(format);
DatePartHandler partHandler = new DatePartHandler();
StringBuffer descBuf = CellFormatPart.parseFormat(format,
// tweak the format pattern to pass tests on JDK 1.7,
// See https://issues.apache.org/bugzilla/show_bug.cgi?id=53369
String ptrn = descBuf.toString().replaceAll("((y)(?!y))(?<!yy)", "yy");
- dateFmt = new SimpleDateFormat(ptrn, LocaleUtil.getUserLocale());
+ dateFmt = new SimpleDateFormat(ptrn, locale);
dateFmt.setTimeZone(LocaleUtil.getUserTimeZone());
}
Formatter formatter = new Formatter(toAppendTo, Locale.ROOT);
try {
long msecs = dateObj.getTime() % 1000;
- formatter.format(LocaleUtil.getUserLocale(), sFmt, msecs / 1000.0);
+ formatter.format(locale, sFmt, msecs / 1000.0);
} finally {
formatter.close();
}
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
+import java.util.Locale;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.logging.Level;
import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.util.DateFormatConverter;
+import org.apache.poi.util.LocaleUtil;
/**
* Format a value according to the standard Excel behavior. This "standard" is
* native character numbers, as documented at https://help.libreoffice.org/Common/Number_Format_Codes
*/
public class CellFormat {
+ private final Locale locale;
private final String format;
private final CellFormatPart posNumFmt;
private final CellFormatPart zeroNumFmt;
CellFormatPart.FORMAT_PAT.pattern() + "(;|$)",
Pattern.COMMENTS | Pattern.CASE_INSENSITIVE);
- private static final CellFormatPart DEFAULT_TEXT_FORMAT =
- new CellFormatPart("@");
-
/*
* Cells that cannot be formatted, e.g. cells that have a date or time
* format and have an invalid date or time value, are displayed as 255
/**
* Format a value as it would be were no format specified. This is also
* used when the format specified is <tt>General</tt>.
+ * @deprecated use {@link #getInstance(Locale, "General")} instead
*/
- public static final CellFormat GENERAL_FORMAT = new CellFormat("General") {
- @Override
- public CellFormatResult apply(Object value) {
- String text = (new CellGeneralFormatter()).format(value);
- return new CellFormatResult(true, text, null);
- }
- };
+ public static final CellFormat GENERAL_FORMAT = createGeneralFormat(LocaleUtil.getUserLocale());
+
+ private static CellFormat createGeneralFormat(final Locale locale) {
+ return new CellFormat(locale, "General") {
+ @Override
+ public CellFormatResult apply(Object value) {
+ String text = (new CellGeneralFormatter(locale)).format(value);
+ return new CellFormatResult(true, text, null);
+ }
+ };
+ }
/** Maps a format string to its parsed version for efficiencies sake. */
- private static final Map<String, CellFormat> formatCache =
- new WeakHashMap<String, CellFormat>();
+ private static final Map<Locale, Map<String, CellFormat>> formatCache =
+ new WeakHashMap<Locale, Map<String, CellFormat>>();
/**
* Returns a {@link CellFormat} that applies the given format. Two calls
* @return A {@link CellFormat} that applies the given format.
*/
public static CellFormat getInstance(String format) {
- CellFormat fmt = formatCache.get(format);
+ return getInstance(LocaleUtil.getUserLocale(), format);
+ }
+
+ /**
+ * Returns a {@link CellFormat} that applies the given format. Two calls
+ * with the same format may or may not return the same object.
+ *
+ * @param locale The locale.
+ * @param format The format.
+ *
+ * @return A {@link CellFormat} that applies the given format.
+ */
+ public static synchronized CellFormat getInstance(Locale locale, String format) {
+ Map<String, CellFormat> formatMap = formatCache.get(locale);
+ if (formatMap == null) {
+ formatMap = new WeakHashMap<String, CellFormat>();
+ formatCache.put(locale, formatMap);
+ }
+ CellFormat fmt = formatMap.get(format);
if (fmt == null) {
if (format.equals("General") || format.equals("@"))
- fmt = GENERAL_FORMAT;
+ fmt = createGeneralFormat(locale);
else
- fmt = new CellFormat(format);
- formatCache.put(format, fmt);
+ fmt = new CellFormat(locale, format);
+ formatMap.put(format, fmt);
}
return fmt;
}
*
* @param format The format.
*/
- private CellFormat(String format) {
+ private CellFormat(Locale locale, String format) {
+ this.locale = locale;
this.format = format;
+ CellFormatPart defaultTextFormat = new CellFormatPart(locale, "@");
Matcher m = ONE_PART.matcher(format);
List<CellFormatPart> parts = new ArrayList<CellFormatPart>();
if (valueDesc.endsWith(";"))
valueDesc = valueDesc.substring(0, valueDesc.length() - 1);
- parts.add(new CellFormatPart(valueDesc));
+ parts.add(new CellFormatPart(locale, valueDesc));
} catch (RuntimeException e) {
CellFormatter.logger.log(Level.WARNING,
"Invalid format: " + CellFormatter.quote(m.group()), e);
posNumFmt = parts.get(0);
negNumFmt = null;
zeroNumFmt = null;
- textFmt = DEFAULT_TEXT_FORMAT;
+ textFmt = defaultTextFormat;
break;
case 2:
posNumFmt = parts.get(0);
negNumFmt = parts.get(1);
zeroNumFmt = null;
- textFmt = DEFAULT_TEXT_FORMAT;
+ textFmt = defaultTextFormat;
break;
case 3:
posNumFmt = parts.get(0);
negNumFmt = parts.get(1);
zeroNumFmt = parts.get(2);
- textFmt = DEFAULT_TEXT_FORMAT;
+ textFmt = defaultTextFormat;
break;
case 4:
default:
|| (posNumFmt.hasCondition() && posNumFmt.applies(val))) {
return posNumFmt;
} else {
- return new CellFormatPart("General");
+ return new CellFormatPart(locale, "General");
}
} else if (formatPartCount == 2) {
if ((!posNumFmt.hasCondition() && val >= 0)
package org.apache.poi.ss.format;
import org.apache.poi.hssf.util.HSSFColor;
+import org.apache.poi.util.LocaleUtil;
import javax.swing.*;
* @param desc The string to parse.
*/
public CellFormatPart(String desc) {
+ this(LocaleUtil.getUserLocale(), desc);
+ }
+
+ /**
+ * Create an object to represent a format part.
+ *
+ * @param locale The locale to use.
+ * @param desc The string to parse.
+ */
+ public CellFormatPart(Locale locale, String desc) {
Matcher m = FORMAT_PAT.matcher(desc);
if (!m.matches()) {
throw new IllegalArgumentException("Unrecognized format: " + quote(
color = getColor(m);
condition = getCondition(m);
type = getCellFormatType(m);
- format = getFormatter(m);
+ format = getFormatter(locale, m);
}
/**
*
* @return The formatter.
*/
- private CellFormatter getFormatter(Matcher matcher) {
+ private CellFormatter getFormatter(Locale locale, Matcher matcher) {
String fdesc = matcher.group(SPECIFICATION_GROUP);
// For now, we don't support localised currencies, so simplify if there
}
// Build a formatter for this simplified string
- return type.formatter(fdesc);
+ return type.formatter(locale, fdesc);
}
/**
package org.apache.poi.ss.format;
+import java.util.Locale;
+
/**
* The different kinds of formats that the formatter understands.
*
/** The general (default) format; also used for <tt>"General"</tt>. */
GENERAL {
+ boolean isSpecial(char ch) {
+ return false;
+ }
CellFormatter formatter(String pattern) {
return new CellGeneralFormatter();
}
- boolean isSpecial(char ch) {
- return false;
+ CellFormatter formatter(Locale locale, String pattern) {
+ return new CellGeneralFormatter(locale);
}
},
/** A numeric format. */
CellFormatter formatter(String pattern) {
return new CellNumberFormatter(pattern);
}
+ CellFormatter formatter(Locale locale, String pattern) {
+ return new CellNumberFormatter(locale, pattern);
+ }
},
/** A date format. */
DATE {
CellFormatter formatter(String pattern) {
return new CellDateFormatter(pattern);
}
+ CellFormatter formatter(Locale locale, String pattern) {
+ return new CellDateFormatter(locale, pattern);
+ }
},
/** An elapsed time format. */
ELAPSED {
CellFormatter formatter(String pattern) {
return new CellElapsedFormatter(pattern);
}
+ CellFormatter formatter(Locale locale, String pattern) {
+ return new CellElapsedFormatter(pattern);
+ }
},
/** A text format. */
TEXT {
CellFormatter formatter(String pattern) {
return new CellTextFormatter(pattern);
}
+ CellFormatter formatter(Locale locale, String pattern) {
+ return new CellTextFormatter(pattern);
+ }
};
/**
* @return A new formatter of the appropriate type, for the given pattern.
*/
abstract CellFormatter formatter(String pattern);
+
+ /**
+ * Returns a new formatter of the appropriate type, for the given pattern.
+ * The pattern must be appropriate for the type.
+ *
+ * @param locale The locale to use.
+ * @param pattern The pattern to use.
+ *
+ * @return A new formatter of the appropriate type, for the given pattern.
+ */
+ abstract CellFormatter formatter(Locale locale, String pattern);
}
==================================================================== */
package org.apache.poi.ss.format;
+import java.util.Locale;
import java.util.logging.Logger;
+import org.apache.poi.util.LocaleUtil;
+
/**
* This is the abstract supertype for the various cell formatters.
*
public abstract class CellFormatter {
/** The original specified format. */
protected final String format;
+ protected final Locale locale;
/**
* Creates a new formatter object, storing the format in {@link #format}.
* @param format The format.
*/
public CellFormatter(String format) {
+ this(LocaleUtil.getUserLocale(), format);
+ }
+
+ /**
+ * Creates a new formatter object, storing the format in {@link #format}.
+ *
+ * @param locale The locale.
+ * @param format The format.
+ */
+ public CellFormatter(Locale locale, String format) {
+ this.locale = locale;
this.format = format;
}
public class CellGeneralFormatter extends CellFormatter {
/** Creates a new general formatter. */
public CellGeneralFormatter() {
- super("General");
+ this(LocaleUtil.getUserLocale());
+ }
+ /** Creates a new general formatter. */
+ public CellGeneralFormatter(Locale locale) {
+ super(locale, "General");
}
/**
stripZeros = false;
}
- Formatter formatter = new Formatter(toAppendTo, LocaleUtil.getUserLocale());
+ Formatter formatter = new Formatter(toAppendTo, locale);
try {
- formatter.format(LocaleUtil.getUserLocale(), fmt, value);
+ formatter.format(locale, fmt, value);
} finally {
formatter.close();
}
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
+import java.util.Locale;
import java.util.Set;
import java.util.TreeSet;
private final Special numerator;
private final Special afterInteger;
private final Special afterFractional;
- private final boolean integerCommas;
+ private final boolean showGroupingSeparator;
private final List<Special> specials = new ArrayList<Special>();
private final List<Special> integerSpecials = new ArrayList<Special>();
private final List<Special> fractionalSpecials = new ArrayList<Special>();
// ("#" for integer values, and "#.#" for floating-point values) is
// different from the 'General' format for numbers ("#" for integer
// values and "#.#########" for floating-point values).
- private static final CellFormatter SIMPLE_NUMBER = new GeneralNumberFormatter();
- private static final CellFormatter SIMPLE_INT = new CellNumberFormatter("#");
- private static final CellFormatter SIMPLE_FLOAT = new CellNumberFormatter("#.#");
+ private final CellFormatter SIMPLE_NUMBER = new GeneralNumberFormatter(locale);
private static class GeneralNumberFormatter extends CellFormatter {
- private GeneralNumberFormatter() {
- super("General");
+ private GeneralNumberFormatter(Locale locale) {
+ super(locale, "General");
}
public void formatValue(StringBuffer toAppendTo, Object value) {
CellFormatter cf;
if (value instanceof Number) {
Number num = (Number) value;
- cf = (num.doubleValue() % 1.0 == 0) ? SIMPLE_INT : SIMPLE_FLOAT;
+ cf = (num.doubleValue() % 1.0 == 0) ? new CellNumberFormatter(locale, "#") :
+ new CellNumberFormatter(locale, "#.#");
} else {
cf = CellTextFormatter.SIMPLE_TEXT;
}
* @param format The format to parse.
*/
public CellNumberFormatter(String format) {
- super(format);
+ this(LocaleUtil.getUserLocale(), format);
+ }
+
+ /**
+ * Creates a new cell number formatter.
+ *
+ * @param locale The locale to use.
+ * @param format The format to parse.
+ */
+ public CellNumberFormatter(Locale locale, String format) {
+ super(locale, format);
CellNumberPartHandler ph = new CellNumberPartHandler();
StringBuffer descBuf = CellFormatPart.parseFormat(format, CellFormatType.NUMBER, ph);
}
double scaleByRef[] = { ph.getScale() };
- integerCommas = interpretIntegerCommas(descBuf, specials, decimalPoint, integerEnd(), fractionalEnd(), scaleByRef);
+ showGroupingSeparator = interpretIntegerCommas(descBuf, specials, decimalPoint, integerEnd(), fractionalEnd(), scaleByRef);
if (exponent == null) {
scale = scaleByRef[0];
} else {
}
fmtBuf.append('E');
placeZeros(fmtBuf, exponentSpecials.subList(2, exponentSpecials.size()));
- DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(LocaleUtil.getUserLocale());
- decimalFmt = new DecimalFormat(fmtBuf.toString(), dfs);
+ decimalFmt = new DecimalFormat(fmtBuf.toString(), getDecimalFormatSymbols());
printfFmt = null;
}
desc = descBuf.toString();
}
+ private DecimalFormatSymbols getDecimalFormatSymbols() {
+ return DecimalFormatSymbols.getInstance(locale);
+ }
+
private static void placeZeros(StringBuffer sb, List<Special> specials) {
for (Special s : specials) {
if (isDigitFmt(s)) {
}
Set<CellNumberStringMod> mods = new TreeSet<CellNumberStringMod>();
- StringBuffer output = new StringBuffer(desc);
+ StringBuffer output = new StringBuffer(localiseFormat(desc));
if (exponent != null) {
writeScientific(value, output, mods);
writeFraction(value, null, fractional, output, mods);
} else {
StringBuffer result = new StringBuffer();
- Formatter f = new Formatter(result, LocaleUtil.getUserLocale());
+ Formatter f = new Formatter(result, locale);
try {
- f.format(LocaleUtil.getUserLocale(), printfFmt, value);
+ f.format(locale, printfFmt, value);
} finally {
f.close();
}
if (numerator == null) {
writeFractional(result, output);
- writeInteger(result, output, integerSpecials, mods, integerCommas);
+ writeInteger(result, output, integerSpecials, mods, showGroupingSeparator);
} else {
writeFraction(value, result, fractional, output, mods);
}
}
+ DecimalFormatSymbols dfs = getDecimalFormatSymbols();
+ String groupingSeparator = Character.toString(dfs.getGroupingSeparator());
+
// Now strip out any remaining '#'s and add any pending text ...
Iterator<CellNumberStringMod> changes = mods.iterator();
CellNumberStringMod nextChange = (changes.hasNext() ? changes.next() : null);
switch (nextChange.getOp()) {
case CellNumberStringMod.AFTER:
// ignore adding a comma after a deleted char (which was a '#')
- if (nextChange.getToAdd().equals(",") && deletedChars.get(s.pos)) {
+ if (nextChange.getToAdd().equals(groupingSeparator) && deletedChars.get(s.pos)) {
break;
}
output.insert(modPos + 1, nextChange.getToAdd());
StringBuffer result = new StringBuffer();
FieldPosition fractionPos = new FieldPosition(DecimalFormat.FRACTION_FIELD);
decimalFmt.format(value, result, fractionPos);
- writeInteger(result, output, integerSpecials, mods, integerCommas);
+ writeInteger(result, output, integerSpecials, mods, showGroupingSeparator);
writeFractional(result, output);
/*
LOG.log(POILogger.ERROR, "error while fraction evaluation", ignored);
}
}
+
+ private String localiseFormat(String format) {
+ DecimalFormatSymbols dfs = getDecimalFormatSymbols();
+ if(format.contains(",") && dfs.getGroupingSeparator() != ',') {
+ if(format.contains(".") && dfs.getDecimalSeparator() != '.') {
+ format = replaceLast(format, "\\.", "[DECIMAL_SEPARATOR]");
+ format = format.replace(',', dfs.getGroupingSeparator())
+ .replace("[DECIMAL_SEPARATOR]", Character.toString(dfs.getDecimalSeparator()));
+ } else {
+ format = format.replace(',', dfs.getGroupingSeparator());
+ }
+ } else if(format.contains(".") && dfs.getDecimalSeparator() != '.') {
+ format = format.replace('.', dfs.getDecimalSeparator());
+ }
+ return format;
+ }
+
+
+ private static String replaceLast(String text, String regex, String replacement) {
+ return text.replaceFirst("(?s)(.*)" + regex, "$1" + replacement);
+ }
private static boolean hasChar(char ch, List<Special>... numSpecials) {
for (List<Special> specials : numSpecials) {
private void writeSingleInteger(String fmt, int num, StringBuffer output, List<Special> numSpecials, Set<CellNumberStringMod> mods) {
StringBuffer sb = new StringBuffer();
- Formatter formatter = new Formatter(sb, LocaleUtil.getUserLocale());
+ Formatter formatter = new Formatter(sb, locale);
try {
- formatter.format(LocaleUtil.getUserLocale(), fmt, num);
+ formatter.format(locale, fmt, num);
} finally {
formatter.close();
}
private void writeInteger(StringBuffer result, StringBuffer output,
List<Special> numSpecials, Set<CellNumberStringMod> mods,
- boolean showCommas) {
+ boolean showGroupingSeparator) {
+
+ DecimalFormatSymbols dfs = getDecimalFormatSymbols();
+ String decimalSeparator = Character.toString(dfs.getDecimalSeparator());
+ String groupingSeparator = Character.toString(dfs.getGroupingSeparator());
- int pos = result.indexOf(".") - 1;
+ int pos = result.indexOf(decimalSeparator) - 1;
if (pos < 0) {
if (exponent != null && numSpecials == integerSpecials) {
pos = result.indexOf("E") - 1;
int strip;
for (strip = 0; strip < pos; strip++) {
char resultCh = result.charAt(strip);
- if (resultCh != '0' && resultCh != ',') {
+ if (resultCh != '0' && resultCh != dfs.getGroupingSeparator()) {
break;
}
}
ListIterator<Special> it = numSpecials.listIterator(numSpecials.size());
- boolean followWithComma = false;
+ boolean followWithGroupingSeparator = false;
Special lastOutputIntegerDigit = null;
int digit = 0;
while (it.hasPrevious()) {
resultCh = '0';
}
Special s = it.previous();
- followWithComma = showCommas && digit > 0 && digit % 3 == 0;
+ followWithGroupingSeparator = showGroupingSeparator && digit > 0 && digit % 3 == 0;
boolean zeroStrip = false;
if (resultCh != '0' || s.ch == '0' || s.ch == '?' || pos >= strip) {
zeroStrip = s.ch == '?' && pos < strip;
output.setCharAt(s.pos, (zeroStrip ? ' ' : resultCh));
lastOutputIntegerDigit = s;
}
- if (followWithComma) {
- mods.add(insertMod(s, zeroStrip ? " " : ",", CellNumberStringMod.AFTER));
- followWithComma = false;
+ if (followWithGroupingSeparator) {
+ mods.add(insertMod(s, zeroStrip ? " " : groupingSeparator, CellNumberStringMod.AFTER));
+ followWithGroupingSeparator = false;
}
digit++;
--pos;
// pos was decremented at the end of the loop above when the iterator was at its end
++pos;
extraLeadingDigits = new StringBuffer(result.substring(0, pos));
- if (showCommas) {
+ if (showGroupingSeparator) {
while (pos > 0) {
if (digit > 0 && digit % 3 == 0) {
- extraLeadingDigits.insert(pos, ',');
+ extraLeadingDigits.insert(pos, groupingSeparator);
}
digit++;
--pos;
int digit;
int strip;
if (fractionalSpecials.size() > 0) {
- digit = result.indexOf(".") + 1;
+ String decimalSeparator = Character.toString(getDecimalFormatSymbols().getDecimalSeparator());
+ digit = result.indexOf(decimalSeparator) + 1;
if (exponent != null) {
strip = result.indexOf("e") - 1;
} else {
* @param cell The cell to retrieve a Format for
* @return A Format for the format String
*/
- private Format getFormat(Cell cell) {
- return getFormat(cell, null);
- }
-
private Format getFormat(Cell cell, ConditionalFormattingEvaluator cfEvaluator) {
if (cell == null) return null;
private Format getFormat(double cellValue, int formatIndex, String formatStrIn) {
localeChangedObservable.checkForLocaleChange();
-
-// // Might be better to separate out the n p and z formats, falling back to p when n and z are not set.
-// // That however would require other code to be re factored.
-// String[] formatBits = formatStrIn.split(";");
-// int i = cellValue > 0.0 ? 0 : cellValue < 0.0 ? 1 : 2;
-// String formatStr = (i < formatBits.length) ? formatBits[i] : formatBits[0];
+
+ // Might be better to separate out the n p and z formats, falling back to p when n and z are not set.
+ // That however would require other code to be re factored.
+ // String[] formatBits = formatStrIn.split(";");
+ // int i = cellValue > 0.0 ? 0 : cellValue < 0.0 ? 1 : 2;
+ // String formatStr = (i < formatBits.length) ? formatBits[i] : formatBits[0];
String formatStr = formatStrIn;
) ) {
try {
// Ask CellFormat to get a formatter for it
- CellFormat cfmt = CellFormat.getInstance(formatStr);
+ CellFormat cfmt = CellFormat.getInstance(locale, formatStr);
// CellFormat requires callers to identify date vs not, so do so
Object cellValueO = Double.valueOf(cellValue);
if (DateUtil.isADateFormat(formatIndex, formatStr) &&
try {
return new ExcelStyleDateFormatter(formatStr, dateSymbols);
} catch(IllegalArgumentException iae) {
-
+ logger.log(POILogger.DEBUG, "Formatting failed for format " + formatStr + ", falling back", iae);
// the pattern could not be parsed correctly,
// so fall back to the default number format
return getDefaultFormat(cellValue);
setExcelStyleRoundingMode(df);
return df;
} catch(IllegalArgumentException iae) {
-
+ logger.log(POILogger.DEBUG, "Formatting failed for format " + formatStr + ", falling back", iae);
// the pattern could not be parsed correctly,
// so fall back to the default number format
return getDefaultFormat(cellValue);
CellReference ref = new CellReference("D47");
Cell cell = wb.getSheetAt(0).getRow(ref.getRow()).getCell(ref.getCol());
- //noinspection deprecation
assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("G9:K9 I7:I12", cell.getCellFormula());
≈ */
@Test
public void testBug60422() {
- //when this is set to Locale.Germany, the result is
- LocaleUtil.setUserLocale(Locale.ROOT);
- try {
- char euro = '\u20AC';
- DataFormatter df = new DataFormatter(Locale.GERMANY);
- String formatString = String.format(Locale.ROOT,
- "_-* #,##0.00\\ \"%s\"_-;\\-* #,##0.00\\ \"%s\"_-;_-* \"-\"??\\ \"%s\"_-;_-@_-",
- euro, euro, euro);
- //this should be 4,33
- assertEquals("4.33 " + euro, df.formatRawCellContents(4.33, 178, formatString));
- } finally {
- LocaleUtil.resetUserLocale();
- }
+ char euro = '\u20AC';
+ DataFormatter df = new DataFormatter(Locale.GERMANY);
+ String formatString = String.format(Locale.ROOT,
+ "_-* #,##0.00\\ \"%s\"_-;\\-* #,##0.00\\ \"%s\"_-;_-* \"-\"??\\ \"%s\"_-;_-@_-",
+ euro, euro, euro);
+ assertEquals("4,33 " + euro, df.formatRawCellContents(4.33, 178, formatString));
+ assertEquals("1.234,33 " + euro, df.formatRawCellContents(1234.33, 178, formatString));
}
}
projects / poi.git / commitdiff