import org.apache.poi.POIXMLDocument;
import org.apache.poi.poifs.crypt.Decryptor;
+import org.apache.poi.poifs.filesystem.FileMagic;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
public final class POIXMLDocumentHandler {
}
protected static boolean isEncrypted(InputStream stream) throws IOException {
- if (POIFSFileSystem.hasPOIFSHeader(stream)) {
- POIFSFileSystem poifs = new POIFSFileSystem(stream);
- try {
+ if (FileMagic.valueOf(stream) == FileMagic.OLE2) {
+ try (POIFSFileSystem poifs = new POIFSFileSystem(stream)) {
if (poifs.getRoot().hasEntry(Decryptor.DEFAULT_POIFS_ENTRY)) {
return true;
}
- } finally {
- poifs.close();
}
throw new IOException("Wrong file format or file extension for OO XML file");
}
import org.apache.poi.hssf.record.OldStringRecord;
import org.apache.poi.hssf.record.RKRecord;
import org.apache.poi.hssf.record.RecordInputStream;
-import org.apache.poi.poifs.filesystem.DirectoryNode;
-import org.apache.poi.poifs.filesystem.DocumentNode;
-import org.apache.poi.poifs.filesystem.NPOIFSFileSystem;
-import org.apache.poi.poifs.filesystem.NotOLE2FileException;
+import org.apache.poi.poifs.filesystem.*;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.util.IOUtils;
open(poifs);
toClose = poifs;
return;
- } catch (OldExcelFormatException e) {
+ } catch (OldExcelFormatException | NotOLE2FileException e) {
// will be handled by workaround below
- } catch (NotOLE2FileException e) {
- // will be handled by workaround below
- } catch (IOException e) {
- // ensure streams are closed correctly
- throw e;
- } catch (RuntimeException e) {
- // ensure streams are closed correctly
- throw e;
} finally {
if (toClose == null) {
IOUtils.closeQuietly(poifs);
FileInputStream biffStream = new FileInputStream(f); // NOSONAR
try {
open(biffStream);
- } catch (IOException e) {
- // ensure that the stream is properly closed here if an Exception
- // is thrown while opening
- biffStream.close();
- throw e;
- } catch (RuntimeException e) {
+ } catch (IOException | RuntimeException e) {
// ensure that the stream is properly closed here if an Exception
// is thrown while opening
biffStream.close();
? (BufferedInputStream)biffStream
: new BufferedInputStream(biffStream, 8);
- if (NPOIFSFileSystem.hasPOIFSHeader(bis)) {
- NPOIFSFileSystem poifs = new NPOIFSFileSystem(bis);
- try {
+ if (FileMagic.valueOf(bis) == FileMagic.OLE2) {
+ try (NPOIFSFileSystem poifs = new NPOIFSFileSystem(bis)) {
open(poifs);
- } finally {
- poifs.close();
}
} else {
ris = new RecordInputStream(bis);
while (iter.hasNext())
{
Property child = iter.next();
- Entry childNode = null;
+ Entry childNode;
if (child.isDirectory())
{
* @return an Iterator; may not be null, but may have an empty
* back end store
*/
- public Iterator<Object> getViewableIterator()
- {
+ public Iterator<Object> getViewableIterator() {
List<Object> components = new ArrayList<>();
components.add(getProperty());
- Iterator<Entry> iter = _entries.iterator();
- while (iter.hasNext())
- {
- components.add(iter.next());
- }
+ components.addAll(_entries);
return components.iterator();
}
package org.apache.poi.poifs.filesystem;
-import java.io.ByteArrayInputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import org.apache.poi.util.Internal;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
-import org.apache.poi.util.Removal;
/**
* <p>This is the main class of the POIFS system; it manages the entire
}
}
- /**
- * Checks that the supplied InputStream (which MUST
- * support mark and reset) has a POIFS (OLE2) header at the start of it.
- * If unsure if your InputStream does support mark / reset,
- * use {@link FileMagic#prepareToCheckMagic(InputStream)} to wrap it and make
- * sure to always use that, and not the original!
- *
- * After the method call, the InputStream is at the
- * same position as of the time of entering the method.
- *
- * @param inp An InputStream which supports mark/reset
- *
- * @deprecated in 3.17-beta2, use {@link FileMagic#valueOf(InputStream)} == {@link FileMagic#OLE2} instead
- */
- @Deprecated
- @Removal(version="4.0")
- public static boolean hasPOIFSHeader(InputStream inp) throws IOException {
- return FileMagic.valueOf(inp) == FileMagic.OLE2;
- }
-
- /**
- * Checks if the supplied first 8 bytes of a stream / file
- * has a POIFS (OLE2) header.
- *
- * @deprecated in 3.17-beta2, use {@link FileMagic#valueOf(InputStream)} == {@link FileMagic#OLE2} instead
- */
- @Deprecated
- @Removal(version="4.0")
- public static boolean hasPOIFSHeader(byte[] header8Bytes) {
- try {
- return hasPOIFSHeader(new ByteArrayInputStream(header8Bytes));
- } catch (IOException e) {
- throw new RuntimeException("invalid header check", e);
- }
- }
-
/**
* Read and process the PropertiesTable and the
* FAT / XFAT blocks, so that we're ready to
*
* @exception IOException
*/
-
public DocumentEntry createDocument(final String name, final int size,
final POIFSWriterListener writer)
throws IOException
*
* @exception IOException thrown on errors writing to the stream
*/
- public void writeFilesystem() throws IOException
- {
+ public void writeFilesystem() throws IOException {
if(_data instanceof FileBackedDataSource) {
// Good, correct type
} else {
*
* @exception IOException thrown on errors writing to the stream
*/
-
- public void writeFilesystem(final OutputStream stream)
- throws IOException
- {
+ public void writeFilesystem(final OutputStream stream) throws IOException {
// Have the datasource updated
syncWithDataSource();
*
* @exception IOException
*/
-
- public static void main(String args[])
- throws IOException
- {
- if (args.length != 2)
- {
+ public static void main(String args[]) throws IOException {
+ if (args.length != 2) {
System.err.println(
"two arguments required: input filename and output filename");
System.exit(1);
}
- FileInputStream istream = new FileInputStream(args[ 0 ]);
- try {
- FileOutputStream ostream = new FileOutputStream(args[ 1 ]);
- try {
- NPOIFSFileSystem fs = new NPOIFSFileSystem(istream);
- try {
+
+ try (FileInputStream istream = new FileInputStream(args[0])) {
+ try (FileOutputStream ostream = new FileOutputStream(args[1])) {
+ try (NPOIFSFileSystem fs = new NPOIFSFileSystem(istream)) {
fs.writeFilesystem(ostream);
- } finally {
- fs.close();
}
- } finally {
- ostream.close();
}
- } finally {
- istream.close();
}
}
*
* @return the root entry
*/
- public DirectoryNode getRoot()
- {
+ public DirectoryNode getRoot() {
if (_root == null) {
_root = new DirectoryNode(_property_table.getRoot(), this, null);
}
* @exception IOException if the document does not exist or the
* name is that of a DirectoryEntry
*/
-
public DocumentInputStream createDocumentInputStream(
- final String documentName)
- throws IOException
- {
+ final String documentName) throws IOException {
return getRoot().createDocumentInputStream(documentName);
}
*
* @param entry to be removed
*/
- void remove(EntryNode entry) throws IOException
- {
+ void remove(EntryNode entry) throws IOException {
// If it's a document, free the blocks
if (entry instanceof DocumentEntry) {
NPOIFSDocument doc = new NPOIFSDocument((DocumentProperty)entry.getProperty(), this);
*
* @return an array of Object; may not be null, but may be empty
*/
-
- public Object [] getViewableArray()
- {
- if (preferArray())
- {
+ public Object [] getViewableArray() {
+ if (preferArray()) {
return getRoot().getViewableArray();
}
+
return new Object[ 0 ];
}
* back end store
*/
- public Iterator<Object> getViewableIterator()
- {
- if (!preferArray())
- {
+ public Iterator<Object> getViewableIterator() {
+ if (!preferArray()) {
return getRoot().getViewableIterator();
}
+
return Collections.emptyList().iterator();
}
* a viewer should call getViewableIterator
*/
- public boolean preferArray()
- {
+ public boolean preferArray() {
return getRoot().preferArray();
}
* @return short description
*/
- public String getShortDescription()
- {
+ public String getShortDescription() {
return "POIFS FileSystem";
}
// First up, do we have any spare ones?
int offset = 0;
- for(int i=0; i<_sbat_blocks.size(); i++) {
- // Check this one
- BATBlock sbat = _sbat_blocks.get(i);
- if(sbat.hasFreeSectors()) {
- // Claim one of them and return it
- for(int j=0; j<sectorsPerSBAT; j++) {
- int sbatValue = sbat.getValueAt(j);
- if(sbatValue == POIFSConstants.UNUSED_BLOCK) {
- // Bingo
- return offset + j;
+ for (BATBlock sbat : _sbat_blocks) {
+ // Check this one
+ if (sbat.hasFreeSectors()) {
+ // Claim one of them and return it
+ for (int j = 0; j < sectorsPerSBAT; j++) {
+ int sbatValue = sbat.getValueAt(j);
+ if (sbatValue == POIFSConstants.UNUSED_BLOCK) {
+ // Bingo
+ return offset + j;
+ }
}
- }
- }
-
- // Move onto the next SBAT
- offset += sectorsPerSBAT;
- }
+ }
+
+ // Move onto the next SBAT
+ offset += sectorsPerSBAT;
+ }
// If we get here, then there aren't any
// free sectors in any of the SBATs
* @return short description
*/
public String getShortDescription() {
- StringBuffer buffer = new StringBuffer();
-
- buffer.append("Document: \"").append(_property.getName()).append("\"");
- buffer.append(" size = ").append(getSize());
- return buffer.toString();
+ return "Document: \"" + _property.getName() + "\"" +
+ " size = " + getSize();
}
/* ********** END begin implementation of POIFSViewable ********** */
dstream.writeFiller(countBlocks() * _bigBlockSize.getBigBlockSize(),
DocumentBlock.getFillByte());
} else {
- for (int k = 0; k < bigBlocks.length; k++) {
- bigBlocks[k].writeBlocks(stream);
+ for (DocumentBlock bigBlock : bigBlocks) {
+ bigBlock.writeBlocks(stream);
}
}
}
import org.apache.poi.util.CloseIgnoringInputStream;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
-import org.apache.poi.util.Removal;
/**
* <p>This is the main class of the POIFS system; it manages the entire
}
}
- /**
- * Checks that the supplied InputStream (which MUST
- * support mark and reset) has a POIFS (OLE2) header at the start of it.
- * If unsure if your InputStream does support mark / reset,
- * use {@link FileMagic#prepareToCheckMagic(InputStream)} to wrap it and make
- * sure to always use that, and not the original!
- *
- * After the method call, the InputStream is at the
- * same position as of the time of entering the method.
- *
- * @param inp An InputStream which supports either mark/reset
- *
- * @deprecated in 3.17-beta2, use {@link FileMagic#valueOf(InputStream)} == {@link FileMagic#OLE2} instead
- */
- @Deprecated
- @Removal(version="4.0")
- public static boolean hasPOIFSHeader(InputStream inp) throws IOException {
- return NPOIFSFileSystem.hasPOIFSHeader(inp);
- }
-
- /**
- * Checks if the supplied first 8 bytes of a stream / file
- * has a POIFS (OLE2) header.
- *
- * @deprecated in 3.17-beta2, use {@link FileMagic#valueOf(InputStream)} == {@link FileMagic#OLE2} instead
- */
- @Deprecated
- @Removal(version="4.0")
- public static boolean hasPOIFSHeader(byte[] header8Bytes) {
- return NPOIFSFileSystem.hasPOIFSHeader(header8Bytes);
- }
-
/**
* Create a new document to be added to the root directory
*
*
* @exception IOException
*/
-
public DocumentEntry createDocument(final String name, final int size,
final POIFSWriterListener writer)
throws IOException
BATManaged bmo = ( BATManaged ) iter.next();
int block_count = bmo.countBlocks();
- if (block_count != 0)
- {
+ if (block_count != 0) {
bmo.setStartBlock(bat.allocateSpace(block_count));
- }
- else
- {
-
+ } /*else {
// Either the BATManaged object is empty or its data
// is composed of SmallBlocks; in either case,
// allocating space in the BAT is inappropriate
- }
+ }*/
}
// allocate space for the block allocation table and take its
writers.add(sbtw);
writers.add(sbtw.getSBAT());
writers.add(bat);
- for (int j = 0; j < xbat_blocks.length; j++)
- {
- writers.add(xbat_blocks[ j ]);
- }
+ Collections.addAll(writers, xbat_blocks);
// now, write everything out
iter = writers.iterator();
*
* @exception IOException
*/
-
public static void main(String args[])
throws IOException
{
{
int startBlock = property.getStartBlock();
int size = property.getSize();
- OPOIFSDocument document = null;
+ OPOIFSDocument document;
if (property.shouldUseSmallBlocks())
{
* @return The created and opened {@link POIFSFileSystem}
*/
public static POIFSFileSystem create(File file) throws IOException {
- // TODO Make this nicer!
// Create a new empty POIFS in the file
- POIFSFileSystem tmp = new POIFSFileSystem();
- try {
- OutputStream out = new FileOutputStream(file);
- try {
+ try (POIFSFileSystem tmp = new POIFSFileSystem()) {
+ try (OutputStream out = new FileOutputStream(file)) {
tmp.writeFilesystem(out);
- } finally {
- out.close();
}
- } finally {
- tmp.close();
}
// Open it up again backed by the file
public abstract class MatrixFunction implements Function{
public static void checkValues(double[] results) throws EvaluationException {
- for (int idx = 0; idx < results.length; idx++) {
- if (Double.isNaN(results[idx]) || Double.isInfinite(results[idx])) {
+ for (double result : results) {
+ if (Double.isNaN(result) || Double.isInfinite(result)) {
throw new EvaluationException(ErrorEval.NUM_ERROR);
}
}
}
double[][] matrix = new double[rows][cols];
-
- for (int idx = 0; idx < vector.length; idx++) {
+
+ for (double aVector : vector) {
if (j < matrix.length) {
if (i == matrix[0].length) {
i = 0;
j++;
}
- matrix[j][i++] = vector[idx];
- }
+ matrix[j][i++] = aVector;
+ }
}
return matrix;
}
double[] vector = new double[matrix.length * matrix[0].length];
-
- for (int j = 0; j < matrix.length; j++) {
+
+ for (double[] aMatrix : matrix) {
for (int i = 0; i < matrix[0].length; i++) {
- vector[idx++] = matrix[j][i];
+ vector[idx++] = aMatrix[i];
}
}
return vector;
@Override
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) {
if (arg0 instanceof AreaEval) {
- double result[] = null, resultArray[][];
- int width = 1, height = 1;
+ double result[], resultArray[][];
+ int width, height;
try {
double values[] = collectValues(arg0);
}
}
else {
- double result[][] = null;
+ double result[][];
try {
double value = NumericFunction.singleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex);
double temp[][] = {{value}};
@Override
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1) {
double result[];
- int width = 1, height = 1;
+ int width, height;
try {
double array0[][], array1[][], resultArray[][];
/** a generic way to open a sample slideshow document **/
public static SlideShow<?,?> openSampleSlideshow(String sampleName) throws IOException {
- InputStream is = _slTests.openResourceAsStream(sampleName);
- try {
+ try (InputStream is = _slTests.openResourceAsStream(sampleName)) {
return SlideShowFactory.create(is);
} catch (Exception e) {
throw new RuntimeException(e);
- } finally {
- is.close();
}
}
assertContains(e.getMessage(), "You are calling the part of POI that deals with OLE2 Office Documents");
}
}
- public void test2003XMLException() throws IOException
- {
+
+ public void test2003XMLException() throws IOException {
InputStream in = openSampleStream("SampleSS.xml");
try {
}
private void confirmIsPOIFS(String sampleFileName, boolean expectedResult) throws IOException {
- InputStream in = FileMagic.prepareToCheckMagic(openSampleStream(sampleFileName));
- try {
- boolean actualResult;
- try {
- actualResult = POIFSFileSystem.hasPOIFSHeader(in);
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- assertEquals(expectedResult, actualResult);
- } finally {
- in.close();
- }
+ try (InputStream in = FileMagic.prepareToCheckMagic(openSampleStream(sampleFileName))) {
+ assertEquals(expectedResult, FileMagic.valueOf(in) == FileMagic.OLE2);
+ }
}
public void testFileCorruption() throws Exception {
// detect header
InputStream in = FileMagic.prepareToCheckMagic(testInput);
- assertFalse(POIFSFileSystem.hasPOIFSHeader(in));
+
+ assertFalse(FileMagic.valueOf(in) == FileMagic.OLE2);
// check if InputStream is still intact
byte[] test = new byte[3];
- in.read(test);
+ assertEquals(3, in.read(test));
assertTrue(Arrays.equals(testData, test));
assertEquals(-1, in.read());
}
// detect header
InputStream in = FileMagic.prepareToCheckMagic(testInput);
- assertFalse(OPOIFSFileSystem.hasPOIFSHeader(in));
+ assertFalse(FileMagic.valueOf(in) == FileMagic.OLE2);
+ assertEquals(FileMagic.UNKNOWN, FileMagic.valueOf(in));
// check if InputStream is still intact
byte[] test = new byte[3];
- in.read(test);
+ assertEquals(3, in.read(test));
assertTrue(Arrays.equals(testData, test));
assertEquals(-1, in.read());
}
projects / poi.git / commitdiff