Beispiel #1
0
        /// <summary>
        /// See <see cref="IByteProvider.WriteByte" /> for more information.
        /// </summary>
        public void WriteByte(long index, byte value)
        {
            try
            {
                // Find the block affected.
                long      blockOffset;
                DataBlock block = GetDataBlock(index, out blockOffset);

                // If the byte is already in a memory block, modify it.
                MemoryDataBlock memoryBlock = block as MemoryDataBlock;
                if (memoryBlock != null)
                {
                    memoryBlock.Data[index - blockOffset] = value;
                    return;
                }

                FileDataBlock fileBlock = (FileDataBlock)block;

                // If the byte changing is the first byte in the block and the previous block is a memory block, extend that.
                if (blockOffset == index && block.PreviousBlock != null)
                {
                    MemoryDataBlock previousMemoryBlock = block.PreviousBlock as MemoryDataBlock;
                    if (previousMemoryBlock != null)
                    {
                        previousMemoryBlock.AddByteToEnd(value);
                        fileBlock.RemoveBytesFromStart(1);
                        if (fileBlock.Length == 0)
                        {
                            _dataMap.Remove(fileBlock);
                        }
                        return;
                    }
                }

                // If the byte changing is the last byte in the block and the next block is a memory block, extend that.
                if (blockOffset + fileBlock.Length - 1 == index && block.NextBlock != null)
                {
                    MemoryDataBlock nextMemoryBlock = block.NextBlock as MemoryDataBlock;
                    if (nextMemoryBlock != null)
                    {
                        nextMemoryBlock.AddByteToStart(value);
                        fileBlock.RemoveBytesFromEnd(1);
                        if (fileBlock.Length == 0)
                        {
                            _dataMap.Remove(fileBlock);
                        }
                        return;
                    }
                }

                // Split the block into a prefix and a suffix and place a memory block in-between.
                FileDataBlock prefixBlock = null;
                if (index > blockOffset)
                {
                    prefixBlock = new FileDataBlock(fileBlock.FileOffset, index - blockOffset);
                }

                FileDataBlock suffixBlock = null;
                if (index < blockOffset + fileBlock.Length - 1)
                {
                    suffixBlock = new FileDataBlock(
                        fileBlock.FileOffset + index - blockOffset + 1,
                        fileBlock.Length - (index - blockOffset + 1));
                }

                block = _dataMap.Replace(block, new MemoryDataBlock(value));

                if (prefixBlock != null)
                {
                    _dataMap.AddBefore(block, prefixBlock);
                }

                if (suffixBlock != null)
                {
                    _dataMap.AddAfter(block, suffixBlock);
                }
            }
            finally
            {
                OnChanged(EventArgs.Empty);
            }
        }
Beispiel #2
0
 public void WriteByte(long index, byte value)
 {
     try
     {
         long      blockOffset;
         DataBlock dataBlock = this.GetDataBlock(index, out blockOffset);
         if (dataBlock is MemoryDataBlock memoryDataBlock)
         {
             memoryDataBlock.Data[index - blockOffset] = value;
         }
         else
         {
             FileDataBlock fileDataBlock1 = (FileDataBlock)dataBlock;
             if (blockOffset == index && dataBlock.PreviousBlock != null && dataBlock.PreviousBlock is MemoryDataBlock previousBlock)
             {
                 previousBlock.AddByteToEnd(value);
                 fileDataBlock1.RemoveBytesFromStart(1L);
                 if (fileDataBlock1.Length != 0L)
                 {
                     return;
                 }
                 this._dataMap.Remove((DataBlock)fileDataBlock1);
             }
             else if (blockOffset + fileDataBlock1.Length - 1L == index && dataBlock.NextBlock != null && dataBlock.NextBlock is MemoryDataBlock nextBlock)
             {
                 nextBlock.AddByteToStart(value);
                 fileDataBlock1.RemoveBytesFromEnd(1L);
                 if (fileDataBlock1.Length != 0L)
                 {
                     return;
                 }
                 this._dataMap.Remove((DataBlock)fileDataBlock1);
             }
             else
             {
                 FileDataBlock fileDataBlock2 = (FileDataBlock)null;
                 if (index > blockOffset)
                 {
                     fileDataBlock2 = new FileDataBlock(fileDataBlock1.FileOffset, index - blockOffset);
                 }
                 FileDataBlock fileDataBlock3 = (FileDataBlock)null;
                 if (index < blockOffset + fileDataBlock1.Length - 1L)
                 {
                     fileDataBlock3 = new FileDataBlock(fileDataBlock1.FileOffset + index - blockOffset + 1L, fileDataBlock1.Length - (index - blockOffset + 1L));
                 }
                 DataBlock block = this._dataMap.Replace(dataBlock, (DataBlock) new MemoryDataBlock(value));
                 if (fileDataBlock2 != null)
                 {
                     this._dataMap.AddBefore(block, (DataBlock)fileDataBlock2);
                 }
                 if (fileDataBlock3 == null)
                 {
                     return;
                 }
                 this._dataMap.AddAfter(block, (DataBlock)fileDataBlock3);
             }
         }
     }
     finally
     {
         this.OnChanged(EventArgs.Empty);
     }
 }
 // Token: 0x06000369 RID: 873 RVA: 0x000122D4 File Offset: 0x000104D4
 public void WriteByte(long index, byte value)
 {
     try
     {
         long            num;
         DataBlock       dataBlock       = this.GetDataBlock(index, out num);
         MemoryDataBlock memoryDataBlock = dataBlock as MemoryDataBlock;
         if (memoryDataBlock != null)
         {
             memoryDataBlock.Data[(int)(checked ((IntPtr)(unchecked (index - num))))] = value;
         }
         else
         {
             FileDataBlock fileDataBlock = (FileDataBlock)dataBlock;
             if (num == index && dataBlock.PreviousBlock != null)
             {
                 MemoryDataBlock memoryDataBlock2 = dataBlock.PreviousBlock as MemoryDataBlock;
                 if (memoryDataBlock2 != null)
                 {
                     memoryDataBlock2.AddByteToEnd(value);
                     fileDataBlock.RemoveBytesFromStart(1L);
                     if (fileDataBlock.Length == 0L)
                     {
                         this._dataMap.Remove(fileDataBlock);
                     }
                     return;
                 }
             }
             if (num + fileDataBlock.Length - 1L == index && dataBlock.NextBlock != null)
             {
                 MemoryDataBlock memoryDataBlock3 = dataBlock.NextBlock as MemoryDataBlock;
                 if (memoryDataBlock3 != null)
                 {
                     memoryDataBlock3.AddByteToStart(value);
                     fileDataBlock.RemoveBytesFromEnd(1L);
                     if (fileDataBlock.Length == 0L)
                     {
                         this._dataMap.Remove(fileDataBlock);
                     }
                     return;
                 }
             }
             FileDataBlock fileDataBlock2 = null;
             if (index > num)
             {
                 fileDataBlock2 = new FileDataBlock(fileDataBlock.FileOffset, index - num);
             }
             FileDataBlock fileDataBlock3 = null;
             if (index < num + fileDataBlock.Length - 1L)
             {
                 fileDataBlock3 = new FileDataBlock(fileDataBlock.FileOffset + index - num + 1L, fileDataBlock.Length - (index - num + 1L));
             }
             dataBlock = this._dataMap.Replace(dataBlock, new MemoryDataBlock(value));
             if (fileDataBlock2 != null)
             {
                 this._dataMap.AddBefore(dataBlock, fileDataBlock2);
             }
             if (fileDataBlock3 != null)
             {
                 this._dataMap.AddAfter(dataBlock, fileDataBlock3);
             }
         }
     }
     finally
     {
         this.OnChanged(EventArgs.Empty);
     }
 }