/* ==================================================================== 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. ==================================================================== */ using HH.WMS.Utils.NPOI.POIFS.Common; using HH.WMS.Utils.NPOI.POIFS.Storage; using HH.WMS.Utils.NPOI.POIFS.Properties; using HH.WMS.Utils.NPOI.POIFS.NIO; using System.Collections.Generic; using System; using HH.WMS.Utils.NPOI.Util; namespace HH.WMS.Utils.NPOI.POIFS.FileSystem { /** * This class handles the MiniStream (small block store) * in the NIO case for {@link NPOIFSFileSystem} */ public class NPOIFSMiniStore : BlockStore { private NPOIFSFileSystem _filesystem; private NPOIFSStream _mini_stream; private List _sbat_blocks; private HeaderBlock _header; private RootProperty _root; public NPOIFSMiniStore(NPOIFSFileSystem filesystem, RootProperty root, List sbats, HeaderBlock header) { this._filesystem = filesystem; this._sbat_blocks = sbats; this._header = header; this._root = root; this._mini_stream = new NPOIFSStream(filesystem, root.StartBlock); } /** * Load the block at the given offset. */ public override ByteBuffer GetBlockAt(int offset) { // Which big block is this? int byteOffset = offset * POIFSConstants.SMALL_BLOCK_SIZE; int bigBlockNumber = byteOffset / _filesystem.GetBigBlockSize(); int bigBlockOffset = byteOffset % _filesystem.GetBigBlockSize(); // Now locate the data block for it StreamBlockByteBufferIterator it = _mini_stream.GetBlockIterator() as StreamBlockByteBufferIterator; for (int i = 0; i < bigBlockNumber; i++) { it.Next(); } ByteBuffer dataBlock = it.Next(); if (dataBlock == null) { throw new IndexOutOfRangeException("Big block " + bigBlockNumber + " outside stream"); } // Position ourselves, and take a slice dataBlock.Position = dataBlock.Position + bigBlockOffset; ByteBuffer miniBuffer = dataBlock.Slice(); miniBuffer.Limit = POIFSConstants.SMALL_BLOCK_SIZE; return miniBuffer; } /** * Load the block, extending the underlying stream if needed */ public override ByteBuffer CreateBlockIfNeeded(int offset) { // Try to Get it without extending the stream try { return GetBlockAt(offset); } catch (IndexOutOfRangeException) { // Need to extend the stream // TODO Replace this with proper append support // For now, do the extending by hand... // Ask for another block int newBigBlock = _filesystem.GetFreeBlock(); _filesystem.CreateBlockIfNeeded(newBigBlock); // Tack it onto the end of our chain ChainLoopDetector loopDetector = _filesystem.GetChainLoopDetector(); int block = _mini_stream.GetStartBlock(); while (true) { loopDetector.Claim(block); int next = _filesystem.GetNextBlock(block); if (next == POIFSConstants.END_OF_CHAIN) { break; } block = next; } _filesystem.SetNextBlock(block, newBigBlock); _filesystem.SetNextBlock(newBigBlock, POIFSConstants.END_OF_CHAIN); // Now try again to Get it return CreateBlockIfNeeded(offset); } } /** * Returns the BATBlock that handles the specified offset, * and the relative index within it */ public override BATBlockAndIndex GetBATBlockAndIndex(int offset) { return BATBlock.GetSBATBlockAndIndex( offset, _header, _sbat_blocks); } /** * Works out what block follows the specified one. */ public override int GetNextBlock(int offset) { BATBlockAndIndex bai = GetBATBlockAndIndex(offset); return bai.Block.GetValueAt(bai.Index); } /** * Changes the record of what block follows the specified one. */ public override void SetNextBlock(int offset, int nextBlock) { BATBlockAndIndex bai = GetBATBlockAndIndex(offset); bai.Block.SetValueAt(bai.Index, nextBlock); } /** * Finds a free block, and returns its offset. * This method will extend the file if needed, and if doing * so, allocate new FAT blocks to Address the extra space. */ public override int GetFreeBlock() { int sectorsPerSBAT = _filesystem.GetBigBlockSizeDetails().GetBATEntriesPerBlock(); // First up, do we have any spare ones? int offset = 0; for (int i = 0; i < _sbat_blocks.Count; i++) { // Check this one BATBlock sbat = _sbat_blocks[i]; if (sbat.HasFreeSectors) { // Claim one of them and return it for (int j = 0; j < sectorsPerSBAT; j++) { int sbatValue = sbat.GetValueAt(j); if (sbatValue == POIFSConstants.UNUSED_BLOCK) { // Bingo return offset + j; } } } // Move onto the next SBAT offset += sectorsPerSBAT; } // If we Get here, then there aren't any // free sectors in any of the SBATs // So, we need to extend the chain and add another // Create a new BATBlock BATBlock newSBAT = BATBlock.CreateEmptyBATBlock(_filesystem.GetBigBlockSizeDetails(), false); int batForSBAT = _filesystem.GetFreeBlock(); newSBAT.OurBlockIndex = batForSBAT; // Are we the first SBAT? if (_header.SBATCount == 0) { _header.SBATStart = batForSBAT; _header.SBATBlockCount = 1; } else { // Find the end of the SBAT stream, and add the sbat in there ChainLoopDetector loopDetector = _filesystem.GetChainLoopDetector(); int batOffset = _header.SBATStart; while (true) { loopDetector.Claim(batOffset); int nextBat = _filesystem.GetNextBlock(batOffset); if (nextBat == POIFSConstants.END_OF_CHAIN) { break; } batOffset = nextBat; } // Add it in at the end _filesystem.SetNextBlock(batOffset, batForSBAT); // And update the count _header.SBATBlockCount = _header.SBATCount + 1; } // Finish allocating _filesystem.SetNextBlock(batForSBAT, POIFSConstants.END_OF_CHAIN); _sbat_blocks.Add(newSBAT); // Return our first spot return offset; } public override ChainLoopDetector GetChainLoopDetector() { return new ChainLoopDetector(_root.Size, this); } public override int GetBlockStoreBlockSize() { return POIFSConstants.SMALL_BLOCK_SIZE; } /** * Writes the SBATs to their backing blocks */ public void SyncWithDataSource() { foreach (BATBlock sbat in _sbat_blocks) { ByteBuffer block = _filesystem.GetBlockAt(sbat.OurBlockIndex); BlockAllocationTableWriter.WriteBlock(sbat, block); } } } }