C# ByteArrayBuffer.Seek方法代码示例

 protected override void Read(LocalObjectContainer file, ByteArrayBuffer reader)
 {
     NewTimerFileLock(file);
     OldEncryptionOff(file);
     CheckThreadFileLock(file, reader);
     reader.Seek(TransactionPointerOffset);
     file.SystemData().TransactionPointer1(reader.ReadInt());
     file.SystemData().TransactionPointer2(reader.ReadInt());
     reader.Seek(BlocksizeOffset);
     file.BlockSizeReadFromFile(reader.ReadInt());
     var systemData = file.SystemData();
     systemData.ClassCollectionID(reader.ReadInt());
     reader.ReadInt();
     // was freespace ID, can no longer be read
     _variablePart = CreateVariablePart(file);
     var variablePartId = reader.ReadInt();
     _variablePart.Read(variablePartId, 0);
 }

 private static FileHeader DetectFileHeader(LocalObjectContainer file, ByteArrayBuffer
     reader)
 {
     for (var i = 0; i < AvailableFileHeaders.Length; i++)
     {
         reader.Seek(0);
         var result = AvailableFileHeaders[i].NewOnSignatureMatch(file, reader);
         if (result != null)
         {
             return result;
         }
     }
     return null;
 }

 protected override void Read(LocalObjectContainer container, ByteArrayBuffer reader
     )
 {
     NewTimerFileLock(container);
     OldEncryptionOff(container);
     CheckThreadFileLock(container, reader);
     reader.Seek(BlocksizeOffset);
     container.BlockSizeReadFromFile(reader.ReadInt());
     var systemData = container.SystemData();
     systemData.ClassCollectionID(reader.ReadInt());
     container.SystemData().IdSystemType(reader.ReadByte());
     _variablePart = CreateVariablePart(container);
     var variablePartAddress = reader.ReadInt();
     var variablePartLength = reader.ReadInt();
     _variablePart.Read(variablePartAddress, variablePartLength);
     _transactionPointerAddress = reader.ReadInt();
     if (_transactionPointerAddress != 0)
     {
         var buffer = new ByteArrayBuffer(TransactionPointerLength);
         buffer.Read(container, _transactionPointerAddress, 0);
         systemData.TransactionPointer1(buffer.ReadInt());
         systemData.TransactionPointer2(buffer.ReadInt());
     }
 }

 protected virtual void CheckThreadFileLock(LocalObjectContainer container, ByteArrayBuffer
     reader)
 {
     reader.Seek(AccessTimeOffset);
     var lastAccessTime = reader.ReadLong();
     if (LockedByOtherSession(container, lastAccessTime))
     {
         _timerFileLock.CheckIfOtherSessionAlive(container, 0, AccessTimeOffset, lastAccessTime
             );
     }
 }

 private bool VersionsAreConsistentAndSeek(ByteArrayBuffer buffer)
 {
     var bytes = buffer._buffer;
     var length = OwnLength();
     var offsets = Offsets();
     var different = false;
     for (var i = 0; i < length; i++)
     {
         var b = bytes[offsets[0] + i];
         for (var j = 1; j < 4; j++)
         {
             if (b != bytes[offsets[j] + i])
             {
                 different = true;
                 break;
             }
         }
     }
     if (!different)
     {
         // The following line cements our checksum algorithm in stone.
         // Things should be safe enough if we remove the throw.
         // If all four versions of the header are the same,
         // it's bound to be OK. (unless all bytes are zero or
         // greyed out by some kind of overwriting algorithm.)
         var firstOffset = 0;
         if (!CheckSumOK(buffer, firstOffset))
         {
             throw new Db4oFileHeaderCorruptionException();
         }
         return true;
     }
     var firstPairDiffers = false;
     var secondPairDiffers = false;
     for (var i = 0; i < length; i++)
     {
         if (bytes[offsets[0] + i] != bytes[offsets[1] + i])
         {
             firstPairDiffers = true;
         }
         if (bytes[offsets[2] + i] != bytes[offsets[3] + i])
         {
             secondPairDiffers = true;
         }
     }
     if (!secondPairDiffers)
     {
         if (CheckSumOK(buffer, offsets[2]))
         {
             buffer.Seek(offsets[2]);
             return false;
         }
     }
     if (firstPairDiffers)
     {
         // Should never ever happen, we are toast.
         // We could still try to use any random version of
         // the header but which one?
         // Maybe the first of the second pair could be an 
         // option for a recovery tool, or it could try all
         // versions.
         throw new Db4oFileHeaderCorruptionException();
     }
     if (!CheckSumOK(buffer, 0))
     {
         throw new Db4oFileHeaderCorruptionException();
     }
     return false;
 }

 private bool CheckSumOK(ByteArrayBuffer buffer, int offset)
 {
     var initialOffSet = buffer.Offset();
     var length = OwnLength();
     length -= ChecksumLength;
     buffer.Seek(offset);
     var readCheckSum = buffer.ReadLong();
     var checkSumBeginOffset = buffer.Offset();
     var bytes = buffer._buffer;
     var calculatedCheckSum = CRC32.CheckSum(bytes, checkSumBeginOffset, length);
     buffer.Seek(initialOffSet);
     return calculatedCheckSum == readCheckSum;
 }

 private void Marshall(ByteArrayBuffer buffer, bool shuttingDown)
 {
     var checkSumOffset = buffer.Offset();
     buffer.IncrementOffset(ChecksumLength);
     var checkSumBeginOffset = buffer.Offset();
     WriteBuffer(buffer, shuttingDown);
     var checkSumEndOffSet = buffer.Offset();
     var bytes = buffer._buffer;
     var length = checkSumEndOffSet - checkSumBeginOffset;
     var checkSum = CRC32.CheckSum(bytes, checkSumBeginOffset, length);
     buffer.Seek(checkSumOffset);
     buffer.WriteLong(checkSum);
     buffer.Seek(checkSumEndOffSet);
 }