poi-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From cen...@apache.org
Subject svn commit: r1773776 - in /poi/trunk/src: java/org/apache/poi/hssf/record/ ooxml/java/org/apache/poi/xssf/eventusermodel/ scratchpad/src/org/apache/poi/hwpf/model/ testcases/org/apache/poi/ss/formula/eval/
Date Mon, 12 Dec 2016 11:41:08 GMT
Author: centic
Date: Mon Dec 12 11:41:07 2016
New Revision: 1773776

URL: http://svn.apache.org/viewvc?rev=1773776&view=rev
Log:
Adjust toString() of ExternalNameRecord
 Fix some IntelliJ warnings
 Reformat TextPieceTable

Modified:
    poi/trunk/src/java/org/apache/poi/hssf/record/ExternalNameRecord.java
    poi/trunk/src/ooxml/java/org/apache/poi/xssf/eventusermodel/XSSFSheetXMLHandler.java
    poi/trunk/src/scratchpad/src/org/apache/poi/hwpf/model/TextPieceTable.java
    poi/trunk/src/testcases/org/apache/poi/ss/formula/eval/TestFormulaBugs.java

Modified: poi/trunk/src/java/org/apache/poi/hssf/record/ExternalNameRecord.java
URL: http://svn.apache.org/viewvc/poi/trunk/src/java/org/apache/poi/hssf/record/ExternalNameRecord.java?rev=1773776&r1=1773775&r2=1773776&view=diff
==============================================================================
--- poi/trunk/src/java/org/apache/poi/hssf/record/ExternalNameRecord.java (original)
+++ poi/trunk/src/java/org/apache/poi/hssf/record/ExternalNameRecord.java Mon Dec 12 11:41:07
2016
@@ -214,15 +214,15 @@ public final class ExternalNameRecord ex
 
 	@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");

Modified: poi/trunk/src/ooxml/java/org/apache/poi/xssf/eventusermodel/XSSFSheetXMLHandler.java
URL: http://svn.apache.org/viewvc/poi/trunk/src/ooxml/java/org/apache/poi/xssf/eventusermodel/XSSFSheetXMLHandler.java?rev=1773776&r1=1773775&r2=1773776&view=diff
==============================================================================
--- poi/trunk/src/ooxml/java/org/apache/poi/xssf/eventusermodel/XSSFSheetXMLHandler.java (original)
+++ poi/trunk/src/ooxml/java/org/apache/poi/xssf/eventusermodel/XSSFSheetXMLHandler.java Mon
Dec 12 11:41:07 2016
@@ -163,6 +163,7 @@ public class XSSFSheetXMLHandler extends
    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
                 //  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
                             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;
                       }
                    }

Modified: poi/trunk/src/scratchpad/src/org/apache/poi/hwpf/model/TextPieceTable.java
URL: http://svn.apache.org/viewvc/poi/trunk/src/scratchpad/src/org/apache/poi/hwpf/model/TextPieceTable.java?rev=1773776&r1=1773775&r2=1773776&view=diff
==============================================================================
--- poi/trunk/src/scratchpad/src/org/apache/poi/hwpf/model/TextPieceTable.java (original)
+++ poi/trunk/src/scratchpad/src/org/apache/poi/hwpf/model/TextPieceTable.java Mon Dec 12
11:41:07 2016
@@ -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 C
             // 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 C
         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 C
     }
 
     @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 C
 
             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 C
     }
 
     @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 C
         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 C
         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 C
         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;
             }
         }

Modified: poi/trunk/src/testcases/org/apache/poi/ss/formula/eval/TestFormulaBugs.java
URL: http://svn.apache.org/viewvc/poi/trunk/src/testcases/org/apache/poi/ss/formula/eval/TestFormulaBugs.java?rev=1773776&r1=1773775&r2=1773776&view=diff
==============================================================================
--- poi/trunk/src/testcases/org/apache/poi/ss/formula/eval/TestFormulaBugs.java (original)
+++ poi/trunk/src/testcases/org/apache/poi/ss/formula/eval/TestFormulaBugs.java Mon Dec 12
11:41:07 2016
@@ -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 {



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


Mime
View raw message