public static async Task Dds2Spr(string path) { var file = File.Open(path, FileMode.Open); var serializer = new BinarySerializer(); #if DEBUG serializer.MemberDeserialized += OnMemberDeserialized; #endif var tex = await serializer.DeserializeAsync <SpriteFile>(file); var ddsFiles = Directory.EnumerateFiles(Path.GetDirectoryName(path)).Where(f => Path.GetExtension(f) == ".dds"); var counter = 0; foreach (var ddsFile in ddsFiles) { using (var ddsEdit = new FileStream(ddsFile, FileMode.Open)) { var dds = await serializer.DeserializeAsync <DdsFile>(ddsEdit); tex.Atlas.Textures[counter++].Mipmaps[0] = dds.ToTxpMip(); } } file = new FileStream(path, FileMode.Create); await serializer.SerializeAsync(file, tex); }
public async Task FromArray() { var Message = await BinarySerializer.DeserializeAsync <Message>(RequestBytes); Assert.AreEqual(Message.ID, 39922); Assert.AreEqual(MessageType.Query, Message.MessageType); Assert.AreEqual(OperationCode.Query, Message.OperationCode); Assert.AreEqual(AuthoritativeAnswer.Cache, Message.AuthoritativeAnswer); Assert.AreEqual(false, Message.Truncated); Assert.AreEqual(true, Message.RecursionDesired); Assert.AreEqual(false, Message.RecursionAvailable); Assert.AreEqual(0, Message.Zero); Assert.AreEqual(false, Message.AuthenticatedData); Assert.AreEqual(false, Message.CheckingDisabled); Assert.AreEqual(ResponseCode.NoError, Message.ResponseCode); Assert.AreEqual(1, Message.QuestionsCount); Assert.AreEqual(0, Message.AnswersCount); Assert.AreEqual(0, Message.AuthorityCount); Assert.AreEqual(0, Message.AdditionalCount); Assert.IsNotNull(Message.Questions); var Question = Message.Questions?.First(); Assert.IsNotNull(Question); Assert.AreEqual(RecordType.A, Question.Type); Assert.AreEqual(RecordClass.Internet, Question.Class); Assert.AreEqual("facebook.com", Question.Domain.Name); }
public static async Task RunAsync() { // Create a full text index with a custom key type var index = new FullTextIndexBuilder <CompositeKey>().Build(); // Index some sample data await index.AddAsync(new CompositeKey(1, 9), "This is some text associated with A: fizz"); await index.AddAsync(new CompositeKey(2, 9), "Some buzz text for B"); await index.AddAsync(new CompositeKey(3, 11), "Text associated with C is both fizz and buzz"); // This would error with: No standard key serializer exists for type CompositeKey - // please provide a custom implementation of IKeySerializer<> when serializing/deserializing. // var serializer = new BinarySerializer<int>(); var serializer = new BinarySerializer <CompositeKey>(new CompositeKeySerializer()); using var stream = new MemoryStream(); // Serialize the index await serializer.SerializeAsync(index, stream, disposeStream : false); // Deserialize the index into a new instance stream.Position = 0; var newIndex = new FullTextIndexBuilder <CompositeKey>().Build(); await serializer.DeserializeAsync(newIndex, stream, disposeStream : false); // Prove that the new index has the same contents and the keys have round-tripped // Emits: only (3, 11) contains Fizz & Buzz var match = newIndex.Search("fizz & buzz").Single(); Console.WriteLine($"Only ({match.Key.UserId}, {match.Key.CompanyId}) contains Fizz & Buzz"); }
public async Task ResolveAsync(UdpReceiveResult UdpReceiveResult) { ushort ID = 0; try { var Request = await BinarySerializer.DeserializeAsync <Message>(UdpReceiveResult.Buffer); ID = Request.ID; var Response = await ResponsibilityChain.Execute(Request); var ResponseBytes = await BinarySerializer.SerializeAsync(Response); await UdpClient.SendAsync(ResponseBytes, ResponseBytes.Length, UdpReceiveResult.RemoteEndPoint); } catch (Exception Error) { var Response = new Message() { ID = ID, MessageType = MessageType.Response, ResponseCode = ResponseCode.FormatError, }; var ResponseBytes = Response.ToArray(); await UdpClient.SendAsync(ResponseBytes, ResponseBytes.Length, UdpReceiveResult.RemoteEndPoint); //Console.WriteLine(Error); } }
public async Task DeserializeFromPipeSpeedTest() { var binarySerializer = new BinarySerializer(new StandartBinarySerializer(), new StandartBinaryDeserializer(), BinarySerializerStuffTest.Converters); var mock = RecursiveMock <RecursiveMock <RecursiveMock <RecursiveMock <RecursiveMock <int> > > > > .Create( RecursiveMock <RecursiveMock <RecursiveMock <RecursiveMock <int> > > > .Create( RecursiveMock <RecursiveMock <RecursiveMock <int> > > .Create( RecursiveMock <RecursiveMock <int> > .Create( RecursiveMock <int> .Create(int.MaxValue ) ) ) ) ); var serialize = binarySerializer.Serialize(mock); var sw = Stopwatch.StartNew(); for (var i = 0; i < 10000; i++) { var pipe = PipeReader.Create(new MemoryStream(serialize.Result.ToArray())); sw.Start(); var data = await binarySerializer.DeserializeAsync <long, RecursiveMock <RecursiveMock <RecursiveMock <RecursiveMock <RecursiveMock <int> > > > > >(pipe, CancellationToken.None); sw.Stop(); Assert.NotNull(data); } Assert.Less(sw.ElapsedMilliseconds, 300); TestContext.WriteLine($"Deserialize: {sw.Elapsed.ToString()}"); }
public static async Task RunAsync() { // Create a full text index with default settings var index = new FullTextIndexBuilder <int>().Build(); // Index some sample data await index.AddAsync(1, "This is some text associated with A: fizz"); await index.AddAsync(2, "Some buzz text for B"); await index.AddAsync(3, "Text associated with C is both fizz and buzz"); var serializer = new BinarySerializer <int>(); using var stream = new MemoryStream(); // Serialize the index await serializer.SerializeAsync(index, stream, disposeStream : false); // Deserialize the index into a new instance stream.Position = 0; var newIndex = new FullTextIndexBuilder <int>().Build(); await serializer.DeserializeAsync(newIndex, stream, disposeStream : false); // Prove that the new index has the same contents // Emits: 3 items contain text in the new index var matches = newIndex.Search("text"); Console.WriteLine($"{matches.Count()} items contain text in the new index"); }
public async Task <byte[]> ResolveAsync(byte[] Query) { var Request = await BinarySerializer.DeserializeAsync <Message>(Query); var Response = await ResolveAsync(Request); return(await BinarySerializer.SerializeAsync(Response)); }
public async Task <IMessage> ResolveAsync(IMessage Message) { var RequestBytes = await BinarySerializer.SerializeAsync(Message); var ResponseBytes = await ResolveAsync(RequestBytes); return(await BinarySerializer.DeserializeAsync <Message>(ResponseBytes)); }
public async Task BytesAsync() { var RequestBytes = await BinarySerializer.SerializeAsync(RequestMessage); var ResponseBytes = await Resolver.ResolveAsync(RequestBytes); ResponseMessage = await BinarySerializer.DeserializeAsync <Message>(ResponseBytes); Assertions(); }
public virtual async ValueTask <IMessage> ResolveAsync(IMessage Query) { var SerializedQuery = await BinarySerializer.SerializeAsync(Query); var SerializedAnswer = await ResolveAsync(SerializedQuery); var AnswerMessage = await BinarySerializer.DeserializeAsync <Message>(SerializedAnswer); return(AnswerMessage); }
protected T Deserialize <T>(Stream stream, object context = null) { #if TESTASYNC var task = Serializer.DeserializeAsync <T>(stream, context); task.ConfigureAwait(false); task.Wait(); return(task.Result); #else return(Serializer.Deserialize <T>(stream, context)); #endif }
protected T DeserializeBe <T>(Stream stream) { #if TESTASYNC var task = SerializerBe.DeserializeAsync <T>(stream); task.ConfigureAwait(false); task.Wait(); return(task.Result); #else return(SerializerBe.Deserialize <T>(stream)); #endif }
public async Task <Message> Run(Message Message, Func <Message, Task <Message> > Next) { //Using Binary Format Over HTTPs var RequestBytes = await BinarySerializer.SerializeAsync(Message); var ResponseBytes = await ResolveAsync(RequestBytes); Message = await BinarySerializer.DeserializeAsync <Message>(ResponseBytes); return(Next is null ? Message : await Next(Message)); }
public async Task SerializeWithPoolDeserializeFromPipeRecursiveComposeValueTypeTest() { var binarySerializer = new BinarySerializer(new ArrayPoolBinarySerializer(), new StandartBinaryDeserializer(), BinarySerializerStuffTest.Converters); var mock = RecursiveMock <int> .Create(1337); var serialize = binarySerializer.Serialize(mock); var pipe = PipeReader.Create(new MemoryStream(serialize.Result.ToArray())); var data = await binarySerializer.DeserializeAsync <long, RecursiveMock <int> >(pipe, CancellationToken.None); Assert.NotNull(data); }
public async Task ShouldDeserializeV2Index() { var index = new FullTextIndexBuilder <string>().Build(); var serializer = new BinarySerializer <string>(); using (var stream = new MemoryStream(TestResources.v2Index)) { await serializer.DeserializeAsync(index, stream); } index.Search("serialized").Should().HaveCount(1); index.Search("亜").Should().HaveCount(1); }
public async Task <(Log _log, byte[] _response)> NewMessageAsync(byte[] bytes) { try { var serializer = new BinarySerializer(); var message = await serializer.DeserializeAsync <SocketMessage>(bytes); var log = new Log() { CreatedOn = DateTime.UtcNow, MobileID = message.OptionsHeader.MobileID.ToHex(), ServiceType = message.Header.ServiceType.ToString(), MessageType = message.Header.MessageType.ToString(), SequenceNumber = message.Header.SequenceNumber, RawData = bytes.ToHex(), Decoded = message }; if (message.Contents.GetType().IsAssignableTo <BaseReportContents>()) { var contents = message.Contents as BaseReportContents; log.UpdateTime = contents.UpdateTime.ToDateTime(); log.Latitude = contents.Latitude; log.Longitude = contents.Longitude; log.Altitude = contents.Altitude; log.Speed = contents.Speed * 0.036; //1cm/s=1/1000000cm/1/3600s=0.036km/h log.Heading = contents.Heading; if (message.Contents.GetType().IsAssignableTo <EventReportMessage>()) { var er = message.Contents as EventReportMessage; var codevalue = string.Empty; if (!DicEventCode.TryGetValue(er.EventCode, out codevalue)) { codevalue = string.Format("No Definition EventCode{0}", er.EventCode); } log.EventCode = codevalue; } } await _repository.InsertOneAsync(log); return(log, Response(message, serializer)); } catch (Exception e) { Console.WriteLine(e.Message); return(null, null); } }
public async Task <IMessage> ResolveAsync(IMessage Query) { var Buffer = await BinarySerializer.SerializeAsync(Query); await Client.SendAsync(Buffer, Buffer.Length, IPEndPoint); var Task = Client.ReceiveAsync(); Task.Wait(Timeout); var Result = Task.IsCompleted ? Task.Result : throw new TimeoutException(); return(await BinarySerializer.DeserializeAsync <Message>(Result.Buffer)); }
public async Task SerializeWithPoolDeserializeFromPipeReaderTest() { var binarySerializer = new BinarySerializer(new ArrayPoolBinarySerializer(), new StandartBinaryDeserializer(), BinarySerializerStuffTest.Converters); var ethalon = Mock.Default(); const int ethalonHeaderLength = 270; var serialize = binarySerializer.Serialize(ethalon); Assert.IsTrue(serialize.Length == ethalon.Size + ethalonHeaderLength); var deserialize = await binarySerializer.DeserializeAsync <long, Mock>(PipeReader.Create(new MemoryStream(serialize.Result.ToArray())), CancellationToken.None); Assert.IsTrue(ethalon.Equals(deserialize.Result)); serialize.Dispose(); }
static async Task Main(string[] args) { if (args.Length == 0) { Console.WriteLine("DIVAFILE Converter\r\n----------------------------------------------------\r\n" + "Converts files to DIVAFILE encryption and vice versa.\r\n\r\nUsage:\r\n" + " Just drag\'n\'drop\r\n\r\nTested:\r\n Project Diva F2nd"); Console.Read(); return; } var serializer = new BinarySerializer(); if (Directory.Exists(args[0])) { } using (var file = new FileStream(args[0], FileMode.Open)) { if (file.Length == 0) { throw new IOException("File contains no data"); } if (DivaFile.IsValid(file)) { var divaFile = await serializer.DeserializeAsync <DivaFile>(file); var decrypt = divaFile.DecryptBytes(); file.Close(); using (var save = new FileStream(args[0], FileMode.Create)) { await serializer.SerializeAsync(save, decrypt); } } else { var divaFile = new DivaFile(file); //divaFile.EncryptedData = new MemoryStream(divaFile.EncryptedData); file.Close(); using (var save = new FileStream(args[0], FileMode.Create)) { await serializer.SerializeAsync(save, divaFile); } } } }
private static async Task <FullTextIndex <string> > SearializeAndDeserializeIndexWithText(string text) { var stream = new MemoryStream(); var serializer = new BinarySerializer <string>(); var index = new FullTextIndexBuilder <string>().Build(); await index.AddAsync("A", text); await serializer.SerializeAsync(index, stream, false); stream.Position = 0; var index2 = new FullTextIndexBuilder <string>().Build(); await serializer.DeserializeAsync(index2, stream); return(index2); }
public async Task QueryAsync() { ResponseMessage = await Resolver.ResolveAsync(RequestMessage); Assert.AreEqual(ID, ResponseMessage.ID); Assert.IsNotNull(ResponseMessage.Questions); Assert.IsNotNull(ResponseMessage.Answers); Assert.IsInstanceOfType(ResponseMessage.Answers[0].Record, typeof(DNS.Records.TXT)); var BinarySerializer = new BinarySerializer(); var Bytes = await BinarySerializer.SerializeAsync(ResponseMessage); ResponseMessage = await BinarySerializer.DeserializeAsync <Message>(Bytes); }
public async Task <IMessage> ResolveAsync(IMessage Request) { if (!TcpClient.Connected || !SslStream.CanWrite) { await InitializeAsync(); } var Bytes = await BinarySerializer.SerializeAsync(Request); var Length = BitConverter.GetBytes((ushort)Bytes.Length); Array.Reverse(Length); await PipeWriter.WriteAsync(Length); await PipeWriter.WriteAsync(Bytes); PipeWriter.Complete(); var Task = PipeReader.ReadAsync().AsTask(); Task.Wait(Options.CurrentValue.Timeout); if (Task.IsCompleted) { var Result = Task.Result; var Buffer = Result.Buffer.Length > 14 ? Result.Buffer.Slice(2) : throw new OperationCanceledException(); var Response = await BinarySerializer.DeserializeAsync <Message>(Buffer); PipeReader.Complete(); return(Response); } else { PipeReader.CancelPendingRead(); PipeReader.Complete(); throw new TimeoutException(); } }
public async Task Test_Diff_Obj_Ctor_Complex() { var a = createComplexCtorC(1); byte[] data = BinarySerializer.Serialize(a); var b = BinarySerializer.Deserialize <DiffTestCtorC>(data); Assert.NotNull(b); MemoryStream ms = new MemoryStream(); await BinarySerializer.SerializeAsync(ms, a); ms.Position = 0; b = await BinarySerializer.DeserializeAsync <DiffTestCtorC>(ms); Assert.NotNull(b); }
protected override async ValueTask InitializeAsync() { var Query = new Message() { ID = (ushort)Random.Next(), MessageType = MessageType.Query, Truncated = false, CheckingDisabled = true, RecursionDesired = true, Questions = new List <IQuestion>() { new Question() { Type = RecordType.TXT, Class = RecordClass.Internet, Domain = Domain.FromString(Stamp.ProviderName) } } }; var SerializedQuery = await BinarySerializer.SerializeAsync(Query); await Client.SendAsync(SerializedQuery, SerializedQuery.Length, IPEndPoint); var Task = Client.ReceiveAsync(); Task.Wait(Options.CurrentValue.Timeout); var SerializedAnswer = Task.IsCompleted ? Task.Result.Buffer : throw new TimeoutException(); var AnswerMessage = await BinarySerializer.DeserializeAsync <Message>(SerializedAnswer); var IsValid = await VerifyServer(AnswerMessage); if (!IsValid) { throw new CryptographicUnexpectedOperationException("Invalid Server Certificate."); } SharedKey = MontgomeryCurve25519.KeyExchange(Certificate.PublicKey, ClientPrivateKey); IsInitialized = true; }
public async Task ShouldRoundTripIndexStructure() { var serializer = new BinarySerializer <string>(); var fileName = Guid.NewGuid().ToString() + ".dat"; using (var stream = File.Open(fileName, FileMode.CreateNew)) { var stopwatch = Stopwatch.StartNew(); var index = await CreateWikipediaIndexAsync(); await serializer.SerializeAsync(index, stream, false); this.output.WriteLine($"Serialized in {stopwatch.ElapsedMilliseconds}ms"); stream.Length.Should().BeGreaterThan(4); var newIndex = new FullTextIndexBuilder <string>().Build(); stream.Position = 0; stopwatch.Restart(); await serializer.DeserializeAsync(newIndex, stream, false); this.output.WriteLine($"Deserialized in {stopwatch.ElapsedMilliseconds}ms"); newIndex.Items.GetIndexedItems().Should().BeEquivalentTo(index.Items.GetIndexedItems()); newIndex.Count.Should().Be(index.Count); newIndex.Root.ToString().Should().Be(index.Root.ToString()); var oldResults = index.Search("test").ToList(); var newResults = newIndex.Search("test").ToList(); oldResults.Should().NotBeEmpty(); newResults.Should().BeEquivalentTo(oldResults); newIndex.Search("🤷♀️").Should().HaveCount(1); } File.Delete(fileName); }
public static async Task Spr2Dds(string path) { var file = File.Open(path, FileMode.Open); var parentPath = Path.GetDirectoryName(path); var serializer = new BinarySerializer(); #if DEBUG serializer.MemberDeserialized += OnMemberDeserialized; #endif var tex = await serializer.DeserializeAsync <SpriteFile>(file); file.Close(); var tst = 0; foreach (var txpTexture in tex.Atlas.Textures) { using (var save = new FileStream($"{parentPath}\\{tex.Header.TextureNames[tst++]}.dds", FileMode.Create)) { await serializer.SerializeAsync(save, (DdsFile)txpTexture); } } }
public async Task Test <T>(T input, Action <T> check, BinarySerializerOptions options = null) { MemoryStream ms = new MemoryStream(); await BinarySerializer.SerializeAsync <T>(ms, input, options); ms.Position = 0; T b = await BinarySerializer.DeserializeAsync <T>(ms, options); check(b); ms.Position = 0; object b1 = await BinarySerializer.DeserializeAsync(ms, options); check((T)b1); byte[] bytes = BinarySerializer.Serialize <T>(input, options); T b2 = BinarySerializer.Deserialize <T>(bytes, options); check(b2); b1 = BinarySerializer.Deserialize(bytes, options); check((T)b1); }
public static async ValueTask <T> DeserializeAsync <T>(this BinarySerializer Serializer, ReadOnlySequence <byte> ReadOnlySequence) { return(await Serializer.DeserializeAsync <T>(ReadOnlySequence.AsStream())); }
static async Task Main(string[] args) { #if DEBUG //using (var file = File.Open(@"D:\Emulators\RPSC3\dev_hdd0\game\NPJB00134\USRDIR\rom\script\pv_007_extreme.dsc", FileMode.Open)) //using (var file = File.Open(@"D:\Emulators\RPSC3\dev_hdd0\disc\BLJM60527\PS3_GAME\USRDIR\rom\script\pv600\pv_600_extreme.dsc", FileMode.Open)) var path = @"D:\dsc\pv_611_extreme.dsc"; path = @"D:\DIVATools\test_files\dsc\pv_717_normal.dsc"; using (var file = File.Open(path, FileMode.Open)) { var serial = new BinarySerializer(); //serial.Endianness = Endianness.Big; serial.MemberDeserialized += OnMemberDeserialized; //file.Position = 68; var dsc = await serial.DeserializeAsync <DscFile2>(file); var notesWrapper = dsc.Functions.Where(func => func.Function.GetType() == typeof(FTarget)).ToList(); var indices = notesWrapper.Select(note => dsc.Functions.FindIndex(elem => elem == note)).ToList(); var timesWrapper = indices.Select(i => dsc.Functions[i - 1]).ToList(); var times = timesWrapper.Select(wrapper => wrapper.Function).Where(time => time.GetType() == typeof(FTime)).ToList(); var notes = notesWrapper.Select(wrapper => wrapper.Function).ToList(); /* * using (var save = new StreamWriter(Path.ChangeExtension(path, ".xml"))) * { * save.WriteLine(@",timestamp,type,holdLength,bIsHoldEnd,posX,posY,entryAngle,oscillationFrequency,oscillationAngle,oscillationAmplitude,timeout"); * for (var i = 0; i < times.Count; ++i) * { * var time = (FTime)times[i]; * var note = (FTarget) notes[i]; * save.WriteLine($"{i},{(time.TimeStamp > 0 ? time.TimeStamp/1000 : -1)},{note.Type},{note.HoldLength},{note.IsHoldEnd},{note.Position.x/10000},{note.Position.y / 10000}," + * $"{note.EntryAngle},{note.OscillationFrequency},{note.OscillationAngle},{note.OscillationAmplitude},{note.TimeOut/1000}"); * } * } */ return; } return; #endif if (args.Length < 1) { Console.WriteLine("FDSC Tool"); Console.WriteLine("========="); Console.WriteLine("Converter for all Project Diva DSC(Diva Script Container) files.\n"); Console.WriteLine("Currently Supports:"); Console.WriteLine(" - All DT games"); Console.WriteLine(" - F"); Console.WriteLine(" - F2nd\n"); Console.WriteLine("Usage:"); Console.WriteLine(" Drag'n'Drop the file onto the application\n"); Console.WriteLine(" or\n"); Console.WriteLine(" Run from command line:"); Console.WriteLine(" "); Console.WriteLine(" FDSC [source] "); Console.WriteLine(" Source is a URI to your dsc file"); Console.ReadLine(); } if (!File.Exists(args[0])) { throw new IOException("file doesn't exist."); } if (File.GetAttributes(args[0]).HasFlag(FileAttributes.Directory)) { throw new NotImplementedException("FDSC doesn't support batch conversion currently."); } switch (Path.GetExtension(args[0])) { case ".dsc": DscConvert(args[0]); break; case ".xml": XmlConvert(args[0]); break; } Console.Write("Conversion Complete!\n"); Console.ReadLine(); }
public static async Task <Question> FromArrayAsync(byte[] Bytes) { var Serializer = new BinarySerializer(); return(await Serializer.DeserializeAsync <Question>(Bytes)); }