C# Context.RegisterTemplate方法代码示例

        public void TestEncodeMessageWithAllFieldTypes()
        {
            var template = new MessageTemplate(
                "",
                new Field[]
                    {
                        new Scalar("1", FastType.String, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("2", FastType.ByteVector, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("3", FastType.Decimal, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("4", FastType.I32, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("5", FastType.String, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("6", FastType.U32, Operator.Copy, ScalarValue.Undefined, false),
                    });

            var context = new Context();
            context.RegisterTemplate(113, template);

            var message = new Message(template);
            message.SetString(1, "H");
            message.SetByteVector(2, new[] {(byte) 0xFF});
            message.SetDecimal(3, 1.201);
            message.SetInteger(4, -1);
            message.SetString(5, "abc");
            message.SetInteger(6, 2);

            //               --PMAP-- --TID--- ---#1--- -------#2-------- ------------#3------------ ---#4--- ------------#5------------ ---#6---
            const string msgstr =
                "11111111 11110001 11001000 10000001 11111111 11111101 00001001 10110001 11111111 01100001 01100010 11100011 10000010";
            AssertEquals(msgstr, new FastEncoder(context).Encode(message));
        }

        public void TestDecodeMessageWithAllFieldTypes()
        {
            //   --PMAP-- --TID--- ---#1--- -------#2-------- ------------#3------------ ---#4--- ------------#5------------ ---#6---
            const string msgstr =
                "11111111 11110001 11001000 10000001 11111111 11111101 00001001 10110001 11111111 01100001 01100010 11100011 10000010";
            Stream input = ByteUtil.CreateByteStream(msgstr);

            var template = new MessageTemplate(
                "",
                new Field[]
                    {
                        new Scalar("1", FastType.Ascii, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("2", FastType.ByteVector, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("3", FastType.Decimal, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("4", FastType.I32, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("5", FastType.Ascii, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("6", FastType.U32, Operator.Copy, ScalarValue.Undefined, false),
                    });
            var context = new Context();
            context.RegisterTemplate(113, template);

            GroupValue message = new Message(template);
            message.SetString(1, "H");
            message.SetByteVector(2, new[] {(byte) 0xFF});
            message.SetDecimal(3, 1.201);
            message.SetInteger(4, -1);
            message.SetString(5, "abc");
            message.SetInteger(6, 2);
            Assert.AreEqual(message, new FastDecoder(context, input).ReadMessage());
        }

        public void TestEncodeEmptyMessage()
        {
            var messageTemplate = new MessageTemplate("", new Field[0]);
            var message = new Message(messageTemplate);
            var context = new Context();
            context.RegisterTemplate(113, messageTemplate);

            byte[] encoding = new FastEncoder(context).Encode(message);
            AssertEquals("11000000 11110001", encoding);
        }

        public void TestDecodeEmptyMessage()
        {
            var messageTemplate = new MessageTemplate("", new Field[0]);
            Stream input = ByteUtil.CreateByteStream("11000000 11110001");
            var context = new Context();
            context.RegisterTemplate(113, messageTemplate);

            Message message = new FastDecoder(context, input).ReadMessage();
            Assert.AreEqual(113, message.GetInt(0));
        }

        public void TestEncodeSimpleMessage()
        {
            var template = new MessageTemplate(
                "",
                new Field[]
                    {
                        new Scalar("1", FastType.U32, Operator.Copy, ScalarValue.Undefined, false)
                    });

            var context = new Context();
            context.RegisterTemplate(113, template);

            var message = new Message(template);
            message.SetInteger(1, 1);

            var encoder = new FastEncoder(context);
            AssertEquals("11100000 11110001 10000001", encoder.Encode(message));
        }

        public void TestEncodeMessageWithUnsignedIntegerFieldTypesAndAllOperators()
        {
            var template = new MessageTemplate(
                "",
                new Field[]
                    {
                        new Scalar("1", FastType.U32, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("2", FastType.U32, Operator.Delta, ScalarValue.Undefined, false),
                        new Scalar("3", FastType.I32, Operator.Increment, new IntegerValue(10), false),
                        new Scalar("4", FastType.I32, Operator.Increment, ScalarValue.Undefined, false),
                        new Scalar("5", FastType.I32, Operator.Constant, new IntegerValue(1), false),
                        /* NON-TRANSFERRABLE */
                        new Scalar("6", FastType.I32, Operator.Default, new IntegerValue(2), false)
                    });

            var context = new Context();
            context.RegisterTemplate(113, template);

            var encoder = new FastEncoder(context);

            var message = new Message(template);
            message.SetInteger(1, 109);
            message.SetInteger(2, 29470);
            message.SetInteger(3, 10);
            message.SetInteger(4, 3);
            message.SetInteger(5, 1);
            message.SetInteger(6, 2);

            //                   --PMAP-- --TID--- ---#1--- ------------#2------------ ---#4---
            const string msg1 = "11101000 11110001 11101101 00000001 01100110 10011110 10000011";
            AssertEquals(msg1, encoder.Encode(message));

            message.SetInteger(2, 29471);
            message.SetInteger(3, 11);
            message.SetInteger(4, 4);
            message.SetInteger(6, 3);

            //                   --PMAP-- ---#2--- ---#6---
            const string msg2 = "10000100 10000001 10000011";
            AssertEquals(msg2, encoder.Encode(message));

            message.SetInteger(1, 96);
            message.SetInteger(2, 30500);
            message.SetInteger(3, 12);
            message.SetInteger(4, 1);

            //                   --PMAP-- ---#1--- --------#2------- ---#4--- ---#6---
            const string msg3 = "10101100 11100000 00001000 10000101 10000001 10000011";
            AssertEquals(msg3, encoder.Encode(message));
        }

        public void TestEncodeSequentialEmptyMessages()
        {
            var messageTemplate = new MessageTemplate("", new Field[0]);
            var message = new Message(messageTemplate);
            var nextMsg = new Message(messageTemplate);
            var context = new Context();
            context.RegisterTemplate(113, messageTemplate);

            var encoder = new FastEncoder(context);

            // Presence map should show that the only field present is the template id.
            AssertEquals("11000000 11110001",
                         encoder.Encode(message));
            // Presence map should be empty (except for leading stop bit)
            AssertEquals("10000000", encoder.Encode(nextMsg));
        }

        protected void SetUp()
        {
            _nameTemplate = Template("<template>" +
                                     "  <string name='name'/>" +
                                     "</template>");
            _template = Template("<template>" +
                                 "  <uInt32 name='quantity'/>" +
                                 "  <templateRef/>" +
                                 "  <decimal name='price'/>" +
                                 "</template>");
            _message = new Message(_template);
            _message.SetInteger(1, 15);
            _message.SetDecimal(3, 102.0);

            _name = new Message(_nameTemplate);
            _name.SetString(1, "IBM");
            _message.SetFieldValue(2, _name);

            _context = new Context();
            _context.RegisterTemplate(1, _template);
            _context.RegisterTemplate(2, _nameTemplate);
        }

        public void TestEncodeMessageWithStringFieldTypesAndAllOperators()
        {
            var template = new MessageTemplate(
                "",
                new Field[]
                    {
                        new Scalar("1", FastType.String, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("2", FastType.String, Operator.Delta, ScalarValue.Undefined, false),
                        new Scalar("3", FastType.String, Operator.Constant, new StringValue("e"), false),
                        /* NON-TRANSFERRABLE */
                        new Scalar("4", FastType.String, Operator.Default, new StringValue("long"), false)
                    });

            var context = new Context();
            context.RegisterTemplate(113, template);

            var message = new Message(template);
            message.SetString(1, "on");
            message.SetString(2, "DCB32");
            message.SetString(3, "e");
            message.SetString(4, "long");

            //   --PMAP-- --TID--- --------#1------- ---------------------#2------------------------------
            const string msg1 =
                "11100000 11110001 01101111 11101110 10000000 01000100 01000011 01000010 00110011 10110010";

            //                   --PMAP-- --------#2---------------- ---------------------#4---------------------
            const string msg2 = "10010000 10000010 00110001 10110110 01110011 01101000 01101111 01110010 11110100";

            var encoder = new FastEncoder(context);

            AssertEquals(msg1, encoder.Encode(message));

            message.SetString(2, "DCB16");
            message.SetString(4, "short");

            AssertEquals(msg2, encoder.Encode(message));
        }

        public void TestGroupWithoutPresenceMap()
        {
            MessageTemplate template = Template(
                "<template>" +
                "  <group name='priceGroup' presence='optional'>" +
                "    <decimal name='price'><delta/></decimal>" +
                "  </group>" +
                "</template>");

            var encodingContext = new Context();
            var decodingContext = new Context();
            encodingContext.RegisterTemplate(1, template);
            decodingContext.RegisterTemplate(1, template);

            const string encodedBits = "11100000 10000001 11111110 10111111";

            var decoder = new FastDecoder(decodingContext,
                                          new MemoryStream(ByteUtil.ConvertBitStringToFastByteArray(encodedBits)));
            Message message = decoder.ReadMessage();
            Assert.AreEqual(0.63, message.GetGroup("priceGroup").GetDouble("price"), 0.01);

            byte[] encoding = template.Encode(message, encodingContext);
            TestUtil.AssertBitVectorEquals(encodedBits, encoding);
        }

        public void TestDecodeMessageWithSignedIntegerFieldTypesAndAllOperators()
        {
            var template = new MessageTemplate(
                "",
                new Field[]
                    {
                        new Scalar("1", FastType.I32, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("2", FastType.I32, Operator.Delta, ScalarValue.Undefined, false),
                        new Scalar("3", FastType.I32, Operator.Increment, new IntegerValue(10), false),
                        new Scalar("4", FastType.I32, Operator.Increment, ScalarValue.Undefined, false),
                        new Scalar("5", FastType.I32, Operator.Constant, new IntegerValue(1), false),
                        /* NON-TRANSFERRABLE */
                        new Scalar("6", FastType.I32, Operator.Default, new IntegerValue(2), false)
                    });

            GroupValue message = new Message(template);
            message.SetInteger(1, 109);
            message.SetInteger(2, 29470);
            message.SetInteger(3, 10);
            message.SetInteger(4, 3);
            message.SetInteger(5, 1);
            message.SetInteger(6, 2);

            //                   --PMAP-- --TID--- --------#1------- ------------#2------------ ---#4---
            const string msg1 = "11101000 11110001 00000000 11101101 00000001 01100110 10011110 10000011";

            //                   --PMAP-- ---#2--- ---#6---
            const string msg2 = "10000100 11111111 10000011";

            //                   --PMAP-- --------#1------- --------#2------- ---#4--- ---#6---
            const string msg3 = "10101100 00000000 11100000 00001000 10000111 10000001 10000011";

            Stream input = ByteUtil.CreateByteStream(msg1 + ' ' + msg2 + ' ' +
                                                     msg3);
            var context = new Context();
            context.RegisterTemplate(113, template);

            var decoder = new FastDecoder(context, input);

            Message readMessage = decoder.ReadMessage();
            Assert.AreEqual(message, readMessage);

            message.SetInteger(2, 29469);
            message.SetInteger(3, 11);
            message.SetInteger(4, 4);
            message.SetInteger(6, 3);

            readMessage = decoder.ReadMessage();
            Assert.AreEqual(message, readMessage);

            message.SetInteger(1, 96);
            message.SetInteger(2, 30500);
            message.SetInteger(3, 12);
            message.SetInteger(4, 1);

            readMessage = decoder.ReadMessage();
            Assert.AreEqual(message, readMessage);
        }

        public void TestDecodeSimpleMessage()
        {
            var template = new MessageTemplate(
                "",
                new Field[]
                    {
                        new Scalar("1", FastType.U32, Operator.Copy, ScalarValue.Undefined, false)
                    });
            Stream input = ByteUtil.CreateByteStream("11100000 11110001 10000001");
            var context = new Context();
            context.RegisterTemplate(113, template);

            var message = new Message(template);
            message.SetInteger(1, 1);

            var decoder = new FastDecoder(context, input);
            GroupValue readMessage = decoder.ReadMessage();
            Assert.AreEqual(message, readMessage);
            Assert.AreEqual(readMessage, message);
        }

 public void TestDecodeGroupWithPresenceMapWithTooManyBits()
 {
     MessageTemplate g = ObjectMother.QuoteTemplate;
     var c = new Context();
     c.RegisterTemplate(1, g);
     try
     {
         g.Decode(
             new MemoryStream(
                 ByteUtil.ConvertBitStringToFastByteArray("11111000 10000001 10000000 10000110 10000000 10000110")),
             g, c, BitVectorReader.InfiniteTrue);
     }
     catch (RepErrorException e)
     {
         Assert.AreEqual(RepError.PmapTooManyBits, e.Error);
     }
 }

        public void TestDecodeSequentialEmptyMessages()
        {
            var messageTemplate = new MessageTemplate("", new Field[0]);
            Stream input = ByteUtil.CreateByteStream("11000000 11110001 10000000");
            var context = new Context();
            context.RegisterTemplate(113, messageTemplate);

            var decoder = new FastDecoder(context, input);
            GroupValue message = decoder.ReadMessage();
            GroupValue message2 = decoder.ReadMessage();
            Assert.AreEqual(113, message.GetInt(0));
            Assert.AreEqual(113, message2.GetInt(0));
        }

        public void TestDecodeMessageWithStringFieldTypesAndAllOperators()
        {
            var template = new MessageTemplate(
                "",
                new Field[]
                    {
                        new Scalar("1", FastType.Ascii, Operator.Copy, ScalarValue.Undefined, false),
                        new Scalar("2", FastType.Ascii, Operator.Delta, ScalarValue.Undefined, false),
                        new Scalar("3", FastType.Ascii, Operator.Constant, new StringValue("e"), false),
                        /* NON-TRANSFERRABLE */
                        new Scalar("4", FastType.Ascii, Operator.Default, new StringValue("long"), false)
                    });

            var message = new Message(template);
            message.SetString(1, "on");
            message.SetString(2, "DCB32");
            message.SetString(3, "e");
            message.SetString(4, "long");

            //   --PMAP-- --TID--- --------#1------- ---------------------#2---------------------
            const string msg1 =
                "11100000 11110001 01101111 11101110 10000000 01000100 01000011 01000010 00110011 10110010";

            //                   --PMAP-- ------------#2------------ ---------------------#4---------------------
            const string msg2 = "10010000 10000010 00110001 10110110 01110011 01101000 01101111 01110010 11110100";

            Stream input = ByteUtil.CreateByteStream(msg1 + ' ' + msg2);
            var context = new Context();
            context.RegisterTemplate(113, template);

            var decoder = new FastDecoder(context, input);

            Message readMessage = decoder.ReadMessage();
            Assert.AreEqual(message, readMessage);

            message.SetString(2, "DCB16");
            message.SetString(4, "short");

            readMessage = decoder.ReadMessage();
            Assert.AreEqual(message, readMessage);
        }