Sonar fixes - "static" base class members should not be accessed via derived types

git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1876159 13f79535-47bb-0310-9956-ffa450edef68

src/java/org/apache/poi/hssf/usermodel/HSSFClientAnchor.java

     /**
      * Creates a new client anchor and sets the top-left and bottom-right
      * coordinates of the anchor.
-     * 
-     * Note: Microsoft Excel seems to sometimes disallow 
-     * higher y1 than y2 or higher x1 than x2, you might need to 
-     * reverse them and draw shapes vertically or horizontally flipped! 
+     *
+     * Note: Microsoft Excel seems to sometimes disallow
+     * higher y1 than y2 or higher x1 than x2, you might need to
+     * reverse them and draw shapes vertically or horizontally flipped!
      *
      * @param dx1  the x coordinate within the first cell.
      * @param dy1  the y coordinate within the first cell.
      */
     public void setRow1(int row1) {
         checkRange(row1, 0, MAX_ROW, "row1");
-        _escherClientAnchor.setRow1(Integer.valueOf(row1).shortValue());
+        _escherClientAnchor.setRow1((short)row1);
     }
 
     /**
      */
     public void setRow2(int row2) {
         checkRange(row2, 0, MAX_ROW, "row2");
-        _escherClientAnchor.setRow2(Integer.valueOf(row2).shortValue());
+        _escherClientAnchor.setRow2((short)row2);
     }
 
     /**
-     * Sets the top-left and bottom-right coordinates of 
+     * Sets the top-left and bottom-right coordinates of
      * the anchor.
-     * 
-     * Note: Microsoft Excel seems to sometimes disallow 
-     * higher y1 than y2 or higher x1 than x2, you might need to 
-     * reverse them and draw shapes vertically or horizontally flipped! 
+     *
+     * Note: Microsoft Excel seems to sometimes disallow
+     * higher y1 than y2 or higher x1 than x2, you might need to
+     * reverse them and draw shapes vertically or horizontally flipped!
      *
      * @param x1   the x coordinate within the first cell.
      * @param y1   the y coordinate within the first cell.
 
     @Override
     public void setDx1(int dx1) {
-        _escherClientAnchor.setDx1(Integer.valueOf(dx1).shortValue());
+        _escherClientAnchor.setDx1((short)dx1);
     }
 
     @Override
 
     @Override
     public void setDy1(int dy1) {
-        _escherClientAnchor.setDy1(Integer.valueOf(dy1).shortValue());
+        _escherClientAnchor.setDy1((short)dy1);
     }
 
     @Override
 
     @Override
     public void setDy2(int dy2) {
-        _escherClientAnchor.setDy2(Integer.valueOf(dy2).shortValue());
+        _escherClientAnchor.setDy2((short)dy2);
     }
 
     @Override
 
     @Override
     public void setDx2(int dx2) {
-        _escherClientAnchor.setDx2(Integer.valueOf(dx2).shortValue());
+        _escherClientAnchor.setDx2((short)dx2);
     }
 }

src/scratchpad/src/org/apache/poi/hwpf/converter/AbstractWordUtils.java

             {
                 TableCell tableCell = tableRow.getCell( c );
 
-                edges.add( Integer.valueOf( tableCell.getLeftEdge() ) );
-                edges.add( Integer.valueOf( tableCell.getLeftEdge()
-                        + tableCell.getWidth() ) );
+                edges.add(tableCell.getLeftEdge());
+                edges.add(tableCell.getLeftEdge() + tableCell.getWidth());
             }
         }
 
         int[] result = new int[sorted.length];
         for ( int i = 0; i < sorted.length; i++ )
         {
-            result[i] = sorted[i].intValue();
+            result[i] = sorted[i];
         }
 
         return result;
 
         switch ( borderCode.getBorderType() )
         {
-        case 1:
-        case 2:
-            return "solid";
-        case 3:
-            return "double";
-        case 5:
-            return "solid";
-        case 6:
-            return "dotted";
-        case 7:
-        case 8:
-            return "dashed";
-        case 9:
-            return "dotted";
-        case 10:
-        case 11:
-        case 12:
-        case 13:
-        case 14:
-        case 15:
-        case 16:
-        case 17:
-        case 18:
-        case 19:
-            return "double";
-        case 20:
-            return "solid";
-        case 21:
-            return "double";
-        case 22:
-            return "dashed";
-        case 23:
-            return "dashed";
-        case 24:
-            return "ridge";
-        case 25:
-            return "grooved";
-        default:
-            return "solid";
+            case 3:
+            case 10:
+            case 11:
+            case 12:
+            case 13:
+            case 14:
+            case 15:
+            case 16:
+            case 17:
+            case 18:
+            case 19:
+            case 21:
+                return "double";
+            case 6:
+            case 9:
+                return "dotted";
+            case 7:
+            case 8:
+            case 22:
+            case 23:
+                return "dashed";
+            case 24:
+                return "ridge";
+            case 25:
+                return "grooved";
+                case 5:
+            case 1:
+            case 2:
+            case 20:
+            default:
+                return "solid";
         }
     }
 
         int pt = lineWidth / 8;
         int pte = lineWidth - pt * 8;
 
-        StringBuilder stringBuilder = new StringBuilder();
-        stringBuilder.append( pt );
-        stringBuilder.append( "." );
-        stringBuilder.append( 1000 / 8 * pte );
-        stringBuilder.append( "pt" );
-        return stringBuilder.toString();
+        return pt + "." + 1000 / 8 * pte + "pt";
     }
 
     public static class NumberingState
 
     public static String getColor( int ico )
     {
-        switch ( ico )
-        {
-        case 1:
-            return "black";
-        case 2:
-            return "blue";
-        case 3:
-            return "cyan";
-        case 4:
-            return "green";
-        case 5:
-            return "magenta";
-        case 6:
-            return "red";
-        case 7:
-            return "yellow";
-        case 8:
-            return "white";
-        case 9:
-            return "darkblue";
-        case 10:
-            return "darkcyan";
-        case 11:
-            return "darkgreen";
-        case 12:
-            return "darkmagenta";
-        case 13:
-            return "darkred";
-        case 14:
-            return "darkyellow";
-        case 15:
-            return "darkgray";
-        case 16:
-            return "lightgray";
-        default:
-            return "black";
+        switch ( ico ) {
+            case 2:
+                return "blue";
+            case 3:
+                return "cyan";
+            case 4:
+                return "green";
+            case 5:
+                return "magenta";
+            case 6:
+                return "red";
+            case 7:
+                return "yellow";
+            case 8:
+                return "white";
+            case 9:
+                return "darkblue";
+            case 10:
+                return "darkcyan";
+            case 11:
+                return "darkgreen";
+            case 12:
+                return "darkmagenta";
+            case 13:
+                return "darkred";
+            case 14:
+                return "darkyellow";
+            case 15:
+                return "darkgray";
+            case 16:
+                return "lightgray";
+            case 1:
+            default:
+                return "black";
         }
     }
 
     public static String getOpacity( int argbValue )
     {
-        int opacity = (int) ( ( argbValue & 0xFF000000l ) >>> 24 );
+        int opacity = (int) ( ( argbValue & 0xFF000000L) >>> 24 );
         if ( opacity == 0 || opacity == 0xFF )
             return ".0";
 
         switch ( js )
         {
         case 0:
+        case 7:
             return "start";
         case 1:
+        case 5:
             return "center";
         case 2:
+        case 8:
             return "end";
         case 3:
         case 4:
+        case 9:
             return "justify";
-        case 5:
-            return "center";
         case 6:
             return "left";
-        case 7:
-            return "start";
-        case 8:
-            return "end";
-        case 9:
-            return "justify";
         }
         return "";
     }
         case 2057:
             return "en-uk";
         default:
-            logger.log( POILogger.WARN, "Uknown or unmapped language code: ",
-                    Integer.valueOf( languageCode ) );
+            logger.log( POILogger.WARN, "Uknown or unmapped language code: ", languageCode);
             return EMPTY;
         }
     }

src/scratchpad/src/org/apache/poi/hwpf/converter/HtmlDocumentFacade.java

     {
         String exising = element.getAttribute( "class" );
         String addition = getOrCreateCssClass( classNamePrefix, style );
-        String newClassValue = WordToHtmlUtils.isEmpty( exising ) ? addition
-                : ( exising + " " + addition );
+        String newClassValue = AbstractWordUtils.isEmpty( exising ) ? addition : ( exising + " " + addition );
         element.setAttribute( "class", newClassValue );
     }
 
 
     public void setTitle( String titleText )
     {
-        if ( WordToHtmlUtils.isEmpty( titleText ) && this.title != null )
+        if ( AbstractWordUtils.isEmpty( titleText ) && this.title != null )
         {
             this.head.removeChild( this.title );
             this.title = null;

src/scratchpad/src/org/apache/poi/hwpf/converter/TextDocumentFacade.java

 
         root.appendChild( head );
         root.appendChild( body );
-        
+
         title = document.createElement( "title" );
         titleText = document.createTextNode( "" );
         head.appendChild( title );
 
     public void setTitle( String titleText )
     {
-        if ( WordToHtmlUtils.isEmpty( titleText ) && this.title != null )
+        if ( AbstractWordUtils.isEmpty( titleText ) && this.title != null )
         {
             this.head.removeChild( this.title );
             this.title = null;

src/scratchpad/src/org/apache/poi/hwpf/converter/WordToFoConverter.java

 ==================================================================== */
 package org.apache.poi.hwpf.converter;
 
+import static org.apache.poi.hwpf.converter.AbstractWordUtils.TWIPS_PER_INCH;
+import static org.apache.poi.hwpf.converter.AbstractWordUtils.isNotEmpty;
+import static org.apache.poi.hwpf.converter.AbstractWordUtils.loadDoc;
+import static org.apache.poi.hwpf.converter.WordToFoUtils.*;
+
 import java.io.File;
 import java.util.ArrayList;
 import java.util.LinkedHashSet;
 
     /**
      * Java main() interface to interact with {@link WordToFoConverter}
-     * 
+     *
      * <p>
      * Usage: WordToFoConverter infile outfile
      * </p>
     static Document process( File docFile ) throws Exception
     {
         final DocumentBuilder docBuild = XMLHelper.newDocumentBuilder();
-        try (final HWPFDocumentCore hwpfDocument = WordToFoUtils.loadDoc( docFile )) {
+        try (final HWPFDocumentCore hwpfDocument = loadDoc( docFile )) {
             WordToFoConverter wordToFoConverter = new WordToFoConverter(docBuild.newDocument());
             wordToFoConverter.processDocument(hwpfDocument);
             return wordToFoConverter.getDocument();
     /**
      * Creates new instance of {@link WordToFoConverter}. Can be used for output
      * several {@link HWPFDocument}s into single FO document.
-     * 
+     *
      * @param document
      *            XML DOM Document used as XSL FO document. Shall support
      *            namespaces
         return inline;
     }
 
-    protected String createPageMaster( Section section, String type,
-            int sectionIndex )
-    {
-        float height = section.getPageHeight() / WordToFoUtils.TWIPS_PER_INCH;
-        float width = section.getPageWidth() / WordToFoUtils.TWIPS_PER_INCH;
-        float leftMargin = section.getMarginLeft()
-                / WordToFoUtils.TWIPS_PER_INCH;
-        float rightMargin = section.getMarginRight()
-                / WordToFoUtils.TWIPS_PER_INCH;
-        float topMargin = section.getMarginTop() / WordToFoUtils.TWIPS_PER_INCH;
-        float bottomMargin = section.getMarginBottom()
-                / WordToFoUtils.TWIPS_PER_INCH;
+    protected String createPageMaster( Section section, String type, int sectionIndex ) {
+        float height = section.getPageHeight() / TWIPS_PER_INCH;
+        float width = section.getPageWidth() / TWIPS_PER_INCH;
+        float leftMargin = section.getMarginLeft() / TWIPS_PER_INCH;
+        float rightMargin = section.getMarginRight() / TWIPS_PER_INCH;
+        float topMargin = section.getMarginTop() / TWIPS_PER_INCH;
+        float bottomMargin = section.getMarginBottom() / TWIPS_PER_INCH;
 
         // add these to the header
         String pageMasterName = type + "-page" + sectionIndex;
 
         /*
          * 6.4.14 fo:region-body
-         * 
+         *
          * The values of the padding and border-width traits must be "0".
          */
         // WordToFoUtils.setBorder(regionBody, sep.getBrcTop(), "top");
                     "" + ( section.getNumColumns() ) );
             if ( section.isColumnsEvenlySpaced() )
             {
-                float distance = section.getDistanceBetweenColumns()
-                        / WordToFoUtils.TWIPS_PER_INCH;
+                float distance = section.getDistanceBetweenColumns() / TWIPS_PER_INCH;
                 regionBody.setAttribute( "column-gap", distance + "in" );
             }
             else
 
         Triplet triplet = getCharacterRunTriplet( characterRun );
 
-        if ( WordToFoUtils.isNotEmpty( triplet.fontName ) )
-            WordToFoUtils.setFontFamily( inline, triplet.fontName );
-        WordToFoUtils.setBold( inline, triplet.bold );
-        WordToFoUtils.setItalic( inline, triplet.italic );
-        WordToFoUtils.setFontSize( inline, characterRun.getFontSize() / 2 );
-        WordToFoUtils.setCharactersProperties( characterRun, inline );
+        if ( isNotEmpty( triplet.fontName ) )
+            setFontFamily( inline, triplet.fontName );
+        setBold( inline, triplet.bold );
+        setItalic( inline, triplet.italic );
+        setFontSize( inline, characterRun.getFontSize() / 2 );
+        setCharactersProperties( characterRun, inline );
 
         if ( isOutputCharactersLanguage() )
-            WordToFoUtils.setLanguage( characterRun, inline );
+            setLanguage( characterRun, inline );
 
         block.appendChild( inline );
 
     protected void processDocumentInformation(
             SummaryInformation summaryInformation )
     {
-        if ( WordToHtmlUtils.isNotEmpty( summaryInformation.getTitle() ) )
+        if ( isNotEmpty( summaryInformation.getTitle() ) )
             foDocumentFacade.setTitle( summaryInformation.getTitle() );
 
-        if ( WordToHtmlUtils.isNotEmpty( summaryInformation.getAuthor() ) )
+        if ( isNotEmpty( summaryInformation.getAuthor() ) )
             foDocumentFacade.setCreator( summaryInformation.getAuthor() );
 
-        if ( WordToHtmlUtils.isNotEmpty( summaryInformation.getKeywords() ) )
+        if ( isNotEmpty( summaryInformation.getKeywords() ) )
             foDocumentFacade.setKeywords( summaryInformation.getKeywords() );
 
-        if ( WordToHtmlUtils.isNotEmpty( summaryInformation.getComments() ) )
+        if ( isNotEmpty( summaryInformation.getComments() ) )
             foDocumentFacade.setDescription( summaryInformation.getComments() );
     }
 
         processCharacters( wordDocument, Integer.MIN_VALUE, endnoteTextRange,
                 endnote );
 
-        WordToFoUtils.compactInlines( endnote );
+        compactInlines( endnote );
         this.endnotes.add( endnote );
     }
 
         processCharacters( wordDocument, Integer.MIN_VALUE, footnoteTextRange,
                 footnoteBlock );
 
-        WordToFoUtils.compactInlines( footnoteBlock );
+        compactInlines( footnoteBlock );
     }
 
     protected void processHyperlink( HWPFDocumentCore wordDocument,
     {
         final Element externalGraphic = foDocumentFacade
                 .createExternalGraphic( url );
-        WordToFoUtils.setPictureProperties( picture, externalGraphic );
+        setPictureProperties( picture, externalGraphic );
         currentBlock.appendChild( externalGraphic );
     }
 
         final Element block = foDocumentFacade.createBlock();
         parentFopElement.appendChild( block );
 
-        WordToFoUtils.setParagraphProperties( paragraph, block );
+        setParagraphProperties( paragraph, block );
 
         final int charRuns = paragraph.numCharacterRuns();
 
 
         boolean haveAnyText = false;
 
-        if ( WordToFoUtils.isNotEmpty( bulletText ) )
+        if ( isNotEmpty( bulletText ) )
         {
             Element inline = foDocumentFacade.createInline();
             block.appendChild( inline );
             block.appendChild( leader );
         }
 
-        WordToFoUtils.compactInlines( block );
+        compactInlines( block );
     }
 
     protected void processSection( HWPFDocumentCore wordDocument,
         Element tableHeader = foDocumentFacade.createTableHeader();
         Element tableBody = foDocumentFacade.createTableBody();
 
-        final int[] tableCellEdges = WordToHtmlUtils
-                .buildTableCellEdgesArray( table );
+        final int[] tableCellEdges = buildTableCellEdgesArray( table );
         final int tableRows = table.numRows();
 
         int maxColumns = Integer.MIN_VALUE;
             TableRow tableRow = table.getRow( r );
 
             Element tableRowElement = foDocumentFacade.createTableRow();
-            WordToFoUtils.setTableRowProperties( tableRow, tableRowElement );
+            setTableRowProperties( tableRow, tableRowElement );
 
             // index of current element in tableCellEdges[]
             int currentEdgeIndex = 0;
                 }
 
                 Element tableCellElement = foDocumentFacade.createTableCell();
-                WordToFoUtils.setTableCellProperties( tableRow, tableCell,
+                setTableCellProperties( tableRow, tableCell,
                         tableCellElement, r == 0, r == tableRows - 1, c == 0,
                         c == rowCells - 1 );
 

src/scratchpad/src/org/apache/poi/hwpf/extractor/WordExtractor.java

 
 import org.apache.poi.extractor.POIOLE2TextExtractor;
 import org.apache.poi.hwpf.HWPFDocument;
+import org.apache.poi.hwpf.HWPFDocumentCore;
 import org.apache.poi.hwpf.converter.WordToTextConverter;
 import org.apache.poi.hwpf.usermodel.HeaderStories;
 import org.apache.poi.hwpf.usermodel.Paragraph;
 
 /**
  * Class to extract the text from a Word Document.
- * 
+ *
  * You should use either getParagraphText() or getText() unless you have a
  * strong reason otherwise.
- * 
+ *
  * @author Nick Burch
  */
 public final class WordExtractor extends POIOLE2TextExtractor {
 
     /**
      * Create a new Word Extractor
-     * 
+     *
      * @param is
      *            InputStream containing the word file
      */
     public WordExtractor( InputStream is ) throws IOException {
-        this( HWPFDocument.verifyAndBuildPOIFS( is ) );
+        this(HWPFDocumentCore.verifyAndBuildPOIFS(is ) );
     }
 
     /**
      * Create a new Word Extractor
-     * 
+     *
      * @param fs
      *            POIFSFileSystem containing the word file
      */
 
     /**
      * Create a new Word Extractor
-     * 
+     *
      * @param doc
      *            The HWPFDocument to extract from
      */

src/scratchpad/src/org/apache/poi/hwpf/model/BookmarksTables.java

 import java.util.Arrays;
 import java.util.List;
 
+import org.apache.poi.hwpf.model.types.BKFAbstractType;
 import org.apache.poi.util.Internal;
 import org.apache.poi.util.POILogFactory;
 import org.apache.poi.util.POILogger;
         int firstDescriptorsStart = fib.getFcPlcfbkf();
         int firstDescriptorsLength = fib.getLcbPlcfbkf();
         if ( firstDescriptorsStart != 0 && firstDescriptorsLength != 0 )
-            descriptorsFirst = new PlexOfCps( tableStream,
-                    firstDescriptorsStart, firstDescriptorsLength,
-                    BookmarkFirstDescriptor.getSize() );
+            descriptorsFirst = new PlexOfCps(tableStream,
+                 firstDescriptorsStart, firstDescriptorsLength,
+                 BKFAbstractType.getSize() );
 
         int limDescriptorsStart = fib.getFcPlcfbkl();
         int limDescriptorsLength = fib.getLcbPlcfbkl();

src/scratchpad/src/org/apache/poi/hwpf/model/FFData.java

 ==================================================================== */
 package org.apache.poi.hwpf.model;
 
+import static org.apache.poi.hwpf.model.types.FFDataBaseAbstractType.ITYPE_CHCK;
+import static org.apache.poi.hwpf.model.types.FFDataBaseAbstractType.ITYPE_DROP;
+import static org.apache.poi.hwpf.model.types.FFDataBaseAbstractType.ITYPE_TEXT;
+
+import org.apache.poi.hwpf.model.types.FFDataBaseAbstractType;
 import org.apache.poi.util.Internal;
 import org.apache.poi.util.LittleEndian;
 import org.apache.poi.util.LittleEndianConsts;
         int offset = startOffset;
 
         this._base = new FFDataBase( std, offset );
-        offset += FFDataBase.getSize();
+        offset += FFDataBaseAbstractType.getSize();
 
         this._xstzName = new Xstz( std, offset );
         offset += this._xstzName.getSize();
 
-        if ( _base.getIType() == FFDataBase.ITYPE_TEXT )
+        if ( _base.getIType() == ITYPE_TEXT )
         {
             _xstzTextDef = new Xstz( std, offset );
             offset += this._xstzTextDef.getSize();
             this._xstzTextDef = null;
         }
 
-        if ( _base.getIType() == FFDataBase.ITYPE_CHCK
-                || _base.getIType() == FFDataBase.ITYPE_DROP )
+        if ( _base.getIType() == ITYPE_CHCK
+                || _base.getIType() == ITYPE_DROP )
         {
-            this._wDef = Integer
-                    .valueOf( LittleEndian.getUShort( std, offset ) );
+            this._wDef = LittleEndian.getUShort(std, offset);
             offset += LittleEndianConsts.SHORT_SIZE;
         }
         else
         _xstzExitMcr = new Xstz( std, offset );
         offset += this._xstzExitMcr.getSize();
 
-        if ( _base.getIType() == FFDataBase.ITYPE_DROP )
-        {
+        if ( _base.getIType() == ITYPE_DROP ) {
             _hsttbDropList = new Sttb( std, offset );
-            offset += _hsttbDropList.getSize();
         }
     }
 
      */
     public int getDefaultDropDownItemIndex()
     {
-        return _wDef.intValue();
+        return _wDef;
     }
 
     public String[] getDropList()
 
     public int getSize()
     {
-        int size = FFDataBase.getSize();
+        int size = FFDataBaseAbstractType.getSize();
 
         size += _xstzName.getSize();
 
-        if ( _base.getIType() == FFDataBase.ITYPE_TEXT )
+        if ( _base.getIType() == ITYPE_TEXT )
         {
             size += _xstzTextDef.getSize();
         }
 
-        if ( _base.getIType() == FFDataBase.ITYPE_CHCK
-                || _base.getIType() == FFDataBase.ITYPE_DROP )
+        if ( _base.getIType() == ITYPE_CHCK
+                || _base.getIType() == ITYPE_DROP )
         {
             size += LittleEndianConsts.SHORT_SIZE;
         }
         size += _xstzEntryMcr.getSize();
         size += _xstzExitMcr.getSize();
 
-        if ( _base.getIType() == FFDataBase.ITYPE_DROP )
+        if ( _base.getIType() == ITYPE_DROP )
         {
             size += _hsttbDropList.getSize();
         }
         int offset = 0;
 
         _base.serialize( buffer, offset );
-        offset += FFDataBase.getSize();
+        offset += FFDataBaseAbstractType.getSize();
 
         offset += _xstzName.serialize( buffer, offset );
 
-        if ( _base.getIType() == FFDataBase.ITYPE_TEXT )
+        if ( _base.getIType() == ITYPE_TEXT )
         {
             offset += _xstzTextDef.serialize( buffer, offset );
         }
 
-        if ( _base.getIType() == FFDataBase.ITYPE_CHCK
-                || _base.getIType() == FFDataBase.ITYPE_DROP )
+        if ( _base.getIType() == ITYPE_CHCK
+                || _base.getIType() == ITYPE_DROP )
         {
             LittleEndian.putUShort( buffer, offset, _wDef );
             offset += LittleEndianConsts.SHORT_SIZE;
         offset += _xstzEntryMcr.serialize( buffer, offset );
         offset += _xstzExitMcr.serialize( buffer, offset );
 
-        if ( _base.getIType() == FFDataBase.ITYPE_DROP )
-        {
-            offset += _hsttbDropList.serialize( buffer, offset );
+        if ( _base.getIType() == ITYPE_DROP ) {
+            _hsttbDropList.serialize( buffer, offset );
         }
 
         return buffer;

src/scratchpad/src/org/apache/poi/hwpf/model/FSPATable.java

 import java.util.List;
 import java.util.Map;
 
+import org.apache.poi.hwpf.model.types.FSPAAbstractType;
 import org.apache.poi.util.Internal;
 
 /**
  * This class holds all the FSPA (File Shape Address) structures.
- * 
- * @author Squeeself
  */
 @Internal
 public final class FSPATable
         int offset = fib.getFSPAPlcfOffset( part );
         int length = fib.getFSPAPlcfLength( part );
 
-        PlexOfCps plex = new PlexOfCps( tableStream, offset, length,
-                FSPA.getSize() );
+        PlexOfCps plex = new PlexOfCps(tableStream, offset, length, FSPAAbstractType.getSize() );
         for ( int i = 0; i < plex.length(); i++ )
         {
             GenericPropertyNode property = plex.getProperty( i );
-            _byStart.put( Integer.valueOf( property.getStart() ), property );
+            _byStart.put(property.getStart(), property );
         }
     }
 
         for ( int i = 0; i < plex.length(); i++ )
         {
             GenericPropertyNode property = plex.getProperty( i );
-            _byStart.put( Integer.valueOf( property.getStart() ), property );
+            _byStart.put(property.getStart(), property );
         }
     }
 
     public FSPA getFspaFromCp( int cp )
     {
-        GenericPropertyNode propertyNode = _byStart.get( Integer.valueOf( cp ) );
+        GenericPropertyNode propertyNode = _byStart.get(cp);
         if ( propertyNode == null )
         {
             return null;
             buf.append( "  " ).append(i).append( " => \t" );
 
             try {
-                FSPA fspa = getFspaFromCp( i.intValue() );
+                FSPA fspa = getFspaFromCp(i);
                 buf.append(fspa);
             } catch ( Exception exc ) {
                 buf.append( exc.getMessage() );

src/scratchpad/src/org/apache/poi/hwpf/model/FileInformationBlock.java

 import java.util.HashSet;
 import java.util.Locale;
 
+import org.apache.poi.hwpf.model.types.FibBaseAbstractType;
+import org.apache.poi.hwpf.model.types.FibRgW97AbstractType;
 import org.apache.poi.util.IOUtils;
 import org.apache.poi.util.Internal;
 import org.apache.poi.util.LittleEndian;
         int offset = 0;
 
         _fibBase = new FibBase( mainDocument, offset );
-        offset = FibBase.getSize();
+        offset = FibBaseAbstractType.getSize();
         assert offset == 32;
 
         _csw = LittleEndian.getUShort( mainDocument, offset );
         offset += LittleEndianConsts.SHORT_SIZE;
-        assert offset == 34;
 
         _fibRgW = new FibRgW97( mainDocument, offset );
-        offset += FibRgW97.getSize();
+        offset += FibRgW97AbstractType.getSize();
         assert offset == 62;
 
         _cslw = LittleEndian.getUShort( mainDocument, offset );
         offset += LittleEndianConsts.SHORT_SIZE;
-        assert offset == 64;
 
         if ( _fibBase.getNFib() < 105 )
         {
         _cbRgFcLcb = _fieldHandler.getFieldsCount();
 
         _fibBase.serialize( mainStream, 0 );
-        int offset = FibBase.getSize();
+        int offset = FibBaseAbstractType.getSize();
 
         LittleEndian.putUShort( mainStream, offset, _csw );
         offset += LittleEndianConsts.SHORT_SIZE;
 
         _fibRgW.serialize( mainStream, offset );
-        offset += FibRgW97.getSize();
+        offset += FibRgW97AbstractType.getSize();
 
         LittleEndian.putUShort( mainStream, offset, _cslw );
         offset += LittleEndianConsts.SHORT_SIZE;
 
     public int getSize()
     {
-        return FibBase.getSize() + LittleEndianConsts.SHORT_SIZE + FibRgW97.getSize()
+        return FibBaseAbstractType.getSize() + LittleEndianConsts.SHORT_SIZE + FibRgW97AbstractType.getSize()
                 + LittleEndianConsts.SHORT_SIZE + FibRgLw97.getSize()
                 + LittleEndianConsts.SHORT_SIZE + _fieldHandler.sizeInBytes();
     }

src/scratchpad/src/org/apache/poi/hwpf/model/ListFormatOverrideLevel.java

 
 import java.util.Objects;
 
+import org.apache.poi.hwpf.model.types.LFOLVLBaseAbstractType;
 import org.apache.poi.util.Internal;
 
 /**
     public ListFormatOverrideLevel( byte[] buf, int offset )
     {
         _base = new LFOLVLBase( buf, offset );
-        offset += LFOLVLBase.getSize();
+        offset += LFOLVLBaseAbstractType.getSize();
 
         if ( _base.isFFormatting() )
         {
 
     public int getSizeInBytes()
     {
-        return _lvl == null ? LFOLVLBase.getSize() : LFOLVLBase.getSize()
+        return _lvl == null ? LFOLVLBaseAbstractType.getSize() : LFOLVLBaseAbstractType.getSize()
                 + _lvl.getSizeInBytes();
     }
 
 
         byte[] buf = new byte[getSizeInBytes()];
         _base.serialize( buf, offset );
-        offset += LFOLVLBase.getSize();
+        offset += LFOLVLBaseAbstractType.getSize();
 
         if ( _lvl != null )
         {

src/scratchpad/src/org/apache/poi/hwpf/model/ListLevel.java

 
 import java.util.Arrays;
 
+import org.apache.poi.hwpf.model.types.LVLFAbstractType;
 import org.apache.poi.util.IOUtils;
 import org.apache.poi.util.Internal;
 import org.apache.poi.util.POILogFactory;
      * from the other paragraphs in the list. Any element in the rgtchar field
      * of this Xst can be a placeholder. Each placeholder is an unsigned 2-byte
      * integer that specifies the zero-based level that the placeholder is for.
-     * 
+     *
      * Each placeholder MUST have a value that is less than or equal to the
      * zero-based level of the list that this LVL represents. The indexes of the
      * placeholders are specified by lvlf.rgbxchNums. Placeholders that
 
     public int getSizeInBytes()
     {
-        return LVLF.getSize() + _lvlf.getCbGrpprlChpx()
+        return LVLFAbstractType.getSize() + _lvlf.getCbGrpprlChpx()
                 + _lvlf.getCbGrpprlPapx() + _xst.getSize();
     }
 
     /**
      * An unsigned integer that specifies the first (most-significant) zero-based level after which the number sequence of this level does not restart. The number sequence of this level does restart after any level that is more significant than the specified level. This MUST be less than or equal to the zero-based level of the list to which this LVLF corresponds.
      * <p>see [MS-DOC], v20140721, 2.9.150</p>
-     * 
+     *
      * @return the first ({@code 0} is the most significant) level after which
      * the numbering does not restart or {@code -1} if no restart is applicable
      */
-    public short getRestart() {    	
+    public short getRestart() {
     	return _lvlf.isFNoRestart() ? _lvlf.getIlvlRestartLim() : -1;
     }
-    
+
     /**
      * Determines if the number formatting shall be overridden by
      * {@code msonfcArabic}; unless it originally was {@code msonfcArabicLZ}
      * in which case it is preserved.
      * <p>see [MS-DOC], v20140721, 2.9.150 and [MS-OSHARED], v20140721, 2.2.1.3</p>
-     * 
+     *
      * @return {@code true} if the level numbering of this and all more
      * significant levels must be overridden; {@code false} otherwise
      */
     public boolean isLegalNumbering() {
     	return _lvlf.isFLegal();
     }
-    
+
     /**
      * Array which specifies the character offsets of the level numbers in a
      * level numbering string.
      * <p>see [MS-DOC], v20140721, 2.9.150</p>
-     * 
-     * @return {@code 0}-terminated array, unless it is full 
+     *
+     * @return {@code 0}-terminated array, unless it is full
      */
-    public byte[] getLevelNumberingPlaceholderOffsets() {    	
+    public byte[] getLevelNumberingPlaceholderOffsets() {
     	return _lvlf.getRgbxchNums();
     }
 
         int offset = startOffset;
 
         _lvlf = new LVLF( data, offset );
-        offset += LVLF.getSize();
+        offset += LVLFAbstractType.getSize();
 
         //short -- no need to safely allocate
         _grpprlPapx = new byte[_lvlf.getCbGrpprlPapx()];
         _lvlf.setCbGrpprlChpx( (short) _grpprlChpx.length );
         _lvlf.setCbGrpprlPapx( (short) _grpprlPapx.length );
         _lvlf.serialize( buf, offset );
-        offset += LVLF.getSize();
+        offset += LVLFAbstractType.getSize();
 
         System.arraycopy( _grpprlPapx, 0, buf, offset, _grpprlPapx.length );
         offset += _grpprlPapx.length;

src/scratchpad/src/org/apache/poi/hwpf/model/ListTables.java

 import java.util.NoSuchElementException;
 import java.util.Objects;
 
+import org.apache.poi.hwpf.model.types.LSTFAbstractType;
 import org.apache.poi.util.Internal;
 import org.apache.poi.util.LittleEndian;
 import org.apache.poi.util.LittleEndianConsts;
 
         int cLst = LittleEndian.getShort( tableStream, offset );
         offset += LittleEndianConsts.SHORT_SIZE;
-        int levelOffset = offset + ( cLst * LSTF.getSize() );
+        int levelOffset = offset + ( cLst * LSTFAbstractType.getSize() );
 
         for ( int x = 0; x < cLst; x++ )
         {
             ListData lst = new ListData( tableStream, offset );
-            _listMap.put( Integer.valueOf( lst.getLsid() ), lst );
-            offset += LSTF.getSize();
+            _listMap.put(lst.getLsid(), lst );
+            offset += LSTFAbstractType.getSize();
 
             int num = lst.numLevels();
             for ( int y = 0; y < num; y++ )
     for(ListData lst : _listMap.values()) {
       tableStream.write(lst.toByteArray());
       ListLevel[] lvls = lst.getLevels();
-      for (int y = 0; y < lvls.length; y++)
-      {
-        levelBuf.write(lvls[y].toByteArray());
-      }
+        for (ListLevel lvl : lvls) {
+            levelBuf.write(lvl.toByteArray());
+        }
     }
 
         /*
 
     /**
      * Get the ListLevel for a given lsid and level
-     * @param lsid
-     * @param level
      * @return ListLevel if found, or <code>null</code> if ListData can't be found or if level is > that available
      */
   public ListLevel getLevel(int lsid, int level)
   {
-    ListData lst = _listMap.get(Integer.valueOf(lsid));
+    ListData lst = _listMap.get(lsid);
     if (lst == null) {
         if (log.check(POILogger.WARN)) {
             log.log(POILogger.WARN, "ListData for " +
 
   public ListData getListData(int lsid)
   {
-    return _listMap.get(Integer.valueOf(lsid));
+    return _listMap.get(lsid);
   }
 
     @Override
         ListTables other = (ListTables) obj;
         if ( !_listMap.equals( other._listMap ) )
             return false;
-        if ( _plfLfo == null )
-        {
-            if ( other._plfLfo != null )
-                return false;
-        }
-        else if ( !_plfLfo.equals( other._plfLfo ) )
-            return false;
-        return true;
+        return Objects.equals(_plfLfo, other._plfLfo);
     }
 
     public int addList( ListData lst, LFO lfo, LFOData lfoData )
     {
         int lsid = lst.getLsid();
-        while ( _listMap.get( Integer.valueOf( lsid ) ) != null )
+        while (_listMap.containsKey(lsid))
         {
             lsid = lst.resetListID();
             lfo.setLsid( lsid );
         }
-        _listMap.put( Integer.valueOf( lsid ), lst );
+        _listMap.put(lsid, lst );
 
         if ( lfo == null && lfoData != null )
         {

src/scratchpad/src/org/apache/poi/hwpf/model/NotesTables.java

 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 
+import org.apache.poi.hwpf.model.types.FRDAbstractType;
 import org.apache.poi.util.Internal;
 
 /**
  * Holds information about document notes (footnotes or ending notes)
- * 
+ *
  * @author Sergey Vladimirov (vlsergey {at} gmail {doc} com)
  */
 @Internal
 public class NotesTables
 {
-    private PlexOfCps descriptors = new PlexOfCps(
-            FootnoteReferenceDescriptor.getSize() );
+    private PlexOfCps descriptors = new PlexOfCps(FRDAbstractType.getSize() );
 
     private final NoteType noteType;
 
 
         if ( referencesStart != 0 && referencesLength != 0 )
             this.descriptors = new PlexOfCps( tableStream, referencesStart,
-                    referencesLength, FootnoteReferenceDescriptor.getSize() );
+                    referencesLength, FRDAbstractType.getSize() );
 
         int textPositionsStart = fib.getNotesTextPositionsOffset( noteType );
         int textPositionsLength = fib.getNotesTextPositionsSize( noteType );

src/scratchpad/src/org/apache/poi/hwpf/model/PICFAndOfficeArtData.java

 import org.apache.poi.ddf.DefaultEscherRecordFactory;
 import org.apache.poi.ddf.EscherContainerRecord;
 import org.apache.poi.ddf.EscherRecord;
+import org.apache.poi.hwpf.model.types.PICFAbstractType;
 import org.apache.poi.util.Internal;
 import org.apache.poi.util.LittleEndian;
 
         int offset = startOffset;
 
         _picf = new PICF( dataStream, offset );
-        offset += PICF.getSize();
+        offset += PICFAbstractType.getSize();
 
         if ( _picf.getMm() == 0x0066 )
         {

src/scratchpad/src/org/apache/poi/hwpf/model/PlfLfo.java

 import java.util.Arrays;
 import java.util.NoSuchElementException;
 
+import org.apache.poi.hwpf.model.types.LFOAbstractType;
 import org.apache.poi.util.LittleEndian;
 import org.apache.poi.util.LittleEndianConsts;
 import org.apache.poi.util.POILogFactory;
         for ( int x = 0; x < _lfoMac; x++ )
         {
             LFO lfo = new LFO( tableStream, offset );
-            offset += LFO.getSize();
+            offset += LFOAbstractType.getSize();
             _rgLfo[x] = lfo;
         }
 
 
         LittleEndian.putUInt( _lfoMac, outputStream );
 
-        byte[] bs = new byte[LFO.getSize() * _lfoMac];
+        byte[] bs = new byte[LFOAbstractType.getSize() * _lfoMac];
         for ( int i = 0; i < _lfoMac; i++ )
         {
-            _rgLfo[i].serialize( bs, i * LFO.getSize() );
+            _rgLfo[i].serialize( bs, i * LFOAbstractType.getSize() );
         }
-        outputStream.write( bs, 0, LFO.getSize() * _lfoMac );
+        outputStream.write( bs, 0, LFOAbstractType.getSize() * _lfoMac );
 
         for ( int i = 0; i < _lfoMac; i++ )
         {

src/scratchpad/src/org/apache/poi/hwpf/model/StyleDescription.java

 package org.apache.poi.hwpf.model;
 
 import java.util.Arrays;
+import java.util.Objects;
 
+import org.apache.poi.hwpf.model.types.StdfBaseAbstractType;
 import org.apache.poi.hwpf.usermodel.CharacterProperties;
 import org.apache.poi.hwpf.usermodel.ParagraphProperties;
 import org.apache.poi.util.IOUtils;
         } else if (baseLength == 0x000A) {
             readStdfPost2000 = false;
         } else {
-            logger.log(POILogger.WARN,
-                    "Style definition has non-standard size of ",
-                    Integer.valueOf(baseLength));
+            logger.log(POILogger.WARN, "Style definition has non-standard size of ", baseLength);
         }
 
         _stdfBase = new StdfBase(std, offset);
-        offset += StdfBase.getSize();
+        offset += StdfBaseAbstractType.getSize();
 
         if (readStdfPost2000) {
             _stdfPost2000 = new StdfPost2000(std, offset);
     }
 
     public byte[] getPAPX() {
-        switch (_stdfBase.getStk()) {
-            case PARAGRAPH_STYLE:
-                return _upxs[0].getUPX();
-            default:
-                return null;
-        }
+        return _stdfBase.getStk() == PARAGRAPH_STYLE ? _upxs[0].getUPX() : null;
     }
 
     @Deprecated
         char[] letters = _name.toCharArray();
         LittleEndian.putShort(buf, _baseLength, (short) letters.length);
         offset += LittleEndianConsts.SHORT_SIZE;
-        for (int x = 0; x < letters.length; x++) {
-            LittleEndian.putShort(buf, offset, (short) letters[x]);
+        for (char letter : letters) {
+            LittleEndian.putShort(buf, offset, (short) letter);
             offset += LittleEndianConsts.SHORT_SIZE;
         }
         // get past the null delimiter for the name.
         offset += LittleEndianConsts.SHORT_SIZE;
 
-        for (int x = 0; x < _upxs.length; x++) {
-            short upxSize = (short) _upxs[x].size();
+        for (UPX upx : _upxs) {
+            short upxSize = (short) upx.size();
             LittleEndian.putShort(buf, offset, upxSize);
             offset += LittleEndianConsts.SHORT_SIZE;
-            System.arraycopy(_upxs[x].getUPX(), 0, buf, offset, upxSize);
+            System.arraycopy(upx.getUPX(), 0, buf, offset, upxSize);
             offset += upxSize + (upxSize % 2);
         }
 
     public boolean equals(Object obj) {
         if (this == obj)
             return true;
-        if (obj == null)
-            return false;
-        if (getClass() != obj.getClass())
+        if (!(obj instanceof StyleDescription))
             return false;
         StyleDescription other = (StyleDescription) obj;
-        if (_name == null) {
-            if (other._name != null)
-                return false;
-        } else if (!_name.equals(other._name))
-            return false;
-        if (_stdfBase == null) {
-            if (other._stdfBase != null)
-                return false;
-        } else if (!_stdfBase.equals(other._stdfBase))
+        if (!Objects.equals(_name, other._name)) {
             return false;
-        if (!Arrays.equals(_upxs, other._upxs))
+        }
+        if (!Objects.equals(_stdfBase, other._stdfBase)) {
             return false;
-        return true;
+        }
+        return Arrays.equals(_upxs, other._upxs);
     }
 
     @Override

src/scratchpad/src/org/apache/poi/hwpf/model/StyleSheet.java

          */
 
         _stshif = new Stshif(tableStream, offset);
-        offset += Stshif.getSize();
 
         // shall we discard cbLSD and mpstilsd?
 
         out.write(buf);
 
         byte[] sizeHolder = new byte[2];
-        for (int x = 0; x < _styleDescriptions.length; x++) {
-            if (_styleDescriptions[x] != null) {
-                byte[] std = _styleDescriptions[x].toByteArray();
+        for (StyleDescription styleDescription : _styleDescriptions) {
+            if (styleDescription != null) {
+                byte[] std = styleDescription.toByteArray();
 
                 // adjust the size so it is always on a word boundary
                 LittleEndian.putShort(sizeHolder, 0, (short) ((std.length) + (std.length % 2)));
             StyleDescription tsd = this._styleDescriptions[i];
             StyleDescription osd = ss._styleDescriptions[i];
             if (tsd == null && osd == null) continue;
-            if (tsd == null || osd == null || !osd.equals(tsd)) return false;
+            if (osd == null || !osd.equals(tsd)) return false;
         }
 
         return true;

src/scratchpad/src/org/apache/poi/hwpf/sprm/ParagraphSprmUncompressor.java

 import java.util.Map;
 
 import org.apache.poi.hwpf.model.TabDescriptor;
+import org.apache.poi.hwpf.model.types.TBDAbstractType;
 import org.apache.poi.hwpf.usermodel.BorderCode;
 import org.apache.poi.hwpf.usermodel.DateAndTime;
 import org.apache.poi.hwpf.usermodel.DropCapSpecifier;
         newPAP.setFNoLnn (sprm.getOperand() != 0);
         break;
       case 0xd:
-        /**handle tabs . variable parameter. seperate processing needed*/
+        // handle tabs . variable parameter. seperate processing needed
         handleTabs(newPAP, sprm);
         break;
       case 0xe:
         break;
       case 0x1b:
         byte param = (byte)sprm.getOperand();
-        /** @todo handle paragraph postioning*/
+        // TODO: handle paragraph postioning
         byte pcVert = (byte) ((param & 0x0c) >> 2);
         byte pcHorz = (byte) (param & 0x03);
         if (pcVert != 3)
     Map<Integer, TabDescriptor> tabMap = new HashMap<>();
     for (int x = 0; x < tabPositions.length; x++)
     {
-      tabMap.put(Integer.valueOf(tabPositions[x]), tabDescriptors[x]);
+      tabMap.put(tabPositions[x], tabDescriptors[x]);
     }
 
     for (int x = 0; x < delSize; x++)
     {
-      tabMap.remove(Integer.valueOf(LittleEndian.getShort(grpprl, offset)));
+      tabMap.remove((int) LittleEndian.getShort(grpprl, offset));
       offset += LittleEndianConsts.SHORT_SIZE;
     }
 
     int start = offset;
     for (int x = 0; x < addSize; x++)
     {
-      Integer key = Integer.valueOf(LittleEndian.getShort(grpprl, offset));
-      TabDescriptor val = new TabDescriptor( grpprl, start + ((TabDescriptor.getSize() * addSize) + x) );
+      Integer key = (int) LittleEndian.getShort(grpprl, offset);
+      TabDescriptor val = new TabDescriptor( grpprl, start + ((TBDAbstractType.getSize() * addSize) + x) );
       tabMap.put(key, val);
       offset += LittleEndianConsts.SHORT_SIZE;
     }
     for (int x = 0; x < tabPositions.length; x++)
     {
       Integer key = list.get(x);
-      tabPositions[x] = key.intValue();
+      tabPositions[x] = key;
       if (tabMap.containsKey( key ))
           tabDescriptors[x] = tabMap.get(key);
       else