Example #1
0
        static internal void OnCallCompleted(
            RcfProtoChannel self)
        {
            // Deserialize the response
            int requestBufferLen = self._GetResponseBufferLength();

            if (requestBufferLen == 0)
            {
                // Get crashes from Google.ProtocolBuffers.dll if we pass in null.
                //Google.ProtocolBuffers.IMessage response = null;
                self.mResponse = self.mResponsePrototype.WeakDefaultInstanceForType;
            }
            else
            {
                // Deserialize response.
                byte[] requestBuffer = new byte[requestBufferLen];
                self._GetResponseBuffer(requestBuffer, requestBufferLen);
                Google.ProtocolBuffers.IBuilder   builder    = self.mResponsePrototype.WeakCreateBuilderForType();
                Google.ProtocolBuffers.ByteString byteString = Google.ProtocolBuffers.ByteString.CopyFrom(requestBuffer);
                builder.WeakMergeFrom(byteString);
                self.mResponse = builder.WeakBuild();
            }

            bool asyncRpc = self.GetAsynchronousRpcMode();

            if (asyncRpc)
            {
                self.mDone(self.mResponse);
            }
        }
Example #2
0
        private bnet.protocol.storage.ExecuteResponse GetHeroDigest(MooNetClient client, bnet.protocol.storage.ExecuteRequest request)
        {
            var results = new List <bnet.protocol.storage.OperationResult>();

            foreach (var operation in request.OperationsList)
            {
                Google.ProtocolBuffers.ByteString data = null;

                // find the requested toons entity-id.
                var stream = new MemoryStream(operation.RowId.Hash.ToByteArray());

                // contains ToonHandle in field form with one unknown field (which is not in message definition):
                // int16 unknown; uint8 realm; uint8 region; uint32 program; uint64 id;
                stream.ReadValueU16();      // unknown
                stream.ReadValueU8();       // realm
                stream.ReadValueU8();       // region
                stream.ReadValueU32(false); // program

                var toonId = stream.ReadValueU64(false);

                if (!client.Account.CurrentGameAccount.Toons.ContainsKey(toonId))
                {
                    Logger.Error("Can't find the requested toon: {0}", toonId);
                    continue;
                }

                var toon = client.Account.CurrentGameAccount.Toons[toonId];

                if (operation.ColumnId.Hash.Equals(HeroDigestColumn))
                {
                    data = toon.Digest.ToByteString();
                }
                else
                {
                    Logger.Warn("Unknown ColumndId requested: {0}", operation.ColumnId.Hash.ToByteArray().HexDump());
                }
                //else if (operation.ColumnId.Hash.Equals(HeroNameColumn))
                //    data = toon.NameText.ToByteString();

                var operationResult = bnet.protocol.storage.OperationResult.CreateBuilder().SetTableId(operation.TableId);
                operationResult.AddData(
                    bnet.protocol.storage.Cell.CreateBuilder()
                    .SetColumnId(request.OperationsList[0].ColumnId)
                    .SetRowId(request.OperationsList[0].RowId)
                    .SetVersion(1)
                    .SetData(data)
                    .Build()
                    );
                results.Add(operationResult.Build());
            }

            var builder = bnet.protocol.storage.ExecuteResponse.CreateBuilder();

            foreach (var result in results)
            {
                builder.AddResults(result);
            }
            return(builder.Build());
        }
    public static string ParseString(this Google.ProtocolBuffers.ByteString str)
    {
        string        ret           = str.ToString(Encoding.ASCII);
        StringBuilder stringBuilder = new StringBuilder();

        foreach (char ch in ret)
        {
            if (Char.IsLetterOrDigit(ch) || ch == '_')
            {
                stringBuilder.Append(ch);
            }
        }
        return(stringBuilder.ToString());
    }
Example #4
0
 static int ToByteString(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 1);
         Google.ProtocolBuffers.AbstractMessageLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> obj = (Google.ProtocolBuffers.AbstractMessageLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder>)ToLua.CheckObject <Google.ProtocolBuffers.AbstractMessageLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> >(L, 1);
         Google.ProtocolBuffers.ByteString o = obj.ToByteString();
         ToLua.PushSealed(L, o);
         return(1);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
Example #5
0
        public void ProcessRequest(HttpContext context)
        {
            byte[] fileData = null;
            using (var binaryReader = new BinaryReader(context.Request.InputStream))
            {
                fileData = binaryReader.ReadBytes(Convert.ToInt32(context.Request.InputStream.Length));
            }
            PersonTest per      = PersonTest.ParseFrom(fileData);//反序列化为对象
            string     filename = per.Name;

            Google.ProtocolBuffers.ByteString str = per.Buf;
            string path = context.Server.MapPath(filename);

            if (per.Isimg)
            {
                ImageHelper.SaveFromBufferOpenOrCreate(str.ToByteArray(), path);//保存图片操作
            }
            else
            {
                FileHelper.SaveFile(str.ToByteArray(), path);//保存图片操作
            }
            var builder = per.ToBuilder();

            builder.SetName(per.Name);
            builder.SetEmail(per.Email);
            builder.SetId(1001);
            builder.SetIsimg(false);

            ByteString bs = ByteString.CopyFrom("ok", System.Text.Encoding.UTF8);

            builder.SetBuf(bs);


            per = builder.Build();

            context.Response.ContentType = "application/protobuf";
            context.Response.BinaryWrite(per.ToByteArray());
        }
Example #6
0
 /// <summary>
 /// Compute the number of bytes that would be needed to encode a
 /// bytes field, including the tag.
 /// </summary>
 public static int ComputeBytesSize(int fieldNumber, ByteString value)
 {
     return(ComputeTagSize(fieldNumber) +
            ComputeRawVarint32Size((uint)value.Length) +
            value.Length);
 }
Example #7
0
        public void ToStringUtf8()
        {
            ByteString bs = ByteString.CopyFromUtf8("\u20ac");

            Assert.AreEqual("\u20ac", bs.ToStringUtf8());
        }
Example #8
0
 /// <summary>
 /// Compute the number of bytes that would be needed to encode a
 /// bytes field, including the tag.
 /// </summary>
 public static int ComputeBytesSizeNoTag(ByteString value)
 {
     return(ComputeRawVarint32Size((uint)value.Length) +
            value.Length);
 }
Example #9
0
 /// <summary>
 /// Compute the number of bytes that would be needed to encode an
 /// unparsed MessageSet extension field to the stream. For
 /// historical reasons, the wire format differs from normal fields.
 /// </summary>
 public static int ComputeRawMessageSetExtensionSize(int fieldNumber, ByteString value)
 {
     return(ComputeTagSize(WireFormat.MessageSetField.Item) * 2 +
            ComputeUInt32Size(WireFormat.MessageSetField.TypeID, (uint)fieldNumber) +
            ComputeBytesSize(WireFormat.MessageSetField.Message, value));
 }
Example #10
0
        /// <summary>
        /// Performs string unescaping from C style (octal, hex, form feeds, tab etc) into a byte string.
        /// </summary>
        public static ByteString UnescapeBytes(string input)
        {
            byte[] result = new byte[input.Length];
            int    pos    = 0;

            for (int i = 0; i < input.Length; i++)
            {
                char c = input[i];
                if (c > 127 || c < 32)
                {
                    throw new FormatException("Escaped string must only contain ASCII");
                }
                if (c != '\\')
                {
                    result[pos++] = (byte)c;
                    continue;
                }
                if (i + 1 >= input.Length)
                {
                    throw new FormatException("Invalid escape sequence: '\\' at end of string.");
                }

                i++;
                c = input[i];
                if (c >= '0' && c <= '7')
                {
                    // Octal escape.
                    int code = ParseDigit(c);
                    if (i + 1 < input.Length && IsOctal(input[i + 1]))
                    {
                        i++;
                        code = code * 8 + ParseDigit(input[i]);
                    }
                    if (i + 1 < input.Length && IsOctal(input[i + 1]))
                    {
                        i++;
                        code = code * 8 + ParseDigit(input[i]);
                    }
                    result[pos++] = (byte)code;
                }
                else
                {
                    switch (c)
                    {
                    case 'a':
                        result[pos++] = 0x07;
                        break;

                    case 'b':
                        result[pos++] = (byte)'\b';
                        break;

                    case 'f':
                        result[pos++] = (byte)'\f';
                        break;

                    case 'n':
                        result[pos++] = (byte)'\n';
                        break;

                    case 'r':
                        result[pos++] = (byte)'\r';
                        break;

                    case 't':
                        result[pos++] = (byte)'\t';
                        break;

                    case 'v':
                        result[pos++] = 0x0b;
                        break;

                    case '\\':
                        result[pos++] = (byte)'\\';
                        break;

                    case '\'':
                        result[pos++] = (byte)'\'';
                        break;

                    case '"':
                        result[pos++] = (byte)'\"';
                        break;

                    case 'x':
                        // hex escape
                        int code;
                        if (i + 1 < input.Length && IsHex(input[i + 1]))
                        {
                            i++;
                            code = ParseDigit(input[i]);
                        }
                        else
                        {
                            throw new FormatException("Invalid escape sequence: '\\x' with no digits");
                        }
                        if (i + 1 < input.Length && IsHex(input[i + 1]))
                        {
                            ++i;
                            code = code * 16 + ParseDigit(input[i]);
                        }
                        result[pos++] = (byte)code;
                        break;

                    default:
                        throw new FormatException("Invalid escape sequence: '\\" + c + "'");
                    }
                }
            }

            return(ByteString.CopyFrom(result, 0, pos));
        }
    static int ParseFrom(IntPtr L)
    {
        try
        {
            int count = LuaDLL.lua_gettop(L);

            if (count == 1 && TypeChecker.CheckTypes <Google.ProtocolBuffers.ByteString>(L, 1))
            {
                Google.ProtocolBuffers.ByteString arg0 = (Google.ProtocolBuffers.ByteString)ToLua.ToObject(L, 1);
                MyLib.CGPlayerCmd o = MyLib.CGPlayerCmd.ParseFrom(arg0);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 1 && TypeChecker.CheckTypes <byte[]>(L, 1))
            {
                byte[]            arg0 = ToLua.CheckByteBuffer(L, 1);
                MyLib.CGPlayerCmd o    = MyLib.CGPlayerCmd.ParseFrom(arg0);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 1 && TypeChecker.CheckTypes <System.IO.Stream>(L, 1))
            {
                System.IO.Stream  arg0 = (System.IO.Stream)ToLua.ToObject(L, 1);
                MyLib.CGPlayerCmd o    = MyLib.CGPlayerCmd.ParseFrom(arg0);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 1 && TypeChecker.CheckTypes <Google.ProtocolBuffers.CodedInputStream>(L, 1))
            {
                Google.ProtocolBuffers.CodedInputStream arg0 = (Google.ProtocolBuffers.CodedInputStream)ToLua.ToObject(L, 1);
                MyLib.CGPlayerCmd o = MyLib.CGPlayerCmd.ParseFrom(arg0);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 2 && TypeChecker.CheckTypes <Google.ProtocolBuffers.ByteString, Google.ProtocolBuffers.ExtensionRegistry>(L, 1))
            {
                Google.ProtocolBuffers.ByteString        arg0 = (Google.ProtocolBuffers.ByteString)ToLua.ToObject(L, 1);
                Google.ProtocolBuffers.ExtensionRegistry arg1 = (Google.ProtocolBuffers.ExtensionRegistry)ToLua.ToObject(L, 2);
                MyLib.CGPlayerCmd o = MyLib.CGPlayerCmd.ParseFrom(arg0, arg1);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 2 && TypeChecker.CheckTypes <byte[], Google.ProtocolBuffers.ExtensionRegistry>(L, 1))
            {
                byte[] arg0 = ToLua.CheckByteBuffer(L, 1);
                Google.ProtocolBuffers.ExtensionRegistry arg1 = (Google.ProtocolBuffers.ExtensionRegistry)ToLua.ToObject(L, 2);
                MyLib.CGPlayerCmd o = MyLib.CGPlayerCmd.ParseFrom(arg0, arg1);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 2 && TypeChecker.CheckTypes <System.IO.Stream, Google.ProtocolBuffers.ExtensionRegistry>(L, 1))
            {
                System.IO.Stream arg0 = (System.IO.Stream)ToLua.ToObject(L, 1);
                Google.ProtocolBuffers.ExtensionRegistry arg1 = (Google.ProtocolBuffers.ExtensionRegistry)ToLua.ToObject(L, 2);
                MyLib.CGPlayerCmd o = MyLib.CGPlayerCmd.ParseFrom(arg0, arg1);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 2 && TypeChecker.CheckTypes <Google.ProtocolBuffers.CodedInputStream, Google.ProtocolBuffers.ExtensionRegistry>(L, 1))
            {
                Google.ProtocolBuffers.CodedInputStream  arg0 = (Google.ProtocolBuffers.CodedInputStream)ToLua.ToObject(L, 1);
                Google.ProtocolBuffers.ExtensionRegistry arg1 = (Google.ProtocolBuffers.ExtensionRegistry)ToLua.ToObject(L, 2);
                MyLib.CGPlayerCmd o = MyLib.CGPlayerCmd.ParseFrom(arg0, arg1);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else
            {
                return(LuaDLL.luaL_throw(L, "invalid arguments to method: MyLib.CGPlayerCmd.ParseFrom"));
            }
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
 IBuilder IBuilder.WeakMergeFrom(ByteString data, ExtensionRegistry registry)
 {
     return(MergeFrom(data, registry));
 }
Example #13
0
        /// <summary>
        /// Escapes bytes in the format used in protocol buffer text format, which
        /// is the same as the format used for C string literals.  All bytes
        /// that are not printable 7-bit ASCII characters are escaped, as well as
        /// backslash, single-quote, and double-quote characters.  Characters for
        /// which no defined short-hand escape sequence is defined will be escaped
        /// using 3-digit octal sequences.
        /// The returned value is guaranteed to be entirely ASCII.
        /// </summary>
        public static String EscapeBytes(ByteString input)
        {
            StringBuilder builder = new StringBuilder(input.Length);

            foreach (byte b in input)
            {
                switch (b)
                {
                // C# does not use \a or \v
                case 0x07:
                    builder.Append("\\a");
                    break;

                case (byte)'\b':
                    builder.Append("\\b");
                    break;

                case (byte)'\f':
                    builder.Append("\\f");
                    break;

                case (byte)'\n':
                    builder.Append("\\n");
                    break;

                case (byte)'\r':
                    builder.Append("\\r");
                    break;

                case (byte)'\t':
                    builder.Append("\\t");
                    break;

                case 0x0b:
                    builder.Append("\\v");
                    break;

                case (byte)'\\':
                    builder.Append("\\\\");
                    break;

                case (byte)'\'':
                    builder.Append("\\\'");
                    break;

                case (byte)'"':
                    builder.Append("\\\"");
                    break;

                default:
                    if (b >= 0x20 && b < 128)
                    {
                        builder.Append((char)b);
                    }
                    else
                    {
                        builder.Append('\\');
                        builder.Append((char)('0' + ((b >> 6) & 3)));
                        builder.Append((char)('0' + ((b >> 3) & 7)));
                        builder.Append((char)('0' + (b & 7)));
                    }
                    break;
                }
            }
            return(builder.ToString());
        }
Example #14
0
 public void FromBase64_Empty()
 {
     // Optimization which also fixes issue 61.
     Assert.AreSame(ByteString.Empty, ByteString.FromBase64(""));
 }
Example #15
0
        public void ToStringWithExplicitEncoding()
        {
            ByteString bs = ByteString.CopyFrom("\u20ac", Encoding.Unicode);

            Assert.AreEqual("\u20ac", bs.ToString(Encoding.Unicode));
        }
Example #16
0
 public void WriteBytesNoTag(ByteString value)
 {
     WriteRawVarint32((uint)value.Length);
     value.WriteRawBytesTo(this);
 }
Example #17
0
 public void WriteBytes(int fieldNumber, string fieldName, ByteString value)
 {
     WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
     WriteRawVarint32((uint)value.Length);
     value.WriteRawBytesTo(this);
 }
Example #18
0
 public void WriteUnknownBytes(int fieldNumber, ByteString value)
 {
     WriteBytes(fieldNumber, null /*not used*/, value);
 }
Example #19
0
 public void IsEmptyWhenNotEmpty()
 {
     Assert.IsFalse(ByteString.CopyFromUtf8("X").IsEmpty);
 }
Example #20
0
 public void IsEmptyWhenEmpty()
 {
     Assert.IsTrue(ByteString.CopyFromUtf8("").IsEmpty);
 }
    static int MergeFrom(IntPtr L)
    {
        try
        {
            int count = LuaDLL.lua_gettop(L);

            if (count == 2 && TypeChecker.CheckTypes <Google.ProtocolBuffers.IMessageLite>(L, 2))
            {
                Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> obj = (Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder>)ToLua.CheckObject <Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> >(L, 1);
                Google.ProtocolBuffers.IMessageLite arg0 = (Google.ProtocolBuffers.IMessageLite)ToLua.ToObject(L, 2);
                MyLib.GCPlayerCmd.Builder           o    = obj.MergeFrom(arg0);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 2 && TypeChecker.CheckTypes <Google.ProtocolBuffers.CodedInputStream>(L, 2))
            {
                Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> obj = (Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder>)ToLua.CheckObject <Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> >(L, 1);
                Google.ProtocolBuffers.CodedInputStream arg0 = (Google.ProtocolBuffers.CodedInputStream)ToLua.ToObject(L, 2);
                MyLib.GCPlayerCmd.Builder o = obj.MergeFrom(arg0);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 2 && TypeChecker.CheckTypes <Google.ProtocolBuffers.ByteString>(L, 2))
            {
                Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> obj = (Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder>)ToLua.CheckObject <Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> >(L, 1);
                Google.ProtocolBuffers.ByteString arg0 = (Google.ProtocolBuffers.ByteString)ToLua.ToObject(L, 2);
                MyLib.GCPlayerCmd.Builder         o    = obj.MergeFrom(arg0);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 2 && TypeChecker.CheckTypes <byte[]>(L, 2))
            {
                Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> obj = (Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder>)ToLua.CheckObject <Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> >(L, 1);
                byte[] arg0 = ToLua.CheckByteBuffer(L, 2);
                MyLib.GCPlayerCmd.Builder o = obj.MergeFrom(arg0);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 2 && TypeChecker.CheckTypes <System.IO.Stream>(L, 2))
            {
                Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> obj = (Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder>)ToLua.CheckObject <Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> >(L, 1);
                System.IO.Stream          arg0 = (System.IO.Stream)ToLua.ToObject(L, 2);
                MyLib.GCPlayerCmd.Builder o    = obj.MergeFrom(arg0);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 3 && TypeChecker.CheckTypes <Google.ProtocolBuffers.CodedInputStream, Google.ProtocolBuffers.ExtensionRegistry>(L, 2))
            {
                Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> obj = (Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder>)ToLua.CheckObject <Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> >(L, 1);
                Google.ProtocolBuffers.CodedInputStream  arg0 = (Google.ProtocolBuffers.CodedInputStream)ToLua.ToObject(L, 2);
                Google.ProtocolBuffers.ExtensionRegistry arg1 = (Google.ProtocolBuffers.ExtensionRegistry)ToLua.ToObject(L, 3);
                MyLib.GCPlayerCmd.Builder o = obj.MergeFrom(arg0, arg1);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 3 && TypeChecker.CheckTypes <Google.ProtocolBuffers.ByteString, Google.ProtocolBuffers.ExtensionRegistry>(L, 2))
            {
                Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> obj = (Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder>)ToLua.CheckObject <Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> >(L, 1);
                Google.ProtocolBuffers.ByteString        arg0 = (Google.ProtocolBuffers.ByteString)ToLua.ToObject(L, 2);
                Google.ProtocolBuffers.ExtensionRegistry arg1 = (Google.ProtocolBuffers.ExtensionRegistry)ToLua.ToObject(L, 3);
                MyLib.GCPlayerCmd.Builder o = obj.MergeFrom(arg0, arg1);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 3 && TypeChecker.CheckTypes <byte[], Google.ProtocolBuffers.ExtensionRegistry>(L, 2))
            {
                Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> obj = (Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder>)ToLua.CheckObject <Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> >(L, 1);
                byte[] arg0 = ToLua.CheckByteBuffer(L, 2);
                Google.ProtocolBuffers.ExtensionRegistry arg1 = (Google.ProtocolBuffers.ExtensionRegistry)ToLua.ToObject(L, 3);
                MyLib.GCPlayerCmd.Builder o = obj.MergeFrom(arg0, arg1);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else if (count == 3 && TypeChecker.CheckTypes <System.IO.Stream, Google.ProtocolBuffers.ExtensionRegistry>(L, 2))
            {
                Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> obj = (Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder>)ToLua.CheckObject <Google.ProtocolBuffers.AbstractBuilderLite <MyLib.GCPlayerCmd, MyLib.GCPlayerCmd.Builder> >(L, 1);
                System.IO.Stream arg0 = (System.IO.Stream)ToLua.ToObject(L, 2);
                Google.ProtocolBuffers.ExtensionRegistry arg1 = (Google.ProtocolBuffers.ExtensionRegistry)ToLua.ToObject(L, 3);
                MyLib.GCPlayerCmd.Builder o = obj.MergeFrom(arg0, arg1);
                ToLua.PushSealed(L, o);
                return(1);
            }
            else
            {
                return(LuaDLL.luaL_throw(L, "invalid arguments to method: Google.ProtocolBuffers.AbstractBuilderLite<MyLib.GCPlayerCmd,MyLib.GCPlayerCmd.Builder>.MergeFrom"));
            }
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
Example #22
0
 /// <summary>
 /// Adds a length-delimited value.
 /// </summary>
 public Builder AddLengthDelimited(ByteString value)
 {
     lengthDelimitedList = Add(lengthDelimitedList, value);
     return(this);
 }
Example #23
0
 /// <summary>
 /// Like <see cref="EscapeBytes" /> but escapes a text string.
 /// The string is first encoded as UTF-8, then each byte escaped individually.
 /// The returned value is guaranteed to be entirely ASCII.
 /// </summary>
 public static string EscapeText(string input)
 {
     return(EscapeBytes(ByteString.CopyFromUtf8(input)));
 }
 IBuilder IBuilder.WeakMergeFrom(ByteString data)
 {
     return(MergeFrom(data));
 }