public virtual void TestGrandChildren()
{
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, 0);
ByteArrayBuffer content = InspectContent(buffer);
Assert.AreEqual(Data1, content.ReadInt());
Assert.AreEqual(Data2, content.ReadByte());
int address = content.ReadInt();
content.Seek(address);
Assert.AreEqual(Data3, content.ReadInt());
Assert.AreEqual(Data4, content.ReadInt());
address = content.ReadInt();
content.Seek(address);
Assert.AreEqual(Data5, content.ReadInt());
}
public virtual void TestLinkOffset()
{
var linkOffset = 7;
var buffer = new MarshallingBuffer();
buffer.WriteInt(Data1);
buffer.WriteByte(Data2);
var child = buffer.AddChild();
child.WriteInt(Data3);
child.WriteInt(Data4);
var grandChild = child.AddChild();
grandChild.WriteInt(Data5);
buffer.MergeChildren(null, 0, linkOffset);
var content = InspectContent(buffer);
var 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());
var 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 void WriteIntAt(ByteArrayBuffer target, int offset, int value)
{
int currentOffset = target.Offset();
target.Seek(offset);
target.WriteInt(value);
target.Seek(currentOffset);
}
private void DefragmentWriteMappedClassId(IDefragmentContext context, ArrayInfo info
, int classIdOffset)
{
ByteArrayBuffer targetBuffer = context.TargetBuffer();
int currentOffset = targetBuffer.Offset();
targetBuffer.Seek(classIdOffset);
int classID = ClassIDFromInfo(Container(context), info);
int mappedID = context.MappedID(classID);
int marshalledMappedId = ClassIdToMarshalledClassId(mappedID, info.Primitive());
targetBuffer.WriteInt(marshalledMappedId);
targetBuffer.Seek(currentOffset);
}
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);
}
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());
}
}
internal void PrepareWrite(Transaction trans)
{
if (_dead)
{
return;
}
BTreeNodeCacheEntry cacheEntry = Btree().CacheEntry(this);
if (CanWrite())
{
return;
}
ByteArrayBuffer buffer = cacheEntry.Buffer();
if (buffer != null)
{
buffer.Seek(0);
Read(trans.SystemTransaction(), buffer);
cacheEntry.Buffer(null);
}
else
{
Read(trans.SystemTransaction());
}
_btree.AddToProcessing(this);
}
private ByteArrayBuffer InspectContent(MarshallingBuffer buffer)
{
ByteArrayBuffer bufferDelegate = buffer.TestDelegate();
bufferDelegate.Seek(0);
return(bufferDelegate);
}
internal ByteArrayBuffer PrepareRead(Transaction trans)
{
BTreeNodeCacheEntry cacheEntry = Btree().CacheEntry(this);
if (CanWrite())
{
return(null);
}
if (IsNew())
{
return(null);
}
Transaction systemTransaction = trans.SystemTransaction();
ByteArrayBuffer buffer = cacheEntry.Buffer();
if (buffer != null)
{
// Cache hit, still unread
buffer.Seek(0);
Read(systemTransaction, buffer);
cacheEntry.Buffer(null);
_btree.AddToProcessing(this);
return(null);
}
buffer = ProduceReadBuffer(systemTransaction);
ReadNodeHeader(buffer);
cacheEntry.Buffer(buffer);
return(buffer);
}
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);
}
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);
}
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);
}
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
);
}
}
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);
}
public virtual ByteArrayBuffer Get(Transaction provider, int id)
{
ByteArrayBuffer buffer = ((ByteArrayBuffer)CacheOn(provider).Produce(id, nullProducer
, null));
if (null == buffer)
{
return(null);
}
buffer.Seek(0);
return(buffer);
}
private static byte[] BytesToSendFor(string message)
{
var io = new LatinStringIO();
var marshalledStringLength = io.Length(message);
var buffer = new ByteArrayBuffer(marshalledStringLength + Const4.IntLength);
buffer.WriteInt(marshalledStringLength);
io.WriteLengthAndString(buffer, message);
buffer.Seek(0);
return(buffer.ReadBytes(buffer.Length()));
}
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);
}
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;
}
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());
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());
}
}
private object WriteAndRead(object obj)
{
int imaginativeID = 500;
ObjectReference @ref = new ObjectReference(ClassMetadataForObject(obj), imaginativeID
);
@ref.SetObject(obj);
MarshallingContext marshallingContext = new MarshallingContext(Trans(), @ref, Container
().UpdateDepthProvider().ForDepth(int.MaxValue), true);
Handlers4.Write(@ref.ClassMetadata().TypeHandler(), marshallingContext, obj);
Pointer4 pointer = marshallingContext.AllocateSlot();
ByteArrayBuffer buffer = marshallingContext.ToWriteBuffer(pointer);
buffer.Seek(0);
// String str = new String(buffer._buffer);
// System.out.println(str);
UnmarshallingContext unmarshallingContext = new UnmarshallingContext(Trans(), @ref
, Const4.AddToIdTree, false);
unmarshallingContext.Buffer(buffer);
unmarshallingContext.ActivationDepth(new LegacyActivationDepth(5));
return(unmarshallingContext.Read());
}
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;
}
public virtual void Seek(int offset)
{
_current.Seek(offset);
}
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 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);
}
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;
}
