final List<Arguments> result = new ArrayList<>(100);
for (String file : scanner.getIncludedFiles()) {
- // if (!file.contains("44958.xls")) continue;
for (FileHandlerKnown handler : sm.getHandler(file)) {
ExcInfo info1 = sm.getExcInfo(file, testName, handler);
if (info1 == null || info1.isValid(testName, handler.name())) {
private DirectoryNode directory;
/** For our own logging use */
- private static final POILogger logger = POILogFactory.getLogger(POIDocument.class);
+ private static final POILogger LOG = POILogFactory.getLogger(POIDocument.class);
/* Have the property streams been read yet? (Only done on-demand) */
private boolean initialized;
if (clazz.isInstance(ps)) {
return (T)ps;
} else if (ps != null) {
- logger.log(POILogger.WARN, localName+" property set came back with wrong class - "+ps.getClass().getName());
+ LOG.log(POILogger.WARN, localName+" property set came back with wrong class - "+ps.getClass().getName());
} else {
- logger.log(POILogger.WARN, localName+" property set came back as null");
+ LOG.log(POILogger.WARN, localName+" property set came back as null");
}
} catch (IOException e) {
- logger.log(POILogger.ERROR, "can't retrieve property set", e);
+ LOG.log(POILogger.ERROR, "can't retrieve property set", e);
}
return null;
}
// Create or Update the Property Set stream in the POIFS
outFS.createOrUpdateDocument(bIn, name);
- logger.log(POILogger.INFO, "Wrote property set ", name, " of size ", data.length);
+ LOG.log(POILogger.INFO, "Wrote property set ", name, " of size ", data.length);
} catch(WritingNotSupportedException ignored) {
- logger.log( POILogger.ERROR, "Couldn't write property set with name ", name, " as not supported by HPSF yet");
+ LOG.log( POILogger.ERROR, "Couldn't write property set with name ", name, " as not supported by HPSF yet");
}
}
public class EscherPropertyMetaData
{
// Escher property types.
- public final static byte TYPE_UNKNOWN = (byte) 0;
- public final static byte TYPE_BOOLEAN = (byte) 1;
- public final static byte TYPE_RGB = (byte) 2;
- public final static byte TYPE_SHAPEPATH = (byte) 3;
- public final static byte TYPE_SIMPLE = (byte)4;
- public final static byte TYPE_ARRAY = (byte)5;
+ public static final byte TYPE_UNKNOWN = (byte) 0;
+ public static final byte TYPE_BOOLEAN = (byte) 1;
+ public static final byte TYPE_RGB = (byte) 2;
+ public static final byte TYPE_SHAPEPATH = (byte) 3;
+ public static final byte TYPE_SIMPLE = (byte)4;
+ public static final byte TYPE_ARRAY = (byte)5;
private String description;
private byte type;
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 100_000;
- private final static POILogger LOG = POILogFactory.getLogger( CodePageString.class );
+ private static final POILogger LOG = POILogFactory.getLogger( CodePageString.class );
private byte[] _value;
@Internal
public class VariantBool {
- private final static POILogger LOG = POILogFactory.getLogger( VariantBool.class );
+ private static final POILogger LOG = POILogFactory.getLogger( VariantBool.class );
static final int SIZE = 2;
Variant.VT_CF, Variant.VT_BOOL };
- private static final POILogger logger = POILogFactory.getLogger(VariantSupport.class);
+ private static final POILogger LOG = POILogFactory.getLogger(VariantSupport.class);
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 100_000;
Long vt = Long.valueOf(ex.getVariantType());
if (!unsupportedMessage.contains(vt))
{
- logger.log( POILogger.ERROR, ex.getMessage());
+ LOG.log( POILogger.ERROR, ex.getMessage());
unsupportedMessage.add(vt);
}
}
*/
public final class BiffViewer {
private static final char[] NEW_LINE_CHARS = System.getProperty("line.separator").toCharArray();
- private static final POILogger logger = POILogFactory.getLogger(BiffViewer.class);
+ private static final POILogger LOG = POILogFactory.getLogger(BiffViewer.class);
private BiffViewer() {
// no instances of this class
try {
hasNext = recStream.hasNextRecord();
} catch (LeftoverDataException e) {
- logger.log(POILogger.ERROR, "Discarding ", recStream.remaining(), " bytes and continuing", e);
+ LOG.log(POILogger.ERROR, "Discarding ", recStream.remaining(), " bytes and continuing", e);
recStream.readRemainder();
hasNext = recStream.hasNextRecord();
}
import org.apache.poi.hssf.record.FormatRecord;
import org.apache.poi.hssf.record.FormulaRecord;
import org.apache.poi.hssf.record.NumberRecord;
-import org.apache.poi.hssf.record.Record;
import org.apache.poi.hssf.usermodel.HSSFDataFormat;
import org.apache.poi.hssf.usermodel.HSSFDataFormatter;
import org.apache.poi.util.LocaleUtil;
* ids.
*/
public class FormatTrackingHSSFListener implements HSSFListener {
- private final static POILogger logger = POILogFactory.getLogger(FormatTrackingHSSFListener.class);
+ private static final POILogger LOG = POILogFactory.getLogger(FormatTrackingHSSFListener.class);
private final HSSFListener _childListener;
private final HSSFDataFormatter _formatter;
private final NumberFormat _defaultFormat;
/**
* Creates a format tracking wrapper around the given listener, using
* the {@link Locale#getDefault() default locale} for the formats.
- *
+ *
* @param childListener the listener to be wrapped
*/
public FormatTrackingHSSFListener(HSSFListener childListener) {
/**
* Creates a format tracking wrapper around the given listener, using
* the given locale for the formats.
- *
+ *
* @param childListener the listener to be wrapped
* @param locale the locale for the formats
*/
*
* TODO - move this to a central class in such a way that hssf.usermodel can
* make use of it too
- *
+ *
* @param cell the cell
- *
+ *
* @return the given numeric of date cells contents as a String
*/
public String formatNumberDateCell(CellValueRecordInterface cell) {
/**
* Returns the format string, eg $##.##, for the given number format index.
- *
+ *
* @param formatIndex the format index
- *
+ *
* @return the format string
*/
public String getFormatString(int formatIndex) {
if (formatIndex >= HSSFDataFormat.getNumberOfBuiltinBuiltinFormats()) {
FormatRecord tfr = _customFormatRecords.get(Integer.valueOf(formatIndex));
if (tfr == null) {
- logger.log( POILogger.ERROR, "Requested format at index ", formatIndex,
+ LOG.log( POILogger.ERROR, "Requested format at index ", formatIndex,
", but it wasn't found");
} else {
format = tfr.getFormatString();
/**
* Returns the format string, eg $##.##, used by your cell
- *
+ *
* @param cell the cell
- *
+ *
* @return the format string
*/
public String getFormatString(CellValueRecordInterface cell) {
/**
* Returns the index of the format string, used by your cell, or -1 if none found
- *
+ *
* @param cell the cell
- *
+ *
* @return the index of the format string
*/
public int getFormatIndex(CellValueRecordInterface cell) {
ExtendedFormatRecord xfr = _xfRecords.get(cell.getXFIndex());
if (xfr == null) {
- logger.log( POILogger.ERROR, "Cell ", cell.getRow(), ",", cell.getColumn(),
+ LOG.log( POILogger.ERROR, "Cell ", cell.getRow(), ",", cell.getColumn(),
" uses XF with index ", cell.getXFIndex(), ", but we don't have that");
return -1;
}
*/
public class OldExcelExtractor implements POITextExtractor {
- private final static int FILE_PASS_RECORD_SID = 0x2f;
+ private static final int FILE_PASS_RECORD_SID = 0x2f;
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 100_000;
*/
public final class ArrayRecord extends SharedValueRecordBase {
- public final static short sid = 0x0221;
+ public static final short sid = 0x0221;
private static final int OPT_ALWAYS_RECALCULATE = 0x0001;
private static final int OPT_CALCULATE_ON_OPEN = 0x0002;
template_params = IOUtils.safelyAllocate(template_param_length, MAX_RECORD_LENGTH);
in.readFully(template_params);
} else {
- logger.log(POILogger.WARN, "CF Rule v12 template params length should be 0 or 16, found " + template_param_length);
+ LOG.log(POILogger.WARN, "CF Rule v12 template params length should be 0 or 16, found " + template_param_length);
in.readRemainder();
}
public static final int TEMPLATE_ABOVE_OR_EQUAL_TO_AVERAGE = 0x001D;
public static final int TEMPLATE_BELOW_OR_EQUAL_TO_AVERAGE = 0x001E;
- protected static final POILogger logger = POILogFactory.getLogger(CFRuleBase.class);
+ protected static final POILogger LOG = POILogFactory.getLogger(CFRuleBase.class);
static final BitField modificationBits = bf(0x003FFFFF); // Bits: font,align,bord,patt,prot
static final BitField alignHor = bf(0x00000001); // 0 = Horizontal alignment modified
public final class DimensionsRecord extends StandardRecord {
- private static final POILogger logger = POILogFactory.getLogger(DimensionsRecord.class);
+ private static final POILogger LOG = POILogFactory.getLogger(DimensionsRecord.class);
public static final short sid = 0x200;
private int field_1_first_row;
field_5_zero = in.readShort();
//POI-61045 -- in practice, there can be an extra 2 bytes
if (in.available() == 2) {
- logger.log(POILogger.INFO, "DimensionsRecord has extra 2 bytes.");
+ LOG.log(POILogger.INFO, "DimensionsRecord has extra 2 bytes.");
in.readShort();
}
}
* stored in a separate entry within the OLE2 compound file.
*/
public final class EmbeddedObjectRefSubRecord extends SubRecord {
- private static POILogger logger = POILogFactory.getLogger(EmbeddedObjectRefSubRecord.class);
+ private static final POILogger LOG = POILogFactory.getLogger(EmbeddedObjectRefSubRecord.class);
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 100_000;
int nUnexpectedPadding = remaining - dataLenAfterFormula;
if (nUnexpectedPadding > 0) {
- logger.log( POILogger.ERROR, "Discarding ", nUnexpectedPadding, " unexpected padding bytes");
+ LOG.log( POILogger.ERROR, "Discarding ", nUnexpectedPadding, " unexpected padding bytes");
readRawData(in, nUnexpectedPadding);
remaining-=nUnexpectedPadding;
}
* up with a {@link FeatHdrRecord}.
*/
public final class FeatRecord extends StandardRecord {
- private static final POILogger logger = POILogFactory.getLogger(FeatRecord.class);
+ private static final POILogger LOG = POILogFactory.getLogger(FeatRecord.class);
public static final short sid = 0x0868;
// SIDs from newer versions
public static final short v11_sid = 0x0872;
sharedFeature = new FeatSmartTag(in);
break;
default:
- logger.log( POILogger.ERROR, "Unknown Shared Feature ", isf_sharedFeatureType, " found!");
+ LOG.log( POILogger.ERROR, "Unknown Shared Feature ", isf_sharedFeatureType, " found!");
}
}
*/
public final class FormatRecord extends StandardRecord {
- private static final POILogger logger = POILogFactory.getLogger(FormatRecord.class);
+ private static final POILogger LOG = POILogFactory.getLogger(FormatRecord.class);
public static final short sid = 0x041E;
}
if (ris.available() > 0) {
- logger.log(POILogger.INFO, "FormatRecord has ", ris.available(), " unexplained bytes. Silently skipping");
+ LOG.log(POILogger.INFO, "FormatRecord has ", ris.available(), " unexplained bytes. Silently skipping");
//swallow what's left
while (ris.available() > 0) {
ris.readByte();
*/
public final class HyperlinkRecord extends StandardRecord {
public static final short sid = 0x01B8;
- private static final POILogger logger = POILogFactory.getLogger(HyperlinkRecord.class);
+ private static final POILogger LOG = POILogFactory.getLogger(HyperlinkRecord.class);
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 100_000;
}
if (in.remaining() > 0) {
- logger.log(POILogger.WARN,
+ LOG.log(POILogger.WARN,
"Hyperlink data remains: " + in.remaining() +
" : " +HexDump.toHex(in.readRemainder())
);
* @see org.apache.poi.hssf.record.LabelSSTRecord
*/
public final class LabelRecord extends Record implements CellValueRecordInterface {
- private static final POILogger logger = POILogFactory.getLogger(LabelRecord.class);
+ private static final POILogger LOG = POILogFactory.getLogger(LabelRecord.class);
public static final short sid = 0x0204;
}
if (in.remaining() > 0) {
- logger.log(POILogger.INFO,
+ LOG.log(POILogger.INFO,
"LabelRecord data remains: ", in.remaining(),
" : ", HexDump.toHex(in.readRemainder())
);
* didn't use {@link LabelSSTRecord}
*/
public final class OldLabelRecord extends OldCellRecord {
- private static final POILogger logger = POILogFactory.getLogger(OldLabelRecord.class);
+ private static final POILogger LOG = POILogFactory.getLogger(OldLabelRecord.class);
//arbitrarily set, may need to increase
private static final int MAX_RECORD_LENGTH = 100_000;
in.read(field_5_bytes, 0, field_4_string_len);
if (in.remaining() > 0) {
- logger.log(POILogger.INFO,
+ LOG.log(POILogger.INFO,
"LabelRecord data remains: ", in.remaining(),
" : ", HexDump.toHex(in.readRemainder())
);
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
-
+
package org.apache.poi.hssf.record;
*/
class SSTDeserializer
{
- private static POILogger logger = POILogFactory.getLogger(SSTDeserializer.class);
+ private static final POILogger LOG = POILogFactory.getLogger(SSTDeserializer.class);
private IntMapper<UnicodeString> strings;
public SSTDeserializer( IntMapper<UnicodeString> strings )
// Extract exactly the count of strings from the SST record.
UnicodeString str;
if (in.available() == 0 && !in.hasNextRecord()) {
- logger.log(POILogger.ERROR, "Ran out of data before creating all the strings! String at index ", i);
+ LOG.log(POILogger.ERROR, "Ran out of data before creating all the strings! String at index ", i);
str = new UnicodeString("");
} else {
str = new UnicodeString(in);
*/
public final class SupBookRecord extends StandardRecord {
- private static final POILogger logger = POILogFactory.getLogger(SupBookRecord.class);
+ private static final POILogger LOG = POILogFactory.getLogger(SupBookRecord.class);
public static final short sid = 0x01AE;
break;
case CH_LONG_VOLUME:
//Don't known to handle...
- logger.log(POILogger.WARN, "Found unexpected key: ChLongVolume - IGNORING");
+ LOG.log(POILogger.WARN, "Found unexpected key: ChLongVolume - IGNORING");
break;
case CH_STARTUP_DIR:
case CH_ALT_STARTUP_DIR:
case CH_LIB_DIR:
- logger.log(POILogger.WARN, "EXCEL.EXE path unkown - using this directoy instead: .");
+ LOG.log(POILogger.WARN, "EXCEL.EXE path unkown - using this directoy instead: .");
sb.append(".").append(PATH_SEPERATOR);
break;
default:
public final class CFRecordsAggregate extends RecordAggregate implements GenericRecord {
/** Excel 97-2003 allows up to 3 conditional formating rules */
private static final int MAX_97_2003_CONDTIONAL_FORMAT_RULES = 3;
- private static final POILogger logger = POILogFactory.getLogger(CFRecordsAggregate.class);
+ private static final POILogger LOG = POILogFactory.getLogger(CFRecordsAggregate.class);
private final CFHeaderBase header;
throw new IllegalArgumentException("rules must not be null");
}
if(pRules.length > MAX_97_2003_CONDTIONAL_FORMAT_RULES) {
- logger.log(POILogger.WARN, "Excel versions before 2007 require that "
+ LOG.log(POILogger.WARN, "Excel versions before 2007 require that "
+ "No more than " + MAX_97_2003_CONDTIONAL_FORMAT_RULES
+ " rules may be specified, " + pRules.length + " were found,"
+ " this file will cause problems with old Excel versions");
throw new IllegalArgumentException("r must not be null");
}
if(rules.size() >= MAX_97_2003_CONDTIONAL_FORMAT_RULES) {
- logger.log(POILogger.WARN, "Excel versions before 2007 cannot cope with"
+ LOG.log(POILogger.WARN, "Excel versions before 2007 cannot cope with"
+ " any more than " + MAX_97_2003_CONDTIONAL_FORMAT_RULES
+ " - this file will cause problems with old Excel versions");
}
@Internal
public class ExtRst implements Comparable<ExtRst>, GenericRecord {
- private static final POILogger _logger = POILogFactory.getLogger(ExtRst.class);
+ private static final POILogger LOG = POILogFactory.getLogger(ExtRst.class);
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 100_000;
// Spot corrupt records
if(reserved != 1) {
- _logger.log(POILogger.WARN, "Warning - ExtRst has wrong magic marker, expecting 1 but found ", reserved, " - ignoring");
+ LOG.log(POILogger.WARN, "Warning - ExtRst has wrong magic marker, expecting 1 but found ", reserved, " - ignoring");
// Grab all the remaining data, and ignore it
for(int i=0; i<expectedLength-2; i++) {
in.readByte();
int extraDataLength = runData - (numRuns*6);
if(extraDataLength < 0) {
- _logger.log( POILogger.WARN, "Warning - ExtRst overran by ", (0-extraDataLength), " bytes");
+ LOG.log( POILogger.WARN, "Warning - ExtRst overran by ", (0-extraDataLength), " bytes");
extraDataLength = 0;
}
extraData = IOUtils.safelyAllocate(extraDataLength, MAX_RECORD_LENGTH);
* This is often called a XLUnicodeRichExtendedString in MS documentation.<p>
*/
public class UnicodeString implements Comparable<UnicodeString>, Duplicatable, GenericRecord {
- private static final POILogger _logger = POILogFactory.getLogger(UnicodeString.class);
+ private static final POILogger LOG = POILogFactory.getLogger(UnicodeString.class);
private static final BitField highByte = BitFieldFactory.getInstance(0x1);
// 0x2 is reserved
if (isExtendedText() && (extensionLength > 0)) {
field_5_ext_rst = new ExtRst(new ContinuableRecordInput(in), extensionLength);
if(field_5_ext_rst.getDataSize()+4 != extensionLength) {
- _logger.log(POILogger.WARN, "ExtRst was supposed to be " + extensionLength + " bytes long, but seems to actually be " + (field_5_ext_rst.getDataSize() + 4));
+ LOG.log(POILogger.WARN, "ExtRst was supposed to be " + extensionLength + " bytes long, but seems to actually be " + (field_5_ext_rst.getDataSize() + 4));
}
}
}
* <code>HSSFClientAnchor.getAnchorHeightInPoints()</code>.
* </blockquote>
*/
-public class EscherGraphics extends Graphics
-{
+public class EscherGraphics extends Graphics {
+ private static final POILogger LOG = POILogFactory.getLogger(EscherGraphics.class);
+
private final HSSFShapeGroup escherGroup;
private final HSSFWorkbook workbook;
private float verticalPointsPerPixel = 1.0f;
private Color foreground;
private Color background = Color.white;
private Font font;
- private static final POILogger logger = POILogFactory.getLogger(EscherGraphics.class);
/**
* Construct an escher graphics object.
@NotImplemented
public void clipRect(int x, int y, int width, int height)
{
- logger.log(POILogger.WARN,"clipRect not supported");
+ LOG.log(POILogger.WARN,"clipRect not supported");
}
@Override
@NotImplemented
public void copyArea(int x, int y, int width, int height, int dx, int dy)
{
- logger.log(POILogger.WARN,"copyArea not supported");
+ LOG.log(POILogger.WARN,"copyArea not supported");
}
@Override
public void drawArc(int x, int y, int width, int height,
int startAngle, int arcAngle)
{
- logger.log(POILogger.WARN,"drawArc not supported");
+ LOG.log(POILogger.WARN,"drawArc not supported");
}
@Override
Color bgcolor,
ImageObserver observer)
{
- logger.log(POILogger.WARN,"drawImage not supported");
+ LOG.log(POILogger.WARN,"drawImage not supported");
return true;
}
int sx1, int sy1, int sx2, int sy2,
ImageObserver observer)
{
- logger.log(POILogger.WARN,"drawImage not supported");
+ LOG.log(POILogger.WARN,"drawImage not supported");
return true;
}
public void drawPolyline(int[] xPoints, int[] yPoints,
int nPoints)
{
- logger.log(POILogger.WARN,"drawPolyline not supported");
+ LOG.log(POILogger.WARN,"drawPolyline not supported");
}
@Override
@NotImplemented
public void drawRect(int x, int y, int width, int height)
{
- logger.log(POILogger.WARN,"drawRect not supported");
+ LOG.log(POILogger.WARN,"drawRect not supported");
}
@Override
public void drawRoundRect(int x, int y, int width, int height,
int arcWidth, int arcHeight)
{
- logger.log(POILogger.WARN,"drawRoundRect not supported");
+ LOG.log(POILogger.WARN,"drawRoundRect not supported");
}
@Override
public void drawString(AttributedCharacterIterator iterator,
int x, int y)
{
- if (logger.check( POILogger.WARN ))
- logger.log(POILogger.WARN,"drawString not supported");
+ if (LOG.check( POILogger.WARN ))
+ LOG.log(POILogger.WARN,"drawString not supported");
}
@Override
public void fillArc(int x, int y, int width, int height,
int startAngle, int arcAngle)
{
- if (logger.check( POILogger.WARN ))
- logger.log(POILogger.WARN,"fillArc not supported");
+ if (LOG.check( POILogger.WARN ))
+ LOG.log(POILogger.WARN,"fillArc not supported");
}
@Override
public void fillRoundRect(int x, int y, int width, int height,
int arcWidth, int arcHeight)
{
- if (logger.check( POILogger.WARN ))
- logger.log(POILogger.WARN,"fillRoundRect not supported");
+ if (LOG.check( POILogger.WARN ))
+ LOG.log(POILogger.WARN,"fillRoundRect not supported");
}
@Override
@NotImplemented
public void setClip(Shape shape)
{
- logger.log(POILogger.WARN,"setClip not supported");
+ LOG.log(POILogger.WARN,"setClip not supported");
}
@Override
@NotImplemented
public void setPaintMode()
{
- logger.log(POILogger.WARN,"setPaintMode not supported");
+ LOG.log(POILogger.WARN,"setPaintMode not supported");
}
@Override
@NotImplemented
public void setXORMode(Color color)
{
- logger.log(POILogger.WARN,"setXORMode not supported");
+ LOG.log(POILogger.WARN,"setXORMode not supported");
}
@Override
@NotImplemented
public void translate(int x, int y)
{
- logger.log(POILogger.WARN,"translate not supported");
+ LOG.log(POILogger.WARN,"translate not supported");
}
public Color getBackground()
* </blockquote>
*/
public final class EscherGraphics2d extends Graphics2D {
+ private static final POILogger LOG = POILogFactory.getLogger(EscherGraphics2d.class);
+
private EscherGraphics _escherGraphics;
private BufferedImage _img;
private AffineTransform _trans;
private Stroke _stroke;
private Paint _paint;
private Shape _deviceclip;
- private POILogger logger = POILogFactory.getLogger(getClass());
/**
* Constructs one escher graphics object from an escher graphics object.
}
else
{
- if (logger.check(POILogger.WARN))
- logger.log(POILogger.WARN, "draw not fully supported");
+ if (LOG.check(POILogger.WARN))
+ LOG.log(POILogger.WARN, "draw not fully supported");
}
}
public boolean drawImage(Image image, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1,
int sx2, int sy2, Color bgColor, ImageObserver imageobserver)
{
- if (logger.check( POILogger.WARN ))
- logger.log(POILogger.WARN,"drawImage() not supported");
+ if (LOG.check( POILogger.WARN ))
+ LOG.log(POILogger.WARN,"drawImage() not supported");
return true;
}
public boolean drawImage(Image image, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1,
int sx2, int sy2, ImageObserver imageobserver)
{
- if (logger.check( POILogger.WARN ))
- logger.log(POILogger.WARN,"drawImage() not supported");
+ if (LOG.check( POILogger.WARN ))
+ LOG.log(POILogger.WARN,"drawImage() not supported");
return drawImage(image, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null, imageobserver);
}
public boolean drawImage(Image image, int dx1, int dy1, int dx2, int dy2, Color bgColor, ImageObserver imageobserver)
{
- if (logger.check( POILogger.WARN ))
- logger.log(POILogger.WARN,"drawImage() not supported");
+ if (LOG.check( POILogger.WARN ))
+ LOG.log(POILogger.WARN,"drawImage() not supported");
return true;
}
public void fill(Shape shape)
{
- if (logger.check( POILogger.WARN ))
- logger.log(POILogger.WARN,"fill(Shape) not supported");
+ if (LOG.check( POILogger.WARN ))
+ LOG.log(POILogger.WARN,"fill(Shape) not supported");
}
public void fillArc(int i, int j, int k, int l, int i1, int j1)
public static final int LAST_COLUMN_NUMBER = SpreadsheetVersion.EXCEL97.getLastColumnIndex(); // 2^8 - 1
private static final String LAST_COLUMN_NAME = SpreadsheetVersion.EXCEL97.getLastColumnName();
- public final static short ENCODING_UNCHANGED = -1;
- public final static short ENCODING_COMPRESSED_UNICODE = 0;
- public final static short ENCODING_UTF_16 = 1;
+ public static final short ENCODING_UNCHANGED = -1;
+ public static final short ENCODING_COMPRESSED_UNICODE = 0;
+ public static final short ENCODING_UTF_16 = 1;
private final HSSFWorkbook _book;
private final HSSFSheet _sheet;
*/
public class HSSFComment extends HSSFTextbox implements Comment {
- private final static int FILL_TYPE_SOLID = 0;
- private final static int FILL_TYPE_PICTURE = 3;
+ private static final int FILL_TYPE_SOLID = 0;
+ private static final int FILL_TYPE_PICTURE = 3;
- private final static int GROUP_SHAPE_PROPERTY_DEFAULT_VALUE = 655362;
- private final static int GROUP_SHAPE_HIDDEN_MASK = 0x1000002;
- private final static int GROUP_SHAPE_NOT_HIDDEN_MASK = 0xFEFFFFFD;
+ private static final int GROUP_SHAPE_PROPERTY_DEFAULT_VALUE = 655362;
+ private static final int GROUP_SHAPE_HIDDEN_MASK = 0x1000002;
+ private static final int GROUP_SHAPE_NOT_HIDDEN_MASK = 0xFEFFFFFD;
/*
* TODO - make HSSFComment more consistent when created vs read from file.
/**
* Normal boldness (not bold)
*/
- final static short BOLDWEIGHT_NORMAL = 0x190;
+ static final short BOLDWEIGHT_NORMAL = 0x190;
/**
* Bold boldness (bold)
*/
- final static short BOLDWEIGHT_BOLD = 0x2bc;
+ static final short BOLDWEIGHT_BOLD = 0x2bc;
/**
* Arial font
*/
- public final static String FONT_ARIAL = "Arial";
+ public static final String FONT_ARIAL = "Arial";
private FontRecord font;
import org.apache.poi.util.POILogger;
/**
- *
+ *
*/
public class HSSFPolygon extends HSSFSimpleShape {
- private static POILogger logger = POILogFactory.getLogger(HSSFPolygon.class);
- public final static short OBJECT_TYPE_MICROSOFT_OFFICE_DRAWING = 0x1E;
+ public static final short OBJECT_TYPE_MICROSOFT_OFFICE_DRAWING = 0x1E;
+
+ private static final POILogger LOG = POILogFactory.getLogger(HSSFPolygon.class);
public HSSFPolygon(EscherContainerRecord spContainer, ObjRecord objRecord, TextObjectRecord _textObjectRecord) {
super(spContainer, objRecord, _textObjectRecord);
*/
public void setPoints(int[] xPoints, int[] yPoints) {
if (xPoints.length != yPoints.length){
- logger.log( POILogger.ERROR, "xPoint.length must be equal to yPoints.length");
+ LOG.log( POILogger.ERROR, "xPoint.length must be equal to yPoints.length");
return;
}
if (xPoints.length == 0){
- logger.log( POILogger.ERROR, "HSSFPolygon must have at least one point");
+ LOG.log( POILogger.ERROR, "HSSFPolygon must have at least one point");
}
EscherArrayProperty verticesProp = new EscherArrayProperty(EscherPropertyTypes.GEOMETRY__VERTICES, false, 0);
verticesProp.setNumberOfElementsInArray(xPoints.length+1);
public final class HSSFRow implements Row, Comparable<HSSFRow> {
// used for collections
- public final static int INITIAL_CAPACITY = Configurator.getIntValue("HSSFRow.ColInitialCapacity", 5);
+ public static final int INITIAL_CAPACITY = Configurator.getIntValue("HSSFRow.ColInitialCapacity", 5);
private int rowNum;
private HSSFCell[] cells;
/**
* An abstract shape.
- *
- * Note: Microsoft Excel seems to sometimes disallow
- * higher y1 than y2 or higher x1 than x2 in the anchor, you might need to
+ *
+ * Note: Microsoft Excel seems to sometimes disallow
+ * higher y1 than y2 or higher x1 than x2 in the anchor, you might need to
* reverse them and draw shapes vertically or horizontally flipped via
- * setFlipVertical() or setFlipHorizontally().
+ * setFlipVertical() or setFlipHorizontally().
*/
public abstract class HSSFShape implements Shape {
private static final POILogger LOG = POILogFactory.getLogger(HSSFShape.class);
-
+
public static final int LINEWIDTH_ONE_PT = 12700;
public static final int LINEWIDTH_DEFAULT = 9525;
public static final int LINESTYLE__COLOR_DEFAULT = 0x08000040;
private final EscherContainerRecord _escherContainer;
private final ObjRecord _objRecord;
private final EscherOptRecord _optRecord;
-
- public final static int NO_FILLHITTEST_TRUE = 0x00110000;
- public final static int NO_FILLHITTEST_FALSE = 0x00010000;
+
+ public static final int NO_FILLHITTEST_TRUE = 0x00110000;
+ public static final int NO_FILLHITTEST_FALSE = 0x00010000;
/**
* creates shapes from existing file
}
/**
- * Return the low-level EscherOptRecord to read/modify not yet wrapped escher properties
+ * Return the low-level EscherOptRecord to read/modify not yet wrapped escher properties
*
* @return the low-level EscherOptRecord
*/
* rows. It is currently set to 20. If you generate larger sheets you may benefit
* by setting this to a higher number and recompiling a custom edition of HSSFSheet.
*/
- public final static int INITIAL_CAPACITY = Configurator.getIntValue("HSSFSheet.RowInitialCapacity", 20);
+ public static final int INITIAL_CAPACITY = Configurator.getIntValue("HSSFSheet.RowInitialCapacity", 20);
/**
* reference to the low level {@link InternalSheet} object
// The commented out ones haven't been tested yet or aren't supported
// by HSSFSimpleShape.
- public final static short OBJECT_TYPE_LINE = HSSFShapeTypes.Line;
- public final static short OBJECT_TYPE_RECTANGLE = HSSFShapeTypes.Rectangle;
- public final static short OBJECT_TYPE_OVAL = HSSFShapeTypes.Ellipse;
- public final static short OBJECT_TYPE_ARC = HSSFShapeTypes.Arc;
- // public final static short OBJECT_TYPE_CHART = 5;
-// public final static short OBJECT_TYPE_TEXT = 6;
-// public final static short OBJECT_TYPE_BUTTON = 7;
- public final static short OBJECT_TYPE_PICTURE = HSSFShapeTypes.PictureFrame;
-
-// public final static short OBJECT_TYPE_POLYGON = 9;
-// public final static short OBJECT_TYPE_CHECKBOX = 11;
-// public final static short OBJECT_TYPE_OPTION_BUTTON = 12;
-// public final static short OBJECT_TYPE_EDIT_BOX = 13;
-// public final static short OBJECT_TYPE_LABEL = 14;
-// public final static short OBJECT_TYPE_DIALOG_BOX = 15;
-// public final static short OBJECT_TYPE_SPINNER = 16;
-// public final static short OBJECT_TYPE_SCROLL_BAR = 17;
-// public final static short OBJECT_TYPE_LIST_BOX = 18;
-// public final static short OBJECT_TYPE_GROUP_BOX = 19;
- public final static short OBJECT_TYPE_COMBO_BOX = HSSFShapeTypes.HostControl;
- public final static short OBJECT_TYPE_COMMENT = HSSFShapeTypes.TextBox;
- public final static short OBJECT_TYPE_MICROSOFT_OFFICE_DRAWING = 30;
-
- public final static int WRAP_SQUARE = 0;
- public final static int WRAP_BY_POINTS = 1;
- public final static int WRAP_NONE = 2;
+ public static final short OBJECT_TYPE_LINE = HSSFShapeTypes.Line;
+ public static final short OBJECT_TYPE_RECTANGLE = HSSFShapeTypes.Rectangle;
+ public static final short OBJECT_TYPE_OVAL = HSSFShapeTypes.Ellipse;
+ public static final short OBJECT_TYPE_ARC = HSSFShapeTypes.Arc;
+ // public static final short OBJECT_TYPE_CHART = 5;
+// public static final short OBJECT_TYPE_TEXT = 6;
+// public static final short OBJECT_TYPE_BUTTON = 7;
+ public static final short OBJECT_TYPE_PICTURE = HSSFShapeTypes.PictureFrame;
+
+// public static final short OBJECT_TYPE_POLYGON = 9;
+// public static final short OBJECT_TYPE_CHECKBOX = 11;
+// public static final short OBJECT_TYPE_OPTION_BUTTON = 12;
+// public static final short OBJECT_TYPE_EDIT_BOX = 13;
+// public static final short OBJECT_TYPE_LABEL = 14;
+// public static final short OBJECT_TYPE_DIALOG_BOX = 15;
+// public static final short OBJECT_TYPE_SPINNER = 16;
+// public static final short OBJECT_TYPE_SCROLL_BAR = 17;
+// public static final short OBJECT_TYPE_LIST_BOX = 18;
+// public static final short OBJECT_TYPE_GROUP_BOX = 19;
+ public static final short OBJECT_TYPE_COMBO_BOX = HSSFShapeTypes.HostControl;
+ public static final short OBJECT_TYPE_COMMENT = HSSFShapeTypes.TextBox;
+ public static final short OBJECT_TYPE_MICROSOFT_OFFICE_DRAWING = 30;
+
+ public static final int WRAP_SQUARE = 0;
+ public static final int WRAP_BY_POINTS = 1;
+ public static final int WRAP_NONE = 2;
private TextObjectRecord _textObjectRecord;
EscherSpRecord spRecord = getEscherContainer().getChildById(EscherSpRecord.RECORD_ID);
spRecord.setShapeType((short) value);
}
-
+
private TextObjectRecord getOrCreateTextObjRecord(){
if (getTextObjectRecord() == null){
_textObjectRecord = createTextObjRecord();
* A textbox is a shape that may hold a rich text string.
*/
public class HSSFTextbox extends HSSFSimpleShape {
- public final static short OBJECT_TYPE_TEXT = 6;
+ public static final short OBJECT_TYPE_TEXT = 6;
/**
* How to align text horizontally
*/
- public final static short HORIZONTAL_ALIGNMENT_LEFT = 1;
- public final static short HORIZONTAL_ALIGNMENT_CENTERED = 2;
- public final static short HORIZONTAL_ALIGNMENT_RIGHT = 3;
- public final static short HORIZONTAL_ALIGNMENT_JUSTIFIED = 4;
- public final static short HORIZONTAL_ALIGNMENT_DISTRIBUTED = 7;
+ public static final short HORIZONTAL_ALIGNMENT_LEFT = 1;
+ public static final short HORIZONTAL_ALIGNMENT_CENTERED = 2;
+ public static final short HORIZONTAL_ALIGNMENT_RIGHT = 3;
+ public static final short HORIZONTAL_ALIGNMENT_JUSTIFIED = 4;
+ public static final short HORIZONTAL_ALIGNMENT_DISTRIBUTED = 7;
/**
* How to align text vertically
*/
- public final static short VERTICAL_ALIGNMENT_TOP = 1;
- public final static short VERTICAL_ALIGNMENT_CENTER = 2;
- public final static short VERTICAL_ALIGNMENT_BOTTOM = 3;
- public final static short VERTICAL_ALIGNMENT_JUSTIFY = 4;
- public final static short VERTICAL_ALIGNMENT_DISTRIBUTED = 7;
+ public static final short VERTICAL_ALIGNMENT_TOP = 1;
+ public static final short VERTICAL_ALIGNMENT_CENTER = 2;
+ public static final short VERTICAL_ALIGNMENT_BOTTOM = 3;
+ public static final short VERTICAL_ALIGNMENT_JUSTIFY = 4;
+ public static final short VERTICAL_ALIGNMENT_DISTRIBUTED = 7;
public HSSFTextbox(EscherContainerRecord spContainer, ObjRecord objRecord, TextObjectRecord textObjectRecord) {
super(spContainer, objRecord, textObjectRecord);
* since you're never allowed to have more or less than three sheets!
*/
- public final static int INITIAL_CAPACITY = Configurator.getIntValue("HSSFWorkbook.SheetInitialCapacity", 3);
+ public static final int INITIAL_CAPACITY = Configurator.getIntValue("HSSFWorkbook.SheetInitialCapacity", 3);
/**
* this is the reference to the low level Workbook object
// {@link org.apache.poi.xssf.usermodel.helpers.XSSFColumnShifter}
@Beta
public final class HSSFColumnShifter extends ColumnShifter {
- private static final POILogger logger = POILogFactory.getLogger(HSSFColumnShifter.class);
+ private static final POILogger LOG = POILogFactory.getLogger(HSSFColumnShifter.class);
public HSSFColumnShifter(HSSFSheet sh) {
super(sh);
// non-Javadoc: When possible, code should be implemented in the RowShifter abstract class to avoid duplication with
// {@link org.apache.poi.xssf.usermodel.helpers.XSSFRowShifter}
public final class HSSFRowShifter extends RowShifter {
- private static final POILogger logger = POILogFactory.getLogger(HSSFRowShifter.class);
+ private static final POILogger LOG = POILogFactory.getLogger(HSSFRowShifter.class);
public HSSFRowShifter(HSSFSheet sh) {
super(sh);
import org.apache.poi.util.TempFile;
public class StandardEncryptor extends Encryptor {
- private static final POILogger logger = POILogFactory.getLogger(StandardEncryptor.class);
+ private static final POILogger LOG = POILogFactory.getLogger(StandardEncryptor.class);
protected StandardEncryptor() {}
IOUtils.copy(fis, leos);
}
if (!fileOut.delete()) {
- logger.log(POILogger.ERROR, "Can't delete temporary encryption file: ", fileOut);
+ LOG.log(POILogger.ERROR, "Can't delete temporary encryption file: ", fileOut);
}
leos.close();
UNKNOWN(new byte[0]);
// update this if a longer pattern is added
- final static int MAX_PATTERN_LENGTH = 44;
+ static final int MAX_PATTERN_LENGTH = 44;
final byte[][] magic;
* A POIFS {@link DataSource} backed by a File
*/
public class FileBackedDataSource extends DataSource implements Closeable {
- private final static POILogger logger = POILogFactory.getLogger(FileBackedDataSource.class);
+ private static final POILogger LOG = POILogFactory.getLogger(FileBackedDataSource.class);
private final FileChannel channel;
private Long channelSize;
try {
CleanerUtil.getCleaner().freeBuffer(buffer);
} catch (IOException e) {
- logger.log(POILogger.WARN, "Failed to unmap the buffer", e);
+ LOG.log(POILogger.WARN, "Failed to unmap the buffer", e);
}
} else {
- logger.log(POILogger.DEBUG, CleanerUtil.UNMAP_NOT_SUPPORTED_REASON);
+ LOG.log(POILogger.DEBUG, CleanerUtil.UNMAP_NOT_SUPPORTED_REASON);
}
}
}
* chain of blocks.
*/
public final class PropertyTable implements BATManaged {
- private static final POILogger _logger =
- POILogFactory.getLogger(PropertyTable.class);
+ private static final POILogger LOG = POILogFactory.getLogger(PropertyTable.class);
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 100_000;
// Looks to be a truncated block
// This isn't allowed, but some third party created files
// sometimes do this, and we can normally read anyway
- _logger.log(POILogger.WARN, "Short Property Block, ", bb.remaining(),
+ LOG.log(POILogger.WARN, "Short Property Block, ", bb.remaining(),
" bytes instead of the expected " + _bigBigBlockSize.getBigBlockSize());
toRead = bb.remaining();
}
}
return numBlocks;
}
-
+
/**
* Prepare to be written
*/
// give each property its index
int i=0;
for (Property p : _properties) {
- // only handle non-null properties
+ // only handle non-null properties
if (p == null) continue;
p.setIndex(i++);
pList.add(p);
// prepare each property for writing
for (Property p : pList) p.preWrite();
- }
-
+ }
+
/**
* Writes the properties out into the given low-level stream
*/
}
}
os.close();
-
+
// Update the start position if needed
if(getStartBlock() != stream.getStartBlock()) {
setStartBlock(stream.getStartBlock());
if (! Property.isValidIndex(index))
return false;
if (index < 0 || index >= _properties.size()) {
- _logger.log(POILogger.WARN, "Property index " + index +
+ LOG.log(POILogger.WARN, "Property index " + index +
"outside the valid range 0.."+_properties.size());
return false;
}
* For now this class renders only images supported by the javax.imageio.ImageIO framework.
**/
public class BitmapImageRenderer implements ImageRenderer {
- private final static POILogger LOG = POILogFactory.getLogger(BitmapImageRenderer.class);
+ private static final POILogger LOG = POILogFactory.getLogger(BitmapImageRenderer.class);
protected BufferedImage img;
import org.apache.poi.util.XMLHelper;
public final class PresetGeometries {
- private final static POILogger LOG = POILogFactory.getLogger(PresetGeometries.class);
+ private static final POILogger LOG = POILogFactory.getLogger(PresetGeometries.class);
private final Map<String, CustomGeometry> map = new TreeMap<>();
}
}
- private final static POILogger LOG = POILogFactory.getLogger(PresetParser.class);
+ private static final POILogger LOG = POILogFactory.getLogger(PresetParser.class);
private Mode mode;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.logging.Level;
+import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
* <dt>One part (example: <tt>[Green]#.##</tt>)</dt>
* <dd>If the value is a number, display according to this one part (example: green text,
* with up to two decimal points). If the value is text, display it as is.</dd>
- *
+ *
* <dt>Two parts (example: <tt>[Green]#.##;[Red]#.##</tt>)</dt>
* <dd>If the value is a positive number or zero, display according to the first part (example: green
* text, with up to two decimal points); if it is a negative number, display
* according to the second part (example: red text, with up to two decimal
* points). If the value is text, display it as is.</dd>
- *
+ *
* <dt>Three parts (example: <tt>[Green]#.##;[Black]#.##;[Red]#.##</tt>)</dt>
* <dd>If the value is a positive
* number, display according to the first part (example: green text, with up to
* (example: black text, with up to two decimal points); if it is a negative
* number, display according to the third part (example: red text, with up to
* two decimal points). If the value is text, display it as is.</dd>
- *
+ *
* <dt>Four parts (example: <tt>[Green]#.##;[Black]#.##;[Red]#.##;[@]</tt>)</dt>
* <dd>If the value is a positive number, display according to the first part (example: green text,
* with up to two decimal points); if it is zero, display according to the
* <p>
* In addition to these, there is a general format that is used when no format
* is specified.
- *
+ *
* TODO Merge this with {@link DataFormatter} so we only have one set of
* code for formatting numbers.
* TODO Re-use parts of this logic with {@link ConditionalFormatting} /
* 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;
- private final CellFormatPart negNumFmt;
- private final CellFormatPart textFmt;
- private final int formatPartCount;
+ /** The logger to use in the formatting code. */
+ private static final Logger LOG = Logger.getLogger(CellFormat.class.getName());
private static final Pattern ONE_PART = Pattern.compile(
CellFormatPart.FORMAT_PAT.pattern() + "(;|$)",
"###################################################" +
"###################################################";
- private static String QUOTE = "\"";
-
+ private static final String QUOTE = "\"";
+
+ private final Locale locale;
+ private final String format;
+ private final CellFormatPart posNumFmt;
+ private final CellFormatPart zeroNumFmt;
+ private final CellFormatPart negNumFmt;
+ private final CellFormatPart textFmt;
+ private final int formatPartCount;
+
private static CellFormat createGeneralFormat(final Locale locale) {
return new CellFormat(locale, "General") {
@Override
parts.add(new CellFormatPart(locale, valueDesc));
} catch (RuntimeException e) {
- CellFormatter.logger.log(Level.WARNING,
- "Invalid format: " + CellFormatter.quote(m.group()), e);
+ LOG.log(Level.WARNING, "Invalid format: " + CellFormatter.quote(m.group()), e);
parts.add(null);
}
}
-
+
formatPartCount = parts.size();
-
+
switch (formatPartCount) {
case 1:
posNumFmt = parts.get(0);
* Returns the {@link CellFormatPart} that applies to the value. Result
* depends on how many parts the cell format has, the cell value and any
* conditions. The value must be a {@link Number}.
- *
+ *
* @param value The value.
* @return The {@link CellFormatPart} that applies to the value.
*/
private CellFormatPart getApplicableFormatPart(Object value) {
-
+
if (value instanceof Number) {
-
+
double val = ((Number) value).doubleValue();
-
+
if (formatPartCount == 1) {
if (!posNumFmt.hasCondition()
|| (posNumFmt.hasCondition() && posNumFmt.applies(val))) {
} else {
throw new IllegalArgumentException("value must be a Number");
}
-
+
}
-
+
/**
* Returns the ultimate cell type, following the results of formulas. If
* the cell is a {@link CellType#FORMULA}, this returns the result of
* {@link Cell#getCachedFormulaResultType()}. Otherwise this returns the
* result of {@link Cell#getCellType()}.
- *
+ *
* @param cell The cell.
*
* @return The ultimate type of this cell.
import java.awt.*;
import java.util.*;
import java.util.List;
+import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import static org.apache.poi.ss.format.CellFormatter.logger;
import static org.apache.poi.ss.format.CellFormatter.quote;
/**
* @author Ken Arnold, Industrious Media LLC
*/
public class CellFormatPart {
+ private static final Logger LOG = Logger.getLogger(CellFormat.class.getName());
+
+ static final Map<String, Color> NAMED_COLORS;
+
+
private final Color color;
private CellFormatCondition condition;
private final CellFormatter format;
private final CellFormatType type;
- static final Map<String, Color> NAMED_COLORS;
-
static {
NAMED_COLORS = new TreeMap<>(
String.CASE_INSENSITIVE_ORDER);
// A condition specification
String condition = "([<>=]=?|!=|<>) # The operator\n" +
" \\s*([0-9]+(?:\\.[0-9]*)?)\\s* # The constant to test against\n";
-
+
// A currency symbol / string, in a specific locale
String currency = "(\\[\\$.{0,3}-[0-9a-f]{3}\\])";
public CellFormatPart(String desc) {
this(LocaleUtil.getUserLocale(), desc);
}
-
+
/**
* Create an object to represent a format part.
*
if (cdesc == null || cdesc.length() == 0)
return null;
Color c = NAMED_COLORS.get(cdesc);
- if (c == null)
- logger.warning("Unknown color: " + quote(cdesc));
+ if (c == null) {
+ LOG.warning("Unknown color: " + quote(cdesc));
+ }
return c;
}
*/
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
Matcher currencyM = CURRENCY_PAT.matcher(fdesc);
if (currencyM.find()) {
}
fdesc = fdesc.replace(currencyPart, currencyRepl);
}
-
+
// Build a formatter for this simplified string
return type.formatter(locale, fdesc);
}
String c2 = null;
if (codePoints.hasNext())
c2 = codePoints.next().toLowerCase(Locale.ROOT);
-
+
switch (c1) {
case "@":
return CellFormatType.TEXT;
/**
* This is the abstract supertype for the various cell formatters.
- *
- * @author Ken Arnold, Industrious Media LLC
*/
public abstract class CellFormatter {
+ /** The logger to use in the formatting code. */
+ private static final Logger LOG = Logger.getLogger(CellFormatter.class.getName());
+
/** The original specified format. */
protected final String format;
protected final Locale locale;
this.format = format;
}
- /** The logger to use in the formatting code. */
- static final Logger logger = Logger.getLogger(
- CellFormatter.class.getName());
-
/**
* Format a value according the format string.
* <p/>
- * NOTE: this method must be thread safe! In particular, if it uses a
+ * NOTE: this method must be thread safe! In particular, if it uses a
* Format instance that is not thread safe, i.e. DateFormat, this method
- * must be synchronized, either on the method, if the format is a final
+ * must be synchronized, either on the method, if the format is a final
* property, or on the format instance itself.
*
* @param toAppendTo The buffer to append to.
/**
* Format a value according to the type, in the most basic way.
* <p/>
- * NOTE: this method must be thread safe! In particular, if it uses a
+ * NOTE: this method must be thread safe! In particular, if it uses a
* Format instance that is not thread safe, i.e. DateFormat, this method
- * must be synchronized, either on the method, if the format is a final
+ * must be synchronized, either on the method, if the format is a final
* property, or on the format instance itself.
*
* @param toAppendTo The buffer to append to.
*/
@Internal
public final class FormulaParser {
- private final static POILogger log = POILogFactory.getLogger(FormulaParser.class);
+ private static final POILogger log = POILogFactory.getLogger(FormulaParser.class);
private final String _formulaString;
private final int _formulaLength;
/** points at the next character to be read (after the {@link #look} codepoint) */
private ParseNode _rootNode;
- private final static char TAB = '\t'; // HSSF + XSSF
- private final static char CR = '\r'; // Normally just XSSF
- private final static char LF = '\n'; // Normally just XSSF
+ private static final char TAB = '\t'; // HSSF + XSSF
+ private static final char CR = '\r'; // Normally just XSSF
+ private static final char LF = '\n'; // Normally just XSSF
/**
* Lookahead unicode codepoint
- private final static String specHeaders = "Headers";
- private final static String specAll = "All";
- private final static String specData = "Data";
- private final static String specTotals = "Totals";
- private final static String specThisRow = "This Row";
+ private static final String specHeaders = "Headers";
+ private static final String specAll = "All";
+ private static final String specData = "Data";
+ private static final String specTotals = "Totals";
+ private static final String specThisRow = "This Row";
/**
* Parses a structured reference, returns it as area reference.
import org.apache.poi.util.POILogger;
/**
* Represents a constant error code value as encoded in a constant values array. <p>
- *
- * This class is a type-safe wrapper for a 16-bit int value performing a similar job to
+ *
+ * This class is a type-safe wrapper for a 16-bit int value performing a similar job to
* <tt>ErrorEval</tt>.
*/
-public class ErrorConstant {
- private static final POILogger logger = POILogFactory.getLogger(ErrorConstant.class);
+public final class ErrorConstant {
+ private static final POILogger LOG = POILogFactory.getLogger(ErrorConstant.class);
private static final ErrorConstant NULL = new ErrorConstant(FormulaError.NULL.getCode());
private static final ErrorConstant DIV_0 = new ErrorConstant(FormulaError.DIV0.getCode());
private static final ErrorConstant VALUE = new ErrorConstant(FormulaError.VALUE.getCode());
private ErrorConstant(int errorCode) {
_errorCode = errorCode;
}
-
+
public int getErrorCode() {
return _errorCode;
}
default: break;
}
}
- logger.log( POILogger.WARN, "Warning - unexpected error code (", errorCode, ")");
+ LOG.log( POILogger.WARN, "Warning - unexpected error code (", errorCode, ")");
return new ErrorConstant(errorCode);
}
public static final FreeRefFunction instance = new Dec2Bin();
- private final static long MIN_VALUE = -512;
- private final static long MAX_VALUE = 511;
- private final static int DEFAULT_PLACES_VALUE = 10;
+ private static final long MIN_VALUE = -512;
+ private static final long MAX_VALUE = 511;
+ private static final int DEFAULT_PLACES_VALUE = 10;
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval numberVE, ValueEval placesVE) {
ValueEval veText1;
public static final FreeRefFunction instance = new Dec2Hex();
- private final static long MIN_VALUE = Long.parseLong("-549755813888");
- private final static long MAX_VALUE = Long.parseLong("549755813887");
- private final static int DEFAULT_PLACES_VALUE = 10;
+ private static final long MIN_VALUE = Long.parseLong("-549755813888");
+ private static final long MAX_VALUE = Long.parseLong("549755813887");
+ private static final int DEFAULT_PLACES_VALUE = 10;
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval number, ValueEval places) {
ValueEval veText1;
public static final FreeRefFunction instance = new Delta();
- private final static NumberEval ONE = new NumberEval(1);
- private final static NumberEval ZERO = new NumberEval(0);
+ private static final NumberEval ONE = new NumberEval(1);
+ private static final NumberEval ZERO = new NumberEval(0);
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg1, ValueEval arg2) {
try {
};
public static final Function POISSON = new Fixed3ArgFunction() {
- private final static double DEFAULT_RETURN_RESULT =1;
+ private static final double DEFAULT_RETURN_RESULT =1;
/**
* This checks is x = 0 and the mean = 0.
* Addition operator PTG the "+" binomial operator.
*/
public final class AddPtg extends ValueOperatorPtg {
- public final static byte sid = 0x03;
+ public static final byte sid = 0x03;
- private final static String ADD = "+";
+ private static final String ADD = "+";
public static final AddPtg instance = new AddPtg();
* Common superclass of 2-D area refs
*/
public abstract class Area2DPtgBase extends AreaPtgBase {
- private final static int SIZE = 9;
+ private static final int SIZE = 9;
protected Area2DPtgBase(int firstRow, int lastRow, int firstColumn, int lastColumn, boolean firstRowRelative, boolean lastRowRelative, boolean firstColRelative, boolean lastColRelative) {
super(firstRow, lastRow, firstColumn, lastColumn, firstRowRelative, lastRowRelative, firstColRelative, lastColRelative);
* The XSSF equivalent is {@link Area3DPxg}
*/
public final class Area3DPtg extends AreaPtgBase implements WorkbookDependentFormula, ExternSheetReferenceToken {
- public final static byte sid = 0x3b;
- private final static int SIZE = 11; // 10 + 1 for Ptg
+ public static final byte sid = 0x3b;
+ private static final int SIZE = 11; // 10 + 1 for Ptg
private int field_1_index_extern_sheet;
* AreaErr - handles deleted cell area references.
*/
public final class AreaErrPtg extends OperandPtg {
- public final static byte sid = 0x2B;
+ public static final byte sid = 0x2B;
private final int unused1;
private final int unused2;
* @author Jason Height (jheight at chariot dot net dot au)
*/
public final class AreaNPtg extends Area2DPtgBase {
- public final static short sid = 0x2D;
+ public static final short sid = 0x2D;
public AreaNPtg(AreaNPtg other) {
super(other);
* Specifies a rectangular area of cells A1:A4 for instance.
*/
public final class AreaPtg extends Area2DPtgBase {
- public final static short sid = 0x25;
+ public static final short sid = 0x25;
public AreaPtg(int firstRow, int lastRow, int firstColumn, int lastColumn, boolean firstRowRelative, boolean lastRowRelative, boolean firstColRelative, boolean lastColRelative) {
super(firstRow, lastRow, firstColumn, lastColumn, firstRowRelative, lastRowRelative, firstColRelative, lastColRelative);
*/
public abstract class AreaPtgBase extends OperandPtg implements AreaI {
- private final static BitField rowRelative = BitFieldFactory.getInstance(0x8000);
- private final static BitField colRelative = BitFieldFactory.getInstance(0x4000);
- private final static BitField columnMask = BitFieldFactory.getInstance(0x3FFF);
+ private static final BitField rowRelative = BitFieldFactory.getInstance(0x8000);
+ private static final BitField colRelative = BitFieldFactory.getInstance(0x4000);
+ private static final BitField columnMask = BitFieldFactory.getInstance(0x3FFF);
/** zero based, unsigned 16 bit */
private int field_1_first_row;
* in SUM functions (i.e. SUM(A1:A3) causes an area PTG then an ATTR with the SUM option set)
*/
public final class AttrPtg extends ControlPtg {
- public final static byte sid = 0x19;
- private final static int SIZE = 4;
+ public static final byte sid = 0x19;
+ private static final int SIZE = 4;
// flags 'volatile' and 'space', can be combined.
// OOO spec says other combinations are theoretically possible but not likely to occur.
package org.apache.poi.ss.formula.ptg;
public final class ConcatPtg extends ValueOperatorPtg {
- public final static byte sid = 0x08;
+ public static final byte sid = 0x08;
- private final static String CONCAT = "&";
+ private static final String CONCAT = "&";
public static final ConcatPtg instance = new ConcatPtg();
* @version 1.0-pre
*/
public final class DeletedArea3DPtg extends OperandPtg implements WorkbookDependentFormula {
- public final static byte sid = 0x3d;
+ public static final byte sid = 0x3d;
private final int field_1_index_extern_sheet;
private final int unused1;
private final int unused2;
* @since 1.0-pre
*/
public final class DeletedRef3DPtg extends OperandPtg implements WorkbookDependentFormula {
- public final static byte sid = 0x3c;
+ public static final byte sid = 0x3c;
private final int field_1_index_extern_sheet;
private final int unused1;
* This PTG implements the standard binomial divide "/"
*/
public final class DividePtg extends ValueOperatorPtg {
- public final static byte sid = 0x06;
+ public static final byte sid = 0x06;
public static final DividePtg instance = new DividePtg();
* @author andy
*/
public final class EqualPtg extends ValueOperatorPtg {
- public final static byte sid = 0x0b;
+ public static final byte sid = 0x0b;
public static final EqualPtg instance = new EqualPtg();
import org.apache.poi.util.LittleEndianOutput;
public final class ExpPtg extends ControlPtg {
- private final static int SIZE = 5;
- public final static short sid = 0x1;
+ private static final int SIZE = 5;
+ public static final short sid = 0x1;
private final int field_1_first_row;
private final int field_2_first_col;
public final class FuncPtg extends AbstractFunctionPtg {
- public final static byte sid = 0x21;
- public final static int SIZE = 3;
+ public static final byte sid = 0x21;
+ public static final int SIZE = 3;
public static FuncPtg create(LittleEndianInput in) {
return create(in.readUShort());
import org.apache.poi.util.LittleEndianOutput;
public final class FuncVarPtg extends AbstractFunctionPtg {
- public final static byte sid = 0x22;
- private final static int SIZE = 4;
+ public static final byte sid = 0x22;
+ private static final int SIZE = 4;
// See spec at 2.5.198.63 PtgFuncVar
private static final BitField ceFunc = BitFieldFactory.getInstance(0xF000);
* PTG class to implement greater or equal to
*/
public final class GreaterEqualPtg extends ValueOperatorPtg {
- public final static int SIZE = 1;
- public final static byte sid = 0x0c;
+ public static final int SIZE = 1;
+ public static final byte sid = 0x0c;
public static final GreaterEqualPtg instance = new GreaterEqualPtg();
* Greater than operator PTG ">"
*/
public final class GreaterThanPtg extends ValueOperatorPtg {
- public final static byte sid = 0x0D;
- private final static String GREATERTHAN = ">";
+ public static final byte sid = 0x0D;
+ private static final String GREATERTHAN = ">";
public static final GreaterThanPtg instance = new GreaterThanPtg();
return i >= MIN_VALUE && i <= MAX_VALUE;
}
- public final static int SIZE = 3;
- public final static byte sid = 0x1e;
+ public static final int SIZE = 3;
+ public static final byte sid = 0x1e;
private final int field_1_value;
public IntPtg(LittleEndianInput in) {
import org.apache.poi.util.LittleEndianOutput;
public final class IntersectionPtg extends OperationPtg {
- public final static byte sid = 0x0f;
+ public static final byte sid = 0x0f;
public static final IntersectionPtg instance = new IntersectionPtg();
* Ptg class to implement less than or equal
*/
public final class LessEqualPtg extends ValueOperatorPtg {
- public final static byte sid = 0x0a;
+ public static final byte sid = 0x0a;
public static final LessEqualPtg instance = new LessEqualPtg();
*/
public final class LessThanPtg extends ValueOperatorPtg {
/** the sid for the less than operator as hex */
- public final static byte sid = 0x09;
+ public static final byte sid = 0x09;
/** identifier for LESS THAN char */
- private final static String LESSTHAN = "<";
+ private static final String LESSTHAN = "<";
public static final LessThanPtg instance = new LessThanPtg();
import org.apache.poi.util.LittleEndianOutput;
public final class MemAreaPtg extends OperandPtg {
- public final static short sid = 0x26;
- private final static int SIZE = 7;
+ public static final short sid = 0x26;
+ private static final int SIZE = 7;
private final int field_1_reserved;
private final int field_2_subex_len;
import org.apache.poi.util.LittleEndianOutput;
public final class MemErrPtg extends OperandPtg {
- public final static short sid = 0x27;
- private final static int SIZE = 7;
+ public static final short sid = 0x27;
+ private static final int SIZE = 7;
private int field_1_reserved;
private short field_2_subex_len;
public final class MemFuncPtg extends OperandPtg {
- public final static byte sid = 0x29;
+ public static final byte sid = 0x29;
private final int field_1_len_ref_subexpression;
/**
*/
public final class MissingArgPtg extends ScalarConstantPtg {
- private final static int SIZE = 1;
- public final static byte sid = 0x16;
+ private static final int SIZE = 1;
+ public static final byte sid = 0x16;
public static final Ptg instance = new MissingArgPtg();
* Implements the standard mathematical multiplication "*"
*/
public final class MultiplyPtg extends ValueOperatorPtg {
- public final static byte sid = 0x05;
+ public static final byte sid = 0x05;
public static final MultiplyPtg instance = new MultiplyPtg();
* See the spec at 2.5.198.76 PtgName
*/
public final class NamePtg extends OperandPtg implements WorkbookDependentFormula {
- public final static short sid = 0x23;
- private final static int SIZE = 5;
+ public static final short sid = 0x23;
+ private static final int SIZE = 5;
/** one-based index to defined name record */
private int field_1_label_index;
* is {@link NameXPxg}
*/
public final class NameXPtg extends OperandPtg implements WorkbookDependentFormula {
- public final static short sid = 0x39;
- private final static int SIZE = 7;
+ public static final short sid = 0x39;
+ private static final int SIZE = 7;
/** index to REF entry in externsheet record */
private final int _sheetRefIndex;
* Ptg class to implement not equal
*/
public final class NotEqualPtg extends ValueOperatorPtg {
- public final static byte sid = 0x0e;
+ public static final byte sid = 0x0e;
public static final NotEqualPtg instance = new NotEqualPtg();
* field using IEEE notation
*/
public final class NumberPtg extends ScalarConstantPtg {
- public final static int SIZE = 9;
- public final static byte sid = 0x1f;
+ public static final int SIZE = 9;
+ public static final byte sid = 0x1f;
private final double field_1_value;
public NumberPtg(LittleEndianInput in) {
* @author andy
*/
public abstract class OperationPtg extends Ptg {
- public final static int TYPE_UNARY = 0;
- public final static int TYPE_BINARY = 1;
- public final static int TYPE_FUNCTION = 2;
+ public static final int TYPE_UNARY = 0;
+ public static final int TYPE_BINARY = 1;
+ public static final int TYPE_FUNCTION = 2;
protected OperationPtg() {}
*/
public final class ParenthesisPtg extends ControlPtg {
- private final static int SIZE = 1;
- public final static byte sid = 0x15;
+ private static final int SIZE = 1;
+ public static final byte sid = 0x15;
public static final ParenthesisPtg instance = new ParenthesisPtg();
* Percent PTG.
*/
public final class PercentPtg extends ValueOperatorPtg {
- public final static int SIZE = 1;
- public final static byte sid = 0x14;
+ public static final int SIZE = 1;
+ public static final byte sid = 0x14;
- private final static String PERCENT = "%";
+ private static final String PERCENT = "%";
public static final PercentPtg instance = new PercentPtg();
package org.apache.poi.ss.formula.ptg;
public final class PowerPtg extends ValueOperatorPtg {
- public final static byte sid = 0x07;
+ public static final byte sid = 0x07;
public static final PowerPtg instance = new PowerPtg();
public final class RangePtg extends OperationPtg {
- public final static int SIZE = 1;
- public final static byte sid = 0x11;
+ public static final int SIZE = 1;
+ public static final byte sid = 0x11;
public static final RangePtg instance = new RangePtg();
import org.apache.poi.util.LittleEndianOutput;
abstract class Ref2DPtgBase extends RefPtgBase {
- private final static int SIZE = 5;
+ private static final int SIZE = 5;
protected Ref2DPtgBase(int row, int column, boolean isRowRelative, boolean isColumnRelative) {
setRow(row);
* is {@link Ref3DPxg}
*/
public final class Ref3DPtg extends RefPtgBase implements WorkbookDependentFormula, ExternSheetReferenceToken {
- public final static byte sid = 0x3a;
+ public static final byte sid = 0x3a;
- private final static int SIZE = 7; // 6 + 1 for Ptg
+ private static final int SIZE = 7; // 6 + 1 for Ptg
private int field_1_index_extern_sheet;
public Ref3DPtg(Ref3DPtg other) {
*/
public final class RefErrorPtg extends OperandPtg {
- private final static int SIZE = 5;
- public final static byte sid = 0x2A;
+ private static final int SIZE = 5;
+ public static final byte sid = 0x2A;
private int field_1_reserved;
public RefErrorPtg() {
import org.apache.poi.util.LittleEndianInput;
public final class RefNPtg extends Ref2DPtgBase {
- public final static byte sid = 0x2C;
+ public static final byte sid = 0x2C;
public RefNPtg(LittleEndianInput in) {
super(in);
* ReferencePtg - handles references (such as A1, A2, IA4)
*/
public final class RefPtg extends Ref2DPtgBase {
- public final static byte sid = 0x24;
+ public static final byte sid = 0x24;
/**
* Takes in a String representation of a cell reference and fills out the
* <length 2 bytes>char[]
*/
public final class StringPtg extends ScalarConstantPtg {
- public final static byte sid = 0x17;
+ public static final byte sid = 0x17;
/** the character (") used in formulas to delimit string literals */
private static final char FORMULA_DELIMITER = '"';
package org.apache.poi.ss.formula.ptg;
public final class SubtractPtg extends ValueOperatorPtg {
- public final static byte sid = 0x04;
+ public static final byte sid = 0x04;
public static final SubtractPtg instance = new SubtractPtg();
* See page 811 of the june 08 binary docs.
*/
public final class TblPtg extends ControlPtg {
- private final static int SIZE = 5;
- public final static short sid = 0x02;
+ private static final int SIZE = 5;
+ public static final short sid = 0x02;
/** The row number of the upper left corner */
private final int field_1_first_row;
* Unary Plus operator - does not have any effect on the operand
*/
public final class UnaryMinusPtg extends ValueOperatorPtg {
- public final static byte sid = 0x13;
+ public static final byte sid = 0x13;
- private final static String MINUS = "-";
+ private static final String MINUS = "-";
public static final UnaryMinusPtg instance = new UnaryMinusPtg();
* Unary Plus operator - does not have any effect on the operand
*/
public final class UnaryPlusPtg extends ValueOperatorPtg {
- public final static byte sid = 0x12;
+ public static final byte sid = 0x12;
- private final static String ADD = "+";
+ private static final String ADD = "+";
public static final UnaryPlusPtg instance = new UnaryPlusPtg();
* @author Glen Stampoultzis (glens at apache.org)
*/
public final class UnionPtg extends OperationPtg {
- public final static byte sid = 0x10;
+ public static final byte sid = 0x10;
public static final UnionPtg instance = new UnionPtg();
*/
public static final int FIRST_USER_DEFINED_FORMAT_INDEX = 164;
- private final static String[] _formats = {
+ private static final String[] _formats = {
"General",
"0",
"0.00",
private final PropertyChangeSupport pcs;
/** For logging any problems we find */
- private static POILogger logger = POILogFactory.getLogger(DataFormatter.class);
+ private static final POILogger LOG = POILogFactory.getLogger(DataFormatter.class);
/**
* Creates a formatter using the {@link Locale#getDefault() default locale}.
// Wrap and return (non-cacheable - CellFormat does that)
return new CellFormatResultWrapper( cfmt.apply(cellValueO) );
} catch (Exception e) {
- logger.log(POILogger.WARN, "Formatting failed for format " + formatStr + ", falling back", e);
+ LOG.log(POILogger.WARN, "Formatting failed for format " + formatStr + ", falling back", e);
}
}
try {
return new ExcelStyleDateFormatter(formatStr, dateSymbols);
} catch(IllegalArgumentException iae) {
- logger.log(POILogger.DEBUG, "Formatting failed for format ", formatStr, ", falling back", iae);
+ LOG.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);
try {
return new InternalDecimalFormatWithScale(format, symbols);
} catch(IllegalArgumentException iae) {
- logger.log(POILogger.DEBUG, "Formatting failed for format ", formatStr, ", falling back", iae);
+ LOG.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);
/**
* The enumeration value indicating the style of fill pattern being used for a cell format.
- *
+ *
*/
public enum FillPatternType {
-
+
/** No background */
NO_FILL(0),
/** Least Dots */
LEAST_DOTS(18);
-
+
/** Codes are used by ExtendedFormatRecord in HSSF */
private final short code;
private FillPatternType(int code) {
this.code = (short) code;
}
-
+
public short getCode() {
return code;
}
-
- private final static int length = values().length;
+
+ private static final int length = values().length;
public static FillPatternType forInt(int code) {
if (code < 0 || code > length) {
throw new IllegalArgumentException("Invalid FillPatternType code: " + code);
GREY_80_PERCENT(63),
AUTOMATIC(64);
- private final static IndexedColors[] _values = new IndexedColors[65];
+ private static final IndexedColors[] _values = new IndexedColors[65];
static {
for (IndexedColors color : values()) {
_values[color.index] = color;
*/
public interface PatternFormatting {
/** No background */
- public final static short NO_FILL = 0 ;
+ public static final short NO_FILL = 0 ;
/** Solidly filled */
- public final static short SOLID_FOREGROUND = 1 ;
+ public static final short SOLID_FOREGROUND = 1 ;
/** Small fine dots */
- public final static short FINE_DOTS = 2 ;
+ public static final short FINE_DOTS = 2 ;
/** Wide dots */
- public final static short ALT_BARS = 3 ;
+ public static final short ALT_BARS = 3 ;
/** Sparse dots */
- public final static short SPARSE_DOTS = 4 ;
+ public static final short SPARSE_DOTS = 4 ;
/** Thick horizontal bands */
- public final static short THICK_HORZ_BANDS = 5 ;
+ public static final short THICK_HORZ_BANDS = 5 ;
/** Thick vertical bands */
- public final static short THICK_VERT_BANDS = 6 ;
+ public static final short THICK_VERT_BANDS = 6 ;
/** Thick backward facing diagonals */
- public final static short THICK_BACKWARD_DIAG = 7 ;
+ public static final short THICK_BACKWARD_DIAG = 7 ;
/** Thick forward facing diagonals */
- public final static short THICK_FORWARD_DIAG = 8 ;
+ public static final short THICK_FORWARD_DIAG = 8 ;
/** Large spots */
- public final static short BIG_SPOTS = 9 ;
+ public static final short BIG_SPOTS = 9 ;
/** Brick-like layout */
- public final static short BRICKS = 10 ;
+ public static final short BRICKS = 10 ;
/** Thin horizontal bands */
- public final static short THIN_HORZ_BANDS = 11 ;
+ public static final short THIN_HORZ_BANDS = 11 ;
/** Thin vertical bands */
- public final static short THIN_VERT_BANDS = 12 ;
+ public static final short THIN_VERT_BANDS = 12 ;
/** Thin backward diagonal */
- public final static short THIN_BACKWARD_DIAG = 13 ;
+ public static final short THIN_BACKWARD_DIAG = 13 ;
/** Thin forward diagonal */
- public final static short THIN_FORWARD_DIAG = 14 ;
+ public static final short THIN_FORWARD_DIAG = 14 ;
/** Squares */
- public final static short SQUARES = 15 ;
+ public static final short SQUARES = 15 ;
/** Diamonds */
- public final static short DIAMONDS = 16 ;
+ public static final short DIAMONDS = 16 ;
/** Less Dots */
- public final static short LESS_DOTS = 17 ;
+ public static final short LESS_DOTS = 17 ;
/** Least Dots */
- public final static short LEAST_DOTS = 18 ;
+ public static final short LEAST_DOTS = 18 ;
short getFillBackgroundColor();
short getFillForegroundColor();
*/
@SuppressWarnings("unused")
public final class DateFormatConverter {
- private static POILogger logger = POILogFactory.getLogger(DateFormatConverter.class);
+ private static final POILogger LOG = POILogFactory.getLogger(DateFormatConverter.class);
private DateFormatConverter() {
}
loc = LocaleID.lookupByLanguageTag(languageTag.substring(0, idx));
}
if (loc == null) {
- logger.log( POILogger.ERROR, "Unable to find prefix for Locale '", languageTag, "' or its parent locales." );
+ LOG.log( POILogger.ERROR, "Unable to find prefix for Locale '", languageTag, "' or its parent locales." );
return "";
}
}
import org.w3c.dom.NodeList;
public final class ImageUtils {
- private static final POILogger logger = POILogFactory.getLogger(ImageUtils.class);
+ private static final POILogger LOG = POILogFactory.getLogger(ImageUtils.class);
private static final int WIDTH_UNITS = 1024;
private static final int HEIGHT_UNITS = 256;
r.dispose();
}
} else {
- logger.log(POILogger.WARN, "ImageIO found no images");
+ LOG.log(POILogger.WARN, "ImageIO found no images");
}
}
} catch (IOException e) {
//silently return if ImageIO failed to read the image
- logger.log(POILogger.WARN, e);
+ LOG.log(POILogger.WARN, e);
}
break;
default:
- logger.log(POILogger.WARN, "Only JPEG, PNG and DIB pictures can be automatically sized");
+ LOG.log(POILogger.WARN, "Only JPEG, PNG and DIB pictures can be automatically sized");
}
return size;
}
* Helper for fetching int values from system properties
*/
public class Configurator {
- private static POILogger logger = POILogFactory.getLogger(Configurator.class);
+ private static final POILogger LOG = POILogFactory.getLogger(Configurator.class);
public static int getIntValue(String systemProperty, int defaultValue) {
String property = System.getProperty(systemProperty);
try {
return Integer.parseInt(property);
} catch (Exception e) {
- logger.log(POILogger.ERROR, "System property -D", systemProperty, " does not contains a valid integer: ", property);
+ LOG.log(POILogger.ERROR, "System property -D", systemProperty, " does not contains a valid integer: ", property);
return defaultValue;
}
}
@Internal
public final class IOUtils {
- private static final POILogger logger = POILogFactory.getLogger( IOUtils.class );
+ private static final POILogger LOG = POILogFactory.getLogger( IOUtils.class );
/**
* The default buffer size to use for the skip() methods.
try {
closeable.close();
} catch ( Exception exc ) {
- logger.log( POILogger.ERROR, "Unable to close resource: ", exc,
+ LOG.log( POILogger.ERROR, "Unable to close resource: ", exc,
exc );
}
}
};
- private static POILogger logger = POILogFactory.getLogger(XMLHelper.class);
+ private static final POILogger LOG = POILogFactory.getLogger(XMLHelper.class);
private static long lastLog;
// DocumentBuilderFactory.newDocumentBuilder is thread-safe
private static void logThrowable(Throwable t, String message, String name) {
if (System.currentTimeMillis() > lastLog + TimeUnit.MINUTES.toMillis(5)) {
- logger.log(POILogger.WARN, message + " [log suppressed for 5 minutes]", name, t);
+ LOG.log(POILogger.WARN, message + " [log suppressed for 5 minutes]", name, t);
lastLog = System.currentTimeMillis();
}
}
':' + ex.getColumnNumber() +
':' + ex.getMessage();
- logger.log(type, message, ex);
+ LOG.log(type, message, ex);
}
}
* </p>
*/
public class POIXMLDocumentPart {
- private static final POILogger logger = POILogFactory.getLogger(POIXMLDocumentPart.class);
+ private static final POILogger LOG = POILogFactory.getLogger(POIXMLDocumentPart.class);
private String coreDocumentRel = PackageRelationshipTypes.CORE_DOCUMENT;
private PackagePart packagePart;
PackagePart pp = getPackagePart();
if (pp.getContentType().equals(XWPFRelation.GLOSSARY_DOCUMENT.getContentType())) {
- logger.log(POILogger.WARN,
+ LOG.log(POILogger.WARN,
"POI does not currently support template.main+xml (glossary) parts. " +
"Skipping this part for now.");
return;
final PackagePart p = packagePart.getPackage().getPart(relName);
if (p == null) {
- logger.log(POILogger.ERROR, "Skipped invalid entry ", rel.getTargetURI());
+ LOG.log(POILogger.ERROR, "Skipped invalid entry ", rel.getTargetURI());
continue;
}
/**
* Logger.
*/
- private static final POILogger logger = POILogFactory.getLogger(OPCPackage.class);
+ private static final POILogger LOG = POILogFactory.getLogger(OPCPackage.class);
/**
* Default package access.
}
if (this.packageAccess == PackageAccess.READ) {
- logger.log(POILogger.WARN,
+ LOG.log(POILogger.WARN,
"The close() method is intended to SAVE a package. This package is open in READ ONLY mode, use the revert() method instead !");
revert();
return;
}
if (this.contentTypeManager == null) {
- logger.log(POILogger.WARN,
+ LOG.log(POILogger.WARN,
"Unable to call close() on a package that hasn't been fully opened yet");
revert();
return;
if (!hasCorePropertiesPart) {
hasCorePropertiesPart = true;
} else {
- logger.log(POILogger.WARN, "OPC Compliance error [M4.1]: " +
+ LOG.log(POILogger.WARN, "OPC Compliance error [M4.1]: " +
"there is more than one core properties relationship in the package! " +
"POI will use only the first, but other software may reject this file.");
}
needCorePropertiesPart = false;
}
} catch (IOException ioe) {
- logger.log(POILogger.WARN, "Unmarshall operation : IOException for "
+ LOG.log(POILogger.WARN, "Unmarshall operation : IOException for "
+ part._partName);
continue;
} catch (InvalidOperationException invoe) {
try {
sourcePartName = PackagingURIHelper.createPartName(sourceURI);
} catch (InvalidFormatException e) {
- logger
+ LOG
.log(POILogger.ERROR, "Part name URI '", sourceURI,
"' is not valid ! This message is not intended to be displayed !");
return;
this.deletePartRecursive(targetPartName);
}
} catch (InvalidFormatException e) {
- logger.log(POILogger.WARN, "An exception occurs while deleting part '"
+ LOG.log(POILogger.WARN, "An exception occurs while deleting part '"
+ partName.getName()
+ "'. Some parts may remain in the package. - "
+ e.getMessage());
try {
partMarshallers.put(new ContentType(contentType), marshaller);
} catch (InvalidFormatException e) {
- logger.log(POILogger.WARN, "The specified content type is not valid: '"
+ LOG.log(POILogger.WARN, "The specified content type is not valid: '"
+ e.getMessage() + "'. The marshaller will not be added !");
}
}
try {
partUnmarshallers.put(new ContentType(contentType), unmarshaller);
} catch (InvalidFormatException e) {
- logger.log(POILogger.WARN, "The specified content type is not valid: '"
+ LOG.log(POILogger.WARN, "The specified content type is not valid: '"
+ e.getMessage()
+ "'. The unmarshaller will not be added !");
}
* @author Julien Chable, CDubettier
* @version 0.1
*/
-public final class PackageRelationshipCollection implements
- Iterable<PackageRelationship> {
+public final class PackageRelationshipCollection implements Iterable<PackageRelationship> {
- private final static POILogger logger = POILogFactory.getLogger(PackageRelationshipCollection.class);
+ private static final POILogger LOG = POILogFactory.getLogger(PackageRelationshipCollection.class);
/**
* Package relationships ordered by ID.
public void parseRelationshipsPart(PackagePart relPart)
throws InvalidFormatException {
try {
- logger.log(POILogger.DEBUG, "Parsing relationship: ", relPart.getPartName());
+ LOG.log(POILogger.DEBUG, "Parsing relationship: ", relPart.getPartName());
Document xmlRelationshipsDoc = DocumentHelper.readDocument(relPart.getInputStream());
// Browse default types
// package
target = PackagingURIHelper.toURI(value);
} catch (URISyntaxException e) {
- logger.log(POILogger.ERROR, "Cannot convert ", value,
+ LOG.log(POILogger.ERROR, "Cannot convert ", value,
" in a valid relationship URI-> dummy-URI used", e);
}
addRelationship(target, targetMode, type, id);
// FIXME: this class implements a lot of path joining and splitting logic that
// is already implemented in java.nio.file.Path.
// This class should heavily leverage Java library code to reduce the number of lines of code that POI has to maintain and test
- private final static POILogger _logger = POILogFactory.getLogger(PackagingURIHelper.class);
+ private static final POILogger LOG = POILogFactory.getLogger(PackagingURIHelper.class);
/**
* Package root URI.
try {
targetURI = new URI(path.substring(1));
} catch (Exception e) {
- _logger.log(POILogger.WARN, e);
+ LOG.log(POILogger.WARN, e);
return null;
}
}
try {
return new URI(retVal.toString());
} catch (Exception e) {
- _logger.log(POILogger.WARN, e);
+ LOG.log(POILogger.WARN, e);
return null;
}
}
try {
return new URI(retVal.toString());
} catch (Exception e) {
- _logger.log(POILogger.WARN, e);
+ LOG.log(POILogger.WARN, e);
return null;
}
}
* <code>null</code>.
*/
public static URI relativizeURI(URI sourceURI, URI targetURI) {
- return relativizeURI(sourceURI, targetURI, false);
+ return relativizeURI(sourceURI, targetURI, false);
}
/**
return sb.toString();
}
- private final static char[] hexDigits = {
+ private static final char[] hexDigits = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
};
/**
* Media type compiled pattern, without parameters
*/
- private final static Pattern patternTypeSubType;
+ private static final Pattern patternTypeSubType;
/**
* Media type compiled pattern, with parameters.
*/
- private final static Pattern patternTypeSubTypeParams;
+ private static final Pattern patternTypeSubTypeParams;
/**
* Pattern to match on just the parameters part, to work
* around the Java Regexp group capture behaviour
*/
- private final static Pattern patternParams;
+ private static final Pattern patternParams;
static {
/*
*/
public final class PackagePropertiesPart extends PackagePart implements PackageProperties {
- public final static String NAMESPACE_DC_URI = PackageProperties.NAMESPACE_DC;
+ public static final String NAMESPACE_DC_URI = PackageProperties.NAMESPACE_DC;
- public final static String NAMESPACE_CP_URI = PackageNamespaces.CORE_PROPERTIES;
+ public static final String NAMESPACE_CP_URI = PackageNamespaces.CORE_PROPERTIES;
- public final static String NAMESPACE_DCTERMS_URI = PackageProperties.NAMESPACE_DCTERMS;
+ public static final String NAMESPACE_DCTERMS_URI = PackageProperties.NAMESPACE_DCTERMS;
- private final static String DEFAULT_DATEFORMAT = "yyyy-MM-dd'T'HH:mm:ss'Z'";
+ private static final String DEFAULT_DATEFORMAT = "yyyy-MM-dd'T'HH:mm:ss'Z'";
- private final static String[] DATE_FORMATS = new String[]{
+ private static final String[] DATE_FORMATS = new String[]{
DEFAULT_DATEFORMAT,
"yyyy-MM-dd'T'HH:mm:ss.SS'Z'",
"yyyy-MM-dd"
* @see ContentTypeManager
*/
public class ZipContentTypeManager extends ContentTypeManager {
- private final static POILogger logger = POILogFactory.getLogger(ZipContentTypeManager.class);
+ private static final POILogger LOG = POILogFactory.getLogger(ZipContentTypeManager.class);
/**
* Delegate constructor to the super constructor.
zos.closeArchiveEntry();
}
} catch (IOException ioe) {
- logger.log(POILogger.ERROR, "Cannot write: ", CONTENT_TYPES_PART_NAME,
+ LOG.log(POILogger.ERROR, "Cannot write: ", CONTENT_TYPES_PART_NAME,
" in Zip !", ioe);
return false;
}
* Forward slash use to convert part name between OPC and zip item naming
* conventions.
*/
- private final static String FORWARD_SLASH = "/";
+ private static final String FORWARD_SLASH = "/";
/**
* Prevent this class to be instancied.
* Package properties marshaller.
*/
public class PackagePropertiesMarshaller implements PartMarshaller {
- private final static NamespaceImpl namespaceDC =
+ private static final NamespaceImpl namespaceDC =
new NamespaceImpl("dc", PackagePropertiesPart.NAMESPACE_DC_URI);
- private final static NamespaceImpl namespaceCoreProperties =
+ private static final NamespaceImpl namespaceCoreProperties =
new NamespaceImpl("cp", PackagePropertiesPart.NAMESPACE_CP_URI);
- private final static NamespaceImpl namespaceDcTerms =
+ private static final NamespaceImpl namespaceDcTerms =
new NamespaceImpl("dcterms", PackagePropertiesPart.NAMESPACE_DCTERMS_URI);
- private final static NamespaceImpl namespaceXSI =
+ private static final NamespaceImpl namespaceXSI =
new NamespaceImpl("xsi", XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI);
protected static final String KEYWORD_CATEGORY = "category";
* Zip part marshaller. This marshaller is use to save any part in a zip stream.
*/
public final class ZipPartMarshaller implements PartMarshaller {
- private final static POILogger logger = POILogFactory.getLogger(ZipPartMarshaller.class);
+ private static final POILogger LOG = POILogFactory.getLogger(ZipPartMarshaller.class);
/**
* Save the specified part to the given stream.
public boolean marshall(PackagePart part, OutputStream os)
throws OpenXML4JException {
if (!(os instanceof ZipArchiveOutputStream)) {
- logger.log(POILogger.ERROR,"Unexpected class ", os.getClass().getName());
+ LOG.log(POILogger.ERROR,"Unexpected class ", os.getClass().getName());
throw new OpenXML4JException("ZipOutputStream expected !");
// Normally should happen only in development phase, so just throw
// exception
zos.closeArchiveEntry();
}
} catch (IOException ioe) {
- logger.log(POILogger.ERROR,"Cannot write: ", part.getPartName(), ": in ZIP",
+ LOG.log(POILogger.ERROR,"Cannot write: ", part.getPartName(), ": in ZIP",
ioe);
return false;
}
zos.closeArchiveEntry();
}
} catch (IOException e) {
- logger.log(POILogger.ERROR,"Cannot create zip entry ", relPartName, e);
+ LOG.log(POILogger.ERROR,"Cannot create zip entry ", relPartName, e);
return false;
}
}
public class EncryptedTempData {
private static POILogger LOG = POILogFactory.getLogger(EncryptedTempData.class);
- private final static CipherAlgorithm cipherAlgorithm = CipherAlgorithm.aes128;
- private final static String PADDING = "PKCS5Padding";
+ private static final CipherAlgorithm cipherAlgorithm = CipherAlgorithm.aes128;
+ private static final String PADDING = "PKCS5Padding";
private final SecretKeySpec skeySpec;
private final byte[] ivBytes;
private final File tempFile;
@Beta
public class SheetDataWriterWithDecorator extends SheetDataWriter {
- final static CipherAlgorithm cipherAlgorithm = CipherAlgorithm.aes128;
+ static final CipherAlgorithm cipherAlgorithm = CipherAlgorithm.aes128;
SecretKeySpec skeySpec;
byte[] ivBytes;
-
+
public SheetDataWriterWithDecorator() throws IOException {
super();
}
-
+
void init() {
if(skeySpec == null) {
SecureRandom sr = new SecureRandom();
Cipher ciEnc = CryptoFunctions.getCipher(skeySpec, cipherAlgorithm, ChainingMode.cbc, ivBytes, Cipher.ENCRYPT_MODE, "PKCS5Padding");
return new CipherOutputStream(fos, ciEnc);
}
-
+
@Override
protected InputStream decorateInputStream(FileInputStream fis) {
Cipher ciDec = CryptoFunctions.getCipher(skeySpec, cipherAlgorithm, ChainingMode.cbc, ivBytes, Cipher.DECRYPT_MODE, "PKCS5Padding");
this.underlying = mode;
}
- private final static HashMap<STBlackWhiteMode.Enum, BlackWhiteMode> reverse = new HashMap<>();
+ private static final HashMap<STBlackWhiteMode.Enum, BlackWhiteMode> reverse = new HashMap<>();
static {
for (BlackWhiteMode value : values()) {
reverse.put(value.underlying, value);
this.underlying = line;
}
- private final static HashMap<STCompoundLine.Enum, CompoundLine> reverse = new HashMap<>();
+ private static final HashMap<STCompoundLine.Enum, CompoundLine> reverse = new HashMap<>();
static {
for (CompoundLine value : values()) {
reverse.put(value.underlying, value);
this.underlying = line;
}
- private final static HashMap<STLineCap.Enum, LineCap> reverse = new HashMap<>();
+ private static final HashMap<STLineCap.Enum, LineCap> reverse = new HashMap<>();
static {
for (LineCap value : values()) {
reverse.put(value.underlying, value);
this.underlying = lineEnd;
}
- private final static HashMap<STLineEndLength.Enum, LineEndLength> reverse = new HashMap<>();
+ private static final HashMap<STLineEndLength.Enum, LineEndLength> reverse = new HashMap<>();
static {
for (LineEndLength value : values()) {
reverse.put(value.underlying, value);
this.underlying = lineEnd;
}
- private final static HashMap<STLineEndType.Enum, LineEndType> reverse = new HashMap<>();
+ private static final HashMap<STLineEndType.Enum, LineEndType> reverse = new HashMap<>();
static {
for (LineEndType value : values()) {
reverse.put(value.underlying, value);
this.underlying = lineEnd;
}
- private final static HashMap<STLineEndWidth.Enum, LineEndWidth> reverse = new HashMap<>();
+ private static final HashMap<STLineEndWidth.Enum, LineEndWidth> reverse = new HashMap<>();
static {
for (LineEndWidth value : values()) {
reverse.put(value.underlying, value);
this.underlying = pathShadeType;
}
- private final static HashMap<STPathShadeType.Enum, PathShadeType> reverse = new HashMap<>();
+ private static final HashMap<STPathShadeType.Enum, PathShadeType> reverse = new HashMap<>();
static {
for (PathShadeType value : values()) {
reverse.put(value.underlying, value);
this.underlying = alignment;
}
- private final static HashMap<STPenAlignment.Enum, PenAlignment> reverse = new HashMap<>();
+ private static final HashMap<STPenAlignment.Enum, PenAlignment> reverse = new HashMap<>();
static {
for (PenAlignment value : values()) {
reverse.put(value.underlying, value);
this.underlying = color;
}
- private final static HashMap<STPresetColorVal.Enum, PresetColor> reverse = new HashMap<>();
+ private static final HashMap<STPresetColorVal.Enum, PresetColor> reverse = new HashMap<>();
static {
for (PresetColor value : values()) {
reverse.put(value.underlying, value);
this.underlying = shape;
}
- private final static HashMap<STShapeType.Enum, PresetGeometry> reverse = new HashMap<>();
+ private static final HashMap<STShapeType.Enum, PresetGeometry> reverse = new HashMap<>();
static {
for (PresetGeometry value : values()) {
reverse.put(value.underlying, value);
this.underlying = dash;
}
- private final static HashMap<STPresetLineDashVal.Enum, PresetLineDash> reverse = new HashMap<>();
+ private static final HashMap<STPresetLineDashVal.Enum, PresetLineDash> reverse = new HashMap<>();
static {
for (PresetLineDash value : values()) {
reverse.put(value.underlying, value);
this.underlying = pattern;
}
- private final static HashMap<STPresetPatternVal.Enum, PresetPattern> reverse = new HashMap<>();
+ private static final HashMap<STPresetPatternVal.Enum, PresetPattern> reverse = new HashMap<>();
static {
for (PresetPattern value : values()) {
reverse.put(value.underlying, value);
this.underlying = alignment;
}
- private final static HashMap<STRectAlignment.Enum, RectangleAlignment> reverse = new HashMap<>();
+ private static final HashMap<STRectAlignment.Enum, RectangleAlignment> reverse = new HashMap<>();
static {
for (RectangleAlignment value : values()) {
reverse.put(value.underlying, value);
this.underlying = color;
}
- private final static HashMap<STSchemeColorVal.Enum, SchemeColor> reverse = new HashMap<>();
+ private static final HashMap<STSchemeColorVal.Enum, SchemeColor> reverse = new HashMap<>();
static {
for (SchemeColor value : values()) {
reverse.put(value.underlying, value);
this.underlying = color;
}
- private final static HashMap<STSystemColorVal.Enum, SystemColor> reverse = new HashMap<>();
+ private static final HashMap<STSystemColorVal.Enum, SystemColor> reverse = new HashMap<>();
static {
for (SystemColor value : values()) {
reverse.put(value.underlying, value);
this.underlying = mode;
}
- private final static HashMap<STTileFlipMode.Enum, TileFlipMode> reverse = new HashMap<>();
+ private static final HashMap<STTileFlipMode.Enum, TileFlipMode> reverse = new HashMap<>();
static {
for (TileFlipMode value : values()) {
reverse.put(value.underlying, value);
this.underlying = crossBetween;
}
- private final static HashMap<STCrossBetween.Enum, AxisCrossBetween> reverse = new HashMap<>();
+ private static final HashMap<STCrossBetween.Enum, AxisCrossBetween> reverse = new HashMap<>();
static {
for (AxisCrossBetween value : values()) {
reverse.put(value.underlying, value);
this.underlying = crosses;
}
- private final static HashMap<STCrosses.Enum, AxisCrosses> reverse = new HashMap<>();
+ private static final HashMap<STCrosses.Enum, AxisCrosses> reverse = new HashMap<>();
static {
for (AxisCrosses value : values()) {
reverse.put(value.underlying, value);
this.underlying = alignment;
}
- private final static HashMap<STLblAlgn.Enum, AxisLabelAlignment> reverse = new HashMap<>();
+ private static final HashMap<STLblAlgn.Enum, AxisLabelAlignment> reverse = new HashMap<>();
static {
for (AxisLabelAlignment value : values()) {
reverse.put(value.underlying, value);
this.underlying = orientation;
}
- private final static HashMap<STOrientation.Enum, AxisOrientation> reverse = new HashMap<>();
+ private static final HashMap<STOrientation.Enum, AxisOrientation> reverse = new HashMap<>();
static {
for (AxisOrientation value : values()) {
reverse.put(value.underlying, value);
this.underlying = position;
}
- private final static HashMap<STAxPos.Enum, AxisPosition> reverse = new HashMap<>();
+ private static final HashMap<STAxPos.Enum, AxisPosition> reverse = new HashMap<>();
static {
for (AxisPosition value : values()) {
reverse.put(value.underlying, value);
this.underlying = position;
}
- private final static HashMap<STTickLblPos.Enum, AxisTickLabelPosition> reverse = new HashMap<>();
+ private static final HashMap<STTickLblPos.Enum, AxisTickLabelPosition> reverse = new HashMap<>();
static {
for (AxisTickLabelPosition value : values()) {
reverse.put(value.underlying, value);
this.underlying = tickMark;
}
- private final static HashMap<STTickMark.Enum, AxisTickMark> reverse = new HashMap<>();
+ private static final HashMap<STTickMark.Enum, AxisTickMark> reverse = new HashMap<>();
static {
for (AxisTickMark value : values()) {
reverse.put(value.underlying, value);
this.underlying = direction;
}
- private final static HashMap<STBarDir.Enum, BarDirection> reverse = new HashMap<>();
+ private static final HashMap<STBarDir.Enum, BarDirection> reverse = new HashMap<>();
static {
for (BarDirection value : values()) {
reverse.put(value.underlying, value);
this.underlying = grouping;
}
- private final static HashMap<STBarGrouping.Enum, BarGrouping> reverse = new HashMap<>();
+ private static final HashMap<STBarGrouping.Enum, BarGrouping> reverse = new HashMap<>();
static {
for (BarGrouping value : values()) {
reverse.put(value.underlying, value);
this.underlying = mode;
}
- private final static HashMap<STDispBlanksAs.Enum, DisplayBlanks> reverse = new HashMap<>();
+ private static final HashMap<STDispBlanksAs.Enum, DisplayBlanks> reverse = new HashMap<>();
static {
for (DisplayBlanks value : values()) {
reverse.put(value.underlying, value);
this.underlying = barType;
}
- private final static HashMap<STErrBarType.Enum, ErrorBarType> reverse = new HashMap<>();
+ private static final HashMap<STErrBarType.Enum, ErrorBarType> reverse = new HashMap<>();
static {
for (ErrorBarType value : values()) {
reverse.put(value.underlying, value);
this.underlying = direction;
}
- private final static HashMap<STErrDir.Enum, ErrorDirection> reverse = new HashMap<>();
+ private static final HashMap<STErrDir.Enum, ErrorDirection> reverse = new HashMap<>();
static {
for (ErrorDirection value : values()) {
reverse.put(value.underlying, value);
this.underlying = valueType;
}
- private final static HashMap<STErrValType.Enum, ErrorValueType> reverse = new HashMap<>();
+ private static final HashMap<STErrValType.Enum, ErrorValueType> reverse = new HashMap<>();
static {
for (ErrorValueType value : values()) {
reverse.put(value.underlying, value);
this.underlying = grouping;
}
- private final static HashMap<STGrouping.Enum, Grouping> reverse = new HashMap<STGrouping.Enum, Grouping>();
+ private static final HashMap<STGrouping.Enum, Grouping> reverse = new HashMap<STGrouping.Enum, Grouping>();
static {
for (Grouping value : values()) {
reverse.put(value.underlying, value);
this.underlying = layoutMode;
}
- private final static HashMap<STLayoutMode.Enum, LayoutMode> reverse = new HashMap<>();
+ private static final HashMap<STLayoutMode.Enum, LayoutMode> reverse = new HashMap<>();
static {
for (LayoutMode value : values()) {
reverse.put(value.underlying, value);
this.underlying = layoutTarget;
}
- private final static HashMap<STLayoutTarget.Enum, LayoutTarget> reverse = new HashMap<>();
+ private static final HashMap<STLayoutTarget.Enum, LayoutTarget> reverse = new HashMap<>();
static {
for (LayoutTarget value : values()) {
reverse.put(value.underlying, value);
this.underlying = position;
}
- private final static HashMap<STLegendPos.Enum, LegendPosition> reverse = new HashMap<>();
+ private static final HashMap<STLegendPos.Enum, LegendPosition> reverse = new HashMap<>();
static {
for (LegendPosition value : values()) {
reverse.put(value.underlying, value);
this.underlying = style;
}
- private final static HashMap<STMarkerStyle.Enum, MarkerStyle> reverse = new HashMap<>();
+ private static final HashMap<STMarkerStyle.Enum, MarkerStyle> reverse = new HashMap<>();
static {
for (MarkerStyle value : values()) {
reverse.put(value.underlying, value);
this.underlying = style;
}
- private final static HashMap<STRadarStyle.Enum, RadarStyle> reverse = new HashMap<>();
+ private static final HashMap<STRadarStyle.Enum, RadarStyle> reverse = new HashMap<>();
static {
for (RadarStyle value : values()) {
reverse.put(value.underlying, value);
this.underlying = style;
}
- private final static HashMap<STScatterStyle.Enum, ScatterStyle> reverse = new HashMap<>();
+ private static final HashMap<STScatterStyle.Enum, ScatterStyle> reverse = new HashMap<>();
static {
for (ScatterStyle value : values()) {
reverse.put(value.underlying, value);
this.underlying = grouping;
}
- private final static HashMap<STShape.Enum, Shape> reverse = new HashMap<>();
+ private static final HashMap<STShape.Enum, Shape> reverse = new HashMap<>();
static {
for (Shape value : values()) {
reverse.put(value.underlying, value);
this.underlying = caps;
}
- private final static HashMap<STTextAnchoringType.Enum, AnchorType> reverse = new HashMap<>();
+ private static final HashMap<STTextAnchoringType.Enum, AnchorType> reverse = new HashMap<>();
static {
for (AnchorType value : values()) {
reverse.put(value.underlying, value);
this.underlying = scheme;
}
- private final static HashMap<STTextAutonumberScheme.Enum, AutonumberScheme> reverse = new HashMap<>();
+ private static final HashMap<STTextAutonumberScheme.Enum, AutonumberScheme> reverse = new HashMap<>();
static {
for (AutonumberScheme value : values()) {
reverse.put(value.underlying, value);
this.underlying = caps;
}
- private final static HashMap<STTextCapsType.Enum, CapsType> reverse = new HashMap<>();
+ private static final HashMap<STTextCapsType.Enum, CapsType> reverse = new HashMap<>();
static {
for (CapsType value : values()) {
reverse.put(value.underlying, value);
this.underlying = align;
}
- private final static HashMap<STTextFontAlignType.Enum, FontAlignment> reverse = new HashMap<>();
+ private static final HashMap<STTextFontAlignType.Enum, FontAlignment> reverse = new HashMap<>();
static {
for (FontAlignment value : values()) {
reverse.put(value.underlying, value);
this.underlying = strike;
}
- private final static HashMap<STTextStrikeType.Enum, StrikeType> reverse = new HashMap<>();
+ private static final HashMap<STTextStrikeType.Enum, StrikeType> reverse = new HashMap<>();
static {
for (StrikeType value : values()) {
reverse.put(value.underlying, value);
this.underlying = align;
}
- private final static HashMap<STTextTabAlignType.Enum, TabAlignment> reverse = new HashMap<>();
+ private static final HashMap<STTextTabAlignType.Enum, TabAlignment> reverse = new HashMap<>();
static {
for (TabAlignment value : values()) {
reverse.put(value.underlying, value);
this.underlying = align;
}
- private final static HashMap<STTextAlignType.Enum, TextAlignment> reverse = new HashMap<>();
+ private static final HashMap<STTextAlignType.Enum, TextAlignment> reverse = new HashMap<>();
static {
for (TextAlignment value : values()) {
reverse.put(value.underlying, value);
this.underlying = underline;
}
- private final static HashMap<STTextUnderlineType.Enum, UnderlineType> reverse = new HashMap<>();
+ private static final HashMap<STTextUnderlineType.Enum, UnderlineType> reverse = new HashMap<>();
static {
for (UnderlineType value : values()) {
reverse.put(value.underlying, value);
@Beta
public class XSLFGroupShape extends XSLFShape
implements XSLFShapeContainer, GroupShape<XSLFShape,XSLFTextParagraph> {
- private final static POILogger _logger = POILogFactory.getLogger(XSLFGroupShape.class);
+ private static final POILogger LOG = POILogFactory.getLogger(XSLFGroupShape.class);
private final List<XSLFShape> _shapes;
private final CTGroupShapeProperties _grpSpPr;
} else if (shape instanceof XSLFTable) {
newShape = createTable();
} else {
- _logger.log(POILogger.WARN, "copying of class "+shape.getClass()+" not supported.");
+ LOG.log(POILogger.WARN, "copying of class "+shape.getClass()+" not supported.");
continue;
}
* you need to implement for reading information from a file.
*/
public class XSSFSheetXMLHandler extends DefaultHandler {
- private static final POILogger logger = POILogFactory.getLogger(XSSFSheetXMLHandler.class);
+ private static final POILogger LOG = POILogFactory.getLogger(XSSFSheetXMLHandler.class);
/**
* These are the different kinds of cells we support.
SST_STRING,
NUMBER,
}
-
+
/**
* Table with the styles used for formatting
*/
this.formatter = dataFormatter;
init(comments);
}
-
+
/**
* Accepts objects needed while parsing.
*
boolean formulasNotResults) {
this(styles, null, strings, sheetContentsHandler, dataFormatter, formulasNotResults);
}
-
+
/**
* Accepts objects needed while parsing.
*
boolean formulasNotResults) {
this(styles, strings, sheetContentsHandler, new DataFormatter(), formulasNotResults);
}
-
+
private void init(Comments commentsTable) {
if (commentsTable != null) {
commentCellRefs = new LinkedList<>();
// It isn't a text tag
return false;
}
-
+
@Override
@SuppressWarnings("unused")
public void startElement(String uri, String localName, String qName,
} else if ("f".equals(localName)) {
// Clear contents cache
formula.setLength(0);
-
+
// Mark us as being a formula if not already
if(nextDataType == xssfDataType.NUMBER) {
nextDataType = xssfDataType.FORMULA;
}
-
+
// Decide where to get the formula string from
String type = attributes.getValue("t");
if(type != null && type.equals("shared")) {
// Is it the one that defines the shared, or uses it?
String ref = attributes.getValue("ref");
String si = attributes.getValue("si");
-
+
if(ref != null) {
// This one defines it
// TODO Save it somewhere
fIsOpen = true;
} else {
// This one uses a shared formula
- // TODO Retrieve the shared formula and tweak it to
+ // TODO Retrieve the shared formula and tweak it to
// match the current cell
if(formulasNotResults) {
- logger.log(POILogger.WARN, "shared formulas not yet supported!");
+ LOG.log(POILogger.WARN, "shared formulas not yet supported!");
} /*else {
// It's a shared formula, so we can't get at the formula string yet
// However, they don't care about the formula string, so that's ok!
// v => contents of a cell
if (isTextTag(localName)) {
vIsOpen = false;
-
+
// Process the value contents as required, now we have it all
switch (nextDataType) {
case BOOLEAN:
thisStr = formula.toString();
} else {
String fv = value.toString();
-
+
if (this.formatString != null) {
try {
// Try to use the value as a formattable number
thisStr = rtss.toString();
}
catch (NumberFormatException ex) {
- logger.log(POILogger.ERROR, "Failed to parse SST index '", sstIndex, ex);
+ LOG.log(POILogger.ERROR, "Failed to parse SST index '", sstIndex, ex);
}
break;
thisStr = "(TODO: Unexpected type: " + nextDataType + ")";
break;
}
-
+
// Do we have a comment for this cell?
checkForEmptyCellComments(EmptyCellCommentsCheckType.CELL);
XSSFComment comment = comments != null ? comments.findCellComment(new CellAddress(cellRef)) : null;
-
+
// Output
output.cell(cellRef, thisStr, comment);
} else if ("f".equals(localName)) {
} else if ("row".equals(localName)) {
// Handle any "missing" cells which had comments attached
checkForEmptyCellComments(EmptyCellCommentsCheckType.END_OF_ROW);
-
+
// Finish up the row
output.endRow(rowNum);
-
+
// some sheets do not have rowNum set in the XML, Excel can read them so we should try to read them as well
nextRowNum = rowNum + 1;
} else if ("sheetData".equals(localName)) {
headerFooter.append(ch, start, length);
}
}
-
+
/**
* Do a check for, and output, comments in otherwise empty cells.
*/
XSSFComment comment = comments.findCellComment(cellRef);
output.cell(cellRef.formatAsString(), null, comment);
}
-
+
private enum EmptyCellCommentsCheckType {
CELL,
END_OF_ROW,
void endRow(int rowNum);
/**
- * A cell, with the given formatted value (may be null),
+ * A cell, with the given formatted value (may be null),
* and possibly a comment (may be null), was encountered.
*
* Sheets that have missing or empty cells may result in
private final XSSFMap _map;
- private static final POILogger logger = POILogFactory.getLogger(XSSFImportFromXML.class);
+ private static final POILogger LOG = POILogFactory.getLogger(XSSFImportFromXML.class);
public XSSFImportFromXML(XSSFMap map) {
_map = map;
// result can be null if value is optional (xsd:minOccurs=0), see bugzilla 55864
if (result != null) {
String textContent = result.getTextContent();
- logger.log(POILogger.DEBUG, "Extracting with xpath " + xpathString + " : value is '" + textContent + "'");
+ LOG.log(POILogger.DEBUG, "Extracting with xpath " + xpathString + " : value is '" + textContent + "'");
XSSFCell cell = singleXmlCell.getReferencedCell();
- logger.log(POILogger.DEBUG, "Setting '" + textContent + "' to cell " + cell.getColumnIndex() + "-" + cell.getRowIndex() + " in sheet "
+ LOG.log(POILogger.DEBUG, "Setting '" + textContent + "' to cell " + cell.getColumnIndex() + "-" + cell.getRowIndex() + " in sheet "
+ cell.getSheet().getSheetName());
setCellValue(textContent, cell, xmlDataType);
}
// TODO: convert the data to the cell format
String value = (String) xpath.evaluate(localXPath, singleNode, XPathConstants.STRING);
- logger.log(POILogger.DEBUG, "Extracting with xpath " + localXPath + " : value is '" + value + "'");
+ LOG.log(POILogger.DEBUG, "Extracting with xpath " + localXPath + " : value is '" + value + "'");
XSSFRow row = table.getXSSFSheet().getRow(rowId);
if (row == null) {
row = table.getXSSFSheet().createRow(rowId);
if (cell == null) {
cell = row.createCell(columnId);
}
- logger.log(POILogger.DEBUG, "Setting '" + value + "' to cell " + cell.getColumnIndex() + "-" + cell.getRowIndex() + " in sheet "
+ LOG.log(POILogger.DEBUG, "Setting '" + value + "' to cell " + cell.getColumnIndex() + "-" + cell.getRowIndex() + " in sheet "
+ table.getXSSFSheet().getSheetName());
setCellValue(value, cell, xmlColumnPr.getXmlDataType());
}
/**
* An variant of SXSSFWorkbook that avoids generating a temporary file and writes data directly to
* the provided OutputStream.
- *
+ *
* This variant is experimental and APIs may change at short notice.
- *
+ *
* @since 5.0.0
*/
@Beta
public class DeferredSXSSFWorkbook extends SXSSFWorkbook {
- private static final POILogger logger = POILogFactory.getLogger(DeferredSXSSFWorkbook.class);
-
+ private static final POILogger LOG = POILogFactory.getLogger(DeferredSXSSFWorkbook.class);
+
public DeferredSXSSFWorkbook() {
this(null);
}
public DeferredSXSSFWorkbook(int rowAccessWindowSize) { this(null, rowAccessWindowSize); }
-
+
public DeferredSXSSFWorkbook(XSSFWorkbook workbook) {
this(workbook, SXSSFWorkbook.DEFAULT_WINDOW_SIZE);
}
-
+
public DeferredSXSSFWorkbook(XSSFWorkbook workbook, int rowAccessWindowSize) {
super(workbook, rowAccessWindowSize, false, false);
}
protected SheetDataWriter createSheetDataWriter() throws IOException {
throw new RuntimeException("Not supported by DeferredSXSSFWorkbook");
}
-
+
protected StreamingSheetWriter createSheetDataWriter(OutputStream out) throws IOException {
return new StreamingSheetWriter(out);
}
-
+
@Override
protected ISheetInjector createSheetInjector(SXSSFSheet sxSheet) throws IOException {
DeferredSXSSFSheet ssxSheet = (DeferredSXSSFSheet) sxSheet;
ssxSheet.writeRows(output);
};
}
-
+
@Override
SXSSFSheet createAndRegisterSXSSFSheet(XSSFSheet xSheet) {
final DeferredSXSSFSheet sxSheet;
registerSheetMapping(sxSheet, xSheet);
return sxSheet;
}
-
+
public DeferredSXSSFSheet createSheet() {
return (DeferredSXSSFSheet) super.createSheet();
}
-
+
public DeferredSXSSFSheet createSheet(String sheetname) {
return (DeferredSXSSFSheet) super.createSheet(sheetname);
}
-
+
/**
* Returns an iterator of the sheets in the workbook in sheet order. Includes hidden and very hidden sheets.
*
public Iterator<Sheet> sheetIterator() {
return new SheetIterator<>();
}
-
+
/**
* Gets the sheet at the given index for streaming.
*
return (DeferredSXSSFSheet) sxSheet;
}
}
-
+
public XSSFSheet getXSSFSheet(String name) {
return _wb.getSheet(name);
}
-
+
/**
* Gets sheet with the given name for streaming.
*
return sxSheet;
}
}
-
+
/**
* Removes sheet at the given index
*
// Get the sheet to be removed
XSSFSheet xSheet = _wb.getSheetAt(index);
SXSSFSheet sxSheet = getSXSSFSheet(xSheet);
-
+
// De-register it
_wb.removeSheetAt(index);
-
+
// The sheet may not be a streaming sheet and is not mapped
if (sxSheet != null) {
deregisterSheetMapping(xSheet);
-
+
// Clean up temporary resources
try {
sxSheet.dispose();
} catch (IOException e) {
- logger.log(POILogger.WARN, e);
+ LOG.log(POILogger.WARN, e);
}
}
}
* regular XSSF Workbook
*/
public class SXSSFCreationHelper implements CreationHelper {
- private static final POILogger logger = POILogFactory.getLogger(SXSSFCreationHelper.class);
-
+ private static final POILogger LOG = POILogFactory.getLogger(SXSSFCreationHelper.class);
+
private final SXSSFWorkbook wb;
private final XSSFCreationHelper helper;
-
+
/**
* Should only be called by {@link SXSSFWorkbook#getCreationHelper()}
*
@Override
public XSSFRichTextString createRichTextString(String text) {
- logger.log(POILogger.INFO, "SXSSF doesn't support Rich Text Strings, any formatting information will be lost");
+ LOG.log(POILogger.INFO, "SXSSF doesn't support Rich Text Strings, any formatting information will be lost");
return new XSSFRichTextString(text);
}
public ClientAnchor createClientAnchor() {
return helper.createClientAnchor();
}
-
+
/**
* {@inheritDoc}
*/
import org.apache.poi.xssf.usermodel.BaseXSSFFormulaEvaluator;
/**
- * Streaming-specific Formula Evaluator, which is able to
+ * Streaming-specific Formula Evaluator, which is able to
* lookup cells within the current Window.
*/
public final class SXSSFFormulaEvaluator extends BaseXSSFFormulaEvaluator {
- private static final POILogger logger = POILogFactory.getLogger(SXSSFFormulaEvaluator.class);
-
- private SXSSFWorkbook wb;
-
+ private static final POILogger LOG = POILogFactory.getLogger(SXSSFFormulaEvaluator.class);
+
+ private final SXSSFWorkbook wb;
+
public SXSSFFormulaEvaluator(SXSSFWorkbook workbook) {
this(workbook, null, null);
}
super(bookEvaluator);
this.wb = workbook;
}
-
+
/**
* @param stabilityClassifier used to optimise caching performance. Pass <code>null</code>
* for the (conservative) assumption that any cell may have its definition changed after
return new SXSSFEvaluationCell((SXSSFCell)cell);
}
-
+
@Override
public SXSSFCell evaluateInCell(Cell cell) {
return (SXSSFCell) super.evaluateInCell(cell);
}
-
+
/**
* For active worksheets only, will loop over rows and
* cells, evaluating formula cells there.
*/
public static void evaluateAllFormulaCells(SXSSFWorkbook wb, boolean skipOutOfWindow) {
SXSSFFormulaEvaluator eval = new SXSSFFormulaEvaluator(wb);
-
+
// Check they're all available
for (Sheet sheet : wb) {
if (((SXSSFSheet)sheet).areAllRowsFlushed()) {
throw new SheetsFlushedException();
}
}
-
+
// Process the sheets as best we can
for (Sheet sheet : wb) {
-
+
if (sheet instanceof SXSSFSheet) {
// Check if any rows have already been flushed out
int lastFlushedRowNum = ((SXSSFSheet) sheet).getLastFlushedRowNum();
if (lastFlushedRowNum > -1) {
if (! skipOutOfWindow) throw new RowFlushedException(0);
- logger.log(POILogger.INFO, "Rows up to ", lastFlushedRowNum, " have already been flushed, skipping");
+ LOG.log(POILogger.INFO, "Rows up to ", lastFlushedRowNum, " have already been flushed, skipping");
}
}
-
+
// Evaluate what we have
for (Row r : sheet) {
for (Cell c : r) {
}
}
}
-
+
/**
* Loops over rows and cells, evaluating formula cells there.
* If any sheets are inactive, or any cells outside of the window,
// Have the evaluation done, with exceptions
evaluateAllFormulaCells(wb, false);
}
-
+
public static class SheetsFlushedException extends IllegalStateException {
protected SheetsFlushedException() {
super("One or more sheets have been flushed, cannot evaluate all cells");
* The main change is to access the rows in the SXSSF sheet, not the always empty rows in the XSSF sheet when checking the row heights.
*/
public final class SXSSFPicture implements Picture {
- private static final POILogger logger = POILogFactory.getLogger(SXSSFPicture.class);
+ private static final POILogger LOG = POILogFactory.getLogger(SXSSFPicture.class);
/**
* Column width measured as the number of characters of the maximum digit width of the
* numbers 0, 1, 2, ..., 9 as rendered in the normal style's font. There are 4 pixels of margin
*
* This value is the same for default font in Office 2007 (Calibri) and Office 2003 and earlier (Arial)
*/
- private static float DEFAULT_COLUMN_WIDTH = 9.140625f;
+ private static final float DEFAULT_COLUMN_WIDTH = 9.140625f;
private final SXSSFWorkbook _wb;
private final XSSFPicture _picture;
XSSFClientAnchor anchor = getClientAnchor();
XSSFClientAnchor pref = getPreferredSize(scale);
if (anchor == null || pref == null) {
- logger.log(POILogger.WARN, "picture is not anchored via client anchor - ignoring resize call");
+ LOG.log(POILogger.WARN, "picture is not anchored via client anchor - ignoring resize call");
return;
}
public XSSFClientAnchor getPreferredSize(double scale){
XSSFClientAnchor anchor = getClientAnchor();
if (anchor == null) {
- logger.log(POILogger.WARN, "picture is not anchored via client anchor - ignoring resize call");
+ LOG.log(POILogger.WARN, "picture is not anchored via client anchor - ignoring resize call");
return null;
}
return ImageUtils.getImageDimension(part.getInputStream(), type);
} catch (IOException e){
//return a "singulariry" if ImageIO failed to read the image
- logger.log(POILogger.WARN, e);
+ LOG.log(POILogger.WARN, e);
return new Dimension();
}
}
XSSFAnchor a = getAnchor();
return (a instanceof XSSFClientAnchor) ? (XSSFClientAnchor)a : null;
}
-
+
public XSSFDrawing getDrawing() {
return _picture.getDrawing();
}
public void setFillColor(int red, int green, int blue) {
_picture.setFillColor(red, green, blue);
}
-
+
@Override
public void setLineStyleColor( int red, int green, int blue ) {
_picture.setLineStyleColor(red, green, blue);
* via {@link SXSSFSheet#getRow} anymore.
*/
public static final int DEFAULT_WINDOW_SIZE = 100;
- private static final POILogger logger = POILogFactory.getLogger(SXSSFWorkbook.class);
+ private static final POILogger LOG = POILogFactory.getLogger(SXSSFWorkbook.class);
protected final XSSFWorkbook _wb;
try {
sxSheet.dispose();
} catch (IOException e) {
- logger.log(POILogger.WARN, e);
+ LOG.log(POILogger.WARN, e);
}
}
SheetDataWriter _writer = sheet.getSheetDataWriter();
if (_writer != null) _writer.close();
} catch (IOException e) {
- logger.log(POILogger.WARN,
+ LOG.log(POILogger.WARN,
"An exception occurred while closing sheet data writer for sheet "
+ sheet.getSheetName() + ".", e);
}
try {
success = sheet.dispose() && success;
} catch (IOException e) {
- logger.log(POILogger.WARN, e);
+ LOG.log(POILogger.WARN, e);
success = false;
}
}
* so that it was renamed to "SheetDataWriter"
*/
public class SheetDataWriter implements Closeable {
- private static final POILogger logger = POILogFactory.getLogger(SheetDataWriter.class);
+ private static final POILogger LOG = POILogFactory.getLogger(SheetDataWriter.class);
private final File _fd;
protected final Writer _out;
@Override
protected void finalize() throws Throwable {
if (_fd.exists() && !_fd.delete()) {
- logger.log(POILogger.ERROR, "Can't delete temporary encryption file: ", _fd);
+ LOG.log(POILogger.ERROR, "Can't delete temporary encryption file: ", _fd);
}
}
*/
@Beta
public class StreamingSheetWriter extends SheetDataWriter {
- private static final POILogger logger = POILogFactory.getLogger(StreamingSheetWriter.class);
-
+ private static final POILogger LOG = POILogFactory.getLogger(StreamingSheetWriter.class);
+
public StreamingSheetWriter() throws IOException {
throw new RuntimeException("StreamingSheetWriter requires OutputStream");
}
-
+
public StreamingSheetWriter(OutputStream out) throws IOException {
super(createWriter(out));
- logger.log(POILogger.DEBUG, "Preparing SSXSSF sheet writer");
+ LOG.log(POILogger.DEBUG, "Preparing SSXSSF sheet writer");
}
-
+
@Override
public File createTempFile() throws IOException {
throw new RuntimeException("Not supported with StreamingSheetWriter");
}
-
+
@Override
public Writer createWriter(File fd) throws IOException {
throw new RuntimeException("Not supported with StreamingSheetWriter");
}
-
+
/**
* Create a writer for the sheet data.
- *
+ *
* @param out the output stream to write to
*/
protected static Writer createWriter(OutputStream out) throws IOException {
return new BufferedWriter(new OutputStreamWriter(out, "UTF-8"));
}
-
+
@Override
public void close() throws IOException {
_out.flush();
}
-
+
@Override
public InputStream getWorksheetXMLInputStream() throws IOException {
throw new RuntimeException("Not supported with StreamingSheetWriter");
}
-
+
@Override
boolean dispose() throws IOException {
_out.close();
* @author Yegor Kozlov
*/
public final class XSSFPicture extends XSSFShape implements Picture {
- private static final POILogger logger = POILogFactory.getLogger(XSSFPicture.class);
+ private static final POILogger LOG = POILogFactory.getLogger(XSSFPicture.class);
/**
* Column width measured as the number of characters of the maximum digit width of the
public void resize(double scale) {
resize(scale, scale);
}
-
+
/**
* Resize the image relatively to its current size.
* <p>
* <code>resize(1.0,1.0)</code> keeps the original size,<br>
* <code>resize(0.5,0.5)</code> resize to 50% of the original,<br>
* <code>resize(2.0,2.0)</code> resizes to 200% of the original.<br>
- * <code>resize({@link Double#MAX_VALUE},{@link Double#MAX_VALUE})</code> resizes to the dimension of the embedded image.
+ * <code>resize({@link Double#MAX_VALUE},{@link Double#MAX_VALUE})</code> resizes to the dimension of the embedded image.
* </p>
*
* @param scaleX the amount by which the image width is multiplied relative to the original width,
XSSFClientAnchor anchor = getClientAnchor();
XSSFClientAnchor pref = getPreferredSize(scaleX,scaleY);
if (anchor == null || pref == null) {
- logger.log(POILogger.WARN, "picture is not anchored via client anchor - ignoring resize call");
+ LOG.log(POILogger.WARN, "picture is not anchored via client anchor - ignoring resize call");
return;
}
public XSSFClientAnchor getPreferredSize(double scale){
return getPreferredSize(scale, scale);
}
-
+
/**
* Calculate the preferred size for this picture.
*
return ImageUtils.getImageDimension(part.getInputStream(), type);
} catch (IOException e){
//return a "singulariry" if ImageIO failed to read the image
- logger.log(POILogger.WARN, e);
+ LOG.log(POILogger.WARN, e);
return new Dimension();
}
}
XSSFPictureData picData = getPictureData();
return getImageDimension(picData.getPackagePart(), picData.getPictureType());
}
-
+
/**
* Return picture data for this shape
*
* High level representation of a row of a spreadsheet.
*/
public class XSSFRow implements Row, Comparable<XSSFRow> {
- //private static final POILogger _logger = POILogFactory.getLogger(XSSFRow.class);
-
/**
* the xml bean containing all cell definitions for this row
*/
* </p>
*/
public class XSSFSheet extends POIXMLDocumentPart implements Sheet {
- private static final POILogger logger = POILogFactory.getLogger(XSSFSheet.class);
+ private static final POILogger LOG = POILogFactory.getLogger(XSSFSheet.class);
private static final double DEFAULT_ROW_HEIGHT = 15.0;
private static final double DEFAULT_MARGIN_HEADER = 0.3;
break;
}
}
- logger.log(POILogger.ERROR, "Can't find drawing with id=", ctDrawing.getId(), " in the list of the sheet's relationships");
+ LOG.log(POILogger.ERROR, "Can't find drawing with id=", ctDrawing.getId(), " in the list of the sheet's relationships");
}
return null;
}
}
}
if(drawing == null){
- logger.log(POILogger.ERROR, "Can't find VML drawing with id=", id, " in the list of the sheet's relationships");
+ LOG.log(POILogger.ERROR, "Can't find VML drawing with id=", id, " in the list of the sheet's relationships");
}
}
return drawing;
}
coo = coos.getOleObjectArray(0);
} catch (XmlException e) {
- logger.log(POILogger.INFO, "can't parse CTOleObjects", e);
+ LOG.log(POILogger.INFO, "can't parse CTOleObjects", e);
} finally {
try {
reader.close();
} catch (XMLStreamException e) {
- logger.log(POILogger.INFO, "can't close reader", e);
+ LOG.log(POILogger.INFO, "can't close reader", e);
}
}
}
* Also used for built-in styles via dummy XML generated from presetTableStyles.xml.
*/
public class XSSFTableStyle implements TableStyle {
- private static final POILogger logger = POILogFactory.getLogger(XSSFTableStyle.class);
+ private static final POILogger LOG = POILogFactory.getLogger(XSSFTableStyle.class);
private final String name;
private final int index;
public XSSFTableStyle(int index, CTDxfs dxfs, CTTableStyle tableStyle, IndexedColorMap colorMap) {
this.name = tableStyle.getName();
this.index = index;
-
+
List<CTDxf> dxfList = new ArrayList<>();
// CT* classes don't handle "mc:AlternateContent" elements, so get the Dxf instances manually
}
if (dxf != null) dxfList.add(dxf);
} catch (XmlException e) {
- logger.log(POILogger.WARN, "Error parsing XSSFTableStyle", e);
+ LOG.log(POILogger.WARN, "Error parsing XSSFTableStyle", e);
}
}
}
elementMap.put(type, dstyle);
}
}
-
+
public String getName() {
return name;
}
public int getIndex() {
return index;
}
-
+
/**
* Always false for these, these are user defined styles
*/
public boolean isBuiltin() {
return false;
}
-
+
public DifferentialStyleProvider getStyle(TableStyleType type) {
return elementMap.get(type);
}
-
+
}
\ No newline at end of file
*/
private List<XSSFPictureData> pictures;
- private static final POILogger logger = POILogFactory.getLogger(XSSFWorkbook.class);
+ private static final POILogger LOG = POILogFactory.getLogger(XSSFWorkbook.class);
/**
* cached instance of XSSFCreationHelper for this workbook
for (CTExternalReference er : this.workbook.getExternalReferences().getExternalReferenceArray()) {
ExternalLinksTable el = elIdMap.get(er.getId());
if(el == null) {
- logger.log(POILogger.WARN, "ExternalLinksTable with r:id ", er.getId(), " was defined, but didn't exist in package, skipping");
+ LOG.log(POILogger.WARN, "ExternalLinksTable with r:id ", er.getId(), " was defined, but didn't exist in package, skipping");
continue;
}
externalLinks.add(el);
public void parseSheet(Map<String, XSSFSheet> shIdMap, CTSheet ctSheet) {
XSSFSheet sh = shIdMap.get(ctSheet.getId());
if(sh == null) {
- logger.log(POILogger.WARN, "Sheet with name ", ctSheet.getName(), " and r:id ",
+ LOG.log(POILogger.WARN, "Sheet with name ", ctSheet.getName(), " and r:id ",
ctSheet.getId(), " was defined, but didn't exist in package, skipping");
return;
}
}
CTWorksheet ct = clonedSheet.getCTWorksheet();
if(ct.isSetLegacyDrawing()) {
- logger.log(POILogger.WARN, "Cloning sheets with comments is not yet supported.");
+ LOG.log(POILogger.WARN, "Cloning sheets with comments is not yet supported.");
ct.unsetLegacyDrawing();
}
if (ct.isSetPageSetup()) {
- logger.log(POILogger.WARN, "Cloning sheets with page setup is not yet supported.");
+ LOG.log(POILogger.WARN, "Cloning sheets with page setup is not yet supported.");
ct.unsetPageSetup();
}
// {@link org.apache.poi.hssf.usermodel.helpers.HSSFColumnShifter}
@Beta
public final class XSSFColumnShifter extends ColumnShifter {
- private static final POILogger logger = POILogFactory.getLogger(XSSFColumnShifter.class);
+ private static final POILogger LOG = POILogFactory.getLogger(XSSFColumnShifter.class);
public XSSFColumnShifter(XSSFSheet sh) {
super(sh);
*/
@Internal
/*private*/ final class XSSFRowColShifter {
- private static final POILogger logger = POILogFactory.getLogger(XSSFRowColShifter.class);
+ private static final POILogger LOG = POILogFactory.getLogger(XSSFRowColShifter.class);
private XSSFRowColShifter() { /*no instances for static classes*/}
return shiftedFmla;
} catch (FormulaParseException fpe) {
// Log, but don't change, rather than breaking
- logger.log(POILogger.WARN, "Error shifting formula on row ", row.getRowNum(), fpe);
+ LOG.log(POILogger.WARN, "Error shifting formula on row ", row.getRowNum(), fpe);
return formula;
}
}
// non-Javadoc: When possible, code should be implemented in the RowShifter abstract class to avoid duplication with
// {@link org.apache.poi.hssf.usermodel.helpers.HSSFRowShifter}
public final class XSSFRowShifter extends RowShifter {
- private static final POILogger logger = POILogFactory.getLogger(XSSFRowShifter.class);
+ private static final POILogger LOG = POILogFactory.getLogger(XSSFRowShifter.class);
public XSSFRowShifter(XSSFSheet sh) {
super(sh);
public void updateFormulas(FormulaShifter formulaShifter) {
XSSFRowColShifter.updateFormulas(sheet, formulaShifter);
}
-
+
/**
* Update the formulas in specified row using the formula shifting policy specified by shifter
*
import org.junit.jupiter.api.Test;
public final class TestListParts {
- private static final POILogger logger = POILogFactory.getLogger(TestListParts.class);
+ private static final POILogger LOG = POILogFactory.getLogger(TestListParts.class);
private TreeMap<PackagePartName, String> expectedValues;
for (PackagePart part : p.getParts()) {
values.put(part.getPartName(), part.getContentType());
- logger.log(POILogger.DEBUG, part.getPartName());
+ LOG.log(POILogger.DEBUG, part.getPartName());
}
// Compare expected values with values return by the package
import org.xml.sax.SAXParseException;
public final class TestPackage {
- private static final POILogger logger = POILogFactory.getLogger(TestPackage.class);
+ private static final POILogger LOG = POILogFactory.getLogger(TestPackage.class);
private static final String NS_OOXML_WP_MAIN = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
private static final String CONTENT_EXT_PROPS = "application/vnd.openxmlformats-officedocument.extended-properties+xml";
private static final POIDataSamples xlsSamples = POIDataSamples.getSpreadSheetInstance();
for (PackagePart part : p.getParts()) {
values.put(part.getPartName(), part.getContentType());
- logger.log(POILogger.DEBUG, part.getPartName());
+ LOG.log(POILogger.DEBUG, part.getPartName());
}
// Compare expected values with values return by the package
for (PackagePart part : p.getParts()) {
values.put(part.getPartName(), part.getContentType());
- logger.log(POILogger.DEBUG, part.getPartName());
+ LOG.log(POILogger.DEBUG, part.getPartName());
}
// Compare expected values with values return by the package
private static final String SHEET_WITH_COMMENTS =
"/xl/worksheets/sheet1.xml";
- private static final POILogger logger = POILogFactory.getLogger(TestPackageCoreProperties.class);
+ private static final POILogger LOG = POILogFactory.getLogger(TestPackageCoreProperties.class);
/**
* Test relationships are correctly loaded. This at the moment fails (as of r499)
void testLoadRelationships() throws Exception {
InputStream is = openSampleStream("sample.xlsx");
try (OPCPackage pkg = OPCPackage.open(is)) {
- logger.log(POILogger.DEBUG, "1: " + pkg);
+ LOG.log(POILogger.DEBUG, "1: " + pkg);
PackageRelationshipCollection rels = pkg.getRelationshipsByType(PackageRelationshipTypes.CORE_DOCUMENT);
PackageRelationship coreDocRelationship = rels.getRelationship(0);
PackagePart corePart = pkg.getPart(coreDocRelationship);
import org.junit.jupiter.api.Test;
class TestDrawPictureShape {
- final static POIDataSamples ssSamples = POIDataSamples.getSlideShowInstance();
+ static final POIDataSamples ssSamples = POIDataSamples.getSlideShowInstance();
private static boolean xslfOnly;
import org.apache.poi.xslf.XSLFTestDataSamples;
import org.junit.jupiter.api.Test;
-/**
- * @author Yegor Kozlov
- */
class TestXSLFTextParagraph {
- // private static POILogger _logger = POILogFactory.getLogger(XSLFTextParagraph.class);
-
static class DrawTextParagraphProxy extends DrawTextParagraph {
DrawTextParagraphProxy(XSLFTextParagraph p) {
super(p);
_columns.add(3);
columns = Collections.unmodifiableSortedSet(_columns);
}
- private final static String SHORT_MESSAGE = "short";
- private final static String LONG_MESSAGE = "This is a test of a long message! This is a test of a long message!";
+ private static final String SHORT_MESSAGE = "short";
+ private static final String LONG_MESSAGE = "This is a test of a long message! This is a test of a long message!";
@BeforeEach
void setUpSheetAndWorkbook() {
*
*/
public final class TestFormulaEvaluatorOnXSSF {
- private static final POILogger logger = POILogFactory.getLogger(TestFormulaEvaluatorOnXSSF.class);
+ private static final POILogger LOG = POILogFactory.getLogger(TestFormulaEvaluatorOnXSSF.class);
private static XSSFWorkbook workbook;
private static Sheet sheet;
*/
private static String getTargetFunctionName(Row r) {
if(r == null) {
- logger.log(POILogger.WARN, "Warning - given null row, can't figure out function name");
+ LOG.log(POILogger.WARN, "Warning - given null row, can't figure out function name");
return null;
}
Cell cell = r.getCell(SS.COLUMN_INDEX_FUNCTION_NAME);
if(cell == null) {
- logger.log(POILogger.WARN, "Warning - Row " + r.getRowNum() + " has no cell " + SS.COLUMN_INDEX_FUNCTION_NAME + ", can't figure out function name");
+ LOG.log(POILogger.WARN, "Warning - Row " + r.getRowNum() + " has no cell " + SS.COLUMN_INDEX_FUNCTION_NAME + ", can't figure out function name");
return null;
}
if(cell.getCellType() == CellType.BLANK) {
* Tests formulas for multi sheet reference (i.e. SUM(Sheet1:Sheet5!A1))
*/
public final class TestMultiSheetFormulaEvaluatorOnXSSF {
- private static final POILogger logger = POILogFactory.getLogger(TestMultiSheetFormulaEvaluatorOnXSSF.class);
+ private static final POILogger LOG = POILogFactory.getLogger(TestMultiSheetFormulaEvaluatorOnXSSF.class);
private static XSSFWorkbook workbook;
private static Sheet sheet;
*/
private static String getTargetFunctionName(Row r) {
if(r == null) {
- logger.log(POILogger.WARN, "Warning - given null row, can't figure out function name");
+ LOG.log(POILogger.WARN, "Warning - given null row, can't figure out function name");
return null;
}
Cell cell = r.getCell(SS.COLUMN_INDEX_FUNCTION_NAME);
if(cell == null) {
- logger.log(POILogger.WARN, "Warning - Row " + r.getRowNum() + " has no cell " + SS.COLUMN_INDEX_FUNCTION_NAME + ", can't figure out function name");
+ LOG.log(POILogger.WARN, "Warning - Row " + r.getRowNum() + " has no cell " + SS.COLUMN_INDEX_FUNCTION_NAME + ", can't figure out function name");
return null;
}
*/
private static String getTargetTestName(Row r) {
if(r == null) {
- logger.log(POILogger.WARN, "Warning - given null row, can't figure out test name");
+ LOG.log(POILogger.WARN, "Warning - given null row, can't figure out test name");
return null;
}
Cell cell = r.getCell(SS.COLUMN_INDEX_TEST_NAME);
if(cell == null) {
- logger.log(POILogger.WARN, "Warning - Row " + r.getRowNum() + " has no cell " + SS.COLUMN_INDEX_TEST_NAME + ", can't figure out test name");
+ LOG.log(POILogger.WARN, "Warning - Row " + r.getRowNum() + " has no cell " + SS.COLUMN_INDEX_TEST_NAME + ", can't figure out test name");
return null;
}
CellType ct = cell.getCellType();
*/
class TestXSSFColGrouping {
- private static final POILogger logger = POILogFactory.getLogger(TestXSSFColGrouping.class);
+ private static final POILogger LOG = POILogFactory.getLogger(TestXSSFColGrouping.class);
/**
sheet = wb2.getSheet("test");
CTCols cols = sheet.getCTWorksheet().getColsArray(0);
- logger.log(POILogger.DEBUG, "test52186/cols:" + cols);
+ LOG.log(POILogger.DEBUG, "test52186/cols:" + cols);
for (CTCol col : cols.getColArray()) {
assertTrue(col.isSetWidth(), "Col width attribute is unset: " + col);
}
sheet.setColumnGroupCollapsed(4, true);
CTCols cols = sheet.getCTWorksheet().getColsArray(0);
- logger.log(POILogger.DEBUG, "test52186_2/cols:" + cols);
+ LOG.log(POILogger.DEBUG, "test52186_2/cols:" + cols);
try (XSSFWorkbook wb2 = XSSFTestDataSamples.writeOutAndReadBack(wb1, "testNoColsWithoutWidthWhenGroupingAndCollapsing")) {
sheet = wb2.getSheet("test");
sheet.groupColumn((short) 2, (short) 3);
sheet.getCTWorksheet().getColsArray(0);
- logger.log(POILogger.DEBUG, "testMergingOverlappingCols_OVERLAPS_2_WRAPS/cols:" + cols);
+ LOG.log(POILogger.DEBUG, "testMergingOverlappingCols_OVERLAPS_2_WRAPS/cols:" + cols);
assertEquals(0, cols.getColArray(0).getOutlineLevel());
assertEquals(2, cols.getColArray(0).getMin()); // 1 based
sheet.groupColumn((short) 1, (short) 5);
cols = sheet.getCTWorksheet().getColsArray(0);
- logger.log(POILogger.DEBUG, "testMergingOverlappingCols_OVERLAPS_1_WRAPS/cols:" + cols);
+ LOG.log(POILogger.DEBUG, "testMergingOverlappingCols_OVERLAPS_1_WRAPS/cols:" + cols);
assertEquals(1, cols.getColArray(0).getOutlineLevel());
assertEquals(2, cols.getColArray(0).getMin()); // 1 based
sheet.groupColumn((short) 3, (short) 5);
cols = sheet.getCTWorksheet().getColsArray(0);
- logger.log(POILogger.DEBUG, "testMergingOverlappingCols_OVERLAPS_1_MINOR/cols:" + cols);
+ LOG.log(POILogger.DEBUG, "testMergingOverlappingCols_OVERLAPS_1_MINOR/cols:" + cols);
assertEquals(0, cols.getColArray(0).getOutlineLevel());
assertEquals(3, cols.getColArray(0).getMin()); // 1 based
sheet.groupColumn((short) 1, (short) 3);
cols = sheet.getCTWorksheet().getColsArray(0);
- logger.log(POILogger.DEBUG, "testMergingOverlappingCols_OVERLAPS_2_MINOR/cols:" + cols);
+ LOG.log(POILogger.DEBUG, "testMergingOverlappingCols_OVERLAPS_2_MINOR/cols:" + cols);
assertEquals(1, cols.getColArray(0).getOutlineLevel());
assertEquals(2, cols.getColArray(0).getMin()); // 1 based
testReadOffice2007("NewStyleConditionalFormattings.xlsx");
}
- private final static java.awt.Color PEAK_ORANGE = new java.awt.Color(255, 239, 221);
+ private static final java.awt.Color PEAK_ORANGE = new java.awt.Color(255, 239, 221);
@Test
void testFontFormattingColor() {
*/
@SuppressWarnings("WeakerAccess")
public class OLE2ScratchpadExtractorFactory implements ExtractorProvider {
- private static final POILogger logger = POILogFactory.getLogger(OLE2ScratchpadExtractorFactory.class);
+ private static final POILogger LOG = POILogFactory.getLogger(OLE2ScratchpadExtractorFactory.class);
@Override
public boolean accepts(FileMagic fm) {
.filter(entry -> entry.getName().startsWith("_"))
.forEach(dirs::add);
} catch(FileNotFoundException e) {
- logger.log(POILogger.INFO, "Ignoring FileNotFoundException while extracting Word document", e.getLocalizedMessage());
+ LOG.log(POILogger.INFO, "Ignoring FileNotFoundException while extracting Word document", e.getLocalizedMessage());
// ignored here
}
//} else if(ext instanceof PowerPointExtractor) {
* Base of all chunks, which hold data, flags etc
*/
public final class Chunk {
+ /** For logging warnings about the structure of the file */
+ private static final POILogger LOG = POILogFactory.getLogger(Chunk.class);
+
/**
* The contents of the chunk, excluding the header,
* trailer and separator
*/
- private byte[] contents;
- private ChunkHeader header;
+ private final byte[] contents;
+ private final ChunkHeader header;
/** May be null */
- private ChunkTrailer trailer;
+ private final ChunkTrailer trailer;
/** May be null */
- private ChunkSeparator separator;
+ private final ChunkSeparator separator;
/** The possible different commands we can hold */
private CommandDefinition[] commandDefinitions;
/** The command+value pairs we hold */
/** The name of the chunk, as found from the commandDefinitions */
private String name;
- /** For logging warnings about the structure of the file */
- private POILogger logger = POILogFactory.getLogger(Chunk.class);
-
public Chunk(ChunkHeader header, ChunkTrailer trailer, ChunkSeparator separator, byte[] contents) {
this.header = header;
this.trailer = trailer;
// Check we seem to have enough data
if(offset >= contents.length) {
- logger.log(POILogger.WARN,
+ LOG.log(POILogger.WARN,
"Command offset ", offset, " past end of data at ", contents.length
);
continue;
break;
default:
- logger.log(POILogger.INFO,
+ LOG.log(POILogger.INFO,
"Command of type ", type, " not processed!");
}
}
catch (Exception e) {
- logger.log(POILogger.ERROR, "Unexpected error processing command, ignoring and continuing. Command: ", command, e);
+ LOG.log(POILogger.ERROR, "Unexpected error processing command, ignoring and continuing. Command: ", command, e);
}
// Add to the array
"/org/apache/poi/hdgf/chunks_parse_cmds.tbl";
/** For logging problems we spot with the file */
- private static final POILogger logger = POILogFactory.getLogger(ChunkFactory.class);
+ private static final POILogger LOG = POILogFactory.getLogger(ChunkFactory.class);
public ChunkFactory(int version) throws IOException {
this.version = version;
// Check we have enough data, and tweak the header size
// as required
if(endOfDataPos > data.length) {
- logger.log(POILogger.WARN,
+ LOG.log(POILogger.WARN,
"Header called for ", header.getLength(), " bytes, but that would take us past the end of the data!");
endOfDataPos = data.length;
data, endOfDataPos);
endOfDataPos += 8;
} else {
- logger.log(POILogger.ERROR, "Header claims a length to ", endOfDataPos, " there's then no space for the trailer in the data (", data.length, ")");
+ LOG.log(POILogger.ERROR, "Header claims a length to ", endOfDataPos, " there's then no space for the trailer in the data (", data.length, ")");
}
}
if(header.hasSeparator()) {
separator = new ChunkSeparator(
data, endOfDataPos);
} else {
- logger.log(POILogger.ERROR, "Header claims a length to ", endOfDataPos, " there's then no space for the separator in the data (", data.length, ")");
+ LOG.log(POILogger.ERROR, "Header claims a length to ", endOfDataPos, " there's then no space for the separator in the data (", data.length, ")");
}
}
* of a Visio file
*/
public final class VSDDumper {
- final static String tabs = "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
+ static final String tabs = "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
private final PrintStream ps;
private final HDGFDiagram hdgf;
import org.apache.poi.util.POILogger;
public final class ChunkStream extends Stream {
- private final static POILogger logger = POILogFactory.getLogger(ChunkStream.class);
-
- private ChunkFactory chunkFactory;
+ private static final POILogger LOG = POILogFactory.getLogger(ChunkStream.class);
+
+ private final ChunkFactory chunkFactory;
/** All the Chunks we contain */
private Chunk[] chunks;
- protected ChunkStream(Pointer pointer, StreamStore store, ChunkFactory chunkFactory) {
+ ChunkStream(Pointer pointer, StreamStore store, ChunkFactory chunkFactory) {
super(pointer, store);
this.chunkFactory = chunkFactory;
pos += chunk.getOnDiskSize();
} else {
- logger.log(POILogger.WARN, "Needed ", headerSize, " bytes to create the next chunk header, but only found ", (contents.length-pos), " bytes, ignoring rest of data");
+ LOG.log(POILogger.WARN, "Needed ", headerSize, " bytes to create the next chunk header, but only found ", (contents.length-pos), " bytes, ignoring rest of data");
pos = contents.length;
}
}
}
catch (Exception e)
{
- logger.log(POILogger.ERROR, "Failed to create chunk at ", pos, ", ignoring rest of data." + e);
+ LOG.log(POILogger.ERROR, "Failed to create chunk at ", pos, ", ignoring rest of data." + e);
}
chunks = chunksA.toArray(new Chunk[0]);
*/
@Internal
public class HemfComment {
- private static final POILogger logger = POILogFactory.getLogger(HemfComment.class);
+ private static final POILogger LOG = POILogFactory.getLogger(HemfComment.class);
private static final int MAX_RECORD_LENGTH = HwmfPicture.MAX_RECORD_LENGTH;
public enum HemfCommentRecordType {
// some emf comments are truncated, so we don't use readFully here
int readBytes = leis.read(wmfData);
if (readBytes < wmfData.length) {
- logger.log(POILogger.INFO, "Emf comment with WMF: expected ", wmfData.length,
+ LOG.log(POILogger.INFO, "Emf comment with WMF: expected ", wmfData.length,
" bytes - received only ", readBytes, " bytes.");
}
/**
* If set, a 2x3 transform matrix MUST be specified in the OptionalData field of an EmfPlusPenData object.
*/
- private final static BitField TRANSFORM = BitFieldFactory.getInstance(0x00000001);
+ private static final BitField TRANSFORM = BitFieldFactory.getInstance(0x00000001);
/**
* If set, the style of a starting line cap MUST be specified in the OptionalData field of an
* EmfPlusPenData object.
*/
- private final static BitField START_CAP = BitFieldFactory.getInstance(0x00000002);
+ private static final BitField START_CAP = BitFieldFactory.getInstance(0x00000002);
/**
* Indicates whether the style of an ending line cap MUST be specified in the OptionalData field
* of an EmfPlusPenData object.
*/
- private final static BitField END_CAP = BitFieldFactory.getInstance(0x00000004);
+ private static final BitField END_CAP = BitFieldFactory.getInstance(0x00000004);
/**
* Indicates whether a line join type MUST be specified in the OptionalData
* field of an EmfPlusPenData object.
*/
- private final static BitField JOIN = BitFieldFactory.getInstance(0x00000008);
+ private static final BitField JOIN = BitFieldFactory.getInstance(0x00000008);
/**
* Indicates whether a miter limit MUST be specified in the OptionalData field of an EmfPlusPenData object.
*/
- private final static BitField MITER_LIMIT = BitFieldFactory.getInstance(0x00000010);
+ private static final BitField MITER_LIMIT = BitFieldFactory.getInstance(0x00000010);
/**
* Indicates whether a line style MUST be specified in the OptionalData field of an EmfPlusPenData object.
*/
- private final static BitField LINE_STYLE = BitFieldFactory.getInstance(0x00000020);
+ private static final BitField LINE_STYLE = BitFieldFactory.getInstance(0x00000020);
/**
* Indicates whether a dashed line cap MUST be specified in the OptionalData field of an EmfPlusPenData object.
*/
- private final static BitField DASHED_LINE_CAP = BitFieldFactory.getInstance(0x00000040);
+ private static final BitField DASHED_LINE_CAP = BitFieldFactory.getInstance(0x00000040);
/**
* Indicates whether a dashed line offset MUST be specified in the OptionalData field of an EmfPlusPenData object.
*/
- private final static BitField DASHED_LINE_OFFSET = BitFieldFactory.getInstance(0x00000080);
+ private static final BitField DASHED_LINE_OFFSET = BitFieldFactory.getInstance(0x00000080);
/**
* Indicates whether an EmfPlusDashedLineData object MUST be specified in the
* OptionalData field of an EmfPlusPenData object.
*/
- private final static BitField DASHED_LINE = BitFieldFactory.getInstance(0x00000100);
+ private static final BitField DASHED_LINE = BitFieldFactory.getInstance(0x00000100);
/**
* Indicates whether a pen alignment MUST be specified in the OptionalData field of an EmfPlusPenData object.
*/
- private final static BitField NON_CENTER = BitFieldFactory.getInstance(0x00000200);
+ private static final BitField NON_CENTER = BitFieldFactory.getInstance(0x00000200);
/**
* Indicates whether the length and content of a EmfPlusCompoundLineData object are present in the
* OptionalData field of an EmfPlusPenData object.
*/
- private final static BitField COMPOUND_LINE = BitFieldFactory.getInstance(0x00000400);
+ private static final BitField COMPOUND_LINE = BitFieldFactory.getInstance(0x00000400);
/**
* Indicates whether an EmfPlusCustomStartCapData object MUST be specified
* in the OptionalData field of an EmfPlusPenData object.y
*/
- private final static BitField CUSTOM_START_CAP = BitFieldFactory.getInstance(0x00000800);
+ private static final BitField CUSTOM_START_CAP = BitFieldFactory.getInstance(0x00000800);
/**
* Indicates whether an EmfPlusCustomEndCapData object MUST be specified in
* the OptionalData field of an EmfPlusPenData object.
*/
- private final static BitField CUSTOM_END_CAP = BitFieldFactory.getInstance(0x00001000);
+ private static final BitField CUSTOM_END_CAP = BitFieldFactory.getInstance(0x00001000);
private static final int[] FLAGS_MASKS = {
0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010,
import org.apache.poi.util.POILogger;
/**
- * A pure-MAPI attribute holding a Date, which applies
+ * A pure-MAPI attribute holding a Date, which applies
* to a {@link HMEFMessage} or one of its {@link Attachment}s.
- *
+ *
* Timestamps are usually given in UTC.
- *
+ *
* @see <a href="https://msdn.microsoft.com/en-us/library/cc433482(v=exchg.80).aspx">[MS-OXOMSG]: Email Object Protocol</a>
* @see <a href="https://msdn.microsoft.com/en-us/library/cc433490(v=exchg.80).aspx">[MS-OXPROPS]: Exchange Server Protocols Master Property List</a>
*/
public final class MAPIDateAttribute extends MAPIAttribute {
- private final static POILogger logger = POILogFactory.getLogger(MAPIDateAttribute.class);
- private Date data;
-
+ private static final POILogger LOG = POILogFactory.getLogger(MAPIDateAttribute.class);
+ private final Date data;
+
/**
* Constructs a single new date attribute from the id, type,
* and the contents of the stream
*/
protected MAPIDateAttribute(MAPIProperty property, int type, byte[] data) {
super(property, type, data);
-
+
// The value is a 64 bit Windows Filetime
this.data = Filetime.filetimeToDate(
LittleEndian.getLong(data, 0)
public Date getDate() {
return this.data;
}
-
+
public String toString() {
DateFormatSymbols dfs = DateFormatSymbols.getInstance(Locale.ROOT);
DateFormat df = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", dfs);
df.setTimeZone(LocaleUtil.TIMEZONE_UTC);
return getProperty() + " " + df.format(data);
}
-
+
/**
* Returns the Date of a Attribute, converting as appropriate
*/
if(attr instanceof MAPIDateAttribute) {
return ((MAPIDateAttribute)attr).getDate();
}
-
- logger.log(POILogger.WARN, "Warning, non date property found: ", attr);
+
+ LOG.log(POILogger.WARN, "Warning, non date property found: ", attr);
return null;
}
}
import org.apache.poi.util.StringUtil;
/**
- * A pure-MAPI attribute holding a String, which applies
+ * A pure-MAPI attribute holding a String, which applies
* to a {@link HMEFMessage} or one of its {@link Attachment}s.
*/
public final class MAPIStringAttribute extends MAPIAttribute {
- private final static POILogger logger = POILogFactory.getLogger(MAPIStringAttribute.class);
+ private static final POILogger LOG = POILogFactory.getLogger(MAPIStringAttribute.class);
private static final String CODEPAGE = "CP1252";
private final String data;
-
+
public MAPIStringAttribute(MAPIProperty property, int type, byte[] data) {
super(property, type, data);
-
+
String tmpData = null;
if(type == Types.ASCII_STRING.getId()) {
tmpData = new String(data, Charset.forName(CODEPAGE));
} else {
throw new IllegalArgumentException("Not a string type " + type);
}
-
+
// Strip off the null terminator if present
if(tmpData.endsWith("\0")) {
tmpData = tmpData.substring(0, tmpData.length()-1);
}
this.data = tmpData;
}
-
+
public String getDataString() {
return data;
}
-
+
public String toString() {
return getProperty() + " " + data;
}
-
+
/**
* Returns the string of a Attribute, converting as appropriate
*/
if(attr instanceof MAPIRtfAttribute) {
return ((MAPIRtfAttribute)attr).getDataString();
}
-
- logger.log(POILogger.WARN, "Warning, non string property found: ", attr);
+
+ LOG.log(POILogger.WARN, "Warning, non string property found: ", attr);
return null;
}
}
* or one of its {@link Attachment}s.
*/
public final class TNEFDateAttribute extends TNEFAttribute {
- private final static POILogger logger = POILogFactory.getLogger(TNEFDateAttribute.class);
- private Date data;
-
+ private static final POILogger LOG = POILogFactory.getLogger(TNEFDateAttribute.class);
+ private final Date data;
+
/**
* Constructs a single new date attribute from the id, type,
* and the contents of the stream
*/
protected TNEFDateAttribute(int id, int type, InputStream inp) throws IOException {
super(id, type, inp);
-
+
byte[] binData = getData();
if(binData.length == 8) {
// The value is a 64 bit Windows Filetime
public Date getDate() {
return this.data;
}
-
+
public String toString() {
DateFormatSymbols dfs = DateFormatSymbols.getInstance(Locale.ROOT);
DateFormat df = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", dfs);
- df.setTimeZone(LocaleUtil.TIMEZONE_UTC);
+ df.setTimeZone(LocaleUtil.TIMEZONE_UTC);
return "Attribute " + getProperty() + ", type=" + getType() +
- ", date=" + df.format(data);
+ ", date=" + df.format(data);
}
-
+
/**
* Returns the Date of a Attribute, converting as appropriate
*/
if(attr instanceof TNEFDateAttribute) {
return ((TNEFDateAttribute)attr).getDate();
}
-
- logger.log(POILogger.WARN, "Warning, non date property found: ", attr);
+
+ LOG.log(POILogger.WARN, "Warning, non date property found: ", attr);
return null;
}
}
* or one of its {@link Attachment}s.
*/
public final class TNEFStringAttribute extends TNEFAttribute {
- private final static POILogger logger = POILogFactory.getLogger(TNEFStringAttribute.class);
- private String data;
-
+ private static final POILogger LOG = POILogFactory.getLogger(TNEFStringAttribute.class);
+ private final String data;
+
/**
* Constructs a single new string attribute from the id, type,
* and the contents of the stream
*/
protected TNEFStringAttribute(int id, int type, InputStream inp) throws IOException {
super(id, type, inp);
-
+
String tmpData = null;
byte[] data = getData();
if(getType() == TNEFProperty.TYPE_TEXT) {
data, 0, data.length
);
}
-
+
// Strip off the null terminator if present
if(tmpData.endsWith("\0")) {
tmpData = tmpData.substring(0, tmpData.length()-1);
public String getString() {
return this.data;
}
-
+
public String toString() {
return "Attribute " + getProperty() + ", type=" + getType() +
- ", data=" + getString();
+ ", data=" + getString();
}
-
+
/**
* Returns the string of a Attribute, converting as appropriate
*/
if(attr instanceof TNEFStringAttribute) {
return ((TNEFStringAttribute)attr).getString();
}
-
- logger.log(POILogger.WARN, "Warning, non string property found: ", attr);
+
+ LOG.log(POILogger.WARN, "Warning, non string property found: ", attr);
return null;
}
}
* Read Quill Contents (/Quill/QuillSub/CONTENTS) from an HPBF (Publisher .pub) document
*/
public final class QuillContents extends HPBFPart {
- private static POILogger logger = POILogFactory.getLogger(QuillContents.class);
+ private static final POILogger LOG = POILogFactory.getLogger(QuillContents.class);
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 1_000_000;
private static final String[] PATH = { "Quill", "QuillSub", "CONTENTS", };
- private QCBit[] bits;
+ private final QCBit[] bits;
public QuillContents(DirectoryNode baseDir) throws IOException {
super(baseDir, PATH);
bits[i] = QCPLCBit.createQCPLCBit(thingType, bitType, bitData);
} catch (ArrayIndexOutOfBoundsException e) {
// bug 60685: fall back so that the rest of the document can be read
- logger.log(POILogger.WARN, "Unable to read Quill Contents PLC Bit record. Ignoring this record.");
+ LOG.log(POILogger.WARN, "Unable to read Quill Contents PLC Bit record. Ignoring this record.");
bits[i] = new UnknownQCBit(thingType, bitType, bitData);
}
} else {
* @author Nick Burch
*/
public final class SlideShowRecordDumper {
- final static String tabs = "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
+ static final String tabs = "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
private boolean optVerbose;
private boolean optEscher;
* (but related) properties
*/
public abstract class BitMaskTextProp extends TextProp {
- protected static final POILogger logger = POILogFactory.getLogger(BitMaskTextProp.class);
+ protected static final POILogger LOG = POILogFactory.getLogger(BitMaskTextProp.class);
private String[] subPropNames;
private int[] subPropMasks;
setWriteMask(writeMask);
super.setValue(maskValue(val));
if (val != super.getValue()) {
- logger.log(POILogger.WARN, "Style properties of '", getName(), "' don't match mask - output will be sanitized");
- if (logger.check(POILogger.DEBUG)) {
+ LOG.log(POILogger.WARN, "Style properties of '", getName(), "' don't match mask - output will be sanitized");
+ if (LOG.check(POILogger.DEBUG)) {
StringBuilder sb = new StringBuilder("The following style attributes of the '")
.append(getName()).append("' property will be ignored:\n");
int i=0;
}
i++;
}
- logger.log(POILogger.DEBUG, sb.toString());
+ LOG.log(POILogger.DEBUG, sb.toString());
}
}
}
*/
public class TextPFException9 implements GenericRecord {
- private final static AutoNumberingScheme DEFAULT_AUTONUMBER_SCHEME = AutoNumberingScheme.arabicPeriod;
- private final static Short DEFAULT_START_NUMBER = 1;
+ private static final AutoNumberingScheme DEFAULT_AUTONUMBER_SCHEME = AutoNumberingScheme.arabicPeriod;
+ private static final Short DEFAULT_START_NUMBER = 1;
//private final byte mask1;
//private final byte mask2;
if(_children[0] instanceof AnimationInfoAtom) {
animationAtom = (AnimationInfoAtom)_children[0];
} else {
- logger.log(POILogger.ERROR, "First child record wasn't a AnimationInfoAtom, was of type ", _children[0].getRecordType());
+ LOG.log(POILogger.ERROR, "First child record wasn't a AnimationInfoAtom, was of type ", _children[0].getRecordType());
}
}
} else if (r instanceof Comment2000Atom){
commentAtom = (Comment2000Atom)r;
} else {
- logger.log(POILogger.WARN, "Unexpected record with type=", r.getRecordType(), " in Comment2000: ", r.getClass().getName());
+ LOG.log(POILogger.WARN, "Unexpected record with type=", r.getRecordType(), " in Comment2000: ", r.getClass().getName());
}
}
*/
public class CurrentUserAtom
{
- private final static POILogger logger = POILogFactory.getLogger(CurrentUserAtom.class);
+ private static final POILogger LOG = POILogFactory.getLogger(CurrentUserAtom.class);
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 1_000_000;
long usernameLen = LittleEndian.getUShort(_contents,20);
if(usernameLen > 512) {
// Handle the case of it being garbage
- logger.log(POILogger.WARN, "Warning - invalid username length ", usernameLen, " found, treating as if there was no username set");
+ LOG.log(POILogger.WARN, "Warning - invalid username length ", usernameLen, " found, treating as if there was no username set");
usernameLen = 0;
}
// (normally it's 2, or 3 if you have notes)
// Complain if it's not
if(slwtcount == 0) {
- logger.log(POILogger.WARN, "No SlideListWithText's found - there should normally be at least one!");
+ LOG.log(POILogger.WARN, "No SlideListWithText's found - there should normally be at least one!");
}
if(slwtcount > 3) {
- logger.log(POILogger.WARN, "Found ", slwtcount, " SlideListWithTexts - normally there should only be three!");
+ LOG.log(POILogger.WARN, "Found ", slwtcount, " SlideListWithTexts - normally there should only be three!");
}
// Now grab all the SLWTs
if(_children[0] instanceof ExEmbedAtom) {
embedAtom = (ExEmbedAtom)_children[0];
} else {
- logger.log(POILogger.ERROR, "First child record wasn't a ExEmbedAtom, was of type ", _children[0].getRecordType());
+ LOG.log(POILogger.ERROR, "First child record wasn't a ExEmbedAtom, was of type ", _children[0].getRecordType());
}
// Second child should be the ExOleObjAtom
if (_children[1] instanceof ExOleObjAtom) {
oleObjAtom = (ExOleObjAtom)_children[1];
} else {
- logger.log(POILogger.ERROR, "Second child record wasn't a ExOleObjAtom, was of type ", _children[1].getRecordType());
+ LOG.log(POILogger.ERROR, "Second child record wasn't a ExOleObjAtom, was of type ", _children[1].getRecordType());
}
for (int i = 2; i < _children.length; i++) {
if(_children[0] instanceof ExHyperlinkAtom) {
linkAtom = (ExHyperlinkAtom)_children[0];
} else {
- logger.log(POILogger.ERROR, "First child record wasn't a ExHyperlinkAtom, was of type ", _children[0].getRecordType());
+ LOG.log(POILogger.ERROR, "First child record wasn't a ExHyperlinkAtom, was of type ", _children[0].getRecordType());
}
for (int i = 1; i < _children.length; i++) {
if ( linkDetailsA == null) linkDetailsA = (CString)_children[i];
else linkDetailsB = (CString)_children[i];
} else {
- logger.log(POILogger.ERROR, "Record after ExHyperlinkAtom wasn't a CString, was of type ", _children[1].getRecordType());
+ LOG.log(POILogger.ERROR, "Record after ExHyperlinkAtom wasn't a CString, was of type ", _children[1].getRecordType());
}
}
if (_children[0] instanceof ExVideoContainer) {
exVideo = (ExVideoContainer) _children[0];
} else {
- logger.log(POILogger.ERROR, "First child record wasn't a ExVideoContainer, was of type ", _children[0].getRecordType());
+ LOG.log(POILogger.ERROR, "First child record wasn't a ExVideoContainer, was of type ", _children[0].getRecordType());
}
}
if(_children[0] instanceof ExMediaAtom) {
mediaAtom = (ExMediaAtom)_children[0];
} else {
- logger.log(POILogger.ERROR, "First child record wasn't a ExMediaAtom, was of type ", _children[0].getRecordType());
+ LOG.log(POILogger.ERROR, "First child record wasn't a ExMediaAtom, was of type ", _children[0].getRecordType());
}
if(_children[1] instanceof CString) {
pathAtom = (CString)_children[1];
} else {
- logger.log(POILogger.ERROR, "Second child record wasn't a CString, was of type ", _children[1].getRecordType());
+ LOG.log(POILogger.ERROR, "Second child record wasn't a CString, was of type ", _children[1].getRecordType());
}
}
HSLFFontInfo fi = addFont(fontHeader);
fi.addFacet(fed);
} else {
- logger.log(POILogger.WARN, "Warning: FontCollection child wasn't a FontEntityAtom, was ", r.getClass().getSimpleName());
+ LOG.log(POILogger.WARN, "Warning: FontCollection child wasn't a FontEntityAtom, was ", r.getClass().getSimpleName());
}
}
}
csFooter = cs;
break;
default:
- logger.log(POILogger.WARN, "Unexpected CString.Options in HeadersFootersContainer: ", opts);
+ LOG.log(POILogger.WARN, "Unexpected CString.Options in HeadersFootersContainer: ", opts);
break;
}
} else {
- logger.log(POILogger.WARN, "Unexpected record in HeadersFootersContainer: ", child);
+ LOG.log(POILogger.WARN, "Unexpected record in HeadersFootersContainer: ", child);
}
}
}
private void findInterestingChildren() {
// First child should be the InteractiveInfoAtom
if (_children == null || _children.length == 0 || !(_children[0] instanceof InteractiveInfoAtom)) {
- logger.log(POILogger.WARN, "First child record wasn't a InteractiveInfoAtom - leaving this atom in an invalid state...");
+ LOG.log(POILogger.WARN, "First child record wasn't a InteractiveInfoAtom - leaving this atom in an invalid state...");
return;
}
try {
read();
} catch (Exception e){
- logger.log(POILogger.ERROR, "Failed to parse MasterTextPropAtom", e);
+ LOG.log(POILogger.ERROR, "Failed to parse MasterTextPropAtom", e);
}
}
// Wind on
int size = r.getRecordSize();
if(size < 8) {
- logger.log(POILogger.WARN, "Hit short DDF record at ", startPos, " - ", size);
+ LOG.log(POILogger.WARN, "Hit short DDF record at ", startPos, " - ", size);
}
/*
* Sometimes it is not so, see an example in bug #44770. Most likely reason is that one of ddf records calculates wrong size.
*/
if(size != escherBytes){
- logger.log(POILogger.WARN, "Record length=", escherBytes, " but getRecordSize() returned ", r.getRecordSize(), "; record: ", r.getClass());
+ LOG.log(POILogger.WARN, "Record length=", escherBytes, " but getRecordSize() returned ", r.getRecordSize(), "; record: ", r.getClass());
size = escherBytes;
}
startPos += size;
if (newPos == null) {
Integer id = me.getKey();
- logger.log(POILogger.WARN, "Couldn't find the new location of the \"slide\" with id " + id + " that used to be at " + oldPos);
- logger.log(POILogger.WARN, "Not updating the position of it, you probably won't be able to find it any more (if you ever could!)");
+ LOG.log(POILogger.WARN, "Couldn't find the new location of the \"slide\" with id " + id + " that used to be at " + oldPos);
+ LOG.log(POILogger.WARN, "Not updating the position of it, you probably won't be able to find it any more (if you ever could!)");
} else {
me.setValue(newPos);
}
public abstract class Record implements GenericRecord
{
// For logging
- protected static final POILogger logger = POILogFactory.getLogger(Record.class);
+ protected static final POILogger LOG = POILogFactory.getLogger(Record.class);
/**
* Is this record type an Atom record (only has data),
// Handle case of a corrupt last record, whose claimed length
// would take us passed the end of the file
if(start + len > b.length ) {
- logger.log(POILogger.WARN, "Warning: Skipping record of type " + type + " at position " + start + " which claims to be longer than the file! (" + len + " vs " + (b.length-start) + ")");
+ LOG.log(POILogger.WARN, "Warning: Skipping record of type " + type + " at position " + start + " which claims to be longer than the file! (" + len + " vs " + (b.length-start) + ")");
return null;
}
if(_children[0] instanceof CString) {
_name = (CString)_children[0];
} else {
- logger.log(POILogger.ERROR, "First child record wasn't a CString, was of type ", _children[0].getRecordType());
+ LOG.log(POILogger.ERROR, "First child record wasn't a CString, was of type ", _children[0].getRecordType());
}
// Second child should be the ExOleObjAtom
if (_children[1] instanceof CString) {
_type = (CString)_children[1];
} else {
- logger.log(POILogger.ERROR, "Second child record wasn't a CString, was of type ", _children[1].getRecordType());
+ LOG.log(POILogger.ERROR, "Second child record wasn't a CString, was of type ", _children[1].getRecordType());
}
for (int i = 2; i < _children.length; i++) {
}
if (rawContents.length > 0 && textHandled != (size+1)){
- logger.log(POILogger.WARN, "Problem reading paragraph style runs: textHandled = ", textHandled, ", text.size+1 = ", (size+1));
+ LOG.log(POILogger.WARN, "Problem reading paragraph style runs: textHandled = ", textHandled, ", text.size+1 = ", (size+1));
}
// Now do the character stylings
}
}
if (rawContents.length > 0 && textHandled != (size+1)){
- logger.log(POILogger.WARN, "Problem reading character style runs: textHandled = ", textHandled, ", text.size+1 = ", (size+1));
+ LOG.log(POILogger.WARN, "Problem reading character style runs: textHandled = ", textHandled, ", text.size+1 = ", (size+1));
}
// Handle anything left over
private int checkTextLength(int readLength, int handledSoFar, int overallSize) {
if (readLength + handledSoFar > overallSize + 1) {
- logger.log(POILogger.WARN, "Style length of ", readLength, " at ", handledSoFar,
+ LOG.log(POILogger.WARN, "Style length of ", readLength, " at ", handledSoFar,
" larger than stated size of ", overallSize, ", truncating");
return overallSize + 1 - handledSoFar;
}
// Get the record data.
read(leis);
} catch (IOException e){
- logger.log(POILogger.ERROR, "Failed to parse TextRulerAtom: ", e.getMessage());
+ LOG.log(POILogger.ERROR, "Failed to parse TextRulerAtom: ", e.getMessage());
}
}
*/
public final class HSLFNotes extends HSLFSheet implements Notes<HSLFShape,HSLFTextParagraph> {
- protected static final POILogger logger = POILogFactory.getLogger(HSLFNotes.class);
-
- private List<List<HSLFTextParagraph>> _paragraphs = new ArrayList<>();
+ private static final POILogger LOG = POILogFactory.getLogger(HSLFNotes.class);
+
+ private final List<List<HSLFTextParagraph>> _paragraphs = new ArrayList<>();
/**
* Constructs a Notes Sheet from the given Notes record.
* Initialises TextRuns, to provide easier access to the text
- *
+ *
* @param notes the Notes record to read from
*/
public HSLFNotes(org.apache.poi.hslf.record.Notes notes) {
for (List<HSLFTextParagraph> l : HSLFTextParagraph.findTextParagraphs(getPPDrawing(), this)) {
if (!_paragraphs.contains(l)) _paragraphs.add(l);
}
-
+
if (_paragraphs.isEmpty()) {
- logger.log(POILogger.WARN, "No text records found for notes sheet");
+ LOG.log(POILogger.WARN, "No text records found for notes sheet");
}
}
/**
* Create a <code>Shape</code> object depending on its type
- *
- * @author Yegor Kozlov
*/
public final class HSLFShapeFactory {
// For logging
- protected static final POILogger logger = POILogFactory.getLogger(HSLFShapeFactory.class);
+ private static final POILogger LOG = POILogFactory.getLogger(HSLFShapeFactory.class);
/**
* Create a new shape from the data provided.
}
}
}
-
+
HSLFGroupShape group;
if (isTable) {
group = new HSLFTable(spContainer, parent);
-
+
} else {
group = new HSLFGroupShape(spContainer, parent);
}
-
+
return group;
}
if (parent instanceof HSLFTable) {
EscherTextboxRecord etr = spContainer.getChildById(EscherTextboxRecord.RECORD_ID);
if (etr == null) {
- logger.log(POILogger.WARN, "invalid ppt - add EscherTextboxRecord to cell");
+ LOG.log(POILogger.WARN, "invalid ppt - add EscherTextboxRecord to cell");
etr = new EscherTextboxRecord();
etr.setRecordId(EscherTextboxRecord.RECORD_ID);
etr.setOptions((short)15);
break;
}
}
-
+
ExObjRefAtom oes = getClientDataRecord(spContainer, RecordTypes.ExObjRefAtom.typeID);
return (oes != null)
? new HSLFObjectShape(spContainer, parent)
: new HSLFPictureShape(spContainer, parent);
}
-
+
private static HSLFShape createNonPrimitive(EscherContainerRecord spContainer, ShapeContainer<HSLFShape,HSLFTextParagraph> parent) {
AbstractEscherOptRecord opt = HSLFShape.getEscherChild(spContainer, EscherOptRecord.RECORD_ID);
EscherProperty prop = HSLFShape.getEscherProperty(opt, EscherPropertyTypes.GEOMETRY__VERTICES);
if(prop != null) {
return new HSLFFreeformShape(spContainer, parent);
}
-
- logger.log(POILogger.INFO, "Creating AutoShape for a NotPrimitive shape");
+
+ LOG.log(POILogger.INFO, "Creating AutoShape for a NotPrimitive shape");
return new HSLFAutoShape(spContainer, parent);
}
-
+
@SuppressWarnings("unchecked")
protected static <T extends Record> T getClientDataRecord(EscherContainerRecord spContainer, int recordType) {
HSLFEscherClientDataRecord cldata = spContainer.getChildById(EscherClientDataRecord.RECORD_ID);
public abstract class HSLFSimpleShape extends HSLFShape implements SimpleShape<HSLFShape,HSLFTextParagraph> {
private static final POILogger LOG = POILogFactory.getLogger(HSLFSimpleShape.class);
- public final static double DEFAULT_LINE_WIDTH = 0.75;
+ public static final double DEFAULT_LINE_WIDTH = 0.75;
protected static final EscherPropertyTypes[] ADJUST_VALUES = {
EscherPropertyTypes.GEOMETRY__ADJUSTVALUE,
*/
public final class HSLFSlideShow extends POIDocument implements SlideShow<HSLFShape,HSLFTextParagraph>, Closeable, GenericRecord {
- //arbitrarily selected; may need to increase
- private static final int MAX_RECORD_LENGTH = 10_000_000;
-
/** Powerpoint document entry/stream name */
- public static final String POWERPOINT_DOCUMENT = "PowerPoint Document";
+ public static final String POWERPOINT_DOCUMENT = "PowerPoint Document";
public static final String PP97_DOCUMENT = "PP97_DUALSTORAGE";
public static final String PP95_DOCUMENT = "PP40";
+ // For logging
+ private static final POILogger LOG = POILogFactory.getLogger(HSLFSlideShow.class);
+
+ //arbitrarily selected; may need to increase
+ private static final int MAX_RECORD_LENGTH = 10_000_000;
+
enum LoadSavePhase {
INIT, LOADED
}
private final List<HSLFNotes> _notes = new ArrayList<>();
private FontCollection _fonts;
- // For logging
- private static final POILogger logger = POILogFactory.getLogger(HSLFSlideShow.class);
-
/**
* Constructs a Powerpoint document from the underlying
if (coreRecordId != null) {
return _mostRecentCoreRecords[coreRecordId];
}
- logger.log(POILogger.ERROR,
+ LOG.log(POILogger.ERROR,
"We tried to look up a reference to a core record, but there was no core ID for reference ID ", refID);
return null;
}
// we need to add null-records, otherwise the index references to other existing don't work anymore
if (r == null) {
- logger.log(POILogger.WARN, loggerLoc+", but that record didn't exist - record ignored.");
+ LOG.log(POILogger.WARN, loggerLoc+", but that record didn't exist - record ignored.");
continue;
}
// Ensure it really is a notes record
if (!(r instanceof Notes)) {
- logger.log(POILogger.ERROR, loggerLoc, ", but that was actually a ", r);
+ LOG.log(POILogger.ERROR, loggerLoc, ", but that was actually a ", r);
continue;
}
// Ensure it really is a slide record
if (!(r instanceof Slide)) {
- logger.log(POILogger.ERROR, "A Slide SlideAtomSet at ", idx,
+ LOG.log(POILogger.ERROR, "A Slide SlideAtomSet at ", idx,
" said its record was at refID ",
spa.getRefID(),
", but that was actually a ", r);
if (notesPos != null && 0 <= notesPos && notesPos < _notes.size()) {
notes = _notes.get(notesPos);
} else {
- logger.log(POILogger.ERROR, "Notes not found for noteId=", noteId);
+ LOG.log(POILogger.ERROR, "Notes not found for noteId=", noteId);
}
}
// Add in to the list of Slides
_slides.add(slide);
- logger.log(POILogger.INFO, "Added slide ", _slides.size(), " with ref ", sp.getRefID(),
+ LOG.log(POILogger.INFO, "Added slide ", _slides.size(), " with ref ", sp.getRefID(),
" and identifier ", sp.getSlideIdentifier());
// Add the core records for this new Slide to the record tree
int slideOffset = slideRecord.getLastOnDiskOffset();
slideRecord.setLastOnDiskOffset(slideOffset);
ptr.addSlideLookup(psrId, slideOffset);
- logger.log(POILogger.INFO, "New slide/object ended up at ", slideOffset);
+ LOG.log(POILogger.INFO, "New slide/object ended up at ", slideOffset);
return psrId;
}
* "reader". It is only a very basic class for now
*/
public final class HSLFSlideShowImpl extends POIDocument implements Closeable {
- private static final POILogger logger = POILogFactory.getLogger(HSLFSlideShowImpl.class);
+ private static final POILogger LOG = POILogFactory.getLogger(HSLFSlideShowImpl.class);
static final int UNSET_OFFSET = -1;
int type = LittleEndian.getUShort(docstream, usrOffset + 2);
int len = LittleEndian.getInt(docstream, usrOffset + 4);
if (ver_inst == 0 && type == 4085 && (len == 0x1C || len == 0x20)) {
- logger.log(POILogger.WARN, "Repairing invalid user edit atom");
+ LOG.log(POILogger.WARN, "Repairing invalid user edit atom");
usr.setLastUserEditAtomOffset(usrOffset);
} else {
throw new CorruptPowerPointFileException("Powerpoint document contains invalid user edit atom");
try {
currentUser = new CurrentUserAtom(getDirectory());
} catch (IOException ie) {
- logger.log(POILogger.ERROR, "Error finding Current User Atom", ie);
+ LOG.log(POILogger.ERROR, "Error finding Current User Atom", ie);
currentUser = new CurrentUserAtom();
}
}
// If they type (including the bonus 0xF018) is 0, skip it
PictureType pt = PictureType.forNativeID(type - 0xF018);
if (pt == null) {
- logger.log(POILogger.ERROR, "Problem reading picture: Invalid image type 0, on picture with length ", imgsize, ".\nYour document will probably become corrupted if you save it!");
- logger.log(POILogger.ERROR, "position: ", pos);
+ LOG.log(POILogger.ERROR, "Problem reading picture: Invalid image type 0, on picture with length ", imgsize, ".\nYour document will probably become corrupted if you save it!");
+ LOG.log(POILogger.ERROR, "position: ", pos);
} else {
//The pictstream can be truncated halfway through a picture.
//This is not a problem if the pictstream contains extra pictures
//that are not used in any slide -- BUG-60305
if (pos + imgsize > pictstream.length) {
- logger.log(POILogger.WARN, "\"Pictures\" stream may have ended early. In some circumstances, this is not a problem; " +
+ LOG.log(POILogger.WARN, "\"Pictures\" stream may have ended early. In some circumstances, this is not a problem; " +
"in others, this could indicate a corrupt file");
break;
}
pict.setIndex(_pictures.size() + 1); // index is 1-based
_pictures.add(pict);
} catch (IllegalArgumentException e) {
- logger.log(POILogger.ERROR, "Problem reading picture: ", e, "\nYour document will probably become corrupted if you save it!");
+ LOG.log(POILogger.ERROR, "Problem reading picture: ", e, "\nYour document will probably become corrupted if you save it!");
}
}
*/
public final class HSLFTextParagraph implements TextParagraph<HSLFShape,HSLFTextParagraph,HSLFTextRun> {
- protected static final POILogger logger = POILogFactory.getLogger(HSLFTextParagraph.class);
+ private static final POILogger LOG = POILogFactory.getLogger(HSLFTextParagraph.class);
/**
* How to align the text
}
if (startIdx[0] >= records.length) {
- logger.log(POILogger.INFO, "header atom wasn't found - container might contain only an OutlineTextRefAtom");
+ LOG.log(POILogger.INFO, "header atom wasn't found - container might contain only an OutlineTextRefAtom");
return new org.apache.poi.hslf.record.Record[0];
}
} else {
master = sheet.getMasterSheet();
if (master == null) {
- logger.log(POILogger.WARN, "MasterSheet is not available");
+ LOG.log(POILogger.WARN, "MasterSheet is not available");
return null;
}
}
}
if (style == null) {
- logger.log(POILogger.INFO, "styles atom doesn't exist. Creating dummy record for later saving.");
+ LOG.log(POILogger.INFO, "styles atom doesn't exist. Creating dummy record for later saving.");
style = new StyleTextPropAtom((textLen < 0) ? 1 : textLen);
} else {
if (textLen >= 0) {
}
}
if (rv == null || rv.isEmpty()) {
- logger.log(POILogger.WARN, "text run not found for OutlineTextRefAtom.TextIndex=" + idx);
+ LOG.log(POILogger.WARN, "text run not found for OutlineTextRefAtom.TextIndex=" + idx);
}
} else {
if (sheet != null) {
if (tbytes == null && tchars == null) {
tbytes = new TextBytesAtom();
// don't add record yet - set it in storeText
- logger.log(POILogger.INFO, "bytes nor chars atom doesn't exist. Creating dummy record for later saving.");
+ LOG.log(POILogger.INFO, "bytes nor chars atom doesn't exist. Creating dummy record for later saving.");
}
String rawText = (tchars != null) ? tchars.getText() : tbytes.getText();
}
if (paragraphCollection.isEmpty()) {
- logger.log(POILogger.DEBUG, "No text records found.");
+ LOG.log(POILogger.DEBUG, "No text records found.");
}
return paragraphCollection;
*/
@SuppressWarnings({"WeakerAccess", "Duplicates", "unused"})
public final class HSLFTextRun implements TextRun {
- private static final POILogger logger = POILogFactory.getLogger(HSLFTextRun.class);
+ private static final POILogger LOG = POILogFactory.getLogger(HSLFTextRun.class);
/** The TextRun we belong to */
private HSLFTextParagraph parentParagraph;
final int txtype = parentParagraph.getRunType();
final HSLFSheet sheet = parentParagraph.getSheet();
if (sheet == null) {
- logger.log(POILogger.ERROR, "Sheet is not available");
+ LOG.log(POILogger.ERROR, "Sheet is not available");
return null;
}
final HSLFMasterSheet master = sheet.getMasterSheet();
if (master == null) {
- logger.log(POILogger.WARN, "MasterSheet is not available");
+ LOG.log(POILogger.WARN, "MasterSheet is not available");
return null;
}
/**
* Reads an Outlook MSG File in and provides hooks into its data structure.
- *
+ *
* If you want to develop with HSMF, you might find it worth getting
* some of the Microsoft public documentation, such as:
- *
+ *
* [MS-OXCMSG]: Message and Attachment Object Protocol Specification
*/
public class MAPIMessage extends POIReadOnlyDocument {
}
/** For logging problems we spot with the file */
- private POILogger logger = POILogFactory.getLogger(MAPIMessage.class);
-
+ private static final POILogger LOG = POILogFactory.getLogger(MAPIMessage.class);
+
private Chunks mainChunks;
private NameIdChunks nameIdChunks;
private RecipientChunks[] recipientChunks;
/**
* Constructor for reading MSG Files from the file system.
- *
+ *
* @param filename Name of the file to read
* @exception IOException on errors reading, or invalid data
*/
}
/**
* Constructor for reading MSG Files from the file system.
- *
+ *
* @param file The file to read from
* @exception IOException on errors reading, or invalid data
*/
/**
* Constructor for reading MSG Files from an input stream.
- *
+ *
* <p>Note - this will buffer the whole message into memory
* in order to process. For lower memory use, use {@link #MAPIMessage(File)}
- *
+ *
* @param in The InputStream to buffer then read from
* @exception IOException on errors reading, or invalid data
*/
}
/**
* Constructor for reading MSG Files from a POIFS filesystem
- *
+ *
* @param fs Open POIFS FileSystem containing the message
* @exception IOException on errors reading, or invalid data
*/
byte[] htmlBodyBinary = htmlBodyBinaryChunk.getValue();
return new String(htmlBodyBinary, encoding);
} catch (UnsupportedEncodingException e) {
- logger.log(POILogger.WARN, "HTML body binary: Invalid codepage ID ", codepage, " set for the message via ",
+ LOG.log(POILogger.WARN, "HTML body binary: Invalid codepage ID ", codepage, " set for the message via ",
MAPIProperty.INTERNET_CPID, ", ignoring");
}
}
throw new ChunkNotFoundException();
}
}
-
+
try {
MAPIRtfAttribute rtf = new MAPIRtfAttribute(
MAPIProperty.RTF_COMPRESSED, Types.BINARY.getId(), chunk.getValue()
/**
* Gets the display value of the "TO" line of the outlook message.
* If there are multiple recipients, they will be separated
- * by semicolons.
- * This is not the actual list of addresses/values that will be
+ * by semicolons.
+ * This is not the actual list of addresses/values that will be
* sent to if you click Reply in the email - those are stored
* in {@link RecipientChunks}.
* @throws ChunkNotFoundException If the to-chunk does not exist and
/**
* Gets the display value of the "CC" line of the outlook message.
* If there are multiple recipients, they will be separated
- * by semicolons.
- * This is not the actual list of addresses/values that will be
+ * by semicolons.
+ * This is not the actual list of addresses/values that will be
* sent to if you click Reply in the email - those are stored
* in {@link RecipientChunks}.
* @throws ChunkNotFoundException If the cc-chunk does not exist and
/**
* Gets the display value of the "BCC" line of the outlook message.
* If there are multiple recipients, they will be separated
- * by semicolons.
- * This is not the actual list of addresses/values that will be
+ * by semicolons.
+ * This is not the actual list of addresses/values that will be
* sent to if you click Reply in the email - those are stored
* in {@link RecipientChunks}.
* This will only be present in sent emails, not received ones!
/**
* Returns all the recipients' email address, separated by
- * semicolons. Checks all the likely chunks in search of
+ * semicolons. Checks all the likely chunks in search of
* the addresses.
*/
public String getRecipientEmailAddress() throws ChunkNotFoundException {
/**
* Returns an array of all the recipient's email address, normally
* in TO then CC then BCC order.
- * Checks all the likely chunks in search of the addresses.
+ * Checks all the likely chunks in search of the addresses.
*/
public String[] getRecipientEmailAddressList() throws ChunkNotFoundException {
if(recipientChunks == null || recipientChunks.length == 0) {
/**
* Returns all the recipients' names, separated by
- * semicolons. Checks all the likely chunks in search of
+ * semicolons. Checks all the likely chunks in search of
* the names.
* See also {@link #getDisplayTo()}, {@link #getDisplayCC()}
* and {@link #getDisplayBCC()}.
/**
* Returns an array of all the recipient's names, normally
* in TO then CC then BCC order.
- * Checks all the likely chunks in search of the names.
+ * Checks all the likely chunks in search of the names.
* See also {@link #getDisplayTo()}, {@link #getDisplayCC()}
* and {@link #getDisplayBCC()}.
*/
return names;
}
-
+
/**
* Tries to identify the correct encoding for 7-bit (non-unicode)
* strings in the file.
* strings, but don't always store the encoding anywhere
* helpful in the file.</p>
* <p>This method checks for codepage properties, and failing that
- * looks at the headers for the message, and uses these to
+ * looks at the headers for the message, and uses these to
* guess the correct encoding for your file.</p>
* <p>Bug #49441 has more on why this is needed</p>
*/
String encoding = CodePageUtil.codepageToEncoding(codepage, true);
generalcodepage = encoding;
} catch (UnsupportedEncodingException e) {
- logger.log(POILogger.WARN, "Invalid codepage ID ", codepage, " set for the message via ",
+ LOG.log(POILogger.WARN, "Invalid codepage ID ", codepage, " set for the message via ",
MAPIProperty.MESSAGE_CODEPAGE, ", ignoring");
}
}
generalcodepage = encoding;
}
} catch (UnsupportedEncodingException e) {
- logger.log(POILogger.WARN, "Invalid codepage ID ", codepage, "from locale ID", lcid, " set for the message via ",
+ LOG.log(POILogger.WARN, "Invalid codepage ID ", codepage, "from locale ID", lcid, " set for the message via ",
MAPIProperty.MESSAGE_LOCALE_ID, ", ignoring");
}
}
bodycodepage = encoding;
}
} catch (UnsupportedEncodingException e) {
- logger.log(POILogger.WARN, "Invalid codepage ID ", codepage, " set for the message via ",
+ LOG.log(POILogger.WARN, "Invalid codepage ID ", codepage, " set for the message via ",
MAPIProperty.INTERNET_CPID, ", ignoring");
}
}
}
}
}
-
+
/**
* Does this file contain any strings that
* are stored as 7 bit rather than unicode?
}
}
}
-
+
if (nameIdChunks!=null) {
for(Chunk c : nameIdChunks.getChunks()) {
if(c instanceof StringChunk) {
}
}
}
-
+
for(RecipientChunks rc : recipientChunks) {
for(Chunk c : rc.getAll()) {
if(c instanceof StringChunk) {
}
return false;
}
-
+
/**
* Returns all the headers, one entry per line
*/
} else if (mc.equalsIgnoreCase("IPM.Post")) {
return MESSAGE_CLASS.POST;
} else {
- logger.log(POILogger.WARN, "I don't recognize message class '", mc, "'. ",
+ LOG.log(POILogger.WARN, "I don't recognize message class '", mc, "'. ",
"Please open an issue on POI's bugzilla");
return MESSAGE_CLASS.UNKNOWN;
}
}
}
}
-
+
if(returnNullOnMissingChunk)
return null;
throw new ChunkNotFoundException();
/**
- * Will you get a null on a missing chunk, or a
+ * Will you get a null on a missing chunk, or a
* {@link ChunkNotFoundException} (default is the
* exception).
*/
/**
* Sets whether on asking for a missing chunk,
* you get back null or a {@link ChunkNotFoundException}
- * (default is the exception).
+ * (default is the exception).
*/
public void setReturnNullOnMissingChunk(boolean returnNullOnMissingChunk) {
this.returnNullOnMissingChunk = returnNullOnMissingChunk;
public static final int PROPERTIES_FLAG_WRITEABLE = 4;
/** For logging problems we spot with the file */
- private POILogger logger = POILogFactory.getLogger(PropertiesChunk.class);
+ private static final POILogger LOG = POILogFactory.getLogger(PropertiesChunk.class);
/**
* Holds properties, indexed by type. If a property is multi-valued, or
if (chunk != null) {
cVal.setValue(chunk);
} else {
- logger.log(POILogger.WARN, "No chunk found matching Property " + cVal);
+ LOG.log(POILogger.WARN, "No chunk found matching Property " + cVal);
}
}
}
prop = MAPIProperty.createCustom(id, type, "Unknown " + id);
}
if (type == null) {
- logger.log(POILogger.WARN, "Invalid type found, expected ",
+ LOG.log(POILogger.WARN, "Invalid type found, expected ",
prop.usualType, " but got ", typeID,
" for property ", prop);
going = false;
// We don't know what this property normally is, but it
// has come
// through with a valid type, so use that
- logger.log(POILogger.INFO, "Property definition for ", prop,
+ LOG.log(POILogger.INFO, "Property definition for ", prop,
" is missing a type definition, found a value with type ", type);
} else {
// Oh dear, something has gone wrong...
- logger.log(POILogger.WARN, "Type mismatch, expected ",
+ LOG.log(POILogger.WARN, "Type mismatch, expected ",
prop.usualType, " but got ", type, " for property ", prop);
going = false;
break;
}
if (properties.get(prop) != null) {
- logger.log(POILogger.WARN,
+ LOG.log(POILogger.WARN,
"Duplicate values found for " + prop);
}
properties.put(prop, propVal);
/**
* Writes this chunk in the specified {@code DirectoryEntry}.
- *
+ *
* @param directory
* The directory.
* @throws IOException
// write the property values
writeNodeData(directory, values);
}
-
+
/**
* Write the nodes for variable-length data. Those properties are returned by
* {@link #writeProperties(java.io.OutputStream)}.
- *
+ *
* @param directory
* The directory.
* @param values
/**
* Writes the header of the properties.
- *
+ *
* @param out
* The {@code OutputStream}.
* @return The variable-length properties that need to be written in another
private static final float DPI = 72;
- private static final POILogger logger = POILogFactory
- .getLogger( ExcelToFoConverter.class );
+ private static final POILogger LOG = POILogFactory.getLogger( ExcelToFoConverter.class );
private static final float PAPER_A4_HEIGHT_INCHES = 29.4f / CM_PER_INCH;
value = ErrorEval.getText( cell.getErrorCellValue() );
break;
default:
- logger.log(
+ LOG.log(
POILogger.WARN,
"Unexpected cell cachedFormulaResultType ("
+ cell.getCachedFormulaResultType() + ")" );
value = ErrorEval.getText( cell.getErrorCellValue() );
break;
default:
- logger.log( POILogger.WARN,
+ LOG.log( POILogger.WARN,
"Unexpected cell type (" + cell.getCellType() + ")" );
return true;
}
*/
@Beta
public class ExcelToHtmlConverter extends AbstractExcelConverter {
- private static final POILogger logger = POILogFactory
- .getLogger( ExcelToHtmlConverter.class );
+ private static final POILogger LOG = POILogFactory.getLogger( ExcelToHtmlConverter.class );
/**
* Java main() interface to interact with {@link ExcelToHtmlConverter}
value = ErrorEval.getText( cell.getErrorCellValue() );
break;
default:
- logger.log(
+ LOG.log(
POILogger.WARN,
"Unexpected cell cachedFormulaResultType ("
+ cell.getCachedFormulaResultType() + ")" );
value = ErrorEval.getText( cell.getErrorCellValue() );
break;
default:
- logger.log( POILogger.WARN,
+ LOG.log( POILogger.WARN,
"Unexpected cell type (" + cell.getCellType() + ")" );
return true;
}
*/
public class HwmfBitmapDib implements GenericRecord {
- private static final POILogger logger = POILogFactory.getLogger(HwmfBitmapDib.class);
+ private static final POILogger LOG = POILogFactory.getLogger(HwmfBitmapDib.class);
private static final int BMP_HEADER_SIZE = 14;
private static final int MAX_RECORD_LENGTH = HwmfPicture.MAX_RECORD_LENGTH;
try {
bi = ImageIO.read(getBMPStream());
} catch (IOException|RuntimeException e) {
- logger.log(POILogger.ERROR, "invalid bitmap data - returning placeholder image");
+ LOG.log(POILogger.ERROR, "invalid bitmap data - returning placeholder image");
return getPlaceholder();
}
import org.apache.poi.util.POILogger;
public class HwmfText {
- private static final POILogger logger = POILogFactory.getLogger(HwmfText.class);
+ private static final POILogger LOG = POILogFactory.getLogger(HwmfText.class);
private static final int MAX_RECORD_LENGTH = 1_000_000;
/**
size += rawTextBytes.length;
if (size >= remainingRecordSize) {
- logger.log(POILogger.INFO, "META_EXTTEXTOUT doesn't contain character tracking info");
+ LOG.log(POILogger.INFO, "META_EXTTEXTOUT doesn't contain character tracking info");
return size;
}
int dxLen = Math.min(stringLength, (remainingRecordSize-size)/LittleEndianConsts.SHORT_SIZE);
if (dxLen < stringLength) {
- logger.log(POILogger.WARN, "META_EXTTEXTOUT tracking info doesn't cover all characters");
+ LOG.log(POILogger.WARN, "META_EXTTEXTOUT tracking info doesn't cover all characters");
}
for (int i=0; i<dxLen; i++) {
/** Max. record length - processing longer records will throw an exception */
public static final int MAX_RECORD_LENGTH = 50_000_000;
- private static final POILogger logger = POILogFactory.getLogger(HwmfPicture.class);
+ private static final POILogger LOG = POILogFactory.getLogger(HwmfPicture.class);
final List<HwmfRecord> records = new ArrayList<>();
final HwmfPlaceableHeader placeableHeader;
recordSize = (int)recordSizeLong;
recordFunction = leis.readShort();
} catch (Exception e) {
- logger.log(POILogger.ERROR, "unexpected eof - wmf file was truncated");
+ LOG.log(POILogger.ERROR, "unexpected eof - wmf file was truncated");
break;
}
// 4 bytes (recordSize) + 2 bytes (recordFunction)
*/
public class HWPFOldDocument extends HWPFDocumentCore {
- private static final POILogger logger = POILogFactory
- .getLogger( HWPFOldDocument.class );
+ private static final POILogger LOG = POILogFactory.getLogger( HWPFOldDocument.class );
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 10_000_000;
- private final static Charset DEFAULT_CHARSET = StringUtil.WIN_1252;
+ private static final Charset DEFAULT_CHARSET = StringUtil.WIN_1252;
private OldTextPieceTable tpt;
//if there was a problem with the guessed charset and the length of the
//textpiece, back off to win1252. This is effectively what we used to do.
tp = buildTextPiece(StringUtil.WIN_1252);
- logger.log(POILogger.WARN, "Error with "+guessedCharset +". Backing off to Windows-1252");
+ LOG.log(POILogger.WARN, "Error with "+guessedCharset +". Backing off to Windows-1252");
}
tpt.add(tp);
return wmfCharset.getCharset();
}
}
- logger.log(POILogger.WARN, "Couldn't find a defined charset; backing off to cp1252");
+ LOG.log(POILogger.WARN, "Couldn't find a defined charset; backing off to cp1252");
//if all else fails
return DEFAULT_CHARSET;
}
private static final byte FIELD_SEPARATOR_MARK = 20;
- private static final POILogger logger = POILogFactory
- .getLogger( AbstractWordConverter.class );
+ private static final POILogger LOG = POILogFactory.getLogger( AbstractWordConverter.class );
private static final Pattern PATTERN_HYPERLINK_EXTERNAL = Pattern
.compile( "^[ \\t\\r\\n]*HYPERLINK \"(.*)\".*$" );
{
if ( previous > range.getEndOffset() )
{
- logger.log( POILogger.WARN, "Latest structure in ", range,
+ LOG.log( POILogger.WARN, "Latest structure in ", range,
" ended at #", previous, " after range boundaries [",
range.getStartOffset(), "; ", range.getEndOffset(),
")" );
debug.append( range.getCharacterRun( i ) );
debug.append( "\n" );
}
- logger.log( POILogger.WARN, debug );
+ LOG.log( POILogger.WARN, debug );
Range deadFieldValueSubrage = new Range( range.getCharacterRun(
separatorMark ).getStartOffset() + 1, range.getCharacterRun(
}
catch ( Exception exc )
{
- logger.log( POILogger.WARN,
+ LOG.log( POILogger.WARN,
"Unable to process document summary information: ", exc,
exc );
}
.getOfficeDrawingAt( characterRun.getStartOffset() );
if ( officeDrawing == null )
{
- logger.log( POILogger.WARN, "Characters #", characterRun,
+ LOG.log( POILogger.WARN, "Characters #", characterRun,
" references missing drawn object" );
return;
}
{
if ( !field.hasSeparator() )
{
- logger.log( POILogger.WARN, parentRange, " contains ", field,
+ LOG.log( POILogger.WARN, parentRange, " contains ", field,
" with 'Embedded Object' but without separator mark" );
return;
}
}
}
- logger.log( POILogger.WARN, parentRange, " contains ", field,
+ LOG.log( POILogger.WARN, parentRange, " contains ", field,
" with unsupported type or format" );
processCharacters( wordDocument, currentTableLevel,
field.secondSubrange( parentRange ), currentBlock );
"_" + characterRun.getPicOffset() );
if ( entry == null )
{
- logger.log( POILogger.WARN, "Referenced OLE2 object '",
+ LOG.log( POILogger.WARN, "Referenced OLE2 object '",
Integer.valueOf( characterRun.getPicOffset() ),
"' not found in ObjectPool" );
return false;
}
catch ( Exception exc )
{
- logger.log( POILogger.WARN,
+ LOG.log( POILogger.WARN,
"Unable to convert internal OLE2 object '",
Integer.valueOf( characterRun.getPicOffset() ), "': ", exc,
exc );
{
static final String EMPTY = "";
- private static final POILogger logger = POILogFactory
- .getLogger( AbstractWordUtils.class );
+ private static final POILogger LOG = POILogFactory.getLogger( AbstractWordUtils.class );
public static final float TWIPS_PER_INCH = 1440.0f;
public static final int TWIPS_PER_PT = 20;
case 2057:
return "en-uk";
default:
- logger.log( POILogger.WARN, "Uknown or unmapped language code: ", languageCode);
+ LOG.log( POILogger.WARN, "Uknown or unmapped language code: ", languageCode);
return EMPTY;
}
}
{
if ( format != 0 )
- logger.log( POILogger.INFO, "NYI: toListItemNumberLabel(): ", format );
+ LOG.log( POILogger.INFO, "NYI: toListItemNumberLabel(): ", format );
return String.valueOf( number );
}
public class WordToFoConverter extends AbstractWordConverter
{
- private static final POILogger logger = POILogFactory
- .getLogger( WordToFoConverter.class );
+ private static final POILogger LOG = POILogFactory.getLogger( WordToFoConverter.class );
/**
* Java main() interface to interact with {@link WordToFoConverter}
}
else
{
- logger.log(
+ LOG.log(
POILogger.WARN,
"Table without body starting on offset ",
table.getStartOffset(), " -- ",
// making sure ID used once
if ( usedIds.contains( id ) )
{
- logger.log( POILogger.WARN,
+ LOG.log( POILogger.WARN,
"Tried to create element with same ID '", id, "'. Skipped" );
return false;
}
}
}
- private static final POILogger logger = POILogFactory.getLogger( WordToHtmlConverter.class );
+ private static final POILogger LOG = POILogFactory.getLogger( WordToHtmlConverter.class );
private final Deque<BlockProperies> blocksProperies = new LinkedList<>();
}
else
{
- logger.log( POILogger.WARN, "Table without body starting at [",
+ LOG.log( POILogger.WARN, "Table without body starting at [",
Integer.valueOf( table.getStartOffset() ), "; ",
Integer.valueOf( table.getEndOffset() ), ")" );
}
@Beta
public class WordToTextConverter extends AbstractWordConverter
{
- private static final POILogger logger = POILogFactory
- .getLogger( WordToTextConverter.class );
+ private static final POILogger LOG = POILogFactory.getLogger( WordToTextConverter.class );
public static String getText( DirectoryNode root ) throws Exception
{
catch ( Exception exc )
{
// no extractor in classpath
- logger.log( POILogger.WARN, "There is an OLE object entry '",
+ LOG.log( POILogger.WARN, "There is an OLE object entry '",
entry.getName(),
"', but there is no text extractor for this object type ",
"or text extractor factory is not available: ", "", exc );
}
catch ( Exception exc )
{
- logger.log( POILogger.ERROR,
+ LOG.log( POILogger.ERROR,
"Unable to extract text from OLE entry '", entry.getName(),
"': ", exc, exc );
return false;
@Internal
public class BookmarksTables
{
- private static final POILogger logger = POILogFactory
- .getLogger( BookmarksTables.class );
+ private static final POILogger LOG = POILogFactory.getLogger( BookmarksTables.class );
private PlexOfCps descriptorsFirst = new PlexOfCps( 4 );
GenericPropertyNode endNode = descriptorsLim.getProperty( i );
if ( startNode.getStart() == endNode.getStart() )
{
- logger.log( POILogger.DEBUG, "Removing bookmark #",
+ LOG.log( POILogger.DEBUG, "Removing bookmark #",
Integer.valueOf( i ), "..." );
remove( i );
i--;
@Internal
public class CHPBinTable
{
- private static final POILogger logger = POILogFactory
- .getLogger( CHPBinTable.class );
+ private static final POILogger LOG = POILogFactory.getLogger( CHPBinTable.class );
/** List of character properties.*/
protected List<CHPX> _textRuns = new ArrayList<>();
_textRuns.add( chpx );
}
}
- logger.log( POILogger.DEBUG, "CHPX FKPs loaded in ",
+ LOG.log( POILogger.DEBUG, "CHPX FKPs loaded in ",
Long.valueOf( System.currentTimeMillis() - start ), " ms (",
Integer.valueOf( _textRuns.size() ), " elements)" );
if ( _textRuns.isEmpty() )
{
- logger.log( POILogger.WARN, "CHPX FKPs are empty" );
+ LOG.log( POILogger.WARN, "CHPX FKPs are empty" );
_textRuns.add( new CHPX( 0, 0, new SprmBuffer( 0 ) ) );
}
}
if ( igrpprl < 0 || igrpprl >= sprmBuffers.length )
{
- logger.log( POILogger.WARN, textPiece
+ LOG.log( POILogger.WARN, textPiece
+ "'s PRM references to unknown grpprl" );
continue;
}
_textRuns.add( chpx );
}
}
- logger.log( POILogger.DEBUG,
+ LOG.log( POILogger.DEBUG,
"Merged with CHPX from complex file table in ",
Long.valueOf( System.currentTimeMillis() - start ),
" ms (", Integer.valueOf( _textRuns.size() ),
List<CHPX> oldChpxSortedByStartPos = new ArrayList<>(_textRuns);
oldChpxSortedByStartPos.sort(PropertyNode.StartComparator);
- logger.log( POILogger.DEBUG, "CHPX sorted by start position in ",
+ LOG.log( POILogger.DEBUG, "CHPX sorted by start position in ",
Long.valueOf( System.currentTimeMillis() - start ), " ms" );
start = System.currentTimeMillis();
}
};
- logger.log( POILogger.DEBUG, "CHPX's order map created in ",
+ LOG.log( POILogger.DEBUG, "CHPX's order map created in ",
Long.valueOf( System.currentTimeMillis() - start ), " ms" );
start = System.currentTimeMillis();
Collections.sort( textRunsBoundariesList );
}
- logger.log( POILogger.DEBUG, "Texts CHPX boundaries collected in ",
+ LOG.log( POILogger.DEBUG, "Texts CHPX boundaries collected in ",
Long.valueOf( System.currentTimeMillis() - start ), " ms" );
start = System.currentTimeMillis();
if ( chpxs.size() == 0 )
{
- logger.log( POILogger.WARN, "Text piece [",
+ LOG.log( POILogger.WARN, "Text piece [",
Integer.valueOf( startInclusive ), "; ",
Integer.valueOf(boundary),
") has no CHPX. Creating new one." );
}
this._textRuns = new ArrayList<>(newChpxs);
- logger.log( POILogger.DEBUG, "CHPX rebuilded in ",
+ LOG.log( POILogger.DEBUG, "CHPX rebuilded in ",
Long.valueOf( System.currentTimeMillis() - start ), " ms (",
Integer.valueOf( _textRuns.size() ), " elements)" );
start = System.currentTimeMillis();
previous = current;
}
- logger.log( POILogger.DEBUG, "CHPX compacted in ",
+ LOG.log( POILogger.DEBUG, "CHPX compacted in ",
Long.valueOf( System.currentTimeMillis() - start ), " ms (",
Integer.valueOf( _textRuns.size() ), " elements)" );
}
public static final int STTBLISTNAMES = 91;
public static final int STTBFUSSR = 92;
- private final static POILogger log = POILogFactory.getLogger(FIBFieldHandler.class);
+ private static final POILogger log = POILogFactory.getLogger(FIBFieldHandler.class);
private static final int FIELD_SIZE = LittleEndianConsts.INT_SIZE * 2;
* </ul>
*/
@Internal
-public final class FileInformationBlock
-{
+public final class FileInformationBlock {
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 100_000;
- public static final POILogger logger = POILogFactory
- .getLogger( FileInformationBlock.class );
+ private static final POILogger LOG = POILogFactory.getLogger( FileInformationBlock.class );
- private FibBase _fibBase;
- private int _csw;
- private FibRgW97 _fibRgW;
- private int _cslw;
- private FibRgLw _fibRgLw;
+ private final FibBase _fibBase;
+ private final int _csw;
+ private final FibRgW97 _fibRgW;
+ private final int _cslw;
+ private final FibRgLw _fibRgLw;
private int _cbRgFcLcb;
private FIBFieldHandler _fieldHandler;
private int _cswNew;
- private int _nFibNew;
- private byte[] _fibRgCswNew;
+ private final int _nFibNew;
+ private final byte[] _fibRgCswNew;
/** Creates a new instance of FileInformationBlock */
public FileInformationBlock( byte[] mainDocument )
/* The Word spec has a much smaller list of "valid" values
* to what the large CommonCrawl corpus contains!
*/
- logger.log(POILogger.WARN, "Invalid file format version number: ", nfib, "(", nfibHex, ")");
+ LOG.log(POILogger.WARN, "Invalid file format version number: ", nfib, "(", nfibHex, ")");
}
}
if ( cbRgFcLcb == expectedCbRgFcLcb )
return;
- logger.log( POILogger.WARN, "Since FIB.nFib == ", strNFib,
+ LOG.log( POILogger.WARN, "Since FIB.nFib == ", strNFib,
" value of FIB.cbRgFcLcb MUST be ", strCbRgFcLcb + ", not 0x",
Integer.toHexString( cbRgFcLcb ) );
}
assertCswNew( "0x0112", 0x0005, "0x0005", _cswNew );
break;
default:
- logger.log(POILogger.WARN, "Invalid file format version number: ", getNFib());
+ LOG.log(POILogger.WARN, "Invalid file format version number: ", getNFib());
}
}
if ( cswNew == expectedCswNew )
return;
- logger.log( POILogger.WARN, "Since FIB.nFib == ", strNFib,
+ LOG.log( POILogger.WARN, "Since FIB.nFib == ", strNFib,
" value of FIB.cswNew MUST be ",
strExpectedCswNew + ", not 0x", Integer.toHexString( cswNew ) );
}
* UnhandledDataStructure and save them on save.
*/
HashSet<Integer> knownFieldSet = new HashSet<>();
- knownFieldSet.add( Integer.valueOf( FIBFieldHandler.STSHF ) );
- knownFieldSet.add( Integer.valueOf( FIBFieldHandler.CLX ) );
- knownFieldSet.add( Integer.valueOf( FIBFieldHandler.DOP ) );
- knownFieldSet.add( Integer.valueOf( FIBFieldHandler.PLCFBTECHPX ) );
- knownFieldSet.add( Integer.valueOf( FIBFieldHandler.PLCFBTEPAPX ) );
- knownFieldSet.add( Integer.valueOf( FIBFieldHandler.PLCFSED ) );
- knownFieldSet.add( Integer.valueOf( FIBFieldHandler.PLFLST ) );
- knownFieldSet.add( Integer.valueOf( FIBFieldHandler.PLFLFO ) );
+ knownFieldSet.add(FIBFieldHandler.STSHF);
+ knownFieldSet.add(FIBFieldHandler.CLX);
+ knownFieldSet.add(FIBFieldHandler.DOP);
+ knownFieldSet.add(FIBFieldHandler.PLCFBTECHPX);
+ knownFieldSet.add(FIBFieldHandler.PLCFBTEPAPX);
+ knownFieldSet.add(FIBFieldHandler.PLCFSED);
+ knownFieldSet.add(FIBFieldHandler.PLFLST);
+ knownFieldSet.add(FIBFieldHandler.PLFLFO);
// field info
for ( FieldsDocumentPart part : FieldsDocumentPart.values() )
knownFieldSet.add( Integer.valueOf( FIBFieldHandler.STTBFBKMK ) );
// notes
- for ( NoteType noteType : NoteType.values() )
- {
- knownFieldSet.add( Integer.valueOf( noteType
- .getFibDescriptorsFieldIndex() ) );
- knownFieldSet.add( Integer.valueOf( noteType
- .getFibTextPositionsFieldIndex() ) );
+ for ( NoteType noteType : NoteType.values() ) {
+ knownFieldSet.add(noteType.getFibDescriptorsFieldIndex());
+ knownFieldSet.add(noteType.getFibTextPositionsFieldIndex());
}
- knownFieldSet.add( Integer.valueOf( FIBFieldHandler.STTBFFFN ) );
- knownFieldSet.add( Integer.valueOf( FIBFieldHandler.STTBFRMARK ) );
- knownFieldSet.add( Integer.valueOf( FIBFieldHandler.STTBSAVEDBY ) );
- knownFieldSet.add( Integer.valueOf( FIBFieldHandler.MODIFIED ) );
+ knownFieldSet.add( FIBFieldHandler.STTBFFFN );
+ knownFieldSet.add( FIBFieldHandler.STTBFRMARK );
+ knownFieldSet.add( FIBFieldHandler.STTBSAVEDBY );
+ knownFieldSet.add( FIBFieldHandler.MODIFIED );
_fieldHandler = new FIBFieldHandler( mainDocument, 154, _cbRgFcLcb,
tableStream, knownFieldSet, true );
@Internal
public final class FontTable
{
- private final static POILogger _logger = POILogFactory.getLogger(FontTable.class);
+ private static final POILogger LOG = POILogFactory.getLogger(FontTable.class);
private short _stringCount;// how many strings are included in the string table
private short _extraDataSz;// size in bytes of the extra data
{
if(chpFtc >= _stringCount)
{
- _logger.log(POILogger.INFO, "Mismatch in chpFtc with stringCount");
+ LOG.log(POILogger.INFO, "Mismatch in chpFtc with stringCount");
return null;
}
{
if(chpFtc >= _stringCount)
{
- _logger.log(POILogger.INFO, "Mismatch in chpFtc with stringCount");
+ LOG.log(POILogger.INFO, "Mismatch in chpFtc with stringCount");
return null;
}
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 10_485_760;
- private static final POILogger logger = POILogFactory
- .getLogger( ListLevel.class );
+ private static final POILogger LOG = POILogFactory.getLogger( ListLevel.class );
private byte[] _grpprlChpx;
private byte[] _grpprlPapx;
{
if ( _xst.getCch() != 1 )
{
- logger.log( POILogger.WARN, "LVL at offset ",
+ LOG.log( POILogger.WARN, "LVL at offset ",
Integer.valueOf( startOffset ),
" has nfc == 0x17 (bullets), but cch != 1 (",
Integer.valueOf( _xst.getCch() ), ")" );
@Internal
public final class ListTables
{
- private final static POILogger log = POILogFactory.getLogger(ListTables.class);
+ private static final POILogger log = POILogFactory.getLogger(ListTables.class);
/**
* Both PlfLst and the following LVLs
@Internal
public final class OldFfn {
- private static final POILogger logger = POILogFactory.getLogger(OldFfn.class);
+ private static final POILogger LOG = POILogFactory.getLogger(OldFfn.class);
- private byte _chs;// character set identifier
+ private final byte _chs;// character set identifier
private final String fontName;
private final String altFontName;
short fontDescriptionLength = buf[offset];
offset += 1;
if (offset + fontDescriptionLength > fontTableEnd) {
- logger.log(POILogger.WARN, "Asked to read beyond font table end. Skipping font");
+ LOG.log(POILogger.WARN, "Asked to read beyond font table end. Skipping font");
return null;
}
Charset charset = null;
FontCharset wmfCharset = FontCharset.valueOf(chs & 0xff);
if (wmfCharset == null) {
- logger.log(POILogger.WARN, "Couldn't find font for type: ", (chs & 0xff));
+ LOG.log(POILogger.WARN, "Couldn't find font for type: ", (chs & 0xff));
} else {
charset = wmfCharset.getCharset();
}
}
}
if (fontNameLength == -1) {
- logger.log(POILogger.WARN, "Couldn't find the zero-byte delimited font name length");
+ LOG.log(POILogger.WARN, "Couldn't find the zero-byte delimited font name length");
return null;
}
String fontName = new String(buf, offset, fontNameLength, charset);
*/
@Internal
public final class OldFontTable {
- private final static POILogger _logger = POILogFactory.getLogger(OldFontTable.class);
+ private static final POILogger LOG = POILogFactory.getLogger(OldFontTable.class);
// added extra facilitator members
// FFN structure containing strings of font names
public String getMainFont(int chpFtc) {
if (chpFtc >= _fontNames.length) {
- _logger.log(POILogger.INFO, "Mismatch in chpFtc with stringCount");
+ LOG.log(POILogger.INFO, "Mismatch in chpFtc with stringCount");
return null;
}
@Internal
public class PAPBinTable
{
- private static final POILogger logger = POILogFactory
- .getLogger( PAPBinTable.class );
+ private static final POILogger LOG = POILogFactory.getLogger( PAPBinTable.class );
protected final ArrayList<PAPX> _paragraphs = new ArrayList<>();
}
}
- logger.log( POILogger.DEBUG, "PAPX tables loaded in ",
+ LOG.log( POILogger.DEBUG, "PAPX tables loaded in ",
Long.valueOf( System.currentTimeMillis() - start ), " ms (",
Integer.valueOf( _paragraphs.size() ), " elements)" );
if ( _paragraphs.isEmpty() )
{
- logger.log( POILogger.WARN, "PAPX FKPs are empty" );
+ LOG.log( POILogger.WARN, "PAPX FKPs are empty" );
_paragraphs.add( new PAPX( 0, 0, new SprmBuffer( 2 ) ) );
}
}
if ( igrpprl < 0 || igrpprl >= sprmBuffers.length )
{
- logger.log( POILogger.WARN, textPiece
+ LOG.log( POILogger.WARN, textPiece
+ "'s PRM references to unknown grpprl" );
continue;
}
}
}
- logger.log( POILogger.DEBUG,
+ LOG.log( POILogger.DEBUG,
"Merged (?) with PAPX from complex file table in ",
Long.valueOf( System.currentTimeMillis() - start ),
" ms (", Integer.valueOf( paragraphs.size() ),
List<PAPX> oldPapxSortedByEndPos = new ArrayList<>(paragraphs);
oldPapxSortedByEndPos.sort(PropertyNode.EndComparator);
- logger.log( POILogger.DEBUG, "PAPX sorted by end position in ",
+ LOG.log( POILogger.DEBUG, "PAPX sorted by end position in ",
Long.valueOf( System.currentTimeMillis() - start ), " ms" );
start = System.currentTimeMillis();
}
};
- logger.log( POILogger.DEBUG, "PAPX's order map created in ",
+ LOG.log( POILogger.DEBUG, "PAPX's order map created in ",
Long.valueOf( System.currentTimeMillis() - start ), " ms" );
start = System.currentTimeMillis();
if ( papxs.size() == 0 )
{
- logger.log( POILogger.WARN, "Paragraph [",
+ LOG.log( POILogger.WARN, "Paragraph [",
Integer.valueOf( startInclusive ), "; ",
Integer.valueOf( endExclusive ),
") has no PAPX. Creating new one." );
paragraphs.clear();
paragraphs.addAll( newPapxs );
- logger.log( POILogger.DEBUG, "PAPX rebuilded from document text in ",
+ LOG.log( POILogger.DEBUG, "PAPX rebuilded from document text in ",
Long.valueOf( System.currentTimeMillis() - start ), " ms (",
Integer.valueOf( paragraphs.size() ), " elements)" );
}
* @author Dmitry Romanov
*/
@Internal
-public final class PicturesTable
-{
- private static final POILogger logger = POILogFactory
- .getLogger( PicturesTable.class );
-
+public final class PicturesTable {
+ private static final POILogger LOG = POILogFactory.getLogger( PicturesTable.class );
+
static final int TYPE_IMAGE = 0x08;
static final int TYPE_IMAGE_WORD2000 = 0x00;
static final int TYPE_IMAGE_PASTED_FROM_CLIPBOARD = 0xA;
}
catch ( Exception exc )
{
- logger.log(
+ LOG.log(
POILogger.WARN,
"Unable to load picture from BLIB record at offset #",
Integer.valueOf( bse.getOffset() ), exc );
*/
public class PlfLfo
{
- private final static POILogger log = POILogFactory.getLogger( PlfLfo.class );
+ private static final POILogger log = POILogFactory.getLogger( PlfLfo.class );
/**
* An unsigned integer that specifies the count of elements in both the
public static final Comparator<PropertyNode<?>> StartComparator = Comparator.comparingInt(PropertyNode::getStart);
- private static final POILogger _logger = POILogFactory.getLogger(PropertyNode.class);
+ private static final POILogger LOG = POILogFactory.getLogger(PropertyNode.class);
protected Object _buf;
_buf = buf;
if (_cpStart < 0) {
- _logger.log(POILogger.WARN, "A property claimed to start before zero, at ", _cpStart, "! Resetting it to zero, and hoping for the best");
+ LOG.log(POILogger.WARN, "A property claimed to start before zero, at ", _cpStart, "! Resetting it to zero, and hoping for the best");
_cpStart = 0;
}
if (_cpEnd < _cpStart) {
- _logger.log(POILogger.WARN, "A property claimed to end (", _cpEnd,
+ LOG.log(POILogger.WARN, "A property claimed to end (", _cpEnd,
") before start! Resetting end to start, and hoping for the best");
_cpEnd = _cpStart;
}
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 100_000;
- private final static POILogger _logger = POILogFactory.getLogger(SectionTable.class);
+ private static final POILogger LOG = POILogFactory.getLogger(SectionTable.class);
private static final int SED_SIZE = 12;
protected List<SEPX> _sections = new ArrayList<>();
}
}
if(! matchAt && matchHalf) {
- _logger.log(POILogger.WARN, "Your document seemed to be mostly unicode, but the section definition was in bytes! Trying anyway, but things may well go wrong!");
+ LOG.log(POILogger.WARN, "Your document seemed to be mostly unicode, but the section definition was in bytes! Trying anyway, but things may well go wrong!");
for(int i=0; i<_sections.size(); i++) {
SEPX s = _sections.get(i);
GenericPropertyNode node = sedPlex.getProperty(i);
@Internal
public final class StyleDescription {
- private static final POILogger logger = POILogFactory.getLogger(StyleDescription.class);
+ private static final POILogger LOG = POILogFactory.getLogger(StyleDescription.class);
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 100_000;
- private final static int PARAGRAPH_STYLE = 1;
- private final static int CHARACTER_STYLE = 2;
- // private final static int TABLE_STYLE = 3;
- // private final static int NUMBERING_STYLE = 4;
+ private static final int PARAGRAPH_STYLE = 1;
+ private static final int CHARACTER_STYLE = 2;
+ // private static final int TABLE_STYLE = 3;
+ // private static final int NUMBERING_STYLE = 4;
private int _baseLength;
private StdfBase _stdfBase;
} else if (baseLength == 0x000A) {
readStdfPost2000 = false;
} else {
- logger.log(POILogger.WARN, "Style definition has non-standard size of ", baseLength);
+ LOG.log(POILogger.WARN, "Style definition has non-standard size of ", baseLength);
}
_stdfBase = new StdfBase(std, offset);
// private static final int TAP_TYPE = 5;
@Deprecated
- private final static ParagraphProperties NIL_PAP = new ParagraphProperties();
+ private static final ParagraphProperties NIL_PAP = new ParagraphProperties();
@Deprecated
- private final static CharacterProperties NIL_CHP = new CharacterProperties();
+ private static final CharacterProperties NIL_CHP = new CharacterProperties();
- private final static byte[] NIL_CHPX = new byte[]{};
- private final static byte[] NIL_PAPX = new byte[]{0, 0};
+ private static final byte[] NIL_CHPX = new byte[]{};
+ private static final byte[] NIL_PAPX = new byte[]{0, 0};
/**
* Size of the STSHI structure
*/
@Internal
public class TextPieceTable implements CharIndexTranslator {
- private static final POILogger logger = POILogFactory
- .getLogger(TextPieceTable.class);
+ private static final POILogger LOG = POILogFactory.getLogger(TextPieceTable.class);
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 100_000_000;
int toAppendLength = toAppend.length();
if (toAppendLength != textPiece.getEnd() - textPiece.getStart()) {
- logger.log(
+ LOG.log(
POILogger.WARN,
"Text piece has boundaries [",
textPiece.getStart(),
+ toAppendLength, toAppend);
}
- logger.log(POILogger.DEBUG, "Document text were rebuilded in ",
+ LOG.log(POILogger.DEBUG, "Document text were rebuilded in ",
System.currentTimeMillis() - start, " ms (",
docText.length(), " chars)");
protected short field_2_bits;
/**/private static final BitField iType = new BitField(0x0003);
/** Specifies that the form field is a textbox. */
- /* */public final static byte ITYPE_TEXT = 0;
+ /* */public static final byte ITYPE_TEXT = 0;
/** Specifies that the form field is a checkbox. */
- /* */public final static byte ITYPE_CHCK = 1;
+ /* */public static final byte ITYPE_CHCK = 1;
/** Specifies that the form field is a dropdown list box. */
- /* */public final static byte ITYPE_DROP = 2;
+ /* */public static final byte ITYPE_DROP = 2;
/**/private static final BitField iRes = new BitField(0x007C);
/**/private static final BitField fOwnHelp = new BitField(0x0080);
/**/private static final BitField fOwnStat = new BitField(0x0100);
/**/private static final BitField iSize = new BitField(0x0400);
/**/private static final BitField iTypeTxt = new BitField(0x3800);
/** Specifies that the textbox value is regular text. */
- /* */public final static byte ITYPETXT_REG = 0;
+ /* */public static final byte ITYPETXT_REG = 0;
/** Specifies that the textbox value is a number. */
- /* */public final static byte ITYPETXT_NUM = 0;
+ /* */public static final byte ITYPETXT_NUM = 0;
/** Specifies that the textbox value is a date or time. */
- /* */public final static byte ITYPETXT_DATE = 0;
+ /* */public static final byte ITYPETXT_DATE = 0;
/** Specifies that the textbox value is the current date. */
- /* */public final static byte ITYPETXT_CURDATE = 0;
+ /* */public static final byte ITYPETXT_CURDATE = 0;
/** Specifies that the textbox value is the current time. */
- /* */public final static byte ITYPETXT_CURTIME = 0;
+ /* */public static final byte ITYPETXT_CURTIME = 0;
/** Specifies that the textbox value is calculated from an expression. The expression is given by FFData.xstzTextDef. */
- /* */protected final static byte ITYPETXT_CALC = 0;
+ /* */protected static final byte ITYPETXT_CALC = 0;
/**/private static final BitField fRecalc = new BitField(0x4000);
/**/private static final BitField fHasListBox = new BitField(0x8000);
protected int field_3_cch;
@Internal
public final class CharacterSprmUncompressor extends SprmUncompressor
{
- private static final POILogger logger = POILogFactory
- .getLogger( CharacterSprmUncompressor.class );
+ private static final POILogger LOG = POILogFactory.getLogger( CharacterSprmUncompressor.class );
public CharacterSprmUncompressor()
{
}
catch ( Exception exc )
{
- logger.log( POILogger.ERROR, "Unable to apply all style ",
+ LOG.log( POILogger.ERROR, "Unable to apply all style ",
style, " CHP SPRMs to CHP: ", exc, exc );
}
}
}
catch ( Exception exc )
{
- logger.log( POILogger.ERROR,
+ LOG.log( POILogger.ERROR,
"Unable to process all direct CHP SPRMs: ", exc, exc );
}
return newProperties;
{
if ( warnAboutNonChpSprms )
{
- logger.log( POILogger.WARN,
+ LOG.log( POILogger.WARN,
"Non-CHP SPRM returned by SprmIterator: ", sprm );
}
continue;
}
catch ( Exception exc )
{
- logger.log( POILogger.ERROR,
+ LOG.log( POILogger.ERROR,
"Unable to extract istd from direct CHP SPRM: ", exc, exc );
}
return style;
// sprmCPicLocation -- 0x6A03
/*
* [MS-DOC]
- *
+ *
* Page 104 of 622
- *
+ *
* A signed 32-bit integer that specifies either the position in the
* Data Stream of a picture or binary data or the name of an OLE
* object storage.
/*
* Microsoft Office Word 97-2007 Binary File Format (.doc)
* Specification
- *
+ *
* Page 78 of 210
- *
+ *
* sprmCPropRMark (opcode 0xCA57) is interpreted by moving the first
* parameter byte to chp.fPropRMark, the next two bytes to
* chp.ibstPropRMark, and the remaining four bytes to
// sprmCFtcBi
break;
case 0x5f:
- // sprmCLidBi
+ // sprmCLidBi
break;
case 0x60:
// sprmCIcoBi
/*
* Microsoft Office Word 97-2007 Binary File Format (.doc)
* Specification
- *
+ *
* Page 78 of 210
- *
+ *
* sprmCDispFldRMark (opcode 0xCA62) is interpreted by moving the
* first parameter byte to chp.fDispFldRMark, the next two bytes to
* chp.ibstDispFldRMark, the next four bytes to
// sprmCShd80
/*
* "A Shd80 structure that specifies the background shading for the text. By default, text is not shaded."
- *
+ *
* Word (.doc) Binary File Format. Copyright (c) 2011 Microsoft
* Corporation. Release: Tuesday, March 15, 2011
*/
// sprmCFNoProof -- 0x875
/*
* "A ToggleOperand value that specifies whether the text is excluded from the proofing analysis. By default, text is not excluded from the proofing analysis."
- *
+ *
* Word (.doc) Binary File Format. Copyright (c) 2012 Microsoft
* Corporation. Released: October 8, 2012
*/
oldCHP.isFNoProof()));
break;
default:
- logger.log( POILogger.DEBUG, "Unknown CHP sprm ignored: ", sprm );
+ LOG.log( POILogger.DEBUG, "Unknown CHP sprm ignored: ", sprm );
break;
}
}
import org.apache.poi.util.POILogger;
@Internal
-public final class ParagraphSprmUncompressor
- extends SprmUncompressor
-{
- private static final POILogger logger = POILogFactory
- .getLogger( ParagraphSprmUncompressor.class );
+public final class ParagraphSprmUncompressor extends SprmUncompressor {
+
+ private static final POILogger LOG = POILogFactory.getLogger( ParagraphSprmUncompressor.class );
public ParagraphSprmUncompressor()
{
}
catch ( Exception exc )
{
- logger.log(
+ LOG.log(
POILogger.ERROR,
"Unable to apply SPRM operation '", sprm.getOperation(), "': ", exc );
}
newPAP.setRsid( sprm.getOperand() );
break;
default:
- logger.log( POILogger.DEBUG, "Unknown PAP sprm ignored: ", sprm );
+ LOG.log( POILogger.DEBUG, "Unknown PAP sprm ignored: ", sprm );
break;
}
}
@Internal
public final class SectionSprmCompressor
{
- private final static SectionProperties DEFAULT_SEP = new SectionProperties();
+ private static final SectionProperties DEFAULT_SEP = new SectionProperties();
public SectionSprmCompressor()
{
}
@Internal
-public final class SectionSprmUncompressor extends SprmUncompressor
-{
- private static final POILogger logger = POILogFactory.getLogger(SectionSprmUncompressor.class);
+public final class SectionSprmUncompressor extends SprmUncompressor {
+
+ private static final POILogger LOG = POILogFactory.getLogger(SectionSprmUncompressor.class);
public SectionSprmUncompressor()
{
newSEP.setNfcEdnRef(sprm.getOperand());
break;
default:
- logger.log(POILogger.INFO, "Unsupported Sprm operation: ", operation, " (", HexDump.byteToHex(operation), ")");
+ LOG.log(POILogger.INFO, "Unsupported Sprm operation: ", operation, " (", HexDump.byteToHex(operation), ")");
break;
}
private static final BitField BITFIELD_TYPE = BitFieldFactory
.getInstance( 0x1c00 );
- final static private short SPRM_LONG_PARAGRAPH = (short) 0xc615;
- final static private short SPRM_LONG_TABLE = (short) 0xd608;
+ static final private short SPRM_LONG_PARAGRAPH = (short) 0xc615;
+ static final private short SPRM_LONG_TABLE = (short) 0xd608;
public static final int TYPE_PAP = 1;
public static final int TYPE_CHP = 2;
import org.apache.poi.util.POILogger;
@Internal
-public final class TableSprmUncompressor
- extends SprmUncompressor
-{
- private static final POILogger logger = POILogFactory.getLogger( TableSprmUncompressor.class );
+public final class TableSprmUncompressor extends SprmUncompressor {
+
+ private static final POILogger LOG = POILogFactory.getLogger( TableSprmUncompressor.class );
public TableSprmUncompressor()
{
}
else
{
- logger.log( POILogger.WARN,
+ LOG.log( POILogger.WARN,
"Some table rows didn't specify number of columns in SPRMs" );
tableProperties = new TableProperties( (short) 1 );
}
}
catch ( ArrayIndexOutOfBoundsException ex )
{
- logger.log( POILogger.ERROR, "Unable to apply ", sprm,
+ LOG.log( POILogger.ERROR, "Unable to apply ", sprm,
": ", ex, ex );
}
}
*/
public class Range {
- private static final POILogger logger = POILogFactory.getLogger( Range.class );
+ private static final POILogger LOG = POILogFactory.getLogger( Range.class );
/**
* @deprecated POI 3.8 beta 5
initAll();
if ( tableEndInclusive >= this._parEnd )
{
- logger.log( POILogger.WARN, "The table's bounds ", "[",
+ LOG.log( POILogger.WARN, "The table's bounds ", "[",
this._parStart, "; ", tableEndInclusive, ")",
" fall outside of this Range paragraphs numbers [",
this._parStart, "; ", this._parEnd, ")" );
public final class TableRow extends Range
{
- private static final POILogger logger = POILogFactory
- .getLogger( TableRow.class );
+ private static final POILogger LOG = POILogFactory.getLogger( TableRow.class );
- private final static short SPRM_DXAGAPHALF = (short) 0x9602;
- private final static short SPRM_DYAROWHEIGHT = (short) 0x9407;
- private final static short SPRM_FCANTSPLIT = 0x3403;
- private final static short SPRM_FTABLEHEADER = 0x3404;
- private final static short SPRM_TJC = 0x5400;
+ private static final short SPRM_DXAGAPHALF = (short) 0x9602;
+ private static final short SPRM_DYAROWHEIGHT = (short) 0x9407;
+ private static final short SPRM_FCANTSPLIT = 0x3403;
+ private static final short SPRM_FTABLEHEADER = 0x3404;
+ private static final short SPRM_TJC = 0x5400;
- private final static char TABLE_CELL_MARK = '\u0007';
+ private static final char TABLE_CELL_MARK = '\u0007';
private TableCell[] _cells;
private boolean _cellsFound;
if ( cells.size() != expectedCellsCount )
{
- logger.log( POILogger.WARN,
+ LOG.log( POILogger.WARN,
"Number of found table cells (", cells.size(),
") for table row [", getStartOffset(), "c; ",
getEndOffset(), "c] not equals to stored property value ",
//https://en.wikipedia.org/wiki/Code_page_950
//see private use area
- private final static char range1Low = '\u8140';
- private final static char range1High = '\u8DFE';
- private final static char range2Low = '\u8E40';
- private final static char range2High = '\uA0FE';
- private final static char range3Low = '\uC6A1';
- private final static char range3High = '\uC8FE';
- private final static char range4Low = '\uFA40';
- private final static char range4High = '\uFEFE';
+ private static final char range1Low = '\u8140';
+ private static final char range1High = '\u8DFE';
+ private static final char range2Low = '\u8E40';
+ private static final char range2High = '\uA0FE';
+ private static final char range3Low = '\uC6A1';
+ private static final char range3High = '\uC8FE';
+ private static final char range4Low = '\uFA40';
+ private static final char range4High = '\uFEFE';
private final byte[] data;
private final int startOffset;
public class HWPFTestDataSamples {
- private static final POILogger logger = POILogFactory
- .getLogger( HWPFTestDataSamples.class );
+ private static final POILogger LOG = POILogFactory.getLogger( HWPFTestDataSamples.class );
public static HWPFDocument openSampleFile(String sampleFileName) {
try {
final long endUnzip = System.currentTimeMillis();
byte[] byteArray = baos.toByteArray();
- logger.log(POILogger.DEBUG, "Unzipped in ",
+ LOG.log(POILogger.DEBUG, "Unzipped in ",
Long.valueOf(endUnzip - start), " ms -- ",
Long.valueOf(byteArray.length), " byte(s)");
HWPFDocument doc = new HWPFDocument(bais);
final long endParse = System.currentTimeMillis();
- logger.log(POILogger.DEBUG, "Parsed in ",
+ LOG.log(POILogger.DEBUG, "Parsed in ",
Long.valueOf(endParse - start), " ms");
return doc;
* against HWPF
*/
class TestBugs {
-
- private static final POILogger logger = POILogFactory.getLogger(TestBugs.class);
-
private static void assertEqualsIgnoreNewline(String expected, String actual) {
String newExpected = expected.replaceAll("\r\n", "\n")
.replaceAll("\r", "\n").trim();
*/
final class TestPLVRecord {
- private final static String DV_DEFINITION = "$A$1:$A$5";
- private final static String XLS_FILENAME = "53972.xls";
- private final static String SHEET_NAME = "S2";
+ private static final String DV_DEFINITION = "$A$1:$A$5";
+ private static final String XLS_FILENAME = "53972.xls";
+ private static final String SHEET_NAME = "S2";
@Test
void testPLVRecord() throws Exception {
* Tests for {@link HSSFDataFormat}
*/
final class TestHSSFDataFormat extends BaseTestDataFormat {
- private static final POILogger _logger = POILogFactory.getLogger(TestHSSFDataFormat.class);
public TestHSSFDataFormat() {
super(HSSFITestDataProvider.instance);
/**
* Name of the test spreadsheet (found in the standard test data folder)
*/
- public final static String FILENAME = "FormulaSheetRange.xls";
+ public static final String FILENAME = "FormulaSheetRange.xls";
/**
* Row (zero-based) in the test spreadsheet where the function examples start.
*/
* A base class for bugzilla issues that can be described in terms of common ss interfaces.
*/
public abstract class BaseTestBugzillaIssues {
- private static final POILogger logger = POILogFactory.getLogger(BaseTestBugzillaIssues.class);
+ private static final POILogger LOG = POILogFactory.getLogger(BaseTestBugzillaIssues.class);
private static final String TEST_32 = "Some text with 32 characters to ";
private static final String TEST_255 = "Some very long text that is exactly 255 characters, which are allowed here, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla bla, bla.....";
// Create a workbook
try (Workbook wb = _testDataProvider.createWorkbook(nrows+1)) {
final Sheet sh = wb.createSheet();
- logger.log(POILogger.DEBUG, wb.getClass().getName(), " column autosizing timing...");
+ LOG.log(POILogger.DEBUG, wb.getClass().getName(), " column autosizing timing...");
final long t0 = time();
_testDataProvider.trackAllColumnsForAutosizing(sh);
}
final double populateSheetTime = delta(t0);
final double populateSheetTimePerCell_ns = (1000000 * populateSheetTime / (nrows * ncols));
- if (logger.check(POILogger.DEBUG)) {
- logger.log(POILogger.DEBUG, "Populate sheet time: ", populateSheetTime, " ms (", populateSheetTimePerCell_ns, " ns/cell)");
+ if (LOG.check(POILogger.DEBUG)) {
+ LOG.log(POILogger.DEBUG, "Populate sheet time: ", populateSheetTime, " ms (", populateSheetTimePerCell_ns, " ns/cell)");
- logger.log(POILogger.DEBUG, "Autosizing...");
+ LOG.log(POILogger.DEBUG, "Autosizing...");
}
final long t1 = time();
for (int c = 0; c < ncols; c++) {
final long t2 = time();
sh.autoSizeColumn(c);
- logger.log(POILogger.DEBUG, "Column ", c, " took ", delta(t2), " ms");
+ LOG.log(POILogger.DEBUG, "Column ", c, " took ", delta(t2), " ms");
}
final double autoSizeColumnsTime = delta(t1);
final double autoSizeColumnsTimePerColumn = autoSizeColumnsTime / ncols;
final double bestFitWidthTimePerCell_ns = 1000000 * autoSizeColumnsTime / (ncols * nrows);
- if (logger.check(POILogger.DEBUG)) {
- logger.log(POILogger.DEBUG, "Auto sizing columns took a total of ", autoSizeColumnsTime, " ms (", autoSizeColumnsTimePerColumn, " ms per column)");
- logger.log(POILogger.DEBUG, "Best fit width time per cell: ", bestFitWidthTimePerCell_ns, " ns");
+ if (LOG.check(POILogger.DEBUG)) {
+ LOG.log(POILogger.DEBUG, "Auto sizing columns took a total of ", autoSizeColumnsTime, " ms (", autoSizeColumnsTimePerColumn, " ms per column)");
+ LOG.log(POILogger.DEBUG, "Best fit width time per cell: ", bestFitWidthTimePerCell_ns, " ns");
}
final double totalTime_s = (populateSheetTime + autoSizeColumnsTime) / 1000;
- logger.log(POILogger.DEBUG, "Total time: ", totalTime_s, " s");
+ LOG.log(POILogger.DEBUG, "Total time: ", totalTime_s, " s");
}
//if (bestFitWidthTimePerCell_ns > 50000) {
projects / poi.git / commitdiff