public CompoundFile(byte[] d,
    WorkbookSettings ws) throws BiffException 
{
                         
    super();
    data = d;
    settings = ws;
    // First verify the OLE identifier
    for (int i = 0; i <  IDENTIFIER.length; i++)
    {
      if (data[i] != IDENTIFIER[i])
      {
        throw new BiffException(BiffException.unrecognizedOLEFile);
      }
    }
    propertySets = new ArrayList();
    numBigBlockDepotBlocks = IntegerHelper.getInt
      (data[NUM_BIG_BLOCK_DEPOT_BLOCKS_POS],
       data[NUM_BIG_BLOCK_DEPOT_BLOCKS_POS + 1],
       data[NUM_BIG_BLOCK_DEPOT_BLOCKS_POS + 2],
       data[NUM_BIG_BLOCK_DEPOT_BLOCKS_POS + 3]);
    sbdStartBlock = IntegerHelper.getInt
      (data[SMALL_BLOCK_DEPOT_BLOCK_POS],
       data[SMALL_BLOCK_DEPOT_BLOCK_POS + 1],
       data[SMALL_BLOCK_DEPOT_BLOCK_POS + 2],
       data[SMALL_BLOCK_DEPOT_BLOCK_POS + 3]);
    rootStartBlock = IntegerHelper.getInt
      (data[ROOT_START_BLOCK_POS],
       data[ROOT_START_BLOCK_POS + 1],
       data[ROOT_START_BLOCK_POS + 2],
       data[ROOT_START_BLOCK_POS + 3]);
    extensionBlock = IntegerHelper.getInt
      (data[EXTENSION_BLOCK_POS],
       data[EXTENSION_BLOCK_POS + 1],
       data[EXTENSION_BLOCK_POS + 2],
       data[EXTENSION_BLOCK_POS + 3]);
    numExtensionBlocks = IntegerHelper.getInt
      (data[NUM_EXTENSION_BLOCK_POS],
       data[NUM_EXTENSION_BLOCK_POS + 1],
       data[NUM_EXTENSION_BLOCK_POS + 2],
       data[NUM_EXTENSION_BLOCK_POS + 3]);
    bigBlockDepotBlocks = new int[numBigBlockDepotBlocks];
    int pos = BIG_BLOCK_DEPOT_BLOCKS_POS;
    int bbdBlocks = numBigBlockDepotBlocks;
    if (numExtensionBlocks != 0)
    {
      bbdBlocks = (BIG_BLOCK_SIZE - BIG_BLOCK_DEPOT_BLOCKS_POS) / 4;
    }
    for (int i = 0; i <  bbdBlocks; i++)
    {
      bigBlockDepotBlocks[i] = IntegerHelper.getInt
        (d[pos], d[pos + 1], d[pos + 2], d[pos + 3]);
      pos += 4;
    }
    for (int j = 0; j <  numExtensionBlocks; j++)
    {
      pos = (extensionBlock + 1) * BIG_BLOCK_SIZE;
      int blocksToRead = Math.min(numBigBlockDepotBlocks - bbdBlocks,
                                  BIG_BLOCK_SIZE / 4 - 1);
      for (int i = bbdBlocks; i <  bbdBlocks + blocksToRead; i++)
      {
        bigBlockDepotBlocks[i] = IntegerHelper.getInt
          (d[pos], d[pos + 1], d[pos + 2], d[pos + 3]);
        pos += 4;
      }
      bbdBlocks += blocksToRead;
      if (bbdBlocks <  numBigBlockDepotBlocks)
      {
        extensionBlock = IntegerHelper.getInt
          (d[pos], d[pos + 1], d[pos + 2], d[pos + 3]);
      }
    }
    readBigBlockDepot();
    readSmallBlockDepot();
    rootEntry = readData(rootStartBlock);
    readPropertySets();
}

Initializes the compound file

Parameters:

d - the raw data of the ole stream

ws - the workbook settings

Throws:

BiffException -

exception: BiffException -

 public PropertyStorage findPropertyStorage(String name) 
{
    return findPropertyStorage(name, rootEntryPropertyStorage);
}

Recursively searches the property storages in hierarchy order for the appropriate name. This is the public version which is invoked from the writable version when copying a sheet with addition property sets.

 public int getNumberOfPropertySets() 
{
    return propertySets.size();
}

Gets the number of property sets

 public PropertyStorage getPropertySet(int index) 
{
    return getPropertyStorage(index);
}

Gets the property set. Invoked when copying worksheets with macros. Simply calls the private counterpart

 public byte[] getStream(String streamName) throws BiffException 
{
    PropertyStorage ps = findPropertyStorage(streamName, 
                                             rootEntryPropertyStorage);
    // Property set can't be found from the direct hierarchy, so just
    // search on the name
    if (ps == null)
    {
      ps = getPropertyStorage(streamName);
    }
    if (ps.size  >= SMALL_BLOCK_THRESHOLD ||
        streamName.equalsIgnoreCase(ROOT_ENTRY_NAME))
    {
      return getBigBlockStream(ps);
    }
    else
    {
      return getSmallBlockStream(ps);
    }
}

Gets the defragmented stream from this ole compound file

 public byte[] getStream(int psIndex) throws BiffException 
{
    PropertyStorage ps = getPropertyStorage(psIndex);
    if (ps.size  >= SMALL_BLOCK_THRESHOLD ||
        ps.name.equalsIgnoreCase(ROOT_ENTRY_NAME))
    {
      return getBigBlockStream(ps);
    }
    else
    {
      return getSmallBlockStream(ps);
    }
}

Gets the defragmented stream from this ole compound file. Used when copying workbooks with macros