public static byte[] GetBytes(object value, Type valueType)
{
if (valueType == typeof(int))
{
return(LittleEndianByteOrder.GetBytes((int)value));
}
if (valueType == typeof(long))
{
return(LittleEndianByteOrder.GetBytes((long)value));
}
if (valueType == typeof(uint))
{
return(LittleEndianByteOrder.GetBytes((uint)value));
}
if (valueType == typeof(float))
{
return(LittleEndianByteOrder.GetBytes((float)value));
}
if (valueType == typeof(double))
{
return(LittleEndianByteOrder.GetBytes((double)value));
}
if (valueType == typeof(string))
{
return(Encoding.UTF8.GetBytesWithNullRepresentation((string)value));
}
if (valueType == typeof(Guid))
{
return(((Guid)value).ToByteArray());
}
throw new InvalidOperationException($"Unsupported Type {valueType}.");
}
private byte[] VariableLengthSerialize(TreeNode <TK, TV> node)
{
using (var m = new MemoryStream())
{
// 4 bytes uint parent id
m.Write(LittleEndianByteOrder.GetBytes(node.ParentId), 0, 4);
// Followed by 4 bytes of how many entries
m.Write(LittleEndianByteOrder.GetBytes((uint)node.EntriesCount), 0, 4);
// Followed by 4 bytes of how manu child references
m.Write(LittleEndianByteOrder.GetBytes((uint)node.ChildrenNodeCount), 0, 4);
// Write entries..
for (var i = 0; i < node.EntriesCount; i++)
{
// Write entry
var entry = node.GetEntry(i);
var key = _keySerializer.Serialize(entry.Item1);
var value = _valueSerializer.Serialize(entry.Item2);
m.Write(LittleEndianByteOrder.GetBytes(key.Length), 0, 4);
m.Write(key, 0, key.Length);
m.Write(LittleEndianByteOrder.GetBytes(value.Length), 0, 4);
m.Write(value, 0, value.Length);
}
// Write child refs..
var childrenIds = node.ChildrenIds;
for (var i = 0; i < node.ChildrenNodeCount; i++)
{
m.Write(LittleEndianByteOrder.GetBytes(childrenIds[i]), 0, 4);
}
return(m.ToArray());
}
}
private void AppendUInt32ToContent(IBlock block, uint value)
{
var contentLength = block.GetHeader(KBlockContentLength);
if (contentLength % 4 != 0)
{
throw new DataMisalignedException("Block content length not %4: " + contentLength);
}
block.Write(LittleEndianByteOrder.GetBytes(value), 0, (int)contentLength, 4);
}
public byte[] Serialize(MapModel model)
{
var nameBytes = System.Text.Encoding.UTF8.GetBytes(model.Name);
var modelData = new byte[
16 + // 16 bytes for Guid id
4 + // 4 bytes indicate the length of the `name` string
nameBytes.Length + // z bytes for name
4 + // 4 bytes for x
4 + // 4 bytes for y
4 + // 4 bytes for sizeX
4 // 4 bytes for sizeY
];
// Id
Buffer.BlockCopy(
src: model.Id.ToByteArray(),
srcOffset: 0,
dst: modelData,
dstOffset: 0,
count: 16
);
// Name
Buffer.BlockCopy(
src: LittleEndianByteOrder.GetBytes((int)nameBytes.Length),
srcOffset: 0,
dst: modelData,
dstOffset: 16 + 4,
count: 4
);
Buffer.BlockCopy(
src: nameBytes,
srcOffset: 0,
dst: modelData,
dstOffset: 16 + 4 + 4 + 4,
count: nameBytes.Length
);
Buffer.BlockCopy(
src: LittleEndianByteOrder.GetBytes((int)model.X),
srcOffset: 0,
dst: modelData,
dstOffset: 16 + 4 + 4 + nameBytes.Length,
count: 4
);
return(modelData);
}
public void TestBlockGetSetHeader()
{
using (var ms = new MemoryStream())
{
var storage = new BlockStorage(new MemoryStream());
var blockStart = storage.BlockSize * 22;
ms.Write(new byte[blockStart], 0, blockStart);
ms.Write(LittleEndianByteOrder.GetBytes(11L), 0, 8);
ms.Write(LittleEndianByteOrder.GetBytes(22L), 0, 8);
ms.Write(LittleEndianByteOrder.GetBytes(33L), 0, 8);
ms.Write(LittleEndianByteOrder.GetBytes(44L), 0, 8);
var firstSector = new byte[storage.DiskSectorSize];
ms.Position = ms.Position - 4 * 8;
ms.Read(firstSector);
using (var block = new Block(storage, 22, firstSector, ms))
{
block.GetHeader(0);
Assert.AreEqual(11L, block.GetHeader(0));
Assert.AreEqual(22L, block.GetHeader(1));
Assert.AreEqual(33L, block.GetHeader(2));
Assert.AreEqual(44L, block.GetHeader(3));
// Change header
block.SetHeader(1, 33L);
// Changed in memory
Assert.AreEqual(33L, block.GetHeader(1));
// Should not be changed in actual stream
var buffer = new byte[8];
ms.Position = blockStart + 8;
ms.Read(buffer, 0, 8);
Assert.AreEqual(22L, LittleEndianByteOrder.GetInt64(buffer));
}
// Until we flush
{
var buffer = new byte[8];
ms.Position = blockStart + 8;
ms.Read(buffer, 0, 8);
Assert.AreEqual(33L, LittleEndianByteOrder.GetInt64(buffer));
}
}
}
public byte[] Serialize(DocumentModel model)
{
var value = model.Value.ToString();
var valueBytes = System.Text.Encoding.UTF8.GetBytes(value);
var data = new byte[16 + 4 + valueBytes.Length];
//Первая часть блока - Id
Buffer.BlockCopy(model.Id.ToByteArray(), 0, data, 0, 16);
//Вторая часть блока - длина json-объекта
Buffer.BlockCopy(LittleEndianByteOrder.GetBytes(valueBytes.Length), 0, data, 16, 4);
//Третья часть блока - json-объект
Buffer.BlockCopy(valueBytes, 0, data, 16 + 4, valueBytes.Length);
return(data);
}
uint ReadUInt32FromTrailingContent(IBlock block)
{
var buffer = new byte[4];
var contentLength = block.GetHeader(KBlockContentLength);
if (contentLength % 4 != 0)
{
throw new DataMisalignedException("Block content length not %4: " + contentLength);
}
if (contentLength == 0)
{
throw new InvalidDataException("Trying to dequeue UInt32 from an empty block");
}
block.Read(buffer, 0, (int)contentLength - 4, 4);
return(LittleEndianByteOrder.GetUInt32(buffer));
}
public byte[] Serialize(T obj)
{
var json = JsonConvert.SerializeObject(obj);
var bytes = Encoding.UTF8.GetBytes(json);
var jsonData = new byte[
// 16 + // 16 bytes for Guid id
4 + // 4 bytes indicate length of data
bytes.Length // y bytes of data
];
// var id = obj.Id.Equals(Guid.Empty) ? Guid.NewGuid() : obj.Id;
// // Id
// Buffer.BlockCopy(
// src: id.ToByteArray(),
// srcOffset: 0,
// dst: jsonData,
// dstOffset: 0,
// count: 16
// );
// Json length
Buffer.BlockCopy(
src: LittleEndianByteOrder.GetBytes((int)bytes.Length),
srcOffset: 0,
dst: jsonData,
dstOffset: 0,
count: 4
);
// Json data
Buffer.BlockCopy(
src: bytes,
srcOffset: 0,
dst: jsonData,
dstOffset: 4,
count: bytes.Length
);
return(jsonData);
}
public void TestBlockReadBody()
{
using (var ms = new MemoryStream())
{
// Generate a stream
var storage = new BlockStorage(new MemoryStream());
var blockStart = storage.BlockSize * 3;
ms.Write(new byte[blockStart], 0, blockStart);
ms.Write(LittleEndianByteOrder.GetBytes(11L), 0, 8);
ms.Write(LittleEndianByteOrder.GetBytes(22L), 0, 8);
ms.Write(LittleEndianByteOrder.GetBytes(33L), 0, 8);
ms.Write(LittleEndianByteOrder.GetBytes(44L), 0, 8);
// Move to start of body
ms.Position = storage.BlockSize * 3 + storage.BlockHeaderSize;
// Write ~6KB bytes of random shits into body
var bodyLength = (6 * 1024) + 71;
var body = new byte[bodyLength];
var rnd = new Random();
for (var i = 0; i < body.Length; i++)
{
body[i] = (byte)rnd.Next(0, 256);
}
ms.Write(body);
// Block to test
// Read first sector first to construct block to test
var firstSector = new byte[storage.DiskSectorSize];
ms.Position = storage.BlockSize * 3;
ms.Read(firstSector);
using (var block = new Block(storage, 3, firstSector, ms))
{
// Test read the whole block
var result = new byte[bodyLength];
block.Read(result, 0, 0, bodyLength);
Assert.IsTrue(result.SequenceEqual(body));
// Test read part of block
result = new byte[1024];
block.Read(result
, 64
, storage.DiskSectorSize - storage.BlockHeaderSize
, 1024 - 64);
var result2 = new byte[1024 - 64];
Buffer.BlockCopy(result, 64, result2, 0, result2.Length);
var expectedResult2 = new byte[1024 - 64];
Buffer.BlockCopy(body
, storage.DiskSectorSize - storage.BlockHeaderSize
, expectedResult2
, 0
, expectedResult2.Length);
Assert.IsTrue(expectedResult2.SequenceEqual(result2));
// Test read just from first 4KB block
result = new byte[128];
block.Read(result, 64, 16, 128 - 64);
var result3 = new byte[128 - 64];
Buffer.BlockCopy(result, 64, result3, 0, result3.Length);
var expectedResult3 = new byte[128 - 64];
Buffer.BlockCopy(body, 16, expectedResult3, 0, expectedResult3.Length);
Assert.IsTrue(expectedResult3.SequenceEqual(result3));
// Test validation
Assert.Throws <ArgumentOutOfRangeException>(delegate
{
block.Read(result, 0, 0, bodyLength + 1);
});
Assert.Throws <ArgumentOutOfRangeException>(delegate
{
block.Read(new byte[12 * 1024], 0, 0, storage.BlockContentSize);
});
}
}
}
public byte[] Serialize(uint value)
{
return(LittleEndianByteOrder.GetBytes(value));
}
public byte[] Serialize(CowModel cow)
{
var breedBytes = System.Text.Encoding.UTF8.GetBytes(cow.Breed);
var nameBytes = System.Text.Encoding.UTF8.GetBytes(cow.Breed);
var cowData = new byte[
16 + // 16 bytes for Guid id
4 + // 4 bytes indicate the length of `breed` string
breedBytes.Length + // n bytes for breed string
4 + // 4 bytes indicate the length of the `name` string
nameBytes.Length + // z bytes for name
4 + // 4 bytes for age
4 + // 4 bytes indicate length of DNA data
cow.DnaData.Length // y bytes of DNA data
];
// Id
Buffer.BlockCopy(
src: cow.Id.ToByteArray(),
srcOffset: 0,
dst: cowData,
dstOffset: 0,
count: 16
);
// Breed
Buffer.BlockCopy(
src: LittleEndianByteOrder.GetBytes((int)breedBytes.Length),
srcOffset: 0,
dst: cowData,
dstOffset: 16,
count: 4
);
Buffer.BlockCopy(
src: breedBytes,
srcOffset: 0,
dst: cowData,
dstOffset: 16 + 4,
count: breedBytes.Length
);
// Name
Buffer.BlockCopy(
src: LittleEndianByteOrder.GetBytes((int)nameBytes.Length),
srcOffset: 0,
dst: cowData,
dstOffset: 16 + 4 + breedBytes.Length,
count: 4
);
Buffer.BlockCopy(
src: nameBytes,
srcOffset: 0,
dst: cowData,
dstOffset: 16 + 4 + breedBytes.Length + 4,
count: nameBytes.Length
);
// Age
Buffer.BlockCopy(
src: LittleEndianByteOrder.GetBytes((int)cow.Age),
srcOffset: 0,
dst: cowData,
dstOffset: 16 + 4 + breedBytes.Length + 4 + nameBytes.Length,
count: 4
);
// DNA
Buffer.BlockCopy(
src: LittleEndianByteOrder.GetBytes(cow.DnaData.Length),
srcOffset: 0,
dst: cowData,
dstOffset: 16 + 4 + breedBytes.Length + 4 + nameBytes.Length + 4,
count: 4
);
Buffer.BlockCopy(
src: cow.DnaData,
srcOffset: 0,
dst: cowData,
dstOffset: 16 + 4 + breedBytes.Length + 4 + nameBytes.Length + 4 + 4,
count: cow.DnaData.Length
);
return(cowData);
}
