public override void Dispose()
{
foreach (var node in _dirty)
{
var ixFileName = Path.Combine(SessionFactory.Dir, string.Format("{0}.{1}.ix", CollectionId, node.Key));
var tmpFileName = string.Format("{0}.tmp_ix", Path.GetFileNameWithoutExtension(ixFileName));
using (var indexStream = new FileStream(
tmpFileName, FileMode.Append, FileAccess.Write, FileShare.None))
{
node.Value.Serialize(indexStream, VectorStream, PostingsStream);
}
SessionFactory.RefreshIndex(CollectionId, node.Key, node.Value);
File.Copy(tmpFileName, ixFileName, overwrite: true);
File.Delete(tmpFileName);
}
ValueStream.Flush();
KeyStream.Flush();
DocStream.Flush();
ValueIndexStream.Flush();
KeyIndexStream.Flush();
DocIndexStream.Flush();
PostingsStream.Flush();
VectorStream.Flush();
base.Dispose();
}
public virtual void Dispose()
{
if (ValueStream != null)
{
ValueStream.Dispose();
}
if (KeyStream != null)
{
KeyStream.Dispose();
}
if (DocStream != null)
{
DocStream.Dispose();
}
if (ValueIndexStream != null)
{
ValueIndexStream.Dispose();
}
if (KeyIndexStream != null)
{
KeyIndexStream.Dispose();
}
if (DocIndexStream != null)
{
DocIndexStream.Dispose();
}
}
public override Guid Deserialize(ValueStream stream)
{
var guidBytes = new byte[16];
stream.Read(guidBytes, 0, guidBytes.Length);
return(new Guid(guidBytes));
}
public void ReferenceTypeSerializeBinaryTest477378791()
{
using (var ms = new ValueStream()) {
var objs = new List <object>();
objs.Add(new Uri("http://localhost"));
objs.Add(new Rectangle(0, 0, 100, 100));
// BinaryTree<int> btree = new BinaryTree<int>();
// btree.AddRange(1, 2, 3, 4, 5, 6);
// objs.Add(btree);
// SerializerTool.BinarySerialize(objs, ms);
SerializerTool.Serialize(objs, ms, BinaryFormatter);
ms.Position = 0;
Console.WriteLine("Original Objects = " + ArrayTool.AsString(objs.ToArray()));
Console.WriteLine("Binary Serialized =\r\n" + ms.GetHexDumpString());
ms.Position = 0;
// List<object> objs2 = (List<object>)SerializerTool.BinaryDeserialize(ms);
var objs2 = SerializerTool.Deserialize <List <object> >(ms, BinaryFormatter);
Console.WriteLine("Deserialized = " + ArrayTool.AsString(objs2.ToArray()));
for (int i = 0; i < objs.Count; i++)
{
Assert.AreEqual(objs[i], objs2[i]);
}
}
}
public override void Serialize(ValueStream stream, ushort data)
{
var union = new UnifiedUnion(data);
stream.WriteByte(union.Byte1);
stream.WriteByte(union.Byte2);
}
public void Dispose()
{
WritableValueStream.Dispose();
ValueIndexStream.Dispose();
WritableValueIndexStream.Dispose();
WritableKeyMapStream.Dispose();
ValueStream.Dispose();
}
public override float Deserialize(ValueStream stream)
{
return(new UnifiedUnion(
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte()).Single);
}
public override uint Deserialize(ValueStream stream)
{
return(new UnifiedUnion(
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte()).UInt32);
}
public TData Deserialize <TData>(ValueStream stream)
{
if (disposed)
{
throw new ObjectDisposedException(nameof(Serializer));
}
return((TData)Deserialize(stream, typeof(TData)));
}
public void Serialize <TData>(ValueStream stream, TData data)
{
if (disposed)
{
throw new ObjectDisposedException(nameof(Serializer));
}
Serialize(stream, data, typeof(TData));
}
public override double Deserialize(ValueStream stream)
{
return(new UnifiedUnion(
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte()).Double);
}
public override long Deserialize(ValueStream stream)
{
return(new UnifiedUnion(
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte()).Int64);
}
public void DoubleResizingOnDifferentSize()
{
using (var stream = new ValueStream())
{
stream.Write(new byte[10], 0, 10);
stream.Write(new byte[20], 0, 20);
stream.Write(new byte[50], 0, 50);
Assert.Equal(80, stream.Position);
Assert.Equal(128, stream.Length);
}
}
public override void Serialize(ValueStream stream, long data)
{
var union = new UnifiedUnion(data);
stream.WriteByte(union.Byte1);
stream.WriteByte(union.Byte2);
stream.WriteByte(union.Byte3);
stream.WriteByte(union.Byte4);
stream.WriteByte(union.Byte5);
stream.WriteByte(union.Byte6);
stream.WriteByte(union.Byte7);
stream.WriteByte(union.Byte8);
}
public override void Serialize(ValueStream stream, string data)
{
var union = new UnifiedUnion(data.Length);
stream.WriteByte(union.Byte1);
stream.WriteByte(union.Byte2);
stream.WriteByte(union.Byte3);
stream.WriteByte(union.Byte4);
var stringBuffer = Encoding.UTF8.GetBytes(data);
stream.Write(stringBuffer, 0, stringBuffer.Length);
}
public override DateTime Deserialize(ValueStream stream)
{
var binary = new UnifiedUnion(
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte()).Int64;
return(DateTime.FromBinary(binary));
}
public override void Serialize(ValueStream stream, DateTime data)
{
var binary = data.ToBinary();
var union = new UnifiedUnion(binary);
stream.WriteByte(union.Byte1);
stream.WriteByte(union.Byte2);
stream.WriteByte(union.Byte3);
stream.WriteByte(union.Byte4);
stream.WriteByte(union.Byte5);
stream.WriteByte(union.Byte6);
stream.WriteByte(union.Byte7);
stream.WriteByte(union.Byte8);
}
public Message GetMessage <TData>(IPayload <TData> payload)
{
using (var stream = new ValueStream(arrayPool))
{
var commandId = commandHolder.GetCommand(payload.CommandType);
stream.WriteInt32(commandId);
serializer.Serialize(stream, payload.Data);
compression.Compress(stream);
encryption.Encrypt(stream);
return(new Message(stream.Buffer, (int)stream.Length));
}
}
public override string Deserialize(ValueStream stream)
{
var union = new UnifiedUnion(
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte());
var length = union.Int32;
var stringBuffer = new byte[length];
stream.Read(stringBuffer, 0, stringBuffer.Length);
return(Encoding.UTF8.GetString(stringBuffer));
}
public void Dispose()
{
if (_disposed)
{
return;
}
WritableValueStream.Dispose();
ValueIndexStream.Dispose();
WritableValueIndexStream.Dispose();
WritableKeyMapStream.Dispose();
ValueStream.Dispose();
_disposed = true;
}
public object Deserialize(ValueStream stream, Type dataType)
{
if (disposed)
{
throw new ObjectDisposedException(nameof(Serializer));
}
if (dataType == null)
{
throw new ArgumentNullException(nameof(dataType));
}
if (!dataType.IsValueType || Nullable.GetUnderlyingType(dataType) != null)
{
if (stream.ReadByte() == 0)
{
return(null);
}
}
var dto = converterContainer.TryGetDto(dataType);
if (dto?.Converter != null)
{
return(dto.Converter.DeserializeObject(stream, dataType));
}
if (stream.ReadByte() == 1)
{
var aliasBytes = new byte[4];
stream.Read(aliasBytes, 0, aliasBytes.Length);
var alias = new UnifiedUnion(aliasBytes[0], aliasBytes[1], aliasBytes[2], aliasBytes[3]).Int32;
dataType = converterContainer.GetTypeFromAlias(alias);
}
var instance = activator.Create(dataType);
var propertyInfo = EnsureProperties(dataType);
for (var i = 0; i < propertyInfo.Length; i++)
{
propertyInfo[i].SetValue(instance, Deserialize(stream, propertyInfo[i].PropertyType));
}
return(instance);
}
public override void Serialize(ValueStream stream, IList elements)
{
var elementType = elements.GetType().GetGenericArguments()[0];
var union = new UnifiedUnion(elements.Count);
stream.WriteByte(union.Byte1);
stream.WriteByte(union.Byte2);
stream.WriteByte(union.Byte3);
stream.WriteByte(union.Byte4);
for (var i = 0; i < elements.Count; i++)
{
serializer.Serialize(stream, elements[i], elementType);
}
}
public override void Serialize(ValueStream stream, Array elements)
{
var elementType = elements.GetType().GetElementType();
var union = new UnifiedUnion(elements.Length);
stream.WriteByte(union.Byte1);
stream.WriteByte(union.Byte2);
stream.WriteByte(union.Byte3);
stream.WriteByte(union.Byte4);
for (var i = 0; i < elements.Length; i++)
{
serializer.Serialize(stream, elements.GetValue(i), elementType);
}
}
public override void Serialize(ValueStream stream, ICollection elements)
{
var elementType = elements.GetType().GetGenericArguments()[0];
var union = new UnifiedUnion(elements.Count);
stream.WriteByte(union.Byte1);
stream.WriteByte(union.Byte2);
stream.WriteByte(union.Byte3);
stream.WriteByte(union.Byte4);
foreach (var element in elements)
{
serializer.Serialize(stream, element, elementType);
}
}
public void AllocationTests()
{
var input1 = new byte[5];
var input2 = new byte[60];
var input3 = new byte[100];
var input4 = new byte[130];
// 42 2 1
var gg1 = GC.CollectionCount(0);
var gg2 = GC.CollectionCount(1);
var gg3 = GC.CollectionCount(2);
using (var pool = new ArrayPoolConfig().Create())
{
for (var i = 0; i < 100_000_0; i++)
{
using (var stream = new ValueStream(pool))
{
stream.Write(input1, 0, input1.Length);
stream.Write(input2, 0, input2.Length);
stream.Write(input3, 0, input3.Length);
stream.Write(input4, 0, input4.Length);
}
}
}
var g1 = GC.CollectionCount(0);
var g2 = GC.CollectionCount(1);
var g3 = GC.CollectionCount(2);
for (var i = 0; i < 100_000_0; i++)
{
using (var stream = new System.IO.MemoryStream())
{
stream.Write(input1, 0, input1.Length);
stream.Write(input2, 0, input2.Length);
stream.Write(input3, 0, input3.Length);
stream.Write(input4, 0, input4.Length);
}
}
// 565 2 1
var g11 = GC.CollectionCount(0);
var g22 = GC.CollectionCount(1);
var g33 = GC.CollectionCount(2);
}
public override void Serialize(ValueStream stream, IEnumerable data)
{
var elements = data.Cast <object>().ToList();
var elementType = data.GetType().GetGenericArguments()[0];
var union = new UnifiedUnion(elements.Count);
stream.WriteByte(union.Byte1);
stream.WriteByte(union.Byte2);
stream.WriteByte(union.Byte3);
stream.WriteByte(union.Byte4);
foreach (var element in elements)
{
serializer.Serialize(stream, element, elementType);
}
}
public void StreamReadsAndWrites()
{
var input = new byte[] { 1, 2, 3, 4, 5 };
using (var stream = new ValueStream())
{
stream.Write(input, 0, input.Length);
stream.Seek(0);
var result = new byte[5];
var read = stream.Read(result, 0, result.Length);
Assert.Equal(result.Length, read);
Assert.Equal(input, result);
}
}
public virtual void Dispose()
{
ValueStream.Dispose();
KeyStream.Dispose();
DocStream.Dispose();
ValueIndexStream.Dispose();
KeyIndexStream.Dispose();
DocIndexStream.Dispose();
if (PostingsStream != null)
{
PostingsStream.Dispose();
}
if (VectorStream != null)
{
VectorStream.Dispose();
}
}
public override object DeserializeObject(ValueStream stream, Type type)
{
var elementType = type.GetElementType();
var length = new UnifiedUnion(
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte(),
(byte)stream.ReadByte()).Int32;
var array = Array.CreateInstance(elementType, length);
for (var i = 0; i < length; i++)
{
array.SetValue(serializer.Deserialize(stream, elementType), i);
}
return(array);
}
public void ReadByteWriteByteWorks()
{
using (var stream = new ValueStream())
{
stream.WriteByte(1);
stream.WriteByte(2);
stream.WriteByte(3);
stream.WriteByte(4);
stream.WriteByte(5);
stream.Seek(0);
Assert.Equal(1, stream.ReadByte());
Assert.Equal(2, stream.ReadByte());
Assert.Equal(3, stream.ReadByte());
Assert.Equal(4, stream.ReadByte());
Assert.Equal(5, stream.ReadByte());
}
}