1    
2    /* ====================================================================
3     * The Apache Software License, Version 1.1
4     *
5     * Copyright (c) 2002 The Apache Software Foundation.  All rights
6     * reserved.
7     *
8     * Redistribution and use in source and binary forms, with or without
9     * modification, are permitted provided that the following conditions
10    * are met:
11    *
12    * 1. Redistributions of source code must retain the above copyright
13    *    notice, this list of conditions and the following disclaimer.
14    *
15    * 2. Redistributions in binary form must reproduce the above copyright
16    *    notice, this list of conditions and the following disclaimer in
17    *    the documentation and/or other materials provided with the
18    *    distribution.
19    *
20    * 3. The end-user documentation included with the redistribution,
21    *    if any, must include the following acknowledgment:
22    *       "This product includes software developed by the
23    *        Apache Software Foundation (http://www.apache.org/)."
24    *    Alternately, this acknowledgment may appear in the software itself,
25    *    if and wherever such third-party acknowledgments normally appear.
26    *
27    * 4. The names "Apache" and "Apache Software Foundation" and
28    *    "Apache POI" must not be used to endorse or promote products
29    *    derived from this software without prior written permission. For
30    *    written permission, please contact apache@apache.org.
31    *
32    * 5. Products derived from this software may not be called "Apache",
33    *    "Apache POI", nor may "Apache" appear in their name, without
34    *    prior written permission of the Apache Software Foundation.
35    *
36    * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
37    * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
38    * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
39    * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
40    * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41    * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
42    * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
43    * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
44    * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
45    * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
46    * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
47    * SUCH DAMAGE.
48    * ====================================================================
49    *
50    * This software consists of voluntary contributions made by many
51    * individuals on behalf of the Apache Software Foundation.  For more
52    * information on the Apache Software Foundation, please see
53    * <http://www.apache.org/>.
54    */
55   
56   package org.apache.poi.poifs.storage;
57   
58   import org.apache.poi.poifs.filesystem.BATManaged;
59   import org.apache.poi.poifs.filesystem.POIFSDocument;
60   import org.apache.poi.poifs.property.RootProperty;
61   
62   import java.util.*;
63   
64   import java.io.*;
65   
66   /**
67    * This class implements storage for writing the small blocks used by
68    * small documents.
69    *
70    * @author Marc Johnson (mjohnson at apache dot org)
71    */
72   
73   public class SmallBlockTableWriter
74       implements BlockWritable, BATManaged
75   {
76       private BlockAllocationTableWriter _sbat;
77       private List                       _small_blocks;
78       private int                        _big_block_count;
79       private RootProperty               _root;
80   
81       /**
82        * Creates new SmallBlockTable
83        *
84        * @param documents a List of POIFSDocument instances
85        * @param root the Filesystem's root property
86        */
87   
88       public SmallBlockTableWriter(final List documents,
89                                    final RootProperty root)
90       {
91           _sbat         = new BlockAllocationTableWriter();
92           _small_blocks = new ArrayList();
93           _root         = root;
94           Iterator iter = documents.iterator();
95   
96           while (iter.hasNext())
97           {
98               POIFSDocument   doc    = ( POIFSDocument ) iter.next();
99               BlockWritable[] blocks = doc.getSmallBlocks();
100  
101              if (blocks.length != 0)
102              {
103                  doc.setStartBlock(_sbat.allocateSpace(blocks.length));
104                  for (int j = 0; j < blocks.length; j++)
105                  {
106                      _small_blocks.add(blocks[ j ]);
107                  }
108              }
109          }
110          _sbat.simpleCreateBlocks();
111          _root.setSize(_small_blocks.size());
112          _big_block_count = SmallDocumentBlock.fill(_small_blocks);
113      }
114  
115      /**
116       * Get the number of SBAT blocks
117       *
118       * @return number of SBAT big blocks
119       */
120      
121      public int getSBATBlockCount()
122      {
123  	return (_big_block_count + 15) / 16;
124      }
125  
126      /**
127       * Get the SBAT
128       *
129       * @return the Small Block Allocation Table
130       */
131  
132      public BlockAllocationTableWriter getSBAT()
133      {
134          return _sbat;
135      }
136  
137      /* ********** START implementation of BATManaged ********** */
138  
139      /**
140       * Return the number of BigBlock's this instance uses
141       *
142       * @return count of BigBlock instances
143       */
144  
145      public int countBlocks()
146      {
147          return _big_block_count;
148      }
149  
150      /**
151       * Set the start block for this instance
152       *
153       * @param index index into the array of BigBlock instances making
154       *              up the the filesystem
155       *
156       * @param start_block
157       */
158  
159      public void setStartBlock(int start_block)
160      {
161          _root.setStartBlock(start_block);
162      }
163  
164      /* **********  END  implementation of BATManaged ********** */
165      /* ********** START implementation of BlockWritable ********** */
166  
167      /**
168       * Write the storage to an OutputStream
169       *
170       * @param stream the OutputStream to which the stored data should
171       *               be written
172       *
173       * @exception IOException on problems writing to the specified
174       *            stream
175       */
176  
177      public void writeBlocks(final OutputStream stream)
178          throws IOException
179      {
180          Iterator iter = _small_blocks.iterator();
181  
182          while (iter.hasNext())
183          {
184              (( BlockWritable ) iter.next()).writeBlocks(stream);
185          }
186      }
187  
188      /* **********  END  implementation of BlockWritable ********** */
189  }
190