private static DocumentBlock[] ConvertRawBlocksToBigBlocks(ListManagedBlock[] blocks)
 {
     DocumentBlock[] result = new DocumentBlock[blocks.Length];
     for (int i = 0; i < result.Length; i++)
         result[i] = new DocumentBlock((RawDataBlock)blocks[i]);
     return result;
 }
Exemple #2
0
 /// <summary>
 /// Initializes a new instance of the <see cref="POIFSDocument"/> class.
 /// </summary>
 /// <param name="name">the name of the POIFSDocument</param>
 /// <param name="stream">the InputStream we read data from</param>
 public POIFSDocument(string name, Stream stream)
 {
     DocumentBlock block;
     IList list = new ArrayList();
     this._size = 0;
     do
     {
         block = new DocumentBlock(stream);
         int size = block.Size;
         if (size > 0)
         {
             list.Add(block);
             this._size += size;
         }
     }
     while (!block.PartiallyRead);
     DocumentBlock[] blocks = (DocumentBlock[])((ArrayList)list).ToArray(typeof(DocumentBlock));
     this._big_store = new BigBlockStore(this, blocks);
     this._property = new DocumentProperty(name, this._size);
     this._property.Document = this;
     if (this._property.ShouldUseSmallBlocks)
     {
         this._small_store = new SmallBlockStore(this, SmallDocumentBlock.Convert(blocks, this._size));
         this._big_store = new BigBlockStore(this, new DocumentBlock[0]);
     }
     else
     {
         this._small_store = new SmallBlockStore(this, new BlockWritable[0]);
     }
 }
        public void TestConvert1()
        {
            MemoryStream stream = new MemoryStream(testData);
            ArrayList documents = new ArrayList();

            while (true)
            {
                DocumentBlock block = new DocumentBlock(stream, POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);

                documents.Add(block);
                if (block.PartiallyRead)
                {
                    break;
                }
            }
            SmallDocumentBlock[] results =
                SmallDocumentBlock.Convert(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, (BlockWritable[])documents.ToArray(typeof(DocumentBlock)), testDataSize);

            Assert.AreEqual((testDataSize + 63) / 64, results.Length, "checking correct result size: ");
            MemoryStream output = new MemoryStream();

            for (int j = 0; j < results.Length; j++)
            {
                results[j].WriteBlocks(output);
            }
            byte[] output_array = output.ToArray();

            Assert.AreEqual(64 * results.Length,
                         output_array.Length, "checking correct output size: ");
            int index = 0;

            for (; index < testDataSize; index++)
            {
                Assert.AreEqual(testData[index],
                             output_array[index], "checking output " + index);
            }
            for (; index < output_array.Length; index++)
            {
                Assert.AreEqual((byte)0xff,
                             output_array[index], "checking output " + index);
            }
        }
Exemple #4
0
        public void TestConstructor()
        {
            MemoryStream input = new MemoryStream(_testdata);
            int index = 0;
            int size = 0;

            while (true)
            {
                byte[] data = new byte[Math.Min(_testdata.Length - index, 512)];

                Array.Copy(_testdata, index, data, 0, data.Length);
                DocumentBlock block = new DocumentBlock(input, POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);

                verifyOutput(block, data);
                size += block.Size;
                if (block.PartiallyRead)
                {
                    break;
                }
                index += 512;
            }
            Assert.AreEqual(_testdata.Length, size);
        }
Exemple #5
0
        /// <summary>
        /// convert a single long array into an array of DocumentBlock
        /// instances
        /// </summary>
        /// <param name="bigBlockSize">the poifs bigBlockSize</param>
        /// <param name="array">the byte array to be converted</param>
        /// <param name="size">the intended size of the array (which may be smaller)</param>
        /// <returns>an array of DocumentBlock instances, filled from the
        /// input array</returns>
        public static DocumentBlock[] Convert(POIFSBigBlockSize bigBlockSize,
                                              byte[] array,
                                              int size)
        {
            DocumentBlock[] rval =
                new DocumentBlock[(size + POIFSConstants.BIG_BLOCK_SIZE - 1) / POIFSConstants.BIG_BLOCK_SIZE];
            int offset = 0;

            for (int k = 0; k < rval.Length; k++)
            {
                rval[k] = new DocumentBlock(bigBlockSize);
                if (offset < array.Length)
                {
                    int length = Math.Min(POIFSConstants.BIG_BLOCK_SIZE,
                                          array.Length - offset);

                    Array.Copy(array, offset, rval[k]._data, 0, length);
                    if (length != POIFSConstants.BIG_BLOCK_SIZE)
                    {
                        for (int j = (length > 0) ? (length - 1) : length; j < POIFSConstants.BIG_BLOCK_SIZE; j++)
                        {
                            rval[k]._data[j] = _default_value;
                        }
                    }
                }
                else
                {
                    for (int j = 0; j < rval[k]._data.Length; j++)
                    {
                        rval[k]._data[j] = _default_value;
                    }
                }
                offset += POIFSConstants.BIG_BLOCK_SIZE;
            }
            return(rval);
        }
Exemple #6
0
        public static DataInputBlock GetDataInputBlock(DocumentBlock[] blocks, int offset)
        {
            if (blocks == null || blocks.Length == 0)
                return null;

            POIFSBigBlockSize bigBlockSize = blocks[0].bigBlockSize;
            int BLOCK_SHIFT = bigBlockSize.GetHeaderValue();
            int BLOCK_SIZE = bigBlockSize.GetBigBlockSize();
            int BLOCK_MASK = BLOCK_SIZE - 1;

            int firstBlockIndex = offset >> BLOCK_SHIFT;
            int firstBlockOffset = offset & BLOCK_MASK;
            return new DataInputBlock(blocks[firstBlockIndex]._data, firstBlockOffset);
        }
Exemple #7
0
        /// <summary>
        /// Read data from an array of DocumentBlocks
        /// </summary>
        /// <param name="blocks">the blocks to Read from</param>
        /// <param name="buffer">the buffer to Write the data into</param>
        /// <param name="offset">the offset into the array of blocks to Read from</param>
        public static void Read(DocumentBlock[] blocks,
                                byte[] buffer, int offset)
        {
            int firstBlockIndex = offset / POIFSConstants.BIG_BLOCK_SIZE;
            int firstBlockOffSet = offset % POIFSConstants.BIG_BLOCK_SIZE;
            int lastBlockIndex = (offset + buffer.Length - 1)
                                   / POIFSConstants.BIG_BLOCK_SIZE;

            if (firstBlockIndex == lastBlockIndex)
            {
                Array.Copy(blocks[firstBlockIndex]._data,
                                 firstBlockOffSet, buffer, 0, buffer.Length);
            }
            else
            {
                int buffer_offset = 0;

                Array.Copy(blocks[firstBlockIndex]._data,
                                 firstBlockOffSet, buffer, buffer_offset,
                                 POIFSConstants.BIG_BLOCK_SIZE
                                 - firstBlockOffSet);
                buffer_offset += POIFSConstants.BIG_BLOCK_SIZE - firstBlockOffSet;
                for (int j = firstBlockIndex + 1; j < lastBlockIndex; j++)
                {
                    Array.Copy(blocks[j]._data, 0, buffer, buffer_offset,
                                     POIFSConstants.BIG_BLOCK_SIZE);
                    buffer_offset += POIFSConstants.BIG_BLOCK_SIZE;
                }
                Array.Copy(blocks[lastBlockIndex]._data, 0, buffer,
                                 buffer_offset, buffer.Length - buffer_offset);
            }
        }
Exemple #8
0
        /// <summary>
        /// convert a single long array into an array of DocumentBlock
        /// instances
        /// </summary>
        /// <param name="bigBlockSize">the poifs bigBlockSize</param>
        /// <param name="array">the byte array to be converted</param>
        /// <param name="size">the intended size of the array (which may be smaller)</param>
        /// <returns>an array of DocumentBlock instances, filled from the
        /// input array</returns>
        public static DocumentBlock[] Convert(POIFSBigBlockSize bigBlockSize,
                                                byte[] array,
                                               int size)
        {
            DocumentBlock[] rval =
                new DocumentBlock[(size + POIFSConstants.BIG_BLOCK_SIZE - 1) / POIFSConstants.BIG_BLOCK_SIZE];
            int offset = 0;

            for (int k = 0; k < rval.Length; k++)
            {
                rval[k] = new DocumentBlock(bigBlockSize);
                if (offset < array.Length)
                {
                    int length = Math.Min(POIFSConstants.BIG_BLOCK_SIZE,
                                          array.Length - offset);

                    Array.Copy(array, offset, rval[k]._data, 0, length);
                    if (length != POIFSConstants.BIG_BLOCK_SIZE)
                    {
                        for (int j = (length > 0) ? (length - 1) : length; j < POIFSConstants.BIG_BLOCK_SIZE; j++)
                        {
                            rval[k]._data[j] = _default_value;
                        }
                    }
                }
                else
                {
                    for (int j = 0; j < rval[k]._data.Length; j++)
                    {
                        rval[k]._data[j] = _default_value;
                    }
                }
                offset += POIFSConstants.BIG_BLOCK_SIZE;
            }
            return rval;
        }
 internal BigBlockStore(POIFSBigBlockSize bigBlockSize, DocumentBlock[] blocks)
 {
     this.bigBlockSize = bigBlockSize;
     bigBlocks = (DocumentBlock[])blocks.Clone();
     path = null;
     name = null;
     size = -1;
     writer = null;
 }
        public POIFSDocument(string name, POIFSBigBlockSize bigBlockSize, Stream stream)
        {
            List<DocumentBlock> blocks = new List<DocumentBlock>();

            _size = 0;
            _bigBigBlockSize = bigBlockSize;
            while (true)
            {
                DocumentBlock block = new DocumentBlock(stream, bigBlockSize);
                int blockSize = block.Size;

                if (blockSize > 0)
                {
                    blocks.Add(block);
                    _size += blockSize;
                }
                if (block.PartiallyRead)
                    break;
            }

            DocumentBlock[] bigBlocks = blocks.ToArray();
            _big_store = new BigBlockStore(bigBlockSize, bigBlocks);
            _property = new DocumentProperty(name, _size);
            _property.Document = this;

            if (_property.ShouldUseSmallBlocks)
            {
                _small_store = new SmallBlockStore(bigBlockSize, SmallDocumentBlock.Convert(bigBlockSize, bigBlocks, _size));
                _big_store = new BigBlockStore(bigBlockSize, new DocumentBlock[0]);
            }
            else
            {
                _small_store = new SmallBlockStore(bigBlockSize, EMPTY_SMALL_BLOCK_ARRAY);
        }

        }
        public void TestRead()
        {
            MemoryStream stream = new MemoryStream(testData);
            ArrayList documents = new ArrayList();

            while (true)
            {
                DocumentBlock block = new DocumentBlock(stream, POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);

                documents.Add(block);
                if (block.PartiallyRead)
                {
                    break;
                }
            }
            SmallDocumentBlock[] blocks =
                SmallDocumentBlock.Convert(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS, (BlockWritable[])documents.ToArray(typeof(DocumentBlock)), testDataSize);

            for (int j = 1; j <= testDataSize; j += 38)
            {
                byte[] buffer = new byte[j];
                int offset = 0;

                for (int k = 0; k < (testDataSize / j); k++)
                {
                    SmallDocumentBlock.Read(blocks, buffer, offset);
                    for (int n = 0; n < buffer.Length; n++)
                    {
                        Assert.AreEqual(testData[(k * j) + n], buffer[n],
                            "checking byte " + (k * j) + n);
                    }
                    offset += j;
                }
            }
        }
Exemple #12
0
        public void TestRead()
        {
            DocumentBlock[] blocks = new DocumentBlock[4];
            MemoryStream input = new MemoryStream(_testdata);

            for (int j = 0; j < 4; j++)
            {
                blocks[j] = new DocumentBlock(input, POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
            }
            for (int j = 1; j <= 2000; j += 17)
            {
                byte[] buffer = new byte[j];
                int offset = 0;

                for (int k = 0; k < (2000 / j); k++)
                {
                    DocumentBlock.Read(blocks, buffer, offset);
                    for (int n = 0; n < buffer.Length; n++)
                    {
                        Assert.AreEqual(_testdata[(k * j) + n], buffer[n]
                            , "checking byte " + (k * j) + n);
                    }
                    offset += j;
                }
            }
        }
Exemple #13
0
        private void verifyOutput(DocumentBlock block, byte[] input)
        {
            Assert.AreEqual(input.Length, block.Size);
            if (input.Length < 512)
            {
                Assert.IsTrue(block.PartiallyRead);
            }
            else
            {
                Assert.IsTrue(!block.PartiallyRead);
            }
            MemoryStream output = new MemoryStream(512);

            block.WriteBlocks(output);
            byte[] copy = output.ToArray();
            int j = 0;

            for (; j < input.Length; j++)
            {
                Assert.AreEqual(input[j], copy[j]);
            }
            for (; j < 512; j++)
            {
                Assert.AreEqual((byte)0xFF, copy[j]);
            }
        }