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());
			SystemData systemData = file.SystemData();
			systemData.ClassCollectionID(reader.ReadInt());
			reader.ReadInt();
			// was freespace ID, can no longer be read
			_variablePart = CreateVariablePart(file);
			int variablePartId = reader.ReadInt();
			_variablePart.Read(variablePartId, 0);
		}

		public virtual void TestMarshalling()
		{
			double expected = 1.1;
			ByteArrayBuffer buffer = new ByteArrayBuffer(_handler.LinkLength());
			_handler.WriteIndexEntry(Context(), buffer, expected);
			buffer.Seek(0);
			object actual = _handler.ReadIndexEntry(Context(), buffer);
			Assert.AreEqual(expected, actual);
		}

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

		public virtual ByteArrayBuffer Marshall(LocalTransaction transaction, IIntIterator4
			 ids, int count)
		{
			ByteArrayBuffer buffer = new ByteArrayBuffer(Const4.IntLength + count * Const4.IntLength
				);
			int sizeOffset = buffer.Offset();
			buffer.WriteInt(0);
			int written = 0;
			while (count > 0 && ids.MoveNext())
			{
				buffer.WriteInt(ids.CurrentInt());
				++written;
				--count;
			}
			buffer.Seek(sizeOffset);
			buffer.WriteInt(written);
			return buffer;
		}

		protected override void Read(LocalObjectContainer container, ByteArrayBuffer reader
			)
		{
			NewTimerFileLock(container);
			OldEncryptionOff(container);
			CheckThreadFileLock(container, reader);
			reader.Seek(BlocksizeOffset);
			container.BlockSizeReadFromFile(reader.ReadInt());
			SystemData systemData = container.SystemData();
			systemData.ClassCollectionID(reader.ReadInt());
			container.SystemData().IdSystemType(reader.ReadByte());
			_variablePart = CreateVariablePart(container);
			int variablePartAddress = reader.ReadInt();
			int variablePartLength = reader.ReadInt();
			_variablePart.Read(variablePartAddress, variablePartLength);
			_transactionPointerAddress = reader.ReadInt();
			if (_transactionPointerAddress != 0)
			{
				ByteArrayBuffer 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);
			long lastAccessTime = reader.ReadLong();
			if (FileHeader.LockedByOtherSession(container, lastAccessTime))
			{
				_timerFileLock.CheckIfOtherSessionAlive(container, 0, AccessTimeOffset, lastAccessTime
					);
			}
		}

		private void Resize(int sizeNeeded)
		{
			int newSize = _delegate.Length() * 2;
			if (newSize - _lastOffSet < sizeNeeded)
			{
				newSize += sizeNeeded;
			}
			ByteArrayBuffer temp = new ByteArrayBuffer(newSize);
			temp.Seek(_lastOffSet);
			_delegate.CopyTo(temp, 0, 0, _delegate.Length());
			_delegate = temp;
		}

 // Scrolls offset in passed reader to the offset the passed field should
 // be read at.
 public HandlerVersion SeekToField(Transaction trans, ByteArrayBuffer buffer, FieldMetadata
     field)
 {
     if (buffer == null)
     {
         return HandlerVersion.Invalid;
     }
     if (!StandardReferenceTypeHandlerIsUsed())
     {
         return HandlerVersion.Invalid;
     }
     buffer.Seek(0);
     var oh = new ObjectHeader(_container, buffer);
     var res = oh.ClassMetadata().SeekToField(new ObjectHeaderContext(trans, buffer,
         oh), field);
     if (!res)
     {
         return HandlerVersion.Invalid;
     }
     return new HandlerVersion(oh.HandlerVersion());
 }

			private void WriteIntAt(ByteArrayBuffer target, int offset, int value)
			{
				int currentOffset = target.Offset();
				target.Seek(offset);
				target.WriteInt(value);
				target.Seek(currentOffset);
			}

		public virtual void TestLinkOffset()
		{
			int linkOffset = 7;
			MarshallingBuffer buffer = new MarshallingBuffer();
			buffer.WriteInt(Data1);
			buffer.WriteByte(Data2);
			MarshallingBuffer child = buffer.AddChild();
			child.WriteInt(Data3);
			child.WriteInt(Data4);
			MarshallingBuffer grandChild = child.AddChild();
			grandChild.WriteInt(Data5);
			buffer.MergeChildren(null, 0, linkOffset);
			ByteArrayBuffer content = InspectContent(buffer);
			ByteArrayBuffer extendedBuffer = new ByteArrayBuffer(content.Length() + linkOffset
				);
			content.CopyTo(extendedBuffer, 0, linkOffset, content.Length());
			extendedBuffer.Seek(linkOffset);
			Assert.AreEqual(Data1, extendedBuffer.ReadInt());
			Assert.AreEqual(Data2, extendedBuffer.ReadByte());
			int address = extendedBuffer.ReadInt();
			extendedBuffer.Seek(address);
			Assert.AreEqual(Data3, extendedBuffer.ReadInt());
			Assert.AreEqual(Data4, extendedBuffer.ReadInt());
			address = extendedBuffer.ReadInt();
			extendedBuffer.Seek(address);
			Assert.AreEqual(Data5, extendedBuffer.ReadInt());
		}

		private static byte[] BytesToSendFor(string message)
		{
			LatinStringIO io = new LatinStringIO();
			int marshalledStringLength = io.Length(message);
			ByteArrayBuffer buffer = new ByteArrayBuffer(marshalledStringLength + Const4.IntLength);

			buffer.WriteInt(marshalledStringLength);

			io.WriteLengthAndString(buffer, message);
			buffer.Seek(0);
			return buffer.ReadBytes(buffer.Length());
		}

		private bool VersionsAreConsistentAndSeek(ByteArrayBuffer buffer)
		{
			byte[] bytes = buffer._buffer;
			int length = OwnLength();
			int[] offsets = Offsets();
			bool different = false;
			for (int i = 0; i < length; i++)
			{
				byte b = bytes[offsets[0] + i];
				for (int 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.)
				int firstOffset = 0;
				if (!CheckSumOK(buffer, firstOffset))
				{
					throw new Db4oFileHeaderCorruptionException();
				}
				return true;
			}
			bool firstPairDiffers = false;
			bool secondPairDiffers = false;
			for (int 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)
		{
			int initialOffSet = buffer.Offset();
			int length = OwnLength();
			length -= ChecksumLength;
			buffer.Seek(offset);
			long readCheckSum = buffer.ReadLong();
			int checkSumBeginOffset = buffer.Offset();
			byte[] bytes = buffer._buffer;
			long calculatedCheckSum = CRC32.CheckSum(bytes, checkSumBeginOffset, length);
			buffer.Seek(initialOffSet);
			return calculatedCheckSum == readCheckSum;
		}

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