Exemple #1
0
 public Protocol(SocketWrapper socket, int protocol)
 {
     this.socketWrapper   = socket;
     this.reader          = new InputBuffer(socketWrapper.GetStream());
     this.writer          = new OutputBuffer(socketWrapper.GetStream());
     this.ProtocolVersion = protocol;
 }
Exemple #2
0
 protected void SendPacket(Packet packet)
 {
     using (MemoryStream stream = new MemoryStream())
     {
         OutputBuffer outgoing = new OutputBuffer(stream);
         outgoing.WriteVarInt(GetOutgoingID(packet));
         packet.Write(outgoing);
         if (compression_treshold > 0)
         {
             var content = stream.ToArray();
             outgoing = new OutputBuffer();
             if (content.Length >= compression_treshold)
             {
                 byte[] compressed_packet = ZlibUtils.Compress(content, (MemoryStream)outgoing.GetStream());
                 outgoing.WriteVarInt(compressed_packet.Length);
                 outgoing.WriteData(compressed_packet);
             }
             else
             {
                 outgoing.WriteVarInt(0);
                 outgoing.WriteData(content);
             }
         }
         writer.WriteVarInt((int)outgoing.GetStream().Length);
         writer.WriteData(outgoing.ToArray());
         outgoing.Dispose();
     }
 }
        static void Publisher()
        {
            var ctx       = new ZContext();
            var publisher = new ZSocket(ctx, ZSocketType.PUB);

            publisher.Bind("tcp://127.0.0.1:12345");

            var src = new Record();

            src.payload.Add("a", 1.0);
            src.payload.Add("b", 2.0);

            var output = new OutputBuffer();
            var writer = new CompactBinaryWriter <OutputBuffer>(output);

            for (;;)
            {
                Marshal.To(writer, src);
                // INCORRECT:
                // var str = Encoding.ASCII.GetString(output.Data.Array);
                // var updateFrame = new ZFrame(str);
                var updateFrame = new ZFrame(output.Data.Array, output.Data.Offset, output.Data.Count);
                publisher.Send(updateFrame);
                output.Position = 0;
            }
        }
Exemple #4
0
        public void TestEventDataSerialization()
        {
            //const string cvText = "CV:1234";

            var variables = new KeyValuePair <string, object>[]
            {
                new KeyValuePair <string, object>("string", "string.Value"),
                new KeyValuePair <string, object>("int", 33),
                new KeyValuePair <string, object>("long", 101),
                new KeyValuePair <string, object>("date", DateTime.Now),
            };

            var             data   = Utility.CreateData(1);
            EventDataRecord record = data.ConvertTo();

            var output          = new OutputBuffer();
            var writer          = new SimpleBinaryWriter <OutputBuffer>(output);
            var writeSerializer = new Serializer <SimpleBinaryWriter <OutputBuffer> >(typeof(EventDataRecord));

            writeSerializer.Serialize(record, writer);

            var input          = new InputBuffer(output.Data);
            var reader         = new SimpleBinaryReader <InputBuffer>(input);
            var readSerializer = new Deserializer <SimpleBinaryReader <InputBuffer> >(typeof(EventDataRecord));

            EventDataRecord resultRecord = readSerializer.Deserialize <EventDataRecord>(reader);
            EventData       result       = resultRecord.ConverTo();

            Utility.VerifyEventData(data, result);
        }
Exemple #5
0
        const string scopeRegex = @"(\$\(.*\))"; // $( exp )
        static void Main(string[] args)
        {
            var stopWatch = Stopwatch.StartNew();

            // find script maches and shedule evaluation
            var template = File.ReadAllText("template");
            Func <string, string> strip = str => str.Remove(str.LastIndexOf(')'), 1).TrimStart('$', '(');
            var maches = Regex.Matches(template, scopeRegex).Select((m) => (match: m, eval: CSharpScript.EvaluateAsync(strip(m.Value), globals: new Globals())));

            // wait until evaluations are done and combine matches and evaluations results
            Task.WaitAll(maches.Select((m) => m.eval).ToArray());
            var matchResults = maches.Select(x => (match: x.match, evalResult: x.eval.Result.ToString().ToCharArray()));

            // calculate new output length
            var evalResultsLength = matchResults.Sum(a => a.evalResult.Length);
            var evalsLength       = matchResults.Sum(a => a.match.Value.Length);
            var newOutputLength   = (template.Length - evalsLength) + evalResultsLength;

            // go through maches and replace it with eval results
            var outputBuffer = new OutputBuffer(template, newOutputLength);

            var enm = matchResults.GetEnumerator();

            while (enm.MoveNext())
            {
                (Match match, char[] taskResult) = enm.Current;
                outputBuffer.Add(match, taskResult);
            }

            outputBuffer.WrapUp();

            stopWatch.Stop();
            System.Console.WriteLine(TimeSpan.FromMilliseconds(stopWatch.ElapsedMilliseconds).Seconds);
            System.Console.WriteLine(outputBuffer.ToString());
        }
Exemple #6
0
        public void Format_should_separate_groups_properly_when_formatting_with_custom_match(string testInput, string[] inputUsingNamespaces, string[] expectedOutputNamespaces)
        {
            // Arrange
            var inputUsings = inputUsingNamespaces.Select(ns => new UsingStatement()
            {
                Namespace = ns
            });

            var rule = GroupingRule.Parse(testInput).Single();

            var output = new OutputBuffer();

            // Act
            rule.Format(output, inputUsings);

            // Assert
            var expectedUsings = expectedOutputNamespaces.Select(ns => (ns == "") ? "" : $"using {ns};");

            output
            .GetLines()
            .Zip(expectedUsings)
            .Apply(
                ((string Actual, string Expected)pair, int index) =>
            {
                pair.Actual.Should().Be(pair.Expected, because: $"line {index} should match");
            });
Exemple #7
0
        public void Setup()
        {
            googleProtobufPersonBytes = BenchmarksData.ProtobufPerson().ToByteArray();

            var protobufNetStream = new MemoryStream();

            ProtoBuf.Serializer.Serialize(protobufNetStream, BenchmarksData.ProtobufNetPerson());
            protobufNetPersonBytes = protobufNetStream.ToArray();

            var bondPerson = BenchmarksData.BondPerson();

            var compactOutput         = new OutputBuffer(256);
            var compactWriter         = new CompactBinaryWriter <OutputBuffer>(compactOutput);
            var compactBondSerializer = new Serializer <CompactBinaryWriter <OutputBuffer> >(typeof(Bond.Person));

            compactBondSerializer.Serialize(bondPerson, compactWriter);
            compactBondPersonBytes = compactOutput.Data.ToArray();

            var fastOutput         = new OutputBuffer(256);
            var fastWriter         = new FastBinaryWriter <OutputBuffer>(fastOutput);
            var fastBondSerializer = new Serializer <FastBinaryWriter <OutputBuffer> >(typeof(Bond.Person));

            fastBondSerializer.Serialize(bondPerson, fastWriter);
            fastBondPersonBytes = fastOutput.Data.ToArray();

            jsonPerson = JsonConvert.SerializeObject(BenchmarksData.JSONPerson());

            var xmlSerializer = new XmlSerializer(typeof(XML.Person));
            var xmlStream     = new MemoryStream();

            xmlSerializer.Serialize(xmlStream, BenchmarksData.XMLPerson());
            xmlPersonBytes = xmlStream.ToArray();
        }
Exemple #8
0
        static void Main()
        {
            var src = new Example
            {
                Name      = "FooBar",
                Constants = { 3.14, 6.28 }
            };

            // Create de/serializer for the Example class and Compact Binary protocol.
            // This may take relatively long time so usually the objects should be cached and reused.
            var exampleSerializer   = new Serializer <CompactBinaryWriter <OutputBuffer> >(typeof(Example));
            var exampleDeserializer = new Deserializer <CompactBinaryReader <InputBuffer> >(typeof(Example));

            var output = new OutputBuffer();
            var writer = new CompactBinaryWriter <OutputBuffer>(output);

            exampleSerializer.Serialize(src, writer);

            var input  = new InputBuffer(output.Data);
            var reader = new CompactBinaryReader <InputBuffer>(input);

            var dst = exampleDeserializer.Deserialize <Example>(reader);

            Debug.Assert(Comparer.Equal(src, dst));
        }
Exemple #9
0
        void RoundtripObjectStream <T>(T obj)
        {
            // SimpleBinary
            {
                var output = new OutputBuffer();
                var writer = new SimpleBinaryWriter <OutputBuffer>(output);
                Serialize.To(writer, obj);

                var input  = new InputStream(new MemoryStream(output.buffer));
                var reader = new SimpleBinaryReader <InputStream>(input);
                T   obj2   = Deserialize <T> .From(reader);

                Assert.True(Comparer.Equal <T>(obj, obj2));
            }

            // CompactBinary
            {
                var output = new OutputBuffer();
                var writer = new CompactBinaryWriter <OutputBuffer>(output);
                Serialize.To(writer, obj);

                var input  = new InputStream(new MemoryStream(output.buffer));
                var reader = new CompactBinaryReader <InputStream>(input);
                T   obj2   = new Deserializer <CompactBinaryReader <InputStream> >(typeof(T)).Deserialize <T>(reader);

                Assert.True(Comparer.Equal <T>(obj, obj2));
            }
        }
Exemple #10
0
        public bool SendMessage(Variant headers, string content)
        {
            //1. Add info about us
            headers[RTSP_HEADERS, RTSP_HEADERS_SERVER]       = RTSP_HEADERS_SERVER_US;
            headers[RTSP_HEADERS, RTSP_HEADERS_X_POWERED_BY] = RTSP_HEADERS_X_POWERED_BY_US;
            //2. Add the content length if required
            if (content.Length > 0)
            {
                headers[RTSP_HEADERS, RTSP_HEADERS_CONTENT_LENGTH] = content.Length.ToString();
            }
            //3. Add the session id if necessary
            if (!string.IsNullOrEmpty(_sessionId))
            {
                headers[RTSP_HEADERS, RTSP_HEADERS_SESSION] = _sessionId;
            }
            var sb = new StringBuilder();

            foreach (var header in headers[RTSP_HEADERS].Children)
            {
                sb.AppendLine(header.Key + ": " + header.Value);
            }
            sb.AppendLine();
            sb.Append(content);
            OutputBuffer.Write(sb.ToString());
            return(EnqueueForOutbound(OutputBuffer));
        }
Exemple #11
0
        public void CorrectSerializeConvertCountBlobStruct()
        {
            var foo = new Decimals();

            foo._dec = new decimal(19.91);
            foo._decVector.Add(new decimal(10.10));
            foo._decVector.Add(new decimal(11.11));
            foo._decList.AddLast(new decimal(12.12));
            foo._decList.AddLast(new decimal(13.13));
            foo._decList.AddLast(new decimal(14.14));

            foo._decMap.Add(1, new decimal(15.15));
            foo._decMap.Add(2, new decimal(16.16));
            foo._decMap.Add(3, new decimal(17.17));

            foo._decNullable = new decimal(20.20);

            foo._decRequired         = new decimal(21.21);
            foo._decRequiredOptional = new decimal(22.22);

            var output     = new OutputBuffer();
            var writer     = new CompactBinaryWriter <OutputBuffer>(output);
            var serializer = new Serializer <CompactBinaryWriter <OutputBuffer> >(typeof(Decimals));

            serializer.Serialize(foo, writer);

            Assert.AreEqual(foo.CountInstances(), BondTypeAliasConverter.ConvertFromDecimalCount);
            Assert.AreEqual(0, BondTypeAliasConverter.ConvertToDecimalCount);
        }
Exemple #12
0
        static void Main()
        {
            var obj = new Struct
            {
                n     = 0x1000,
                str   = "test",
                items = { 3.14, 0 }
            };

            // OutputBuffer implements the Bond output stream interface on top
            // of a memory buffer.
            var output = new OutputBuffer();
            // Use the Compact Binary protocol for encoding; the data will be
            // written to the OutputBuffer which will allocate memory as needed.
            var writer = new CompactBinaryWriter <OutputBuffer>(output);

            // The first calls to Serialize.To and Deserialize<T>.From can take
            // a relatively long time because they generate the
            // serializer/deserializer for a given type, protocol, and stream.
            // See the serializer example for a way to control this.
            Serialize.To(writer, obj);

            // At this point the OutputBuffer contains a serialized
            // representation of the object.

            // Use the Compact Binary protocol for decoding (the same protocol
            // that was used for encoding) and InputBuffer which implements the
            // input stream interface on top of a memory blob.
            var input  = new InputBuffer(output.Data);
            var reader = new CompactBinaryReader <InputBuffer>(input);

            var obj2 = Deserialize <Struct> .From(reader);

            ThrowIfFalse(Comparer.Equal(obj, obj2));
        }
Exemple #13
0
        public void CorrectSerializeConvertCountLongStruct()
        {
            var foo = new Dates();

            foo._date = MakeUtcDateTime(2015, 1, 8);
            foo._dateVector.Add(MakeUtcDateTime(2015, 1, 9));
            foo._dateVector.Add(MakeUtcDateTime(2015, 1, 10));
            foo._dateList.AddLast(MakeUtcDateTime(2015, 1, 11));
            foo._dateList.AddLast(MakeUtcDateTime(2015, 1, 12));
            foo._dateList.AddLast(MakeUtcDateTime(2015, 1, 13));

            foo._dateMap.Add(1, MakeUtcDateTime(2015, 1, 14));
            foo._dateMap.Add(2, MakeUtcDateTime(2015, 1, 15));
            foo._dateMap.Add(3, MakeUtcDateTime(2015, 1, 16));

            foo._dateNullable = MakeUtcDateTime(2015, 1, 17);

            foo._dateRequired         = MakeUtcDateTime(2015, 1, 18);
            foo._dateRequiredOptional = MakeUtcDateTime(2015, 1, 19);

            var output     = new OutputBuffer();
            var writer     = new CompactBinaryWriter <OutputBuffer>(output);
            var serializer = new Serializer <CompactBinaryWriter <OutputBuffer> >(typeof(Dates));

            serializer.Serialize(foo, writer);

            Assert.AreEqual(foo.CountInstances(), BondTypeAliasConverter.ConvertFromDateTimeCount);
            Assert.AreEqual(0, BondTypeAliasConverter.ConvertToDateTimeCount);
        }
Exemple #14
0
        public override void ComplexTest()
        {
            var output = new OutputBuffer();
            var writer = new CompactBinaryWriter <OutputBuffer>(output);

            Serialize.To(writer, complexInput);

            var input  = new InputBuffer(output.Data);
            var reader = new CompactBinaryReader <InputBuffer>(input);

            var complexOutput = Deserialize <Complex> .From(reader);

            WriteLine("{0}:{1},{2},{3},{4}",
                      output.Data.Count,
                      complexOutput.SimpleValue.Value,
                      complexOutput.SimpleValue.ShortValue,
                      complexOutput.SimpleValue.IntValue,
                      complexOutput.SimpleValue.LongValue);

            for (int i = 0; i < complexOutput.ListValue.Count; i++)
            {
                WriteLine("{0},{1},{2},{3}",
                          complexOutput.ListValue[i].Value,
                          complexOutput.ListValue[i].ShortValue,
                          complexOutput.ListValue[i].IntValue,
                          complexOutput.ListValue[i].LongValue);
            }
        }
        public void WatchdogScheduledItem_SerializationTest()
        {
            // Serialize to the output buffer as binary.
            OutputBuffer output = new OutputBuffer();
            CompactBinaryWriter <OutputBuffer> writer = new CompactBinaryWriter <OutputBuffer>(output);

            Serialize.To(writer, hcs);

            // De-serialize from the binary output.
            InputBuffer input = new InputBuffer(output.Data);
            CompactBinaryReader <InputBuffer> reader = new CompactBinaryReader <InputBuffer>(input);
            WatchdogScheduledItem             hcs1   = Deserialize <WatchdogScheduledItem> .From(reader);

            Assert.IsTrue(hcs.Equals(hcs1));

            // Using the generic BondCustomSerializer.
            using (MemoryStream ms = new MemoryStream())
            {
                using (BinaryWriter bw = new BinaryWriter(ms))
                {
                    BondCustomSerializer <WatchdogScheduledItem> bcs = new BondCustomSerializer <WatchdogScheduledItem>();
                    bcs.Write(hcs, bw);

                    ms.Position = 0L;

                    using (BinaryReader br = new BinaryReader(ms))
                    {
                        hcs1 = bcs.Read(br);
                        Assert.IsTrue(hcs.Equals(hcs1));
                    }
                }
            }
        }
        public void ParserExtractsRuleComponents()
        {
            //Arrange
            var buffer = new OutputBuffer()
            {
                BufferWidth = 133
            };
            var output = new Output(buffer);

            //Act
            var results = TestStrings
                          .Select(s => new { String = s, Result = EntityReferenceParser.Parse(s) })
                          .ToList();

            //Assert
            var report = results.AsReport(rep => rep
                                          .AddColumn(r => r.String, cc => cc.Heading("Input"))
                                          .AddColumn(r => r.Result.Valid, cc => { })
                                          .AddChild(r => new[] { new { r.Result?.Error } }, erep => erep.AddColumn(e => e.Error, cc => { }))
                                          .AddChild(r => new[] { new { Result = r.Result?.EntityReference?.Describe() } },
                                                    drep => drep.AddColumn(e => e.Result ?? "NULL", cc => cc.Heading("Result")))
                                          );

            output.FormatTable(report);
            Approvals.Verify(output.Report);
        }
Exemple #17
0
 public override void Write(OutputBuffer output)
 {
     output.WriteVarInt(ProtocolVersion);
     output.WriteString(HostName);
     output.WriteShort(Port);
     output.WriteVarInt(Intent);
 }
Exemple #18
0
        internal void VarIntTestImpl()
        {
            IntTest <ushort> test16 = (value) =>
            {
                var output = new OutputBuffer();
                output.WriteVarUInt16(value);
                var input = new InputBuffer(output.Data);
                Assert.AreEqual(value, input.ReadVarUInt16());
            };

            IntTest <uint> test32 = (value) =>
            {
                var output = new OutputBuffer();
                output.WriteVarUInt32(value);
                var input = new InputBuffer(output.Data);
                Assert.AreEqual(value, input.ReadVarUInt32());
            };

            IntTest <ulong> test64 = (value) =>
            {
                var output = new OutputBuffer();
                output.WriteVarUInt64(value);
                var input = new InputBuffer(output.Data);
                Assert.AreEqual(value, input.ReadVarUInt64());
            };

            test16(ushort.MinValue);
            test16(ushort.MaxValue);
            test32(uint.MinValue);
            test32(uint.MaxValue);
            test64(ulong.MinValue);
            test64(ulong.MaxValue);
        }
Exemple #19
0
            private void WriteOutput()
            {
                var param1 = GetParameter(1);

                OutputBuffer.Add(param1);
                _iPointer += 2;
            }
Exemple #20
0
        public void CorrectSerializeConvertCountRef()
        {
            var foo = new RefObjects();

            foo._ref = new RefObject("1111");
            foo._refVector.Add(new RefObject("2222"));
            foo._refVector.Add(new RefObject("3333"));
            foo._refList.AddLast(new RefObject("4444"));
            foo._refList.AddLast(new RefObject("5555"));
            foo._refList.AddLast(new RefObject("6666"));

            foo._refMap.Add(1, new RefObject("7777"));
            foo._refMap.Add(2, new RefObject("8888"));
            foo._refMap.Add(3, new RefObject("9999"));

            foo._refNullable = new RefObject("10010");

            foo._refRequired         = new RefObject("11011");
            foo._refRequiredOptional = new RefObject("12012");

            var output     = new OutputBuffer();
            var writer     = new CompactBinaryWriter <OutputBuffer>(output);
            var serializer = new Serializer <CompactBinaryWriter <OutputBuffer> >(typeof(RefObjects));

            serializer.Serialize(foo, writer);

            Assert.AreEqual(foo.CountInstances(), BondTypeAliasConverter.ConvertFromRefObjectCount);
            Assert.AreEqual(0, BondTypeAliasConverter.ConvertToRefObjectCount);
        }
Exemple #21
0
        static void Main()
        {
            var data = Enumerable.Range(0, 255).Select(i => (byte)i).ToArray();
            var src  = new Example
            {
                ListOfBlobs =
                {
                    new ArraySegment <byte>(data,  0, 10),
                    new ArraySegment <byte>(data, 10, 10)
                },

                NullableBlob      = new ArraySegment <byte>(data, 20, 10),
                UninitializedBlob = new ArraySegment <byte>(data, 30, 70)
            };

            var output = new OutputBuffer();
            var writer = new CompactBinaryWriter <OutputBuffer>(output);

            Serialize.To(writer, src);

            var input  = new InputBuffer(output.Data);
            var reader = new CompactBinaryReader <InputBuffer>(input);

            var dst = Deserialize <Example> .From(reader);

            ThrowIfFalse(Comparer.Equal(src, dst));
        }
Exemple #22
0
        private static byte[] ToByteArray(IMessage <T> input)
        {
            if (input == null)
            {
                return(null);
            }

            var output = new OutputBuffer(128);
            var writer = new CompactBinaryWriter <OutputBuffer>(output);

            input.Payload.Serialize(writer);

            var arraySegment = output.Data;

            if (arraySegment.Offset == 0 && arraySegment.Count == arraySegment.Array.Length)
            {
                // perfect match, so we can just return the backing buffer
                return(arraySegment.Array);
            }

            // size or offset doesn't line up, so we need to make a copy
            var bytes = new byte[arraySegment.Count];

            Buffer.BlockCopy(
                src: arraySegment.Array,
                srcOffset: arraySegment.Offset,
                dst: bytes,
                dstOffset: 0,
                count: arraySegment.Count);
            return(bytes);
        }
Exemple #23
0
        public void EventListSerializtionRountTrip()
        {
            var evt = new Event
            {
                EventType = "AAA",
                Payload   = new byte[8]
            };

            var batch = new KafkaEventBusBatchContainer {
                Events = new List <Event> {
                    evt
                }
            };

            var output     = new OutputBuffer();
            var bondWriter = new SimpleBinaryWriter <OutputBuffer>(output);

            Serialize.To(bondWriter, batch);
            var data = output.Data.ToArray();


            var input      = new InputBuffer(data);
            var bondReader = new SimpleBinaryReader <InputBuffer>(input);
            var result     = Deserialize <KafkaEventBusBatchContainer> .From(bondReader);

            result.Events.Should().BeEquivalentTo(batch.Events);
        }
Exemple #24
0
        static void Main()
        {
            // Define root node for a tree of strings
            var root = new Node <string> {
                data = "root"
            };

            root.left = new Node <string> {
                data = "root/left"
            };
            root.right = new Node <string> {
                data = "root/right"
            };
            root.left.left = new Node <string> {
                data = "root/left/left"
            };
            root.left.left.right = new Node <string> {
                data = "root/left/left/right"
            };

            var output = new OutputBuffer();
            var writer = new CompactBinaryWriter <OutputBuffer>(output);

            Marshal.To(writer, root);

            var tree = Unmarshal <Node <string> > .From(output.Data);

            Debug.Assert(Comparer.Equal(root, tree));
        }
Exemple #25
0
        static void Main(string[] args)
        {
            var asmName    = new AssemblyName("Foo");
            var asmBuilder = AssemblyBuilder.DefineDynamicAssembly
                                 (asmName, AssemblyBuilderAccess.RunAndSave);
            var moduleBuilder = asmBuilder.DefineDynamicModule("Foo", "Foo.exe");

            var typeBuilder   = moduleBuilder.DefineType("Program", TypeAttributes.Public);
            var methodBuilder = typeBuilder.DefineMethod("Main",
                                                         MethodAttributes.Static, typeof(void), new[] { typeof(string) });

            var serializer = new Serializer <CompactBinaryWriter <OutputBuffer> >(typeof(AnswerConfig));
            var expression = serializer.GetExpressions().First();

            var visitor          = new MyVisitor();
            LambdaExpression exp = (LambdaExpression)visitor.Visit(expression);

            exp.CompileToMethod(methodBuilder);

            typeBuilder.CreateType();
            asmBuilder.SetEntryPoint(methodBuilder);
            asmBuilder.Save("Foo.exe");

            var output = new OutputBuffer();
            var writer = new CompactBinaryWriter <OutputBuffer>(output);

            //BondExpressionsInterceptor.Serialize.To<CompactBinaryWriter<OutputBuffer>, Record>(writer, src);

            var input  = new InputBuffer(output.Data);
            var reader = new CompactBinaryReader <InputBuffer>(input);

            var dst = Deserialize <Record> .From(reader);
        }
Exemple #26
0
        static ArraySegment <byte> SerializeStream()
        {
            // An output stream can be used to accumulate multiple serialized
            // structs. This can be done by re-using the same writer over the same
            // stream.
            var output = new OutputBuffer();
            // Use Compact Binary protocol for encoding; the data will be written to
            // output which will allocate more memory as needed.
            var writer = new CompactBinaryWriter <OutputBuffer>(output);

            for (uint n = 1; n <= NumObjects; ++n)
            {
                var obj = new Struct
                {
                    n   = n,
                    str = new string('#', (int)n)
                };

                Serialize.To(writer, obj);
            }

            // At this point output contains the serialized representation
            // of a stream of objects. OutputStream.Data can be used to get
            // the written data.
            return(output.Data);
        }
Exemple #27
0
        public void VarInts_RoundTrip()
        {
            Action <ushort> test16 = value =>
            {
                var output = new OutputBuffer();
                output.WriteVarUInt16(value);
                var input = MakeInputStream(output.Data);
                Assert.AreEqual(value, input.ReadVarUInt16());
            };

            Action <uint> test32 = value =>
            {
                var output = new OutputBuffer();
                output.WriteVarUInt32(value);
                var input = MakeInputStream(output.Data);
                Assert.AreEqual(value, input.ReadVarUInt32());
            };

            Action <ulong> test64 = value =>
            {
                var output = new OutputBuffer();
                output.WriteVarUInt64(value);
                var input = MakeInputStream(output.Data);
                Assert.AreEqual(value, input.ReadVarUInt64());
            };

            test16(ushort.MinValue);
            test16(ushort.MaxValue);
            test32(uint.MinValue);
            test32(uint.MaxValue);
            test64(ulong.MinValue);
            test64(ulong.MaxValue);
        }
Exemple #28
0
        static void Main()
        {
            // Get runtime schemas for two "versions" of Example schema.
            // When using untagged protocols the consumer must have access to runtime schema of the data.
            var schema1 = Schema <Example1> .RuntimeSchema;
            var schema2 = Schema <Example2> .RuntimeSchema;

            // Create and cache deserializers for objects of type Example2 from payloads using the two schemas
            var deserializers = new Dictionary <string, Deserializer <SimpleBinaryReader <InputBuffer> > >
            {
                { "Example1", new Deserializer <SimpleBinaryReader <InputBuffer> >(typeof(Example2), schema1) },
                { "Example2", new Deserializer <SimpleBinaryReader <InputBuffer> >(typeof(Example2), schema2) }
            };

            // Create payload serializing an instance of Example1
            var src = new Example1
            {
                Enabled = true,
                Name    = "Foo"
            };

            var output = new OutputBuffer();
            var writer = new SimpleBinaryWriter <OutputBuffer>(output);

            Serialize.To(writer, src);

            var input  = new InputBuffer(output.Data);
            var reader = new SimpleBinaryReader <InputBuffer>(input);

            // Use the precreated deserializer to deserialize an instance of Example2 schema for Example1
            var dst = deserializers["Example1"].Deserialize <Example2>(reader);

            Debug.Assert(src.Enabled == dst.Enabled);
            Debug.Assert(src.Name == dst.Name);
        }
Exemple #29
0
        public int FastBond()
        {
            var output = new OutputBuffer(256);
            var writer = new FastBinaryWriter <OutputBuffer>(output);

            fastBondSerializer.Serialize(BondPerson, writer);
            return(output.Data.Count);
        }
Exemple #30
0
        public static ArraySegment <byte> SerializeSP <T>(T obj, ushort version)
        {
            var output = new OutputBuffer();
            var writer = new SimpleBinaryWriter <OutputBuffer>(output, version);

            Serialize.To(writer, obj);
            return(output.Data);
        }
 public ScriptingHostRawUserInterface(ApplicationSettings settings)
 {
     Output = new OutputBuffer();
     backgroundColor = settings.BackgroundColor;
     foregroundColor = settings.ForegroundColor;
     cursorPosition = new Coordinates(0, 0);
     windowPosition = new Coordinates(0, 0);
     cursorSize = 1;
     bufferSize = new Size(settings.HostWidth, Int32.MaxValue);
     windowSize = bufferSize;
 }
Exemple #32
0
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                cmdSave.Visible = IsLoggedIn && (!string.IsNullOrEmpty(Request["id"]) || !string.IsNullOrEmpty(Request["load"]));
            }

            // We store the game in the Session, but use a dictionary keyed by GUIDs which
            // are stored in the ViewState. This allows the same user in the same browser
            // to open multiple games in different browser tabs.

            if (Games == null)
            {
                Games = new Dictionary<string, PlayerHandler>();
            }

            if (OutputBuffers == null)
            {
                OutputBuffers = new Dictionary<string, OutputBuffer>();
            }

            if (Resources == null)
            {
                Resources = new SessionResources();
            }

            m_gameId = (string)ViewState["GameId"];
            if (m_gameId == null)
            {
                m_gameId = Guid.NewGuid().ToString();
                ViewState["GameId"] = m_gameId;
            }

            if (Page.IsPostBack)
            {
                if (Games.ContainsKey(m_gameId))
                {
                    m_player = Games[m_gameId];
                }

                if (!OutputBuffers.ContainsKey(m_gameId))
                {
                    // TO DO: Think this only ever happens while debugging?
                    return;
                }
                m_buffer = OutputBuffers[m_gameId];
            }
            else
            {
                m_buffer = new OutputBuffer();
                OutputBuffers.Add(m_gameId, m_buffer);
            }
        }
        public StressTestShim(ITestOutputHelper output)
        {
            _output = output;

            _outbuff = new OutputBuffer(1024 * 200, output);
        }
Exemple #34
0
 public ThreadUnsafeOutput(UInt32 bufferLength)
 {
     this.buffer = new OutputBuffer(new Byte[bufferLength]);
 }
Exemple #35
0
 void SessionTimeoutMessage()
 {
     m_buffer = new OutputBuffer(null);
     m_buffer.AddJavaScriptToBuffer("sessionTimeout");
     ClearJavaScriptBuffer();
 }