More PropertyTable refactoring - pull common code out into a Base, so we can plug in a different block reader/writer for NIO

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

src/java/org/apache/poi/poifs/filesystem/NPOIFSFileSystem.java

@@ -102,9 +102,10 @@ public class NPOIFSFileSystem
      */
     public NPOIFSFileSystem()
     {
-        _property_table = new PropertyTable(bigBlockSize);
+        _header         = new HeaderBlock(bigBlockSize);
-        _blocks = new ArrayList<BATBlock>();
+        _property_table = new PropertyTable(_header);// TODO Needs correct type
-        _root   = null;
+        _blocks         = new ArrayList<BATBlock>();
+        _root           = null;
     }
 
     /**

src/java/org/apache/poi/poifs/filesystem/POIFSFileSystem.java

@@ -90,7 +90,8 @@ public class POIFSFileSystem
      */
     public POIFSFileSystem()
     {
-        _property_table = new PropertyTable(bigBlockSize);
+        HeaderBlock header_block = new HeaderBlock(bigBlockSize);
+        _property_table = new PropertyTable(header_block);
         _documents      = new ArrayList();
         _root           = null;
     }

src/java/org/apache/poi/poifs/property/PropertyTable.java

@@ -19,13 +19,8 @@ package org.apache.poi.poifs.property;
 
 import java.io.IOException;
 import java.io.OutputStream;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Stack;
 
 import org.apache.poi.poifs.common.POIFSBigBlockSize;
-import org.apache.poi.poifs.common.POIFSConstants;
-import org.apache.poi.poifs.filesystem.BATManaged;
 import org.apache.poi.poifs.storage.BlockWritable;
 import org.apache.poi.poifs.storage.HeaderBlock;
 import org.apache.poi.poifs.storage.PropertyBlock;
@@ -38,18 +33,14 @@ import org.apache.poi.poifs.storage.RawDataBlockList;
  *
  * @author Marc Johnson (mjohnson at apache dot org)
  */
-public final class PropertyTable implements BATManaged, BlockWritable {
+public final class PropertyTable extends PropertyTableBase implements BlockWritable {
     private POIFSBigBlockSize _bigBigBlockSize;
-    private int               _start_block;
-    private List<Property>    _properties;
     private BlockWritable[]   _blocks;
 
-    public PropertyTable(POIFSBigBlockSize bigBlockSize)
+    public PropertyTable(HeaderBlock headerBlock)
     {
-        _bigBigBlockSize = bigBlockSize;
+        super(headerBlock);
-        _start_block = POIFSConstants.END_OF_CHAIN;
+        _bigBigBlockSize = headerBlock.getBigBlockSize();
-        _properties  = new ArrayList<Property>();
-        addProperty(new RootProperty());
         _blocks = null;
     }
 
@@ -68,45 +59,14 @@ public final class PropertyTable implements BATManaged, BlockWritable {
                          final RawDataBlockList blockList)
         throws IOException
     {
-        _bigBigBlockSize = headerBlock.getBigBlockSize();
+        super(
-        _start_block = POIFSConstants.END_OF_CHAIN;
+              headerBlock,
-        _blocks      = null;
+              PropertyFactory.convertToProperties(
-        _properties  = PropertyFactory.convertToProperties(
+                    blockList.fetchBlocks(headerBlock.getPropertyStart(), -1)
-              blockList.fetchBlocks(headerBlock.getPropertyStart(), -1)
+              )
         );
-        populatePropertyTree(( DirectoryProperty ) _properties.get(0));
+        _bigBigBlockSize = headerBlock.getBigBlockSize();
-    }
+        _blocks      = null;
-
-    /**
-     * Add a property to the list of properties we manage
-     *
-     * @param property the new Property to manage
-     */
-    public void addProperty(Property property)
-    {
-        _properties.add(property);
-    }
-
-    /**
-     * Remove a property from the list of properties we manage
-     *
-     * @param property the Property to be removed
-     */
-    public void removeProperty(final Property property)
-    {
-        _properties.remove(property);
-    }
-
-    /**
-     * Get the root property
-     *
-     * @return the root property
-     */
-    public RootProperty getRoot()
-    {
-
-        // it's always the first element in the List
-        return ( RootProperty ) _properties.get(0);
     }
 
     /**
@@ -131,53 +91,7 @@ public final class PropertyTable implements BATManaged, BlockWritable {
             properties[ k ].preWrite();
         }
     }
-
+    
-    /**
-     * Get the start block for the property table
-     *
-     * @return start block index
-     */
-    public int getStartBlock()
-    {
-        return _start_block;
-    }
-
-    private void populatePropertyTree(DirectoryProperty root)
-        throws IOException
-    {
-        int index = root.getChildIndex();
-
-        if (!Property.isValidIndex(index))
-        {
-
-            // property has no children
-            return;
-        }
-        Stack<Property> children = new Stack<Property>();
-
-        children.push(_properties.get(index));
-        while (!children.empty())
-        {
-            Property property = children.pop();
-
-            root.addChild(property);
-            if (property.isDirectory())
-            {
-                populatePropertyTree(( DirectoryProperty ) property);
-            }
-            index = property.getPreviousChildIndex();
-            if (Property.isValidIndex(index))
-            {
-                children.push(_properties.get(index));
-            }
-            index = property.getNextChildIndex();
-            if (Property.isValidIndex(index))
-            {
-                children.push(_properties.get(index));
-            }
-        }
-    }
-
     /**
      * Return the number of BigBlock's this instance uses
      *
@@ -189,17 +103,6 @@ public final class PropertyTable implements BATManaged, BlockWritable {
                                  : _blocks.length;
     }
 
-    /**
-     * Set the start block for this instance
-     *
-     * @param index index into the array of BigBlock instances making
-     *              up the the filesystem
-     */
-    public void setStartBlock(final int index)
-    {
-        _start_block = index;
-    }
-
     /**
      * Write the storage to an OutputStream
      *

src/java/org/apache/poi/poifs/property/PropertyTableBase.java

@@ -0,0 +1,153 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.poifs.property;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+import org.apache.poi.poifs.filesystem.BATManaged;
+import org.apache.poi.poifs.storage.HeaderBlock;
+
+/**
+ * This class embodies the Property Table for the filesystem,
+ *  which looks up entries in the filesystem to their
+ *  chain of blocks.
+ * This is the core support, there are implementations
+ *  for the different block schemes as needed.
+ */
+public abstract class PropertyTableBase implements BATManaged {
+    private   final HeaderBlock    _header_block;
+    protected final List<Property> _properties;
+
+    public PropertyTableBase(final HeaderBlock header_block)
+    {
+        _header_block = header_block;
+        _properties  = new ArrayList<Property>();
+        addProperty(new RootProperty());
+    }
+
+    /**
+     * Reading constructor (used when we've read in a file and we want
+     * to extract the property table from it). Populates the
+     * properties thoroughly
+     *
+     * @param startBlock the first block of the property table
+     * @param blockList the list of blocks
+     *
+     * @exception IOException if anything goes wrong (which should be
+     *            a result of the input being NFG)
+     */
+    public PropertyTableBase(final HeaderBlock header_block,
+                         final List<Property> properties)
+        throws IOException
+    {
+        _header_block = header_block;
+        _properties   = properties;
+        populatePropertyTree( (DirectoryProperty)_properties.get(0));
+    }
+
+    /**
+     * Add a property to the list of properties we manage
+     *
+     * @param property the new Property to manage
+     */
+    public void addProperty(Property property)
+    {
+        _properties.add(property);
+    }
+
+    /**
+     * Remove a property from the list of properties we manage
+     *
+     * @param property the Property to be removed
+     */
+    public void removeProperty(final Property property)
+    {
+        _properties.remove(property);
+    }
+
+    /**
+     * Get the root property
+     *
+     * @return the root property
+     */
+    public RootProperty getRoot()
+    {
+        // it's always the first element in the List
+        return ( RootProperty ) _properties.get(0);
+    }
+    
+    private void populatePropertyTree(DirectoryProperty root)
+        throws IOException
+    {
+        int index = root.getChildIndex();
+
+        if (!Property.isValidIndex(index))
+        {
+
+            // property has no children
+            return;
+        }
+        Stack<Property> children = new Stack<Property>();
+
+        children.push(_properties.get(index));
+        while (!children.empty())
+        {
+            Property property = children.pop();
+
+            root.addChild(property);
+            if (property.isDirectory())
+            {
+                populatePropertyTree(( DirectoryProperty ) property);
+            }
+            index = property.getPreviousChildIndex();
+            if (Property.isValidIndex(index))
+            {
+                children.push(_properties.get(index));
+            }
+            index = property.getNextChildIndex();
+            if (Property.isValidIndex(index))
+            {
+                children.push(_properties.get(index));
+            }
+        }
+    }
+
+    /**
+     * Get the start block for the property table
+     *
+     * @return start block index
+     */
+    public int getStartBlock()
+    {
+        return _header_block.getPropertyStart();
+    }
+
+    /**
+     * Set the start block for this instance
+     *
+     * @param index index into the array of BigBlock instances making
+     *              up the the filesystem
+     */
+    public void setStartBlock(final int index)
+    {
+        _header_block.setPropertyStart(index);
+    }
+}

src/testcases/org/apache/poi/poifs/property/TestPropertyTable.java

@@ -71,7 +71,8 @@ public final class TestPropertyTable extends TestCase {
 	public void testWriterPropertyTable() throws IOException {
 
 		// create the PropertyTable
-		PropertyTable table = new PropertyTable(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+	   HeaderBlock   headerBlock = new HeaderBlock(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+		PropertyTable table = new PropertyTable(headerBlock);
 
 		// create three DocumentProperty instances and add them to the
 		// PropertyTable

src/testcases/org/apache/poi/poifs/storage/TestSmallBlockTableWriter.java

@@ -75,7 +75,9 @@ public final class TestSmallBlockTableWriter extends TestCase {
         documents
             .add(new POIFSDocument("doc9",
                                    new ByteArrayInputStream(new byte[ 9 ])));
-        RootProperty               root = new PropertyTable(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS).getRoot();
+        
+        HeaderBlock              header = new HeaderBlock(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
+        RootProperty               root = new PropertyTable(header).getRoot();
         SmallBlockTableWriter      sbtw = new SmallBlockTableWriter(
               POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, documents,root);
         BlockAllocationTableWriter bat  = sbtw.getSBAT();