Apache
/
poi
mirror of https://github.com/apache/poi.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Adjust toString() of ExternalNameRecord 

Fix some IntelliJ warnings
 Reformat TextPieceTable

git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1773776 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Dominik Stadler 2016-12-12 11:41:07 +00:00
parent c6d28db7e8
commit 1ebe4d3c99
4 changed files with 146 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/java/org/apache/poi/hssf/record/ExternalNameRecord.java
View File

@ -214,15 +214,15 @@ public final class ExternalNameRecord extends StandardRecord {
@Override
public String toString() {
StringBuffer sb = new StringBuffer();
StringBuilder sb = new StringBuilder();
sb.append("[EXTERNALNAME]\n");
sb.append(" .options = ").append(field_1_option_flag).append("\n");
sb.append(" .options = ").append(field_1_option_flag).append("\n");
sb.append(" .ix = ").append(field_2_ixals).append("\n");
sb.append(" .name = ").append(field_4_name).append("\n");
if(field_5_name_definition != null) {
Ptg[] ptgs = field_5_name_definition.getTokens();
for (Ptg ptg : ptgs) {
sb.append(ptg.toString()).append(ptg.getRVAType()).append("\n");
sb.append(" .namedef = ").append(ptg.toString()).append(ptg.getRVAType()).append("\n");
}
}
sb.append("[/EXTERNALNAME]\n");

7
src/ooxml/java/org/apache/poi/xssf/eventusermodel/XSSFSheetXMLHandler.java
View File

@ -163,6 +163,7 @@ public class XSSFSheetXMLHandler extends DefaultHandler {
private void init() {
if (commentsTable != null) {
commentCellRefs = new LinkedList<CellAddress>();
//noinspection deprecation
for (CTComment comment : commentsTable.getCTComments().getCommentList().getCommentArray()) {
commentCellRefs.add(new CellAddress(comment.getRef()));
}
@ -228,10 +229,10 @@ public class XSSFSheetXMLHandler extends DefaultHandler {
// match the current cell
if(formulasNotResults) {
logger.log(POILogger.WARN, "shared formulas not yet supported!");
} else {
} /*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!
}
}*/
}
} else {
fIsOpen = true;
@ -334,7 +335,7 @@ public class XSSFSheetXMLHandler extends DefaultHandler {
thisStr = fv;
}
} else {
// No formating applied, just do raw value in all cases
// No formatting applied, just do raw value in all cases
thisStr = fv;
}
}

344
src/scratchpad/src/org/apache/poi/hwpf/model/TextPieceTable.java
View File

@ -34,59 +34,52 @@ import org.apache.poi.util.POILogger;
* The piece table for matching up character positions to bits of text. This
* mostly works in bytes, but the TextPieces themselves work in characters. This
* does the icky convertion.
*
*
* @author Ryan Ackley
*/
@Internal
public class TextPieceTable implements CharIndexTranslator
{
public class TextPieceTable implements CharIndexTranslator {
private static final POILogger logger = POILogFactory
.getLogger( TextPieceTable.class );
.getLogger(TextPieceTable.class);
// int _multiple;
int _cpMin;
protected ArrayList<TextPiece> _textPieces = new ArrayList<TextPiece>();
protected ArrayList<TextPiece> _textPiecesFCOrder = new ArrayList<TextPiece>();
public TextPieceTable()
{
public TextPieceTable() {
}
public TextPieceTable( byte[] documentStream, byte[] tableStream,
int offset, int size, int fcMin )
{
public TextPieceTable(byte[] documentStream, byte[] tableStream,
int offset, int size, int fcMin) {
// get our plex of PieceDescriptors
PlexOfCps pieceTable = new PlexOfCps( tableStream, offset, size,
PieceDescriptor.getSizeInBytes() );
PlexOfCps pieceTable = new PlexOfCps(tableStream, offset, size,
PieceDescriptor.getSizeInBytes());
int length = pieceTable.length();
PieceDescriptor[] pieces = new PieceDescriptor[length];
// iterate through piece descriptors raw bytes and create
// PieceDescriptor objects
for ( int x = 0; x < length; x++ )
{
GenericPropertyNode node = pieceTable.getProperty( x );
pieces[x] = new PieceDescriptor( node.getBytes(), 0 );
for (int x = 0; x < length; x++) {
GenericPropertyNode node = pieceTable.getProperty(x);
pieces[x] = new PieceDescriptor(node.getBytes(), 0);
}
// Figure out the cp of the earliest text piece
// Note that text pieces don't have to be stored in order!
_cpMin = pieces[0].getFilePosition() - fcMin;
for ( int x = 0; x < pieces.length; x++ )
{
int start = pieces[x].getFilePosition() - fcMin;
if ( start < _cpMin )
{
for (PieceDescriptor piece : pieces) {
int start = piece.getFilePosition() - fcMin;
if (start < _cpMin) {
_cpMin = start;
}
}
// using the PieceDescriptors, build our list of TextPieces.
for ( int x = 0; x < pieces.length; x++ )
{
for (int x = 0; x < pieces.length; x++) {
int start = pieces[x].getFilePosition();
GenericPropertyNode node = pieceTable.getProperty( x );
GenericPropertyNode node = pieceTable.getProperty(x);
// Grab the start and end, which are in characters
int nodeStartChars = node.getStart();
@ -95,82 +88,72 @@ public class TextPieceTable implements CharIndexTranslator
// What's the relationship between bytes and characters?
boolean unicode = pieces[x].isUnicode();
int multiple = 1;
if ( unicode )
{
if (unicode) {
multiple = 2;
}
// Figure out the length, in bytes and chars
int textSizeChars = ( nodeEndChars - nodeStartChars );
int textSizeChars = (nodeEndChars - nodeStartChars);
int textSizeBytes = textSizeChars * multiple;
// Grab the data that makes up the piece
byte[] buf = new byte[textSizeBytes];
System.arraycopy( documentStream, start, buf, 0, textSizeBytes );
System.arraycopy(documentStream, start, buf, 0, textSizeBytes);
// And now build the piece
final TextPiece newTextPiece = new TextPiece( nodeStartChars, nodeEndChars, buf,
pieces[x] );
final TextPiece newTextPiece = new TextPiece(nodeStartChars, nodeEndChars, buf,
pieces[x]);
_textPieces.add( newTextPiece );
_textPieces.add(newTextPiece);
}
// In the interest of our sanity, now sort the text pieces
// into order, if they're not already
Collections.sort( _textPieces );
_textPiecesFCOrder = new ArrayList<TextPiece>( _textPieces );
Collections.sort( _textPiecesFCOrder, new FCComparator() );
Collections.sort(_textPieces);
_textPiecesFCOrder = new ArrayList<TextPiece>(_textPieces);
Collections.sort(_textPiecesFCOrder, new FCComparator());
}
public void add( TextPiece piece )
{
_textPieces.add( piece );
_textPiecesFCOrder.add( piece );
Collections.sort( _textPieces );
Collections.sort( _textPiecesFCOrder, new FCComparator() );
public void add(TextPiece piece) {
_textPieces.add(piece);
_textPiecesFCOrder.add(piece);
Collections.sort(_textPieces);
Collections.sort(_textPiecesFCOrder, new FCComparator());
}
/**
* Adjust all the text piece after inserting some text into one of them
*
* @param listIndex
* The TextPiece that had characters inserted into
* @param length
* The number of characters inserted
*
* @param listIndex The TextPiece that had characters inserted into
* @param length The number of characters inserted
*/
public int adjustForInsert( int listIndex, int length )
{
public int adjustForInsert(int listIndex, int length) {
int size = _textPieces.size();
TextPiece tp = _textPieces.get( listIndex );
TextPiece tp = _textPieces.get(listIndex);
// Update with the new end
tp.setEnd( tp.getEnd() + length );
tp.setEnd(tp.getEnd() + length);
// Now change all subsequent ones
for ( int x = listIndex + 1; x < size; x++ )
{
tp = _textPieces.get( x );
tp.setStart( tp.getStart() + length );
tp.setEnd( tp.getEnd() + length );
for (int x = listIndex + 1; x < size; x++) {
tp = _textPieces.get(x);
tp.setStart(tp.getStart() + length);
tp.setEnd(tp.getEnd() + length);
}
// All done
return length;
}
public boolean equals( Object o )
{
public boolean equals(Object o) {
if (!(o instanceof TextPieceTable)) return false;
TextPieceTable tpt = (TextPieceTable) o;
int size = tpt._textPieces.size();
if ( size == _textPieces.size() )
{
for ( int x = 0; x < size; x++ )
{
if ( !tpt._textPieces.get( x ).equals( _textPieces.get( x ) ) )
{
if (size == _textPieces.size()) {
for (int x = 0; x < size; x++) {
if (!tpt._textPieces.get(x).equals(_textPieces.get(x))) {
return false;
}
}
@ -179,27 +162,23 @@ public class TextPieceTable implements CharIndexTranslator
return false;
}
public int getByteIndex( int charPos )
{
public int getByteIndex(int charPos) {
int byteCount = 0;
for ( TextPiece tp : _textPieces )
{
if ( charPos >= tp.getEnd() )
{
for (TextPiece tp : _textPieces) {
if (charPos >= tp.getEnd()) {
byteCount = tp.getPieceDescriptor().getFilePosition()
+ ( tp.getEnd() - tp.getStart() )
* ( tp.isUnicode() ? 2 : 1 );
+ (tp.getEnd() - tp.getStart())
* (tp.isUnicode() ? 2 : 1);
if ( charPos == tp.getEnd() )
if (charPos == tp.getEnd())
break;
continue;
}
if ( charPos < tp.getEnd() )
{
if (charPos < tp.getEnd()) {
int left = charPos - tp.getStart();
byteCount = tp.getPieceDescriptor().getFilePosition() + left
* ( tp.isUnicode() ? 2 : 1 );
* (tp.isUnicode() ? 2 : 1);
break;
}
}
@ -207,20 +186,17 @@ public class TextPieceTable implements CharIndexTranslator
}
@Deprecated
public int getCharIndex( int bytePos )
{
return getCharIndex( bytePos, 0 );
public int getCharIndex(int bytePos) {
return getCharIndex(bytePos, 0);
}
@Deprecated
public int getCharIndex( int startBytePos, int startCP )
{
public int getCharIndex(int startBytePos, int startCP) {
int charCount = 0;
int bytePos = lookIndexForward( startBytePos );
int bytePos = lookIndexForward(startBytePos);
for ( TextPiece tp : _textPieces )
{
for (TextPiece tp : _textPieces) {
int pieceStart = tp.getPieceDescriptor().getFilePosition();
int bytesLength = tp.bytesLength();
@ -228,31 +204,22 @@ public class TextPieceTable implements CharIndexTranslator
int toAdd;
if ( bytePos < pieceStart || bytePos > pieceEnd )
{
if (bytePos < pieceStart || bytePos > pieceEnd) {
toAdd = bytesLength;
}
else if ( bytePos > pieceStart && bytePos < pieceEnd )
{
toAdd = ( bytePos - pieceStart );
}
else
{
toAdd = bytesLength - ( pieceEnd - bytePos );
} else if (bytePos > pieceStart && bytePos < pieceEnd) {
toAdd = (bytePos - pieceStart);
} else {
toAdd = bytesLength - (pieceEnd - bytePos);
}
if ( tp.isUnicode() )
{
if (tp.isUnicode()) {
charCount += toAdd / 2;
}
else
{
} else {
charCount += toAdd;
}
if ( bytePos >= pieceStart && bytePos <= pieceEnd
&& charCount >= startCP )
{
if (bytePos >= pieceStart && bytePos <= pieceEnd
&& charCount >= startCP) {
break;
}
}
@ -261,106 +228,94 @@ public class TextPieceTable implements CharIndexTranslator
}
@Override
public int[][] getCharIndexRanges( int startBytePosInclusive,
int endBytePosExclusive )
{
public int[][] getCharIndexRanges(int startBytePosInclusive,
int endBytePosExclusive) {
List<int[]> result = new LinkedList<int[]>();
for ( TextPiece textPiece : _textPiecesFCOrder )
{
for (TextPiece textPiece : _textPiecesFCOrder) {
final int tpStart = textPiece.getPieceDescriptor()
.getFilePosition();
final int tpEnd = textPiece.getPieceDescriptor().getFilePosition()
+ textPiece.bytesLength();
if ( startBytePosInclusive > tpEnd )
if (startBytePosInclusive > tpEnd)
continue;
if ( endBytePosExclusive <= tpStart )
if (endBytePosExclusive <= tpStart)
break;
final int rangeStartBytes = Math.max( tpStart,
startBytePosInclusive );
final int rangeEndBytes = Math.min( tpEnd, endBytePosExclusive );
final int rangeStartBytes = Math.max(tpStart,
startBytePosInclusive);
final int rangeEndBytes = Math.min(tpEnd, endBytePosExclusive);
final int rangeLengthBytes = rangeEndBytes - rangeStartBytes;
if ( rangeStartBytes > rangeEndBytes )
if (rangeStartBytes > rangeEndBytes)
continue;
final int encodingMultiplier = textPiece.isUnicode() ? 2 : 1;
final int rangeStartCp = textPiece.getStart()
+ ( rangeStartBytes - tpStart ) / encodingMultiplier;
+ (rangeStartBytes - tpStart) / encodingMultiplier;
final int rangeEndCp = rangeStartCp + rangeLengthBytes
/ encodingMultiplier;
result.add( new int[] { rangeStartCp, rangeEndCp } );
result.add(new int[]{rangeStartCp, rangeEndCp});
}
return result.toArray( new int[result.size()][] );
return result.toArray(new int[result.size()][]);
}
public int getCpMin()
{
public int getCpMin() {
return _cpMin;
}
public StringBuilder getText()
{
public StringBuilder getText() {
final long start = System.currentTimeMillis();
// rebuild document paragraphs structure
StringBuilder docText = new StringBuilder();
for ( TextPiece textPiece : _textPieces )
{
for (TextPiece textPiece : _textPieces) {
String toAppend = textPiece.getStringBuilder().toString();
int toAppendLength = toAppend.length();
if ( toAppendLength != textPiece.getEnd() - textPiece.getStart() )
{
if (toAppendLength != textPiece.getEnd() - textPiece.getStart()) {
logger.log(
POILogger.WARN,
"Text piece has boundaries [",
Integer.valueOf( textPiece.getStart() ),
Integer.valueOf(textPiece.getStart()),
"; ",
Integer.valueOf( textPiece.getEnd() ),
Integer.valueOf(textPiece.getEnd()),
") but length ",
Integer.valueOf( textPiece.getEnd()
- textPiece.getStart() ) );
Integer.valueOf(textPiece.getEnd()
- textPiece.getStart()));
}
docText.replace( textPiece.getStart(), textPiece.getStart()
+ toAppendLength, toAppend );
docText.replace(textPiece.getStart(), textPiece.getStart()
+ toAppendLength, toAppend);
}
logger.log( POILogger.DEBUG, "Document text were rebuilded in ",
Long.valueOf( System.currentTimeMillis() - start ), " ms (",
Integer.valueOf( docText.length() ), " chars)" );
logger.log(POILogger.DEBUG, "Document text were rebuilded in ",
Long.valueOf(System.currentTimeMillis() - start), " ms (",
Integer.valueOf(docText.length()), " chars)");
return docText;
}
public List<TextPiece> getTextPieces()
{
public List<TextPiece> getTextPieces() {
return _textPieces;
}
@Override
public int hashCode()
{
public int hashCode() {
return _textPieces.size();
}
public boolean isIndexInTable( int bytePos )
{
for ( TextPiece tp : _textPiecesFCOrder )
{
public boolean isIndexInTable(int bytePos) {
for (TextPiece tp : _textPiecesFCOrder) {
int pieceStart = tp.getPieceDescriptor().getFilePosition();
if ( bytePos > pieceStart + tp.bytesLength() )
{
if (bytePos > pieceStart + tp.bytesLength()) {
continue;
}
if ( pieceStart > bytePos )
{
if (pieceStart > bytePos) {
return false;
}
@ -370,21 +325,18 @@ public class TextPieceTable implements CharIndexTranslator
return false;
}
boolean isIndexInTable( int startBytePos, int endBytePos )
{
for ( TextPiece tp : _textPiecesFCOrder )
{
boolean isIndexInTable(int startBytePos, int endBytePos) {
for (TextPiece tp : _textPiecesFCOrder) {
int pieceStart = tp.getPieceDescriptor().getFilePosition();
if ( startBytePos >= pieceStart + tp.bytesLength() )
{
if (startBytePos >= pieceStart + tp.bytesLength()) {
continue;
}
int left = Math.max( startBytePos, pieceStart );
int right = Math.min( endBytePos, pieceStart + tp.bytesLength() );
int left = Math.max(startBytePos, pieceStart);
int right = Math.min(endBytePos, pieceStart + tp.bytesLength());
if ( left >= right )
if (left >= right)
return false;
return true;
@ -393,23 +345,19 @@ public class TextPieceTable implements CharIndexTranslator
return false;
}
public int lookIndexBackward( final int startBytePos )
{
public int lookIndexBackward(final int startBytePos) {
int bytePos = startBytePos;
int lastEnd = 0;
for ( TextPiece tp : _textPiecesFCOrder )
{
for (TextPiece tp : _textPiecesFCOrder) {
int pieceStart = tp.getPieceDescriptor().getFilePosition();
if ( bytePos > pieceStart + tp.bytesLength() )
{
if (bytePos > pieceStart + tp.bytesLength()) {
lastEnd = pieceStart + tp.bytesLength();
continue;
}
if ( pieceStart > bytePos )
{
if (pieceStart > bytePos) {
bytePos = lastEnd;
}
@ -419,101 +367,87 @@ public class TextPieceTable implements CharIndexTranslator
return bytePos;
}
public int lookIndexForward( final int startBytePos )
{
if ( _textPiecesFCOrder.isEmpty() )
throw new IllegalStateException( "Text pieces table is empty" );
public int lookIndexForward(final int startBytePos) {
if (_textPiecesFCOrder.isEmpty())
throw new IllegalStateException("Text pieces table is empty");
if ( _textPiecesFCOrder.get( 0 ).getPieceDescriptor().getFilePosition() > startBytePos )
return _textPiecesFCOrder.get( 0 ).getPieceDescriptor().getFilePosition();
if (_textPiecesFCOrder.get(0).getPieceDescriptor().getFilePosition() > startBytePos)
return _textPiecesFCOrder.get(0).getPieceDescriptor().getFilePosition();
if ( _textPiecesFCOrder.get( _textPiecesFCOrder.size() - 1 )
.getPieceDescriptor().getFilePosition() <= startBytePos )
if (_textPiecesFCOrder.get(_textPiecesFCOrder.size() - 1)
.getPieceDescriptor().getFilePosition() <= startBytePos)
return startBytePos;
int low = 0;
int high = _textPiecesFCOrder.size() - 1;
while ( low <= high )
{
int mid = ( low + high ) >>> 1;
final TextPiece textPiece = _textPiecesFCOrder.get( mid );
while (low <= high) {
int mid = (low + high) >>> 1;
final TextPiece textPiece = _textPiecesFCOrder.get(mid);
int midVal = textPiece.getPieceDescriptor().getFilePosition();
if ( midVal < startBytePos )
if (midVal < startBytePos)
low = mid + 1;
else if ( midVal > startBytePos )
else if (midVal > startBytePos)
high = mid - 1;
else
// found piece with exact start
return textPiece.getPieceDescriptor().getFilePosition();
}
assert low == high;
assert _textPiecesFCOrder.get( low ).getPieceDescriptor()
assert _textPiecesFCOrder.get(low).getPieceDescriptor()
.getFilePosition() < startBytePos;
// last line can't be current, can it?
assert _textPiecesFCOrder.get( low + 1 ).getPieceDescriptor()
assert _textPiecesFCOrder.get(low + 1).getPieceDescriptor()
.getFilePosition() > startBytePos;
// shifting to next piece start
return _textPiecesFCOrder.get( low + 1 ).getPieceDescriptor().getFilePosition();
return _textPiecesFCOrder.get(low + 1).getPieceDescriptor().getFilePosition();
}
public byte[] writeTo( HWPFOutputStream docStream ) throws IOException
{
PlexOfCps textPlex = new PlexOfCps( PieceDescriptor.getSizeInBytes() );
public byte[] writeTo(HWPFOutputStream docStream) throws IOException {
PlexOfCps textPlex = new PlexOfCps(PieceDescriptor.getSizeInBytes());
// int fcMin = docStream.getOffset();
int size = _textPieces.size();
for ( int x = 0; x < size; x++ )
{
TextPiece next = _textPieces.get( x );
for (TextPiece next : _textPieces) {
PieceDescriptor pd = next.getPieceDescriptor();
int offset = docStream.getOffset();
int mod = ( offset % POIFSConstants.SMALLER_BIG_BLOCK_SIZE );
if ( mod != 0 )
{
int mod = (offset % POIFSConstants.SMALLER_BIG_BLOCK_SIZE);
if (mod != 0) {
mod = POIFSConstants.SMALLER_BIG_BLOCK_SIZE - mod;
byte[] buf = new byte[mod];
docStream.write( buf );
docStream.write(buf);
}
// set the text piece position to the current docStream offset.
pd.setFilePosition( docStream.getOffset() );
pd.setFilePosition(docStream.getOffset());
// write the text to the docstream and save the piece descriptor to
// the
// plex which will be written later to the tableStream.
docStream.write( next.getRawBytes() );
docStream.write(next.getRawBytes());
// The TextPiece is already in characters, which
// makes our life much easier
int nodeStart = next.getStart();
int nodeEnd = next.getEnd();
textPlex.addProperty( new GenericPropertyNode( nodeStart, nodeEnd,
pd.toByteArray() ) );
textPlex.addProperty(new GenericPropertyNode(nodeStart, nodeEnd,
pd.toByteArray()));
}
return textPlex.toByteArray();
}
private static class FCComparator implements Comparator<TextPiece>, Serializable
{
public int compare( TextPiece textPiece, TextPiece textPiece1 )
{
if ( textPiece.getPieceDescriptor().fc > textPiece1
.getPieceDescriptor().fc )
{
private static class FCComparator implements Comparator<TextPiece>, Serializable {
public int compare(TextPiece textPiece, TextPiece textPiece1) {
if (textPiece.getPieceDescriptor().fc > textPiece1
.getPieceDescriptor().fc) {
return 1;
}
else if ( textPiece.getPieceDescriptor().fc < textPiece1
.getPieceDescriptor().fc )
{
} else if (textPiece.getPieceDescriptor().fc < textPiece1
.getPieceDescriptor().fc) {
return -1;
}
else
{
} else {
return 0;
}
}

1
src/testcases/org/apache/poi/ss/formula/eval/TestFormulaBugs.java
View File

@ -118,7 +118,6 @@ public final class TestFormulaBugs {
/**
* Bug 42448 - Can't parse SUMPRODUCT(A!C7:A!C67, B8:B68) / B69 <p/>
* @throws IOException
*/
@Test
public void test42448() throws IOException {