public virtual TSet Read()
{
if (!_initialized)
{
throw new NotSupportedException("Reading from an uninitialized Session is not supported");
}
if (_data != null)
{
return(_data);
}
_data = new TSet();
if (!File.Exists(_fileName))
{
return(_data);
}
using (MemoryMappedFile memFile = MemoryMappedFile.CreateFromFile(_fileName, FileMode.Open, _mapName, 0, MemoryMappedFileAccess.Read))
using (MemoryMappedViewStream view = memFile.CreateViewStream(0, 0, MemoryMappedFileAccess.Read))
{
RuntimeHelpers.PrepareConstrainedRegions();
long headerSize = Unsafe.SizeOf <Header>();
TMap map = new TMap();
byte *ptr = (byte *)0;
try
{
view.SafeMemoryMappedViewHandle.AcquirePointer(ref ptr);
byte *loc = ptr;
Header info = Unsafe.Read <Header>(loc);
loc += headerSize;
byte[] metaBytes = new byte[info.MetaLen];
Marshal.Copy((IntPtr)loc, metaBytes, 0, info.MetaLen);
loc += info.MetaLen;
_data.MetaData = MetaFormatter.Deserialize <TMeta>(metaBytes);
int len = Unsafe.SizeOf <TStruct>();
for (int i = 0; i < info.ItemCount; ++i)
{
_data.Add(map.ToData(Unsafe.Read <TStruct>(loc), _data.MetaData));
loc += len;
}
}
finally
{
if (ptr != null)
{
view.SafeMemoryMappedViewHandle.ReleasePointer();
}
}
}
return(_data);
}
internal long CalculateSize(TMeta metadata, int count)
{
long metaSize = MetaFormatter.Serialize <TMeta>(metadata).Length;
long headerSize = Unsafe.SizeOf <Header>();
long dataSize = Unsafe.SizeOf <TStruct>() * count;
return(metaSize + headerSize + dataSize);
}
public TestCommand(ILogger <TestCommand> logger, EgretConsole console, ConfigDeserializer serializer, TestCommandOptions options, Executor executor, MetaFormatter metaFormatter
)
{
this.serializer = serializer;
this.options = options;
this.executor = executor;
this.logger = logger;
this.console = console;
resultFormatter = metaFormatter;
}
public void Write(TSet items, WriteType writeType = WriteType.Update)
{
if (!_initialized)
{
throw new NotSupportedException("Writing to an uninitialized Session is not supported");
}
_syncLock.EnterWriteLock();
try
{
_data = Read();
if (_data.Count == 0 || writeType == WriteType.Overwrite)
{
_data = items;
}
else
{
if (writeType == WriteType.Update)
{
_data.Update(items);
_data.MetaData = items.MetaData;
}
else if (writeType == WriteType.Append)
{
_data.Append(items);
_data.MetaData = items.MetaData;
}
}
long fileSize = CalculateSize(_data.MetaData, _data.Count);
byte[] metaBytes = MetaFormatter.Serialize <TMeta>(_data.MetaData);
long headerSize = Unsafe.SizeOf <Header>();
long dataStart = Unsafe.SizeOf <Header>() + metaBytes.Length;
long dataEnd = dataStart + (Unsafe.SizeOf <TStruct>() * items.Count);
Header info = new Header
{
MetaLen = metaBytes.Length,
ItemCount = items.Count
};
using (MemoryMappedFile memFile = MemoryMappedFile.CreateFromFile(_fileName, FileMode.Create, _mapName, fileSize, MemoryMappedFileAccess.ReadWrite))
using (MemoryMappedViewStream view = memFile.CreateViewStream(0, 0, MemoryMappedFileAccess.Write))
{
TMap map = new TMap();
RuntimeHelpers.PrepareConstrainedRegions();
byte *ptr = (byte *)0;
try
{
view.SafeMemoryMappedViewHandle.AcquirePointer(ref ptr);
byte *start = ptr;
byte *end = ptr + fileSize;
Unsafe.Write <Header>(start, info);
start += headerSize;
Marshal.Copy(metaBytes, 0, IntPtr.Add(new IntPtr(ptr), (int)headerSize), metaBytes.Length);
start += metaBytes.Length;
int len = Unsafe.SizeOf <TStruct>();
foreach (TData item in items)
{
TStruct strct = map.ToStruct(item);
Unsafe.Write <TStruct>(start, strct);
start += len;
}
}
finally
{
if (ptr != null)
{
view.SafeMemoryMappedViewHandle.ReleasePointer();
}
}
}
}
catch (Exception e)
{
throw e;
}
finally
{
_syncLock.ExitWriteLock();
}
}
