static int ParseDelimitedFrom(IntPtr L) { try { int count = LuaDLL.lua_gettop(L); if (count == 1) { System.IO.Stream arg0 = (System.IO.Stream)ToLua.CheckObject <System.IO.Stream>(L, 1); MyLib.CGPlayerCmd o = MyLib.CGPlayerCmd.ParseDelimitedFrom(arg0); ToLua.PushSealed(L, o); return(1); } else if (count == 2) { System.IO.Stream arg0 = (System.IO.Stream)ToLua.CheckObject <System.IO.Stream>(L, 1); Google.ProtocolBuffers.ExtensionRegistry arg1 = (Google.ProtocolBuffers.ExtensionRegistry)ToLua.CheckObject(L, 2, typeof(Google.ProtocolBuffers.ExtensionRegistry)); MyLib.CGPlayerCmd o = MyLib.CGPlayerCmd.ParseDelimitedFrom(arg0, arg1); ToLua.PushSealed(L, o); return(1); } else { return(LuaDLL.luaL_throw(L, "invalid arguments to method: MyLib.CGPlayerCmd.ParseDelimitedFrom")); } } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
static int MergeDelimitedFrom(IntPtr L) { try { int count = LuaDLL.lua_gettop(L); if (count == 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.CheckObject <System.IO.Stream>(L, 2); MyLib.GCPlayerCmd.Builder o = obj.MergeDelimitedFrom(arg0); ToLua.PushSealed(L, o); return(1); } else if (count == 3) { 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.CheckObject <System.IO.Stream>(L, 2); Google.ProtocolBuffers.ExtensionRegistry arg1 = (Google.ProtocolBuffers.ExtensionRegistry)ToLua.CheckObject(L, 3, typeof(Google.ProtocolBuffers.ExtensionRegistry)); MyLib.GCPlayerCmd.Builder o = obj.MergeDelimitedFrom(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>.MergeDelimitedFrom")); } } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
protected override bool ParseUnknownField(ICodedInputStream input, ExtensionRegistry extensionRegistry, uint tag, string fieldName) { TMessage messageBeingBuilt = this.MessageBeingBuilt; FieldSet extensions = messageBeingBuilt.Extensions; WireFormat.WireType tagWireType = WireFormat.GetTagWireType(tag); int tagFieldNumber = WireFormat.GetTagFieldNumber(tag); IGeneratedExtensionLite generatedExtensionLite = extensionRegistry[this.DefaultInstanceForType, tagFieldNumber]; if (generatedExtensionLite == null) { return(input.SkipField()); } IFieldDescriptorLite descriptor = generatedExtensionLite.Descriptor; if (descriptor == null) { return(input.SkipField()); } WireFormat.WireType wireType = descriptor.IsPacked ? WireFormat.WireType.LengthDelimited : WireFormat.GetWireType(descriptor.FieldType); if (tagWireType != wireType) { wireType = WireFormat.GetWireType(descriptor.FieldType); if (tagWireType != wireType && (!descriptor.IsRepeated || tagWireType != WireFormat.WireType.LengthDelimited || (wireType != WireFormat.WireType.Varint && wireType != WireFormat.WireType.Fixed32 && wireType != WireFormat.WireType.Fixed64))) { return(input.SkipField()); } } if (!descriptor.IsRepeated && tagWireType != WireFormat.GetWireType(descriptor.FieldType)) { return(input.SkipField()); } FieldType fieldType = descriptor.FieldType; switch (fieldType) { case FieldType.Group: case FieldType.Message: { if (descriptor.IsRepeated) { List <IMessageLite> list = new List <IMessageLite>(); if (descriptor.FieldType == FieldType.Group) { input.ReadGroupArray <IMessageLite>(tag, fieldName, list, generatedExtensionLite.MessageDefaultInstance, extensionRegistry); } else { input.ReadMessageArray <IMessageLite>(tag, fieldName, list, generatedExtensionLite.MessageDefaultInstance, extensionRegistry); } using (List <IMessageLite> .Enumerator enumerator = list.GetEnumerator()) { while (enumerator.MoveNext()) { IMessageLite current = enumerator.Current; extensions.AddRepeatedField(descriptor, current); } } return(true); } IMessageLite messageLite = extensions[generatedExtensionLite.Descriptor] as IMessageLite; IBuilderLite builderLite = (messageLite ?? generatedExtensionLite.MessageDefaultInstance).WeakToBuilder(); if (descriptor.FieldType == FieldType.Group) { input.ReadGroup(descriptor.FieldNumber, builderLite, extensionRegistry); } else { input.ReadMessage(builderLite, extensionRegistry); } extensions[descriptor] = builderLite.WeakBuild(); break; } default: if (fieldType == FieldType.Enum) { if (!descriptor.IsRepeated) { IEnumLite value = null; object obj; if (input.ReadEnum(ref value, out obj, descriptor.EnumType)) { extensions[descriptor] = value; break; } break; } else { List <IEnumLite> list2 = new List <IEnumLite>(); ICollection <object> collection; input.ReadEnumArray(tag, fieldName, list2, out collection, descriptor.EnumType); using (List <IEnumLite> .Enumerator enumerator2 = list2.GetEnumerator()) { while (enumerator2.MoveNext()) { IEnumLite current2 = enumerator2.Current; extensions.AddRepeatedField(descriptor, current2); } break; } } } if (!descriptor.IsRepeated) { object value2 = null; if (input.ReadPrimitiveField(descriptor.FieldType, ref value2)) { extensions[descriptor] = value2; } } else { List <object> list3 = new List <object>(); input.ReadPrimitiveArray(descriptor.FieldType, tag, fieldName, list3); using (List <object> .Enumerator enumerator3 = list3.GetEnumerator()) { while (enumerator3.MoveNext()) { object current3 = enumerator3.Current; extensions.AddRepeatedField(descriptor, current3); } } } break; } return(true); }
/// <summary> /// Like <see cref="MergeFrom(ICodedInputStream, ExtensionRegistry, IBuilder)" /> /// but parses a single field. /// </summary> /// <param name="input">The input to read the field from</param> /// <param name="extensionRegistry">Registry to use when an extension field is encountered</param> /// <param name="builder">Builder to merge field into, if it's a known field</param> /// <param name="tag">The tag, which should already have been read from the input</param> /// <returns>true unless the tag is an end-group tag</returns> internal bool MergeFieldFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry, IBuilder builder, uint tag, string fieldName) { if (tag == 0 && fieldName != null) { FieldDescriptor fieldByName = builder.DescriptorForType.FindFieldByName(fieldName); if (fieldByName != null) { tag = WireFormat.MakeTag(fieldByName); } else { ExtensionInfo extension = extensionRegistry.FindByName(builder.DescriptorForType, fieldName); if (extension != null) { tag = WireFormat.MakeTag(extension.Descriptor); } } } MessageDescriptor type = builder.DescriptorForType; if (type.Options.MessageSetWireFormat && tag == WireFormat.MessageSetTag.ItemStart) { MergeMessageSetExtensionFromCodedStream(input, extensionRegistry, builder); return(true); } WireFormat.WireType wireType = WireFormat.GetTagWireType(tag); int fieldNumber = WireFormat.GetTagFieldNumber(tag); FieldDescriptor field; IMessageLite defaultFieldInstance = null; if (type.IsExtensionNumber(fieldNumber)) { ExtensionInfo extension = extensionRegistry[type, fieldNumber]; if (extension == null) { field = null; } else { field = extension.Descriptor; defaultFieldInstance = extension.DefaultInstance; } } else { field = type.FindFieldByNumber(fieldNumber); } // Unknown field or wrong wire type. Skip. if (field == null) { return(MergeFieldFrom(tag, input)); } if (wireType != WireFormat.GetWireType(field)) { WireFormat.WireType expectedType = WireFormat.GetWireType(field.FieldType); if (wireType == expectedType) { //Allowed as of 2.3, this is unpacked data for a packed array } else if (field.IsRepeated && wireType == WireFormat.WireType.LengthDelimited && (expectedType == WireFormat.WireType.Varint || expectedType == WireFormat.WireType.Fixed32 || expectedType == WireFormat.WireType.Fixed64)) { //Allowed as of 2.3, this is packed data for an unpacked array } else { return(MergeFieldFrom(tag, input)); } } switch (field.FieldType) { case FieldType.Group: case FieldType.Message: { IBuilderLite subBuilder = (defaultFieldInstance != null) ? defaultFieldInstance.WeakCreateBuilderForType() : builder.CreateBuilderForField(field); if (!field.IsRepeated) { subBuilder.WeakMergeFrom((IMessageLite)builder[field]); if (field.FieldType == FieldType.Group) { input.ReadGroup(field.FieldNumber, subBuilder, extensionRegistry); } else { input.ReadMessage(subBuilder, extensionRegistry); } builder[field] = subBuilder.WeakBuild(); } else { List <IMessageLite> list = new List <IMessageLite>(); if (field.FieldType == FieldType.Group) { input.ReadGroupArray(tag, fieldName, list, subBuilder.WeakDefaultInstanceForType, extensionRegistry); } else { input.ReadMessageArray(tag, fieldName, list, subBuilder.WeakDefaultInstanceForType, extensionRegistry); } foreach (IMessageLite m in list) { builder.WeakAddRepeatedField(field, m); } return(true); } break; } case FieldType.Enum: { if (!field.IsRepeated) { object unknown; IEnumLite value = null; if (input.ReadEnum(ref value, out unknown, field.EnumType)) { builder[field] = value; } else if (unknown is int) { MergeVarintField(fieldNumber, (ulong)(int)unknown); } } else { ICollection <object> unknown; List <IEnumLite> list = new List <IEnumLite>(); input.ReadEnumArray(tag, fieldName, list, out unknown, field.EnumType); foreach (IEnumLite en in list) { builder.WeakAddRepeatedField(field, en); } if (unknown != null) { foreach (object oval in unknown) { if (oval is int) { MergeVarintField(fieldNumber, (ulong)(int)oval); } } } } break; } default: { if (!field.IsRepeated) { object value = null; if (input.ReadPrimitiveField(field.FieldType, ref value)) { builder[field] = value; } } else { List <object> list = new List <object>(); input.ReadPrimitiveArray(field.FieldType, tag, fieldName, list); foreach (object oval in list) { builder.WeakAddRepeatedField(field, oval); } } break; } } return(true); }
/// <summary> /// Called by subclasses to parse an unknown field or an extension. /// </summary> /// <returns>true unless the tag is an end-group tag</returns> protected override bool ParseUnknownField(ICodedInputStream input, ExtensionRegistry extensionRegistry, uint tag, string fieldName) { FieldSet extensions = MessageBeingBuilt.Extensions; WireFormat.WireType wireType = WireFormat.GetTagWireType(tag); int fieldNumber = WireFormat.GetTagFieldNumber(tag); IGeneratedExtensionLite extension = extensionRegistry[DefaultInstanceForType, fieldNumber]; if (extension == null) //unknown field { return(input.SkipField()); } IFieldDescriptorLite field = extension.Descriptor; // Unknown field or wrong wire type. Skip. if (field == null) { return(input.SkipField()); } WireFormat.WireType expectedType = field.IsPacked ? WireFormat.WireType.LengthDelimited : WireFormat.GetWireType(field.FieldType); if (wireType != expectedType) { expectedType = WireFormat.GetWireType(field.FieldType); if (wireType == expectedType) { //Allowed as of 2.3, this is unpacked data for a packed array } else if (field.IsRepeated && wireType == WireFormat.WireType.LengthDelimited && (expectedType == WireFormat.WireType.Varint || expectedType == WireFormat.WireType.Fixed32 || expectedType == WireFormat.WireType.Fixed64)) { //Allowed as of 2.3, this is packed data for an unpacked array } else { return(input.SkipField()); } } if (!field.IsRepeated && wireType != WireFormat.GetWireType(field.FieldType)) //invalid wire type { return(input.SkipField()); } switch (field.FieldType) { case FieldType.Group: case FieldType.Message: { if (!field.IsRepeated) { IMessageLite message = extensions[extension.Descriptor] as IMessageLite; IBuilderLite subBuilder = (message ?? extension.MessageDefaultInstance).WeakToBuilder(); if (field.FieldType == FieldType.Group) { input.ReadGroup(field.FieldNumber, subBuilder, extensionRegistry); } else { input.ReadMessage(subBuilder, extensionRegistry); } extensions[field] = subBuilder.WeakBuild(); } else { List <IMessageLite> list = new List <IMessageLite>(); if (field.FieldType == FieldType.Group) { input.ReadGroupArray(tag, fieldName, list, extension.MessageDefaultInstance, extensionRegistry); } else { input.ReadMessageArray(tag, fieldName, list, extension.MessageDefaultInstance, extensionRegistry); } foreach (IMessageLite m in list) { extensions.AddRepeatedField(field, m); } return(true); } break; } case FieldType.Enum: { if (!field.IsRepeated) { object unknown; IEnumLite value = null; if (input.ReadEnum(ref value, out unknown, field.EnumType)) { extensions[field] = value; } } else { ICollection <object> unknown; List <IEnumLite> list = new List <IEnumLite>(); input.ReadEnumArray(tag, fieldName, list, out unknown, field.EnumType); foreach (IEnumLite en in list) { extensions.AddRepeatedField(field, en); } } break; } default: { if (!field.IsRepeated) { object value = null; if (input.ReadPrimitiveField(field.FieldType, ref value)) { extensions[field] = value; } } else { List <object> list = new List <object>(); input.ReadPrimitiveArray(field.FieldType, tag, fieldName, list); foreach (object oval in list) { extensions.AddRepeatedField(field, oval); } } break; } } return(true); }
public override Builder MergeFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry) { wrappedBuilder.WeakMergeFrom(input, extensionRegistry); return(this); }
IBuilderLite IBuilderLite.WeakMergeFrom(CodedInputStream input, ExtensionRegistry registry) { return(MergeFrom(input)); }
/// <summary> /// Called by MergeFieldFrom to parse a MessageSet extension. /// </summary> private void MergeMessageSetExtensionFromCodedStream(CodedInputStream input, ExtensionRegistry extensionRegistry, IBuilder builder) { MessageDescriptor type = builder.DescriptorForType; // The wire format for MessageSet is: // message MessageSet { // repeated group Item = 1 { // required int32 typeId = 2; // required bytes message = 3; // } // } // "typeId" is the extension's field number. The extension can only be // a message type, where "message" contains the encoded bytes of that // message. // // In practice, we will probably never see a MessageSet item in which // the message appears before the type ID, or where either field does not // appear exactly once. However, in theory such cases are valid, so we // should be prepared to accept them. int typeId = 0; ByteString rawBytes = null; // If we encounter "message" before "typeId" IBuilderLite subBuilder = null; FieldDescriptor field = null; while (true) { uint tag = input.ReadTag(); if (tag == 0) { break; } if (tag == WireFormat.MessageSetTag.TypeID) { typeId = input.ReadInt32(); // Zero is not a valid type ID. if (typeId != 0) { ExtensionInfo extension = extensionRegistry[type, typeId]; if (extension != null) { field = extension.Descriptor; subBuilder = extension.DefaultInstance.WeakCreateBuilderForType(); IMessageLite originalMessage = (IMessageLite)builder[field]; if (originalMessage != null) { subBuilder.WeakMergeFrom(originalMessage); } if (rawBytes != null) { // We already encountered the message. Parse it now. // TODO(jonskeet): Check this is okay. It's subtly different from the Java, as it doesn't create an input stream from rawBytes. // In fact, why don't we just call MergeFrom(rawBytes)? And what about the extension registry? subBuilder.WeakMergeFrom(rawBytes.CreateCodedInput()); rawBytes = null; } } else { // Unknown extension number. If we already saw data, put it // in rawBytes. if (rawBytes != null) { MergeField(typeId, UnknownField.CreateBuilder().AddLengthDelimited(rawBytes).Build()); rawBytes = null; } } } } else if (tag == WireFormat.MessageSetTag.Message) { if (typeId == 0) { // We haven't seen a type ID yet, so we have to store the raw bytes for now. rawBytes = input.ReadBytes(); } else if (subBuilder == null) { // We don't know how to parse this. Ignore it. MergeField(typeId, UnknownField.CreateBuilder().AddLengthDelimited(input.ReadBytes()).Build()); } else { // We already know the type, so we can parse directly from the input // with no copying. Hooray! input.ReadMessage(subBuilder, extensionRegistry); } } else { // Unknown tag. Skip it. if (!input.SkipField(tag)) { break; // end of group } } } input.CheckLastTagWas(WireFormat.MessageSetTag.ItemEnd); if (subBuilder != null) { builder[field] = subBuilder.WeakBuild(); } }
public static void Merge(TextReader reader, ExtensionRegistry registry, IBuilder builder) { Merge(reader.ReadToEnd(), registry, builder); }
protected override bool ParseUnknownField(CodedInputStream input, ExtensionRegistry extensionRegistry, uint tag) { FieldSet extensions = MessageBeingBuilt.Extensions; WireFormat.WireType wireType = WireFormat.GetTagWireType(tag); int fieldNumber = WireFormat.GetTagFieldNumber(tag); IGeneratedExtensionLite extension = extensionRegistry[DefaultInstanceForType, fieldNumber]; bool unknown = false; bool packed = false; if (extension == null) { unknown = true; // Unknown field. } else if (wireType == FieldMappingAttribute.WireTypeFromFieldType(extension.Descriptor.FieldType, false /* isPacked */)) { packed = false; // Normal, unpacked value. } else if (extension.Descriptor.IsRepeated && //?? just returns true ?? extension.Descriptor.type.isPackable() && wireType == FieldMappingAttribute.WireTypeFromFieldType(extension.Descriptor.FieldType, true /* isPacked */)) { packed = true; // Packed value. } else { unknown = true; // Wrong wire type. } if (unknown) // Unknown field or wrong wire type. Skip. { return(input.SkipField(tag)); } if (packed) { int length = (int)Math.Min(int.MaxValue, input.ReadRawVarint32()); int limit = input.PushLimit(length); if (extension.Descriptor.FieldType == FieldType.Enum) { while (!input.ReachedLimit) { int rawValue = input.ReadEnum(); Object value = extension.Descriptor.EnumType.FindValueByNumber(rawValue); if (value == null) { // If the number isn't recognized as a valid value for this // enum, drop it (don't even add it to unknownFields). return(true); } extensions.AddRepeatedField(extension.Descriptor, value); } } else { while (!input.ReachedLimit) { Object value = input.ReadPrimitiveField(extension.Descriptor.FieldType); extensions.AddRepeatedField(extension.Descriptor, value); } } input.PopLimit(limit); } else { Object value; switch (extension.Descriptor.MappedType) { case MappedType.Message: { IBuilderLite subBuilder = null; if (!extension.Descriptor.IsRepeated) { IMessageLite existingValue = extensions[extension.Descriptor] as IMessageLite; if (existingValue != null) { subBuilder = existingValue.WeakToBuilder(); } } if (subBuilder == null) { subBuilder = extension.MessageDefaultInstance.WeakCreateBuilderForType(); } if (extension.Descriptor.FieldType == FieldType.Group) { input.ReadGroup(extension.Number, subBuilder, extensionRegistry); } else { input.ReadMessage(subBuilder, extensionRegistry); } value = subBuilder.WeakBuild(); break; } case MappedType.Enum: int rawValue = input.ReadEnum(); value = extension.Descriptor.EnumType.FindValueByNumber(rawValue); // If the number isn't recognized as a valid value for this enum, // drop it. if (value == null) { return(true); } break; default: value = input.ReadPrimitiveField(extension.Descriptor.FieldType); break; } if (extension.Descriptor.IsRepeated) { extensions.AddRepeatedField(extension.Descriptor, value); } else { extensions[extension.Descriptor] = value; } } return(true); }
public void ExtensionWriterTestPacked() { TestPackedExtensionsLite.Builder builder = TestPackedExtensionsLite.CreateBuilder() .AddExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, true) .AddExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, true) .AddExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 123) .AddExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 123u) .AddExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 123u); TestPackedExtensionsLite msg = builder.Build(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); UnitTestLiteProtoFile.RegisterAllExtensions(registry); TestPackedExtensionsLite.Builder copyBuilder = TestPackedExtensionsLite.CreateBuilder().MergeFrom(msg.ToByteArray(), registry); TestPackedExtensionsLite copy = copyBuilder.Build(); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 0)); Assert.AreEqual(true, copy.GetExtension(UnitTestLiteProtoFile.PackedBoolExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedDoubleExtensionLite, 1)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed32ExtensionLite, 1)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedFixed64ExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedFloatExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt32ExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedInt64ExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed32ExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSfixed64ExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint32ExtensionLite, 1)); Assert.AreEqual(123, copy.GetExtension(UnitTestLiteProtoFile.PackedSint64ExtensionLite, 1)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint32ExtensionLite, 1)); Assert.AreEqual(123u, copy.GetExtension(UnitTestLiteProtoFile.PackedUint64ExtensionLite, 1)); }
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)); } }
/// <summary> /// Parse a message of the given type from the given stream and extension registry. /// </summary> /// <param name="type"></param> /// <param name="input"></param> /// <param name="extensionRegistry"></param> /// <returns></returns> public static DynamicMessage ParseFrom(MessageDescriptor type, CodedInputStream input, ExtensionRegistry extensionRegistry) { Builder builder = CreateBuilder(type); Builder dynamicBuilder = builder.MergeFrom(input, extensionRegistry); return(dynamicBuilder.BuildParsed()); }
/// <summary> /// Parse <paramref name="data"/> as a message of the given type and return it. /// </summary> public static DynamicMessage ParseFrom(MessageDescriptor type, ByteString data, ExtensionRegistry extensionRegistry) { Builder builder = CreateBuilder(type); Builder dynamicBuilder = builder.MergeFrom(data, extensionRegistry); return(dynamicBuilder.BuildParsed()); }
/// <summary> /// Called by subclasses to parse an unknown field or an extension. /// </summary> /// <returns>true unless the tag is an end-group tag</returns> protected override bool ParseUnknownField(ICodedInputStream input, UnknownFieldSet.Builder unknownFields, ExtensionRegistry extensionRegistry, uint tag, string fieldName) { return(unknownFields.MergeFieldFrom(input, extensionRegistry, this, tag, fieldName)); }
/// <summary> /// Parses a single field from the specified tokenizer and merges it into /// the builder. /// </summary> private static void MergeField(TextTokenizer tokenizer, ExtensionRegistry extensionRegistry, IBuilder builder) { FieldDescriptor field; MessageDescriptor type = builder.DescriptorForType; ExtensionInfo extension = null; if (tokenizer.TryConsume("[")) { // An extension. StringBuilder name = new StringBuilder(tokenizer.ConsumeIdentifier()); while (tokenizer.TryConsume(".")) { name.Append("."); name.Append(tokenizer.ConsumeIdentifier()); } extension = extensionRegistry.FindByName(type, name.ToString()); if (extension == null) { throw tokenizer.CreateFormatExceptionPreviousToken("Extension \"" + name + "\" not found in the ExtensionRegistry."); } else if (extension.Descriptor.ContainingType != type) { throw tokenizer.CreateFormatExceptionPreviousToken("Extension \"" + name + "\" does not extend message type \"" + type.FullName + "\"."); } tokenizer.Consume("]"); field = extension.Descriptor; } else { String name = tokenizer.ConsumeIdentifier(); field = type.FindDescriptor <FieldDescriptor>(name); // Group names are expected to be capitalized as they appear in the // .proto file, which actually matches their type names, not their field // names. if (field == null) { // Explicitly specify the invariant culture so that this code does not break when // executing in Turkey. String lowerName = name.ToLowerInvariant(); field = type.FindDescriptor <FieldDescriptor>(lowerName); // If the case-insensitive match worked but the field is NOT a group, // TODO(jonskeet): What? Java comment ends here! if (field != null && field.FieldType != FieldType.Group) { field = null; } } // Again, special-case group names as described above. if (field != null && field.FieldType == FieldType.Group && field.MessageType.Name != name) { field = null; } if (field == null) { throw tokenizer.CreateFormatExceptionPreviousToken( "Message type \"" + type.FullName + "\" has no field named \"" + name + "\"."); } } object value = null; if (field.MappedType == MappedType.Message) { tokenizer.TryConsume(":"); // optional String endToken; if (tokenizer.TryConsume("<")) { endToken = ">"; } else { tokenizer.Consume("{"); endToken = "}"; } IBuilder subBuilder; if (extension == null) { subBuilder = builder.CreateBuilderForField(field); } else { subBuilder = extension.DefaultInstance.WeakCreateBuilderForType() as IBuilder; if (subBuilder == null) { throw new NotSupportedException("Lite messages are not supported."); } } while (!tokenizer.TryConsume(endToken)) { if (tokenizer.AtEnd) { throw tokenizer.CreateFormatException("Expected \"" + endToken + "\"."); } MergeField(tokenizer, extensionRegistry, subBuilder); } value = subBuilder.WeakBuild(); } else { tokenizer.Consume(":"); switch (field.FieldType) { case FieldType.Int32: case FieldType.SInt32: case FieldType.SFixed32: value = tokenizer.ConsumeInt32(); break; case FieldType.Int64: case FieldType.SInt64: case FieldType.SFixed64: value = tokenizer.ConsumeInt64(); break; case FieldType.UInt32: case FieldType.Fixed32: value = tokenizer.ConsumeUInt32(); break; case FieldType.UInt64: case FieldType.Fixed64: value = tokenizer.ConsumeUInt64(); break; case FieldType.Float: value = tokenizer.ConsumeFloat(); break; case FieldType.Double: value = tokenizer.ConsumeDouble(); break; case FieldType.Bool: value = tokenizer.ConsumeBoolean(); break; case FieldType.String: value = tokenizer.ConsumeString(); break; case FieldType.Bytes: value = tokenizer.ConsumeByteString(); break; case FieldType.Enum: { EnumDescriptor enumType = field.EnumType; if (tokenizer.LookingAtInteger()) { int number = tokenizer.ConsumeInt32(); value = enumType.FindValueByNumber(number); if (value == null) { throw tokenizer.CreateFormatExceptionPreviousToken( "Enum type \"" + enumType.FullName + "\" has no value with number " + number + "."); } } else { String id = tokenizer.ConsumeIdentifier(); value = enumType.FindValueByName(id); if (value == null) { throw tokenizer.CreateFormatExceptionPreviousToken( "Enum type \"" + enumType.FullName + "\" has no value named \"" + id + "\"."); } } break; } case FieldType.Message: case FieldType.Group: throw new InvalidOperationException("Can't get here."); } } if (field.IsRepeated) { builder.WeakAddRepeatedField(field, value); } else { builder.SetField(field, value); } }
/// <summary> /// Like <see cref="MergeFrom(CodedInputStream, ExtensionRegistry, IBuilder)" /> /// but parses a single field. /// </summary> /// <param name="input">The input to read the field from</param> /// <param name="extensionRegistry">Registry to use when an extension field is encountered</param> /// <param name="builder">Builder to merge field into, if it's a known field</param> /// <param name="tag">The tag, which should already have been read from the input</param> /// <returns>true unless the tag is an end-group tag</returns> internal bool MergeFieldFrom(CodedInputStream input, ExtensionRegistry extensionRegistry, IBuilder builder, uint tag) { MessageDescriptor type = builder.DescriptorForType; if (type.Options.MessageSetWireFormat && tag == WireFormat.MessageSetTag.ItemStart) { MergeMessageSetExtensionFromCodedStream(input, extensionRegistry, builder); return(true); } WireFormat.WireType wireType = WireFormat.GetTagWireType(tag); int fieldNumber = WireFormat.GetTagFieldNumber(tag); FieldDescriptor field; IMessageLite defaultFieldInstance = null; if (type.IsExtensionNumber(fieldNumber)) { ExtensionInfo extension = extensionRegistry[type, fieldNumber]; if (extension == null) { field = null; } else { field = extension.Descriptor; defaultFieldInstance = extension.DefaultInstance; } } else { field = type.FindFieldByNumber(fieldNumber); } // Unknown field or wrong wire type. Skip. if (field == null || wireType != WireFormat.GetWireType(field)) { return(MergeFieldFrom(tag, input)); } if (field.IsPacked) { int length = (int)input.ReadRawVarint32(); int limit = input.PushLimit(length); if (field.FieldType == FieldType.Enum) { while (!input.ReachedLimit) { int rawValue = input.ReadEnum(); object value = field.EnumType.FindValueByNumber(rawValue); if (value == null) { // If the number isn't recognized as a valid value for this // enum, drop it (don't even add it to unknownFields). return(true); } builder.WeakAddRepeatedField(field, value); } } else { while (!input.ReachedLimit) { Object value = input.ReadPrimitiveField(field.FieldType); builder.WeakAddRepeatedField(field, value); } } input.PopLimit(limit); } else { object value; switch (field.FieldType) { case FieldType.Group: case FieldType.Message: { IBuilderLite subBuilder; if (defaultFieldInstance != null) { subBuilder = defaultFieldInstance.WeakCreateBuilderForType(); } else { subBuilder = builder.CreateBuilderForField(field); } if (!field.IsRepeated) { subBuilder.WeakMergeFrom((IMessageLite)builder[field]); } if (field.FieldType == FieldType.Group) { input.ReadGroup(field.FieldNumber, subBuilder, extensionRegistry); } else { input.ReadMessage(subBuilder, extensionRegistry); } value = subBuilder.WeakBuild(); break; } case FieldType.Enum: { int rawValue = input.ReadEnum(); value = field.EnumType.FindValueByNumber(rawValue); // If the number isn't recognized as a valid value for this enum, // drop it. if (value == null) { MergeVarintField(fieldNumber, (ulong)rawValue); return(true); } break; } default: value = input.ReadPrimitiveField(field.FieldType); break; } if (field.IsRepeated) { builder.WeakAddRepeatedField(field, value); } else { builder[field] = value; } } return(true); }
private MessageStreamIterator(StreamProvider streamProvider, ExtensionRegistry extensionRegistry) : this(streamProvider, extensionRegistry, CodedInputStream.DefaultSizeLimit) { }
IBuilderLite IBuilderLite.WeakMergeFrom(ByteString data, ExtensionRegistry registry) { return(MergeFrom(data)); }
/// <summary> /// Creates a new instance which uses the same stream provider as this one, /// but the specified extension registry. /// </summary> public MessageStreamIterator <TMessage> WithExtensionRegistry(ExtensionRegistry newRegistry) { return(new MessageStreamIterator <TMessage>(streamProvider, newRegistry, sizeLimit)); }
protected virtual bool ParseUnknownField(ICodedInputStream input, ExtensionRegistry extensionRegistry, uint tag, string fieldName) { return(input.SkipField()); }
IBuilder IBuilder.WeakMergeFrom(ICodedInputStream input, ExtensionRegistry registry) { return(MergeFrom(input, registry)); }
protected virtual bool ParseUnknownField(CodedInputStream input, UnknownFieldSet.Builder unknownFields, ExtensionRegistry extensionRegistry, uint tag) { return(unknownFields.MergeFieldFrom(tag, input)); }
public void ExtensionWriterTest() { TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder() .SetExtension(UnitTestProtoFile.DefaultBoolExtension, true) .SetExtension(UnitTestProtoFile.DefaultBytesExtension, ByteString.CopyFromUtf8("123")) .SetExtension(UnitTestProtoFile.DefaultCordExtension, "123") .SetExtension(UnitTestProtoFile.DefaultDoubleExtension, 123) .SetExtension(UnitTestProtoFile.DefaultFixed32Extension, 123u) .SetExtension(UnitTestProtoFile.DefaultFixed64Extension, 123u) .SetExtension(UnitTestProtoFile.DefaultFloatExtension, 123) .SetExtension(UnitTestProtoFile.DefaultForeignEnumExtension, ForeignEnum.FOREIGN_BAZ) .SetExtension(UnitTestProtoFile.DefaultImportEnumExtension, ImportEnum.IMPORT_BAZ) .SetExtension(UnitTestProtoFile.DefaultInt32Extension, 123) .SetExtension(UnitTestProtoFile.DefaultInt64Extension, 123) .SetExtension(UnitTestProtoFile.DefaultNestedEnumExtension, TestAllTypes.Types.NestedEnum.FOO) .SetExtension(UnitTestProtoFile.DefaultSfixed32Extension, 123) .SetExtension(UnitTestProtoFile.DefaultSfixed64Extension, 123) .SetExtension(UnitTestProtoFile.DefaultSint32Extension, 123) .SetExtension(UnitTestProtoFile.DefaultSint64Extension, 123) .SetExtension(UnitTestProtoFile.DefaultStringExtension, "123") .SetExtension(UnitTestProtoFile.DefaultStringPieceExtension, "123") .SetExtension(UnitTestProtoFile.DefaultUint32Extension, 123u) .SetExtension(UnitTestProtoFile.DefaultUint64Extension, 123u) //Optional .SetExtension(UnitTestProtoFile.OptionalBoolExtension, true) .SetExtension(UnitTestProtoFile.OptionalBytesExtension, ByteString.CopyFromUtf8("123")) .SetExtension(UnitTestProtoFile.OptionalCordExtension, "123") .SetExtension(UnitTestProtoFile.OptionalDoubleExtension, 123) .SetExtension(UnitTestProtoFile.OptionalFixed32Extension, 123u) .SetExtension(UnitTestProtoFile.OptionalFixed64Extension, 123u) .SetExtension(UnitTestProtoFile.OptionalFloatExtension, 123) .SetExtension(UnitTestProtoFile.OptionalForeignEnumExtension, ForeignEnum.FOREIGN_BAZ) .SetExtension(UnitTestProtoFile.OptionalImportEnumExtension, ImportEnum.IMPORT_BAZ) .SetExtension(UnitTestProtoFile.OptionalInt32Extension, 123) .SetExtension(UnitTestProtoFile.OptionalInt64Extension, 123) .SetExtension(UnitTestProtoFile.OptionalNestedEnumExtension, TestAllTypes.Types.NestedEnum.FOO) .SetExtension(UnitTestProtoFile.OptionalSfixed32Extension, 123) .SetExtension(UnitTestProtoFile.OptionalSfixed64Extension, 123) .SetExtension(UnitTestProtoFile.OptionalSint32Extension, 123) .SetExtension(UnitTestProtoFile.OptionalSint64Extension, 123) .SetExtension(UnitTestProtoFile.OptionalStringExtension, "123") .SetExtension(UnitTestProtoFile.OptionalStringPieceExtension, "123") .SetExtension(UnitTestProtoFile.OptionalUint32Extension, 123u) .SetExtension(UnitTestProtoFile.OptionalUint64Extension, 123u) //Repeated .AddExtension(UnitTestProtoFile.RepeatedBoolExtension, true) .AddExtension(UnitTestProtoFile.RepeatedBytesExtension, ByteString.CopyFromUtf8("123")) .AddExtension(UnitTestProtoFile.RepeatedCordExtension, "123") .AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 123) .AddExtension(UnitTestProtoFile.RepeatedFixed32Extension, 123u) .AddExtension(UnitTestProtoFile.RepeatedFixed64Extension, 123u) .AddExtension(UnitTestProtoFile.RepeatedFloatExtension, 123) .AddExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAZ) .AddExtension(UnitTestProtoFile.RepeatedImportEnumExtension, ImportEnum.IMPORT_BAZ) .AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 123) .AddExtension(UnitTestProtoFile.RepeatedInt64Extension, 123) .AddExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, TestAllTypes.Types.NestedEnum.FOO) .AddExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 123) .AddExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 123) .AddExtension(UnitTestProtoFile.RepeatedSint32Extension, 123) .AddExtension(UnitTestProtoFile.RepeatedSint64Extension, 123) .AddExtension(UnitTestProtoFile.RepeatedStringExtension, "123") .AddExtension(UnitTestProtoFile.RepeatedStringPieceExtension, "123") .AddExtension(UnitTestProtoFile.RepeatedUint32Extension, 123u) .AddExtension(UnitTestProtoFile.RepeatedUint64Extension, 123u) ; TestAllExtensions msg = builder.Build(); ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); UnitTestProtoFile.RegisterAllExtensions(registry); TestAllExtensions.Builder copyBuilder = TestAllExtensions.CreateBuilder().MergeFrom(msg.ToByteArray(), registry); TestAllExtensions copy = copyBuilder.Build(); Assert.AreEqual(msg.ToByteArray(), copy.ToByteArray()); Assert.AreEqual(true, copy.GetExtension(UnitTestProtoFile.DefaultBoolExtension)); Assert.AreEqual(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnitTestProtoFile.DefaultBytesExtension)); Assert.AreEqual("123", copy.GetExtension(UnitTestProtoFile.DefaultCordExtension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.DefaultDoubleExtension)); Assert.AreEqual(123u, copy.GetExtension(UnitTestProtoFile.DefaultFixed32Extension)); Assert.AreEqual(123u, copy.GetExtension(UnitTestProtoFile.DefaultFixed64Extension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.DefaultFloatExtension)); Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, copy.GetExtension(UnitTestProtoFile.DefaultForeignEnumExtension)); Assert.AreEqual(ImportEnum.IMPORT_BAZ, copy.GetExtension(UnitTestProtoFile.DefaultImportEnumExtension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.DefaultInt32Extension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.DefaultInt64Extension)); Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, copy.GetExtension(UnitTestProtoFile.DefaultNestedEnumExtension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.DefaultSfixed32Extension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.DefaultSfixed64Extension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.DefaultSint32Extension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.DefaultSint64Extension)); Assert.AreEqual("123", copy.GetExtension(UnitTestProtoFile.DefaultStringExtension)); Assert.AreEqual("123", copy.GetExtension(UnitTestProtoFile.DefaultStringPieceExtension)); Assert.AreEqual(123u, copy.GetExtension(UnitTestProtoFile.DefaultUint32Extension)); Assert.AreEqual(123u, copy.GetExtension(UnitTestProtoFile.DefaultUint64Extension)); Assert.AreEqual(true, copy.GetExtension(UnitTestProtoFile.OptionalBoolExtension)); Assert.AreEqual(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnitTestProtoFile.OptionalBytesExtension)); Assert.AreEqual("123", copy.GetExtension(UnitTestProtoFile.OptionalCordExtension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.OptionalDoubleExtension)); Assert.AreEqual(123u, copy.GetExtension(UnitTestProtoFile.OptionalFixed32Extension)); Assert.AreEqual(123u, copy.GetExtension(UnitTestProtoFile.OptionalFixed64Extension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.OptionalFloatExtension)); Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, copy.GetExtension(UnitTestProtoFile.OptionalForeignEnumExtension)); Assert.AreEqual(ImportEnum.IMPORT_BAZ, copy.GetExtension(UnitTestProtoFile.OptionalImportEnumExtension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.OptionalInt32Extension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.OptionalInt64Extension)); Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, copy.GetExtension(UnitTestProtoFile.OptionalNestedEnumExtension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.OptionalSfixed32Extension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.OptionalSfixed64Extension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.OptionalSint32Extension)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.OptionalSint64Extension)); Assert.AreEqual("123", copy.GetExtension(UnitTestProtoFile.OptionalStringExtension)); Assert.AreEqual("123", copy.GetExtension(UnitTestProtoFile.OptionalStringPieceExtension)); Assert.AreEqual(123u, copy.GetExtension(UnitTestProtoFile.OptionalUint32Extension)); Assert.AreEqual(123u, copy.GetExtension(UnitTestProtoFile.OptionalUint64Extension)); Assert.AreEqual(true, copy.GetExtension(UnitTestProtoFile.RepeatedBoolExtension, 0)); Assert.AreEqual(ByteString.CopyFromUtf8("123"), copy.GetExtension(UnitTestProtoFile.RepeatedBytesExtension, 0)); Assert.AreEqual("123", copy.GetExtension(UnitTestProtoFile.RepeatedCordExtension, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.RepeatedDoubleExtension, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestProtoFile.RepeatedFixed32Extension, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestProtoFile.RepeatedFixed64Extension, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.RepeatedFloatExtension, 0)); Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, copy.GetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 0)); Assert.AreEqual(ImportEnum.IMPORT_BAZ, copy.GetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.RepeatedInt32Extension, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.RepeatedInt64Extension, 0)); Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, copy.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.RepeatedSint32Extension, 0)); Assert.AreEqual(123, copy.GetExtension(UnitTestProtoFile.RepeatedSint64Extension, 0)); Assert.AreEqual("123", copy.GetExtension(UnitTestProtoFile.RepeatedStringExtension, 0)); Assert.AreEqual("123", copy.GetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestProtoFile.RepeatedUint32Extension, 0)); Assert.AreEqual(123u, copy.GetExtension(UnitTestProtoFile.RepeatedUint64Extension, 0)); }
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)); } }
/// <summary> /// Method we'll use to build messageReader, with the first parameter fixed to TMessage.CreateBuilder. Note that we /// have to introduce another type parameter (TMessage2) as we can't constrain TMessage for just a single method /// (and we can't do it at the type level because we don't know TBuilder). However, by constraining TMessage2 /// to not only implement IMessage appropriately but also to derive from TMessage2, we can avoid doing a cast /// for every message; the implicit reference conversion will be fine. In practice, TMessage2 and TMessage will /// be the same type when we construct the generic method by reflection. /// </summary> private static TMessage BuildImpl <TMessage2, TBuilder>(Func <TBuilder> builderBuilder, CodedInputStream input, ExtensionRegistry registry) where TBuilder : IBuilder <TMessage2, TBuilder> where TMessage2 : TMessage, IMessage <TMessage2, TBuilder> { TBuilder builder = builderBuilder(); input.ReadMessage(builder, registry); return(builder.Build()); }