/// <summary>
/// Serializes this tags index to the given stream.
/// </summary>
/// <param name="stream">The stream to write to. Writing will start at position 0.</param>
public long Serialize(System.IO.Stream stream)
{ // serialize the tags and strings index.
var size = _tagsIndex.Serialize(stream);
var limitedStream = new LimitedStream(stream);
return(_stringIndex.Serialize(limitedStream) + size);
}
/// <summary>
/// Deserializes the vertices
/// </summary>
/// <param name="stream"></param>
/// <param name="graph"></param>
/// <param name="size"></param>
protected virtual void DeserializeVertices(LimitedStream stream, long size, DynamicGraphRouterDataSource <TEdgeData> graph)
{
RuntimeTypeModel typeModel = RuntimeTypeModel.Create();
typeModel.Add(typeof(SerializableVertex), true);
long position = stream.Position;
uint vertex = 0;
while (stream.Position - position < size)
{ // keep reading vertices until the appriated number of bytes have been read.
var vertices = typeModel.DeserializeWithSize(stream, null, typeof(SerializableVertex[])) as SerializableVertex[];
if (vertices != null)
{ // there are a vertices.
for (int idx = 0; idx < vertices.Length; idx++)
{
if (vertices[idx] != null)
{ // there is a vertex.
graph.AddVertex(vertices[idx].Latitude, vertices[idx].Longitude);
}
vertex++;
}
}
}
}
/// <summary>
/// Deserializes a tags index from the given stream.
/// </summary>
public static AttributesIndex Deserialize(System.IO.Stream stream, bool copy = false,
AttributesIndexMode defaultIndexMode = AttributesIndexMode.ReverseStringIndexKeysOnly)
{
// read version byte.
long position = 1;
var version = stream.ReadByte();
int type = 0;
if (version < 2)
{ // unversioned version.
type = (byte)version;
}
else
{ // versioned.
// read the index mode.
var indexModeByte = stream.ReadByte();
position++;
defaultIndexMode = (AttributesIndexMode)indexModeByte;
// read the type.
type = stream.ReadByte();
position++;
}
// read the actual data.
long size;
if (type == 0)
{ // regular index.
var tagsIndex = Index <int[]> .CreateFromWithSize(stream, out size, !copy);
position += size + 8;
stream.Seek(position, System.IO.SeekOrigin.Begin);
var limitedStream = new LimitedStream(stream);
var stringIndex = Index <string> .CreateFromWithSize(limitedStream, out size, !copy);
position += size + 8;
stream.Seek(position, System.IO.SeekOrigin.Begin);
return(new AttributesIndex(defaultIndexMode, stringIndex, tagsIndex));
}
else
{ // increase one index.
var tagsIndex = Index <int[]> .CreateFromWithSize(stream, out size, !copy);
position += size + 8;
stream.Seek(position, System.IO.SeekOrigin.Begin);
var limitedStream = new LimitedStream(stream);
var stringIndex = Index <string> .CreateFromWithSize(limitedStream, out size, !copy);
position += size + 8;
stream.Seek(position, System.IO.SeekOrigin.Begin);
var indexLengthBytes = new byte[8];
stream.Read(indexLengthBytes, 0, 8);
var indexLength = BitConverter.ToInt64(indexLengthBytes, 0);
var index = Context.ArrayFactory.CreateMemoryBackedArray <uint>(indexLength);
index.CopyFrom(stream);
return(new AttributesIndex(defaultIndexMode, stringIndex, tagsIndex, index));
}
}
public ResultModel ConvertFile(ConversionDto conversionDto)
{
var fileNames = _storageRepository.ParseNames(conversionDto.sessionId);
if (fileNames == null)
{
return(ResultModel.Error(fileNames.Id, "Invalid session id", 400));
}
return(OpConvert.Measure(fileNames.Id, () =>
{
FileFormat fmt;
if (conversionDto.outputType != null && formats.TryGetValue(conversionDto.outputType, out fmt))
{
SceneImportContext importContext = CreateLoadContext(fileNames);
//User uploaded an unsupported file format.
if (importContext.SourceFormat == null)
{
_logger.LogError("Failed to detect file type from file {0}", fileNames.Id);
return ResultModel.Error(fileNames.Id, "Unsupported input file", 400);
}
Scene scene;
try
{
scene = importContext.LoadScene();
}
catch (Exception e)
{
_logger.LogError(e, "Failed to open input file {0}", fileNames.Id);
OperationFailed(e);
return ResultModel.Error(fileNames.Id, "Internal server error", 500);
}
var originalFile = importContext.MainFile;
try
{
var fileName = fileNames[OutputFile];
using (var stream = LimitedStream.CreateFile(fileName, MaximumOutputSize))
{
scene.Save(stream, fmt);
}
}
catch (Exception e)
{
var msg = "Internal server error";
if (e is ExportException)
{
msg = e.Message;
}
_logger.LogError(e, "Failed to save converted file to {0}", fileNames[SourceFile]);
OperationFailed(e);
return ResultModel.Error(fileNames.Id, msg, 500);
}
var newFileName = Path.ChangeExtension(originalFile, fmt.Extension);
importContext.MetaData.OutputFile = newFileName;
SetMetaData(fileNames, importContext.MetaData);
return ResultModel.Ok(true);
}
return ResultModel.Error(fileNames.Id, "Output type not found", 400);
}));
}
/// <summary>
/// Does the v2 deserialization.
/// </summary>
/// <param name="stream"></param>
/// <param name="lazy"></param>
/// <returns></returns>
protected override IBasicRouterDataSource <CHEdgeData> DoDeserialize(
LimitedStream stream, bool lazy)
{
var intBytes = new byte[4];
stream.Read(intBytes, 0, 4);
int startOfBlocks = BitConverter.ToInt32(intBytes, 0);
// deserialize regions index.
stream.Read(intBytes, 0, 4);
int sizeRegionIndex = BitConverter.ToInt32(intBytes, 0);
var chVertexRegionIndex = (CHVertexRegionIndex)_runtimeTypeModel.Deserialize(
new CappedStream(stream, stream.Position, sizeRegionIndex), null,
typeof(CHVertexRegionIndex));
// deserialize blocks index.
stream.Seek(startOfBlocks, SeekOrigin.Begin);
stream.Read(intBytes, 0, 4);
int sizeBlockIndex = BitConverter.ToInt32(intBytes, 0);
var chBlockIndex = (CHBlockIndex)_runtimeTypeModel.Deserialize(
new CappedStream(stream, stream.Position, sizeBlockIndex), null,
typeof(CHBlockIndex));
return(new CHEdgeDataDataSource(stream, this, sizeRegionIndex + 8,
chVertexRegionIndex, RegionZoom, startOfBlocks + sizeBlockIndex + 4, chBlockIndex, BlockVertexSize));
}
public static byte[] ReadMax(this Stream stream, Size limit, Size?estimatedSize = null)
{
using (LimitedStream limitedStream = new LimitedStream(stream, limit, leaveOpen: true))
{
return(limitedStream.ReadToEnd(estimatedSize));
}
}
public static async Task <byte[]> ReadMaxAsync(this Stream stream, Size limit, Size?estimatedSize = null)
{
using (LimitedStream limitedStream = new LimitedStream(stream, limit, leaveOpen: true))
{
return(await limitedStream.ReadToEndAsync(estimatedSize));
}
}
/// <summary>
/// Fills the given simple scene with objects inside the given view and for the given zoomFactor.
/// </summary>
/// <param name="scene"></param>
/// <param name="view"></param>
/// <param name="zoomFactor"></param>
public void Get(Scene2DSimple scene, View2D view, float zoomFactor)
{
lock (_stream) { // make sure there is only synchonous access to the stream.
// check what is in the non-simplified scene.
IScene2DPrimitivesSource simpleSource = this.GetNonSimplifiedStream();
simpleSource.Get(scene, view, zoomFactor);
// check what index this zoomfactor is for.
int idx = this.SearchForScene(zoomFactor);
if (idx >= 0) // the index was found.
{
if (!_loadedScenes.TryGetValue(idx, out simpleSource)) // the scene was not found.
{
long position = _index.SceneIndexes [idx];
_stream.Seek(position, SeekOrigin.Begin);
LimitedStream stream = new LimitedStream(_stream);
//Scene2DRTreeSerializer serializer = new Scene2DRTreeSerializer(true);
//simpleSource = new Scene2DPrimitivesSource(serializer.Deserialize(stream));
OsmSharp.UI.Renderer.Scene.Storage.Styled.Scene2DStyledSerializer serializer =
new Styled.Scene2DStyledSerializer();
simpleSource = serializer.Deserialize(stream, true);
_loadedScenes.Add(idx, simpleSource);
}
simpleSource.Get(scene, view, zoomFactor);
OsmSharp.Logging.Log.TraceEvent("Scene2DLayeredSource", System.Diagnostics.TraceEventType.Verbose,
string.Format("Deserialized from scene at zoom {0} and idx {1} synchronized.", zoomFactor, idx));
}
}
}
private void ReadResponseBody(ByteStreamReader reader, HttpResponseMessage response)
{
HttpContent content = null;
if (response.Headers.TransferEncodingChunked.GetValueOrDefault(false))
{
// read the body with chunked transfer encoding
var remainingStream = reader.GetRemainingStream();
var chunkedStream = new ReadsFromChunksStream(remainingStream);
content = new StreamContent(chunkedStream);
}
else if (response.Content.Headers.ContentLength.HasValue)
{
// read the body with a content-length
var remainingStream = reader.GetRemainingStream();
var limitedStream = new LimitedStream(remainingStream, response.Content.Headers.ContentLength.Value);
content = new StreamContent(limitedStream);
}
else
{
// TODO: should we immediately close the connection in this case?
}
if (content != null)
{
// copy over the content headers
foreach (var header in response.Content.Headers)
{
content.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
response.Content = content;
}
}
/// <summary>
/// Does the v1 deserialization.
/// </summary>
/// <param name="stream"></param>
/// <param name="lazy"></param>
/// <param name="vehicles"></param>
/// <returns></returns>
protected override IBasicRouterDataSource <TEdgeData> DoDeserialize(
LimitedStream stream, bool lazy, IEnumerable <string> vehicles)
{
ITagsCollectionIndex tagsCollectionIndex = this.CreateTagsCollectionIndex();
DynamicGraphRouterDataSource <TEdgeData> graph = this.CreateGraph(tagsCollectionIndex);
// deserialize vertices.
var sizeBytes = new byte[8];
stream.Read(sizeBytes, 0, 8);
var position = stream.Position;
var size = BitConverter.ToInt64(sizeBytes, 0);
this.DeserializeVertices(stream, size, graph);
stream.Seek(position + size, System.IO.SeekOrigin.Begin);
// deserialize edges.
stream.Read(sizeBytes, 0, 8);
position = stream.Position;
size = BitConverter.ToInt64(sizeBytes, 0);
this.DeserializeEdges(stream, size, graph);
stream.Seek(position + size, System.IO.SeekOrigin.Begin);
// deserialize tags.
stream.Read(sizeBytes, 0, 8);
position = stream.Position;
size = BitConverter.ToInt64(sizeBytes, 0);
this.DeserializeTags(stream, size, tagsCollectionIndex);
stream.Seek(position + size, System.IO.SeekOrigin.Begin);
return(graph);
}
/// <summary>
/// Does the v2 deserialization.
/// </summary>
/// <param name="stream"></param>
/// <param name="lazy"></param>
/// <param name="vehicles"></param>
/// <returns></returns>
protected override IBasicRouterDataSource <CHEdgeData> DoDeserialize(
LimitedStream stream, bool lazy, IEnumerable <string> vehicles)
{
var intBytes = new byte[4];
stream.Read(intBytes, 0, 4);
int startOfBlocks = BitConverter.ToInt32(intBytes, 0);
stream.Read(intBytes, 0, 4);
int startOfTags = BitConverter.ToInt32(intBytes, 0);
stream.Read(intBytes, 0, 4);
int sizeRegionIndex = BitConverter.ToInt32(intBytes, 0);
// deserialize regions index.
var chVertexRegionIndex = (CHVertexRegionIndex)_runtimeTypeModel.Deserialize(
new CappedStream(stream, stream.Position, sizeRegionIndex), null,
typeof(CHVertexRegionIndex));
// deserialize blocks index.
stream.Seek(startOfBlocks, SeekOrigin.Begin);
stream.Read(intBytes, 0, 4);
int sizeBlockIndex = BitConverter.ToInt32(intBytes, 0);
var chBlockIndex = (CHBlockIndex)_runtimeTypeModel.Deserialize(
new CappedStream(stream, stream.Position, sizeBlockIndex), null,
typeof(CHBlockIndex));
// deserialize tags.
stream.Seek(startOfTags, SeekOrigin.Begin);
ITagsCollectionIndexReadonly tagsIndex = TagIndexSerializer.DeserializeBlocks(stream);
return(new v2.CHEdgeDataDataSource(stream, this, vehicles, sizeRegionIndex + 12,
chVertexRegionIndex, _regionZoom, startOfBlocks + sizeBlockIndex + 4, chBlockIndex, (uint)_blockVertexSize,
tagsIndex));
}
/// <summary>
/// Serializes the given graph.
/// </summary>
/// <param name="stream"></param>
/// <param name="graph"></param>
/// <param name="metaTags"></param>
public void Serialize(Stream stream, RouterDataSource <TEdgeData> graph, TagsCollectionBase metaTags)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (graph == null)
{
throw new ArgumentNullException("graph");
}
// write the header.
this.WriteVersionHeader(stream);
// write the vehicles.
this.WriteVehicleProfiles(stream, graph.GetSupportedProfiles());
// write the meta-data.
this.WriteMeta(stream, metaTags);
// wrap the stream.
var routingSerializerStream = new LimitedStream(stream);
// do the version-specific serialization.
this.DoSerialize(routingSerializerStream, graph);
}
/// <summary>
/// Deserializes all edges.
/// </summary>
/// <param name="stream"></param>
/// <param name="size"></param>
/// <param name="graph"></param>
protected override void DeserializeEdges(LimitedStream stream, long size, DynamicGraphRouterDataSource <LiveEdge> graph)
{
var typeModel = RuntimeTypeModel.Create();
typeModel.Add(typeof(SerializableEdge), true);
typeModel.Add(typeof(GeoCoordinateSimple), true);
long position = stream.Position;
while (stream.Position < position + size)
{ // keep looping until the appropriate number of bytes have been read.
var serializableEdges = typeModel.DeserializeWithSize(stream, null, typeof(SerializableEdge[])) as SerializableEdge[];
for (int idx = 0; idx < serializableEdges.Length; idx++)
{
ICoordinateCollection coordinateCollection = null;
if (serializableEdges[idx].Coordinates != null)
{
coordinateCollection = new CoordinateArrayCollection <GeoCoordinateSimple>(serializableEdges[idx].Coordinates);
}
graph.AddEdge(serializableEdges[idx].FromId, serializableEdges[idx].ToId,
new LiveEdge()
{
Distance = serializableEdges[idx].Distance,
Value = serializableEdges[idx].Value
}, coordinateCollection);
}
}
}
/// <summary>
/// Deserializes the given stream into a routable graph.
/// </summary>
/// <param name="stream"></param>
/// <param name="lazy"></param>
/// <param name="metaTags"></param>
/// <returns></returns>
public RouterDataSource <TEdgeData> Deserialize(Stream stream, out TagsCollectionBase metaTags, bool lazy = true)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
// make sure the stream seeks to the beginning.
stream.Seek(0, SeekOrigin.Begin);
if (this.CanDeSerialize(stream))
{
// read/verify the current version header.
this.ReadAndValidateHeader(stream);
// read vehicle profiles.
var vehicles = this.ReadVehicleProfiles(stream);
// deserialize meta data.
metaTags = this.ReadMeta(stream);
// wrap the stream.
var routingSerializerStream = new LimitedStream(stream);
// do the actual version-specific deserialization.
return(this.DoDeserialize(routingSerializerStream, lazy, vehicles));
}
throw new ArgumentOutOfRangeException("stream", "Cannot deserialize the given stream, version unsupported or content unrecognized!");
}
public void TestWriteWithinThenAboveLimit()
{
var innerStream = new MemoryStream();
var sut = new LimitedStream(innerStream, 10);
sut.Write(new byte[5] {
1, 2, 3, 4, 5
}, 0, 5);
var actual5 = new byte[5];
innerStream.Seek(0, SeekOrigin.Begin);
innerStream.Read(actual5, 0, 5);
Assert.Equal((byte)1, actual5[0]);
Assert.Equal((byte)5, actual5[4]);
sut.Write(new byte[5] {
6, 7, 8, 9, 10
}, 0, 5);
var actual10 = new byte[10];
innerStream.Seek(0, SeekOrigin.Begin);
innerStream.Read(actual10, 0, 10);
Assert.Equal((byte)1, actual10[0]);
Assert.Equal((byte)10, actual10[9]);
Assert.Throws <ArgumentOutOfRangeException>(() => sut.Write(new byte[1] {
11
}, 0, 1));
}
public void TestWriteWithinThenAboveLimit()
{
MemoryStream innerStream = new MemoryStream();
LimitedStream sut = new LimitedStream(innerStream, 10);
sut.Write(new byte[5] {
(byte)1, (byte)2, (byte)3, (byte)4, (byte)5
}, 0, 5);
byte[] actual5 = new byte[5];
innerStream.Seek(0, SeekOrigin.Begin);
innerStream.Read(actual5, 0, 5);
Assert.AreEqual((byte)1, actual5[0]);
Assert.AreEqual((byte)5, actual5[4]);
sut.Write(new byte[5] {
(byte)6, (byte)7, (byte)8, (byte)9, (byte)10
}, 0, 5);
byte[] actual10 = new byte[10];
innerStream.Seek(0, SeekOrigin.Begin);
innerStream.Read(actual10, 0, 10);
Assert.AreEqual((byte)1, actual10[0]);
Assert.AreEqual((byte)10, actual10[9]);
sut.Write(new byte[1] {
(byte)11
}, 0, 1);
}
public void TestWriteAboveLimit()
{
var innerStream = new MemoryStream();
var sut = new LimitedStream(innerStream, 3);
Assert.Throws <ArgumentOutOfRangeException>(() => sut.Write(new byte[5] {
1, 2, 3, 4, 5
}, 0, 5));
}
public void TestWriteAboveLimitWithByteLengthShorterThanCount()
{
var innerStream = new MemoryStream();
var sut = new LimitedStream(innerStream, 3);
Assert.Throws <ArgumentOutOfRangeException>(() => sut.Write(new byte[5] {
1, 2, 3, 4, 5
}, 1, 13));
}
public void TestWriteAboveLimitWithByteLengthShorterThanCount()
{
MemoryStream innerStream = new MemoryStream();
LimitedStream sut = new LimitedStream(innerStream, 3);
sut.Write(new byte[5] {
(byte)1, (byte)2, (byte)3, (byte)4, (byte)5
}, 1, 13);
}
public void TestWriteAboveLimit()
{
MemoryStream innerStream = new MemoryStream();
LimitedStream sut = new LimitedStream(innerStream, 3);
sut.Write(new byte[5] {
(byte)1, (byte)2, (byte)3, (byte)4, (byte)5
}, 0, 5);
}
protected HttpResponseMessage StreamResult(string filename, Stream resultContent)
{
var response = new HttpResponseMessage
{
Headers =
{
TransferEncodingChunked = false
}
};
long length;
ContentRangeHeaderValue contentRange = null;
if (Request.Headers.Range != null)
{
if (Request.Headers.Range.Ranges.Count != 1)
{
throw new InvalidOperationException("Can't handle multiple range values");
}
var range = Request.Headers.Range.Ranges.First();
var from = range.From ?? 0;
var to = range.To ?? resultContent.Length;
length = (to - from);
// "to" in Content-Range points on the last byte. In other words the set is: <from..to> not <from..to)
if (from < to)
{
contentRange = new ContentRangeHeaderValue(from, to - 1, resultContent.Length);
resultContent = new LimitedStream(resultContent, from, to);
}
else
{
contentRange = new ContentRangeHeaderValue(0);
resultContent = Stream.Null;
}
}
else
{
length = resultContent.Length;
}
response.Content = new StreamContent(resultContent)
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = filename
},
// ContentLength = length,
ContentRange = contentRange,
}
};
return(response);
}
/// <summary>
/// Deserializes to the level of primitive blocks (PrimitiveBlock)
/// </summary>
private void ReadFilePdb()
{
using (var file = File.OpenRead(_pathFilePdb))
{
int length, blockCount = 0;
while (Serializer.TryReadLengthPrefix(file, PrefixStyle.Fixed32, out length))
{
length = LowLevelReader.IntLittleEndianToBigEndian((uint)length);
BlobHeader header;
using (var tmp = new LimitedStream(file, length))
{
try
{
header = Serializer.Deserialize <BlobHeader>(tmp);
}
catch (Exception e)
{
throw new FileLoadException("Invalid file format .pdb", e);
}
}
Blob blob;
using (var tmp = new LimitedStream(file, header.datasize))
{
blob = Serializer.Deserialize <Blob>(tmp);
}
if (blob.zlib_data == null)
{
throw new NotSupportedException("I'm only handling zlib here!");
}
HeaderBlock headerBlock;
PrimitiveBlock primitiveBlock;
using (var ms = new MemoryStream(blob.zlib_data))
using (var zlib = new ZLibStream(ms))
{
if (header.type == "OSMHeader")
{
headerBlock = Serializer.Deserialize <HeaderBlock>(zlib);
}
if (header.type == "OSMData")
{
primitiveBlock = Serializer.Deserialize <PrimitiveBlock>(zlib);
if (primitiveBlock != null)
{
ReadPrimitiveBlock(primitiveBlock);
}
}
}
blockCount++;
}
if (_tagsValues.Rows.Count > 0)
{
this.ImportDataTableInDb(ref _tagsValues, new GetTable(GetTableTagsValue));
}
}
}
/// <summary>
/// Serializes all edges.
/// </summary>
/// <param name="stream"></param>
/// <param name="graph"></param>
protected override void SerializeEdges(LimitedStream stream, DynamicGraphRouterDataSource <LiveEdge> graph)
{
var typeModel = RuntimeTypeModel.Create();
typeModel.Add(typeof(SerializableEdge), true);
typeModel.Add(typeof(GeoCoordinateSimple), true);
int blockSize = 1000;
var arcsQueue = new List <SerializableEdge>(blockSize);
uint vertex = 0;
while (vertex < graph.VertexCount)
{ // keep looping and serialize all vertices.
var arcs = graph.GetEdges(vertex);
if (arcs != null)
{ // serialize the arcs, but serialize them only once.
// choose only those arcs that start at a vertex smaller than the target.
for (int idx = 0; idx < arcs.Length; idx++)
{
if (arcs[idx].Key > vertex)
{
GeoCoordinateSimple[] coordinates;
if (!graph.GetEdgeShape(vertex, arcs[idx].Key, out coordinates))
{
coordinates = null;
}
arcsQueue.Add(new SerializableEdge()
{
Distance = arcs[idx].Value.Distance,
FromId = vertex,
ToId = arcs[idx].Key,
Value = arcs[idx].Value.Value,
Coordinates = coordinates
});
if (arcsQueue.Count == blockSize)
{ // execute serialization.
typeModel.SerializeWithSize(stream, arcsQueue.ToArray());
arcsQueue.Clear();
}
}
}
// serialize.
vertex++;
}
}
if (arcsQueue.Count > 0)
{ // execute serialization.
typeModel.SerializeWithSize(stream, arcsQueue.ToArray());
arcsQueue.Clear();
}
}
public void TestCopyToAboveLimit()
{
var innerStream = new MemoryStream();
var sut = new LimitedStream(innerStream, 3);
var sourceStream = new MemoryStream(new byte[5] {
1, 2, 3, 4, 5
});
Assert.Throws <ArgumentOutOfRangeException>(() => sourceStream.CopyTo(sut));
}
public void TestCopyToAboveLimit()
{
MemoryStream innerStream = new MemoryStream();
LimitedStream sut = new LimitedStream(innerStream, 3);
MemoryStream sourceStream = new MemoryStream(new byte[5] {
(byte)1, (byte)2, (byte)3, (byte)4, (byte)5
});
sourceStream.CopyTo(sut);
}
/// <summary>
/// Deserializes a tags index from the given stream.
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public static TagsIndex Deserialize(System.IO.Stream stream)
{
long size;
var tagsIndex = MemoryMappedIndex <int[]> .Deserialize(stream, MemoryMappedDelegates.ReadFromIntArray, MemoryMappedDelegates.WriteToIntArray, false, out size);
stream.Seek(size, System.IO.SeekOrigin.Begin);
var limitedStream = new LimitedStream(stream);
var stringIndex = MemoryMappedIndex <string> .Deserialize(limitedStream, MemoryMappedDelegates.ReadFromString, MemoryMappedDelegates.WriteToString, false);
return(new TagsIndex(stringIndex, tagsIndex));
}
public async Task Limits_Asynchronously()
{
// ARRANGE
var innerStream = new MemoryStream(Encoding.ASCII.GetBytes("foobar"));
var stream = new LimitedStream(innerStream, 3);
// ACT
var actual = await new StreamReader(stream, Encoding.ASCII).ReadToEndAsync();
// ASSERT
actual.Should().Be("foo");
}
public async Task TestReadAsync()
{
Size limitedSize = new Size(2);
using (FileStream fileStream = readFileInfo.OpenRead())
using (LimitedStream limitedStream = new LimitedStream(fileStream, limitedSize))
{
Assert.AreNotEqual(limitedSize.Bytes, fileStream.Length);
Assert.AreEqual(limitedSize.Bytes, (await limitedStream.ReadToEndAsync()).LongLength);
Assert.AreEqual(0, (await limitedStream.ReadToEndAsync()).LongLength);
}
}
/// <summary>
/// Serialize/deserialize index.
/// </summary>
/// <param name="index"></param>
/// <param name="position"></param>
/// <returns></returns>
private ITagsCollectionIndexReadonly SerializeDeserializeLimitedStream(ITagsCollectionIndex index, int position)
{
MemoryStream memoryStream = new MemoryStream();
memoryStream.Seek(position, SeekOrigin.Begin);
LimitedStream stream = new LimitedStream(memoryStream);
TagIndexSerializer.Serialize(stream, index);
stream.Seek(0, SeekOrigin.Begin);
return(TagIndexSerializer.Deserialize(stream));
}
/// <summary>
/// Serialize/deserialize index.
/// </summary>
/// <param name="index"></param>
/// <param name="blockSize"></param>
/// <param name="position"></param>
/// <returns></returns>
private ITagsIndexReadonly SerializeDeserializeBlockLimitedStream(ITagsIndex index, uint blockSize, int position)
{
MemoryStream memoryStream = new MemoryStream();
memoryStream.Seek(position, SeekOrigin.Begin);
LimitedStream stream = new LimitedStream(memoryStream);
stream.Seek(position, SeekOrigin.Begin);
TagIndexSerializer.SerializeBlocks(stream, index, blockSize);
stream.Seek(position, SeekOrigin.Begin);
return(TagIndexSerializer.DeserializeBlocks(stream));
}
