/// <summary> /// Constructs an instance that will expect messages using the given /// descriptor. Normally <paramref name="baseDescriptor"/> should be /// a descriptor for TestAllTypes. However, if extensionRegistry is non-null, /// then baseDescriptor should be for TestAllExtensions instead, and instead of /// reading and writing normal fields, the tester will read and write extensions. /// All of the TestAllExtensions extensions must be registered in the registry. /// </summary> private ReflectionTester(MessageDescriptor baseDescriptor, ExtensionRegistry extensionRegistry) { this.baseDescriptor = baseDescriptor; this.extensionRegistry = extensionRegistry; this.file = baseDescriptor.File; Assert.AreEqual(1, file.Dependencies.Count); this.importFile = file.Dependencies[0]; MessageDescriptor testAllTypes; if (baseDescriptor.Name == "TestAllTypes") { testAllTypes = baseDescriptor; } else { testAllTypes = file.FindTypeByName<MessageDescriptor>("TestAllTypes"); Assert.NotNull(testAllTypes); } if (extensionRegistry == null) { // Use testAllTypes, rather than baseDescriptor, to allow // initialization using TestPackedTypes descriptors. These objects // won't be used by the methods for packed fields. this.optionalGroup = testAllTypes.FindDescriptor<MessageDescriptor>("OptionalGroup"); this.repeatedGroup = testAllTypes.FindDescriptor<MessageDescriptor>("RepeatedGroup"); } else { this.optionalGroup = file.FindTypeByName<MessageDescriptor>("OptionalGroup_extension"); this.repeatedGroup = file.FindTypeByName<MessageDescriptor>("RepeatedGroup_extension"); } this.nestedMessage = testAllTypes.FindDescriptor<MessageDescriptor>("NestedMessage"); this.foreignMessage = file.FindTypeByName<MessageDescriptor>("ForeignMessage"); this.importMessage = importFile.FindTypeByName<MessageDescriptor>("ImportMessage"); this.nestedEnum = testAllTypes.FindDescriptor<EnumDescriptor>("NestedEnum"); this.foreignEnum = file.FindTypeByName<EnumDescriptor>("ForeignEnum"); this.importEnum = importFile.FindTypeByName<EnumDescriptor>("ImportEnum"); Assert.NotNull(optionalGroup); Assert.NotNull(repeatedGroup); Assert.NotNull(nestedMessage); Assert.NotNull(foreignMessage); Assert.NotNull(importMessage); Assert.NotNull(nestedEnum); Assert.NotNull(foreignEnum); Assert.NotNull(importEnum); this.nestedB = nestedMessage.FindDescriptor<FieldDescriptor>("bb"); this.foreignC = foreignMessage.FindDescriptor<FieldDescriptor>("c"); this.importD = importMessage.FindDescriptor<FieldDescriptor>("d"); this.nestedFoo = nestedEnum.FindValueByName("FOO"); this.nestedBar = nestedEnum.FindValueByName("BAR"); this.nestedBaz = nestedEnum.FindValueByName("BAZ"); this.foreignFoo = foreignEnum.FindValueByName("FOREIGN_FOO"); this.foreignBar = foreignEnum.FindValueByName("FOREIGN_BAR"); this.foreignBaz = foreignEnum.FindValueByName("FOREIGN_BAZ"); this.importFoo = importEnum.FindValueByName("IMPORT_FOO"); this.importBar = importEnum.FindValueByName("IMPORT_BAR"); this.importBaz = importEnum.FindValueByName("IMPORT_BAZ"); this.groupA = optionalGroup.FindDescriptor<FieldDescriptor>("a"); this.repeatedGroupA = repeatedGroup.FindDescriptor<FieldDescriptor>("a"); Assert.NotNull(groupA); Assert.NotNull(repeatedGroupA); Assert.NotNull(nestedB); Assert.NotNull(foreignC); Assert.NotNull(importD); Assert.NotNull(nestedFoo); Assert.NotNull(nestedBar); Assert.NotNull(nestedBaz); Assert.NotNull(foreignFoo); Assert.NotNull(foreignBar); Assert.NotNull(foreignBaz); Assert.NotNull(importFoo); Assert.NotNull(importBar); Assert.NotNull(importBaz); }
public override IMessage Receive(IBuilder builder, ExtensionRegistry extensions) { QualityMessage message; lock (input) { // only one thread can read from the stream at one time message = QualityMessage.ParseDelimitedFrom(input, extensions); } return message; }
protected RpcServer(IRpcServerStub implementation) { _exceptionDetails = RpcErrorDetailBehavior.FullDetails; _extensions = ExtensionRegistry.CreateInstance(); _serverPrincipalName = null; _implementation = implementation; }
public QualityMessage GetMessage(ExtensionRegistry extensions) { lock (lockObject) { if (message == null && rawMessage != null) message = QualityMessage.ParseFrom(ByteString.CopyFrom(rawMessage), extensions); } return message; }
public static void Merge(string text, ExtensionRegistry registry, IBuilder builder) { TextTokenizer tokenizer = new TextTokenizer(text); while (!tokenizer.AtEnd) { MergeField(tokenizer, registry, builder); } }
public QualityMessage Evaluate(SolutionMessage solution, ExtensionRegistry qualityExtensions) { int tries = 0, maxTries = RetryParameter.Value.Value; bool success = false; QualityMessage result = null; while (!success) { try { tries++; CheckAndOpenChannel(); Channel.Send(solution); result = (QualityMessage)Channel.Receive(QualityMessage.CreateBuilder(), qualityExtensions); success = true; } catch (InvalidOperationException) { throw; } catch { if (tries >= maxTries) throw; } } if (result != null && result.SolutionId != solution.SolutionId) throw new InvalidDataException(Name + ": Received a quality for a different solution."); return result; }
/// <summary> /// Merges the input stream into the provided IBuilderLite /// </summary> public virtual bool ReadGroup(IBuilderLite value, ExtensionRegistry registry) { return(ReadMessage(value, registry)); }
public static AppStartUp ParseFrom(byte[] data, ExtensionRegistry extensionRegistry) { return(CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed()); }
public static AppStartUp ParseFrom( ICodedInputStream input, ExtensionRegistry extensionRegistry) { return(CreateBuilder().MergeFrom(input, extensionRegistry).BuildParsed()); }
internal void MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry, IBuilder builder) { while (true) { uint tag = input.ReadTag(); if (tag == 0) { break; } if (!MergeFieldFrom(input, extensionRegistry, builder, tag)) { // end group tag break; } } }
public abstract IMessage Receive(IBuilder builder, ExtensionRegistry extensions);
public IMessageLite CallMethod(string methodName, ICodedInputStream input, ExtensionRegistry registry) { WindowsIdentity currentUser = WindowsIdentity.GetCurrent(); if (currentUser == null) { throw new ArgumentNullException(); } IClientContext ctx = RpcCallContext.Current.Client; switch (methodName) { case "ncalrpc": { Assert.AreEqual(new byte[0], ctx.ClientAddress); Assert.AreEqual(Process.GetCurrentProcess().Id, ctx.ClientPid); Assert.AreEqual(true, ctx.ClientUser.IsAuthenticated); Assert.IsTrue(ctx.ClientUser.AuthenticationType == "NTLM" || ctx.ClientUser.AuthenticationType == "Negotiate" || ctx.ClientUser.AuthenticationType == "Kerberos"); Assert.AreEqual(currentUser.Name, ctx.ClientUser.Name); Assert.AreEqual(true, ctx.IsClientLocal); Assert.AreEqual(true, ctx.IsAuthenticated); Assert.AreEqual(false, ctx.IsImpersonating); using (ctx.Impersonate()) Assert.AreEqual(true, ctx.IsImpersonating); break; } case "ncacn_ip_tcp": { Assert.AreEqual(16, ctx.ClientAddress.Length); Assert.AreEqual(true, ctx.ClientUser.IsAuthenticated); Assert.IsTrue(ctx.ClientUser.AuthenticationType == "NTLM" || ctx.ClientUser.AuthenticationType == "Negotiate" || ctx.ClientUser.AuthenticationType == "Kerberos"); Assert.AreEqual(currentUser.Name, ctx.ClientUser.Name); Assert.AreEqual(true, ctx.IsAuthenticated); Assert.AreEqual(false, ctx.IsImpersonating); using (ctx.Impersonate()) Assert.AreEqual(true, ctx.IsImpersonating); break; } case "ncacn_np": { Assert.AreEqual(new byte[0], ctx.ClientAddress); Assert.AreEqual(true, ctx.ClientUser.IsAuthenticated); Assert.IsTrue(ctx.ClientUser.AuthenticationType == "NTLM" || ctx.ClientUser.AuthenticationType == "Negotiate" || ctx.ClientUser.AuthenticationType == "Kerberos"); Assert.AreEqual(currentUser.Name, ctx.ClientUser.Name); Assert.AreEqual(true, ctx.IsAuthenticated); Assert.AreEqual(false, ctx.IsImpersonating); using (ctx.Impersonate()) Assert.AreEqual(true, ctx.IsImpersonating); break; } case "ncacn_np-Anonymous": { Assert.AreEqual(new byte[0], ctx.ClientAddress); Assert.AreEqual(false, ctx.ClientUser.IsAuthenticated); Assert.AreEqual("", ctx.ClientUser.AuthenticationType); Assert.AreEqual("", ctx.ClientUser.Name); Assert.AreEqual(false, ctx.IsAuthenticated); Assert.AreEqual(false, ctx.IsImpersonating); try { // impersonation not allowed when no credentials were provided, however, you can use ctx.ClientUser.Impersonate ctx.Impersonate(); } catch (UnauthorizedAccessException) { } Assert.AreEqual(false, ctx.IsImpersonating); break; } } return RpcVoid.DefaultInstance; }
IBuilderLite IBuilderLite.WeakMergeFrom(CodedInputStream input, ExtensionRegistry registry) { return MergeFrom(input); }
public static RustProto.Item ParseFrom(ByteString data, ExtensionRegistry extensionRegistry) { return(CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed()); }
public static RustProto.Item ParseFrom(Stream input, ExtensionRegistry extensionRegistry) { return(CreateBuilder().MergeFrom(input, extensionRegistry).BuildParsed()); }
public override DownloadVoiceResponse.Builder MergeFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry) { uint num; string str; this.PrepareBuilder(); while (input.ReadTag(out num, out str)) { if ((num == 0) && (str != null)) { int index = Array.BinarySearch <string>(DownloadVoiceResponse._downloadVoiceResponseFieldNames, str, StringComparer.Ordinal); if (index >= 0) { num = DownloadVoiceResponse._downloadVoiceResponseFieldTags[index]; } else { this.ParseUnknownField(input, extensionRegistry, num, str); continue; } } switch (num) { case 0x10: { this.result.hasOffset = input.ReadUInt32(ref this.result.offset_); continue; } case 0x18: { this.result.hasLength = input.ReadUInt32(ref this.result.length_); continue; } case 40: { this.result.hasVoiceLength = input.ReadUInt32(ref this.result.voiceLength_); continue; } case 0: throw InvalidProtocolBufferException.InvalidTag(); case 8: { this.result.hasMsgId = input.ReadUInt32(ref this.result.msgId_); continue; } case 50: { this.result.hasClientMsgId = input.ReadString(ref this.result.clientMsgId_); continue; } case 0x3a: { SKBuiltinBuffer_t.Builder builder = SKBuiltinBuffer_t.CreateBuilder(); if (this.result.hasData) { builder.MergeFrom(this.Data); } input.ReadMessage(builder, extensionRegistry); this.Data = builder.BuildPartial(); continue; } case 0x40: { this.result.hasEndFlag = input.ReadUInt32(ref this.result.endFlag_); continue; } case 0x4a: { micromsg.BaseResponse.Builder builder2 = micromsg.BaseResponse.CreateBuilder(); if (this.result.hasBaseResponse) { builder2.MergeFrom(this.BaseResponse); } input.ReadMessage(builder2, extensionRegistry); this.BaseResponse = builder2.BuildPartial(); continue; } case 80: break; default: { if (WireFormat.IsEndGroupTag(num)) { return(this); } this.ParseUnknownField(input, extensionRegistry, num, str); continue; } } this.result.hasCancelFlag = input.ReadUInt32(ref this.result.cancelFlag_); } return(this); }
protected virtual RpcMultiPartResponse MultiPartMessage(RpcMultiPartRequest request, ExtensionRegistry registry) { RpcSession session = RpcCallContext.Session; string messageId = request.TransactionId.ToBase64(); Stream message; if (!session.TryGetValue(messageId, out message)) { if (request.CurrentPosition != 0) { throw new InvalidDataException("The TransactionId is not valid."); } session.Add(messageId, message = CreateStream(request.TotalBytes)); message.SetLength(request.TotalBytes); } if (request.MessageStatus == RpcMultiPartRequest.Types.RpcMessageStatus.CANCEL) { message.Dispose(); session.Remove(messageId); return(RpcMultiPartResponse.CreateBuilder().SetContinue(false).Build()); } if (message.Position != request.CurrentPosition || message.Length != request.TotalBytes || request.BytesSent != request.PayloadBytes.Length) { throw new InvalidDataException(); } request.PayloadBytes.WriteTo(message); if (request.MessageStatus == RpcMultiPartRequest.Types.RpcMessageStatus.COMPLETE) { using (message) { session.Remove(messageId); if (message.Position != request.TotalBytes) { throw new InvalidDataException(); } message.Position = 0; byte[] response = next.CallMethod(request.MethodName, CodedInputStream.CreateInstance(message), registry). ToByteArray(); return(RpcMultiPartResponse.CreateBuilder() .SetResponseBytes(ByteString.CopyFrom(response)) .SetContinue(true) .Build()); } } return(RpcMultiPartResponse.CreateBuilder() .SetContinue(true) .Build()); }
public abstract IMessage Receive(IBuilder builder, ExtensionRegistry extensions);
protected override TBuilder DeserializeMessage <TMessage, TBuilder>(object message, TBuilder builder, ExtensionRegistry registry) { new DictionaryReader((IDictionary <string, object>)message).Merge(builder); return(builder); }
// Token: 0x060000A8 RID: 168 RVA: 0x00002EFE File Offset: 0x000010FE public static PushListResult ParseFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry) { return(CreateBuilder().MergeFrom(input, extensionRegistry).BuildParsed()); }
public IMessageLite CallMethod(string methodName, ICodedInputStream input, ExtensionRegistry registry) { using (RpcCallContext.Current.Impersonate()) return _next.CallMethod(methodName, input, registry); }
public override RustProto.Item.Builder MergeFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry) { uint num; string str; this.PrepareBuilder(); UnknownFieldSet.Builder unknownFields = null; while (input.ReadTag(out num, out str)) { if ((num == 0) && (str != null)) { int index = Array.BinarySearch <string>(RustProto.Item._itemFieldNames, str, StringComparer.Ordinal); if (index >= 0) { num = RustProto.Item._itemFieldTags[index]; } else { if (unknownFields == null) { unknownFields = UnknownFieldSet.CreateBuilder(this.UnknownFields); } this.ParseUnknownField(input, unknownFields, extensionRegistry, num, str); continue; } } switch (num) { case 0: throw InvalidProtocolBufferException.InvalidTag(); case 8: { this.result.hasId = input.ReadInt32(ref this.result.id_); continue; } case 0x12: { this.result.hasName = input.ReadString(ref this.result.name_); continue; } case 0x18: { this.result.hasSlot = input.ReadInt32(ref this.result.slot_); continue; } case 0x20: { this.result.hasCount = input.ReadInt32(ref this.result.count_); continue; } case 0x2a: { input.ReadMessageArray <RustProto.Item>(num, str, this.result.subitem_, RustProto.Item.DefaultInstance, extensionRegistry); continue; } case 0x30: { this.result.hasSubslots = input.ReadInt32(ref this.result.subslots_); continue; } case 0x3d: { this.result.hasCondition = input.ReadFloat(ref this.result.condition_); continue; } case 0x45: break; default: { if (WireFormat.IsEndGroupTag(num)) { if (unknownFields != null) { this.UnknownFields = unknownFields.Build(); } return(this); } if (unknownFields == null) { unknownFields = UnknownFieldSet.CreateBuilder(this.UnknownFields); } this.ParseUnknownField(input, unknownFields, extensionRegistry, num, str); continue; } } this.result.hasMaxcondition = input.ReadFloat(ref this.result.maxcondition_); } if (unknownFields != null) { this.UnknownFields = unknownFields.Build(); } return(this); }
/// <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; }
public override SendMsgResponseNew.Builder MergeFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry) { uint num; string str; this.PrepareBuilder(); while (input.ReadTag(out num, out str)) { if ((num == 0) && (str != null)) { int index = Array.BinarySearch <string>(SendMsgResponseNew._sendMsgResponseNewFieldNames, str, StringComparer.Ordinal); if (index >= 0) { num = SendMsgResponseNew._sendMsgResponseNewFieldTags[index]; } else { this.ParseUnknownField(input, extensionRegistry, num, str); continue; } } switch (num) { case 0: throw InvalidProtocolBufferException.InvalidTag(); case 10: { BaseResponse.Builder builder = BaseResponse.CreateBuilder(); if (this.result.hasBaseResponse) { builder.MergeFrom(this.BaseResponse); } input.ReadMessage(builder, extensionRegistry); this.BaseResponse = builder.BuildPartial(); continue; } case 0x10: { this.result.hasCount = input.ReadUInt32(ref this.result.count_); continue; } case 0x1a: break; default: { if (WireFormat.IsEndGroupTag(num)) { return(this); } this.ParseUnknownField(input, extensionRegistry, num, str); continue; } } input.ReadMessageArray <MicroMsgResponseNew>(num, str, this.result.list_, MicroMsgResponseNew.DefaultInstance, extensionRegistry); } return(this); }
public PropertyDispatcherFactory(ExtensionRegistry extensions, object target, Type type, string name, params object[] arguments) : base(extensions, target, type, name, arguments) { }
public ProtobufDecoder(IMessageLite prototype, ExtensionRegistry extensions) { _prototype = prototype; _extensions = extensions; }
public override IMessage Receive(IBuilder builder, ExtensionRegistry extensions) { try { byte[] buffer = GetMessageBuffer(); return builder.WeakMergeFrom(ByteString.CopyFrom(buffer), extensions).WeakBuild(); } catch (SocketException) { Close(); throw; } catch (ObjectDisposedException) { socket = null; Close(); throw; } }
public static RustProto.Avatar ParseFrom(byte[] data, ExtensionRegistry extensionRegistry) { return(CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed()); }
public QualityMessage GetValue(SolutionMessage message, Evaluator evaluate, ExtensionRegistry extensions) { var entry = new CacheEntry(message.ToString()); bool lockTaken = false; bool waited = false; try { Monitor.Enter(cacheLock, ref lockTaken); while (true) { LinkedListNode<CacheEntry> node; if (index.TryGetValue(entry, out node)) { list.Remove(node); list.AddLast(node); Hits++; lockTaken = false; Monitor.Exit(cacheLock); OnChanged(); return node.Value.GetMessage(extensions); } else { if (!waited && activeEvaluations.Contains(entry.Key)) { while (activeEvaluations.Contains(entry.Key)) Monitor.Wait(cacheLock); waited = true; } else { activeEvaluations.Add(entry.Key); lockTaken = false; Monitor.Exit(cacheLock); OnChanged(); try { entry.SetMessage(evaluate(message)); Monitor.Enter(cacheLock, ref lockTaken); index[entry] = list.AddLast(entry); Trim(); } finally { if (!lockTaken) Monitor.Enter(cacheLock, ref lockTaken); activeEvaluations.Remove(entry.Key); Monitor.PulseAll(cacheLock); lockTaken = false; Monitor.Exit(cacheLock); } OnChanged(); return entry.GetMessage(extensions); } } } } finally { if (lockTaken) Monitor.Exit(cacheLock); } }
public static RustProto.Avatar ParseFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry) { return(CreateBuilder().MergeFrom(input, extensionRegistry).BuildParsed()); }
public static objectFireBarrel ParseFrom(Stream input, ExtensionRegistry extensionRegistry) { return(CreateBuilder().MergeFrom(input, extensionRegistry).BuildParsed()); }
public override RustProto.Avatar.Builder MergeFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry) { uint num; string str; this.PrepareBuilder(); UnknownFieldSet.Builder unknownFields = null; while (input.ReadTag(out num, out str)) { if ((num == 0) && (str != null)) { int index = Array.BinarySearch <string>(RustProto.Avatar._avatarFieldNames, str, StringComparer.Ordinal); if (index >= 0) { num = RustProto.Avatar._avatarFieldTags[index]; } else { if (unknownFields == null) { unknownFields = UnknownFieldSet.CreateBuilder(this.UnknownFields); } this.ParseUnknownField(input, unknownFields, extensionRegistry, num, str); continue; } } switch (num) { case 0: throw InvalidProtocolBufferException.InvalidTag(); case 10: { Vector.Builder builder = Vector.CreateBuilder(); if (this.result.hasPos) { builder.MergeFrom(this.Pos); } input.ReadMessage(builder, extensionRegistry); this.Pos = builder.BuildPartial(); continue; } case 0x12: { Quaternion.Builder builder3 = Quaternion.CreateBuilder(); if (this.result.hasAng) { builder3.MergeFrom(this.Ang); } input.ReadMessage(builder3, extensionRegistry); this.Ang = builder3.BuildPartial(); continue; } case 0x1a: { RustProto.Vitals.Builder builder4 = RustProto.Vitals.CreateBuilder(); if (this.result.hasVitals) { builder4.MergeFrom(this.Vitals); } input.ReadMessage(builder4, extensionRegistry); this.Vitals = builder4.BuildPartial(); continue; } case 0x22: { input.ReadMessageArray <RustProto.Blueprint>(num, str, this.result.blueprints_, RustProto.Blueprint.DefaultInstance, extensionRegistry); continue; } case 0x2a: { input.ReadMessageArray <RustProto.Item>(num, str, this.result.inventory_, RustProto.Item.DefaultInstance, extensionRegistry); continue; } case 50: { input.ReadMessageArray <RustProto.Item>(num, str, this.result.wearable_, RustProto.Item.DefaultInstance, extensionRegistry); continue; } case 0x3a: { input.ReadMessageArray <RustProto.Item>(num, str, this.result.belt_, RustProto.Item.DefaultInstance, extensionRegistry); continue; } case 0x42: { RustProto.AwayEvent.Builder builder5 = RustProto.AwayEvent.CreateBuilder(); if (this.result.hasAwayEvent) { builder5.MergeFrom(this.AwayEvent); } input.ReadMessage(builder5, extensionRegistry); this.AwayEvent = builder5.BuildPartial(); continue; } } if (WireFormat.IsEndGroupTag(num)) { if (unknownFields != null) { this.UnknownFields = unknownFields.Build(); } return(this); } if (unknownFields == null) { unknownFields = UnknownFieldSet.CreateBuilder(this.UnknownFields); } this.ParseUnknownField(input, unknownFields, extensionRegistry, num, str); } if (unknownFields != null) { this.UnknownFields = unknownFields.Build(); } return(this); }
public static AppStartUp ParseDelimitedFrom( Stream input, ExtensionRegistry extensionRegistry) { return(CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed()); }
public static RustProto.Avatar ParseDelimitedFrom(Stream input, ExtensionRegistry extensionRegistry) { return(CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed()); }
/// <summary> /// Merges the input stream into the provided IBuilderLite /// </summary> protected abstract bool ReadMessage(IBuilderLite builder, ExtensionRegistry registry);
public static SmsContentEntry ParseFrom( byte[] data, ExtensionRegistry extensionRegistry) { return(SmsContentEntry.CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed()); }
/// <summary> /// Merges the contents of stream into the provided message builder /// </summary> public abstract TBuilder Merge <TBuilder>(TBuilder builder, ExtensionRegistry registry) where TBuilder : IBuilderLite;
public static SmsContentEntry ParseDelimitedFrom( Stream input, ExtensionRegistry extensionRegistry) { return(SmsContentEntry.CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed()); }
public MethodDispatcherFactory(ExtensionRegistry extensions, object target, Type type, string methodName, params object[] arguments) : base(extensions, target, type, methodName, arguments) { }
public static SmsContentEntry ParseFrom( ICodedInputStream input, ExtensionRegistry extensionRegistry) { return(SmsContentEntry.CreateBuilder().MergeFrom(input, extensionRegistry).BuildParsed()); }
internal void MergeFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry, IBuilder builder) { uint tag; string name; while (input.ReadTag(out tag, out name)) { if (tag == 0 && name != null) { FieldDescriptor fieldByName = builder.DescriptorForType.FindFieldByName(name); if (fieldByName != null) { tag = WireFormat.MakeTag(fieldByName); } else { ExtensionInfo extension = extensionRegistry.FindByName(builder.DescriptorForType, name); if (extension != null) { tag = WireFormat.MakeTag(extension.Descriptor); } } } if (tag == 0) { if (input.SkipField()) { continue; //can't merge unknown without field tag } break; } if (!MergeFieldFrom(input, extensionRegistry, builder, tag, name)) { // end group tag break; } } }
public override SmsContentEntry.Builder MergeFrom( ICodedInputStream input, ExtensionRegistry extensionRegistry) { this.PrepareBuilder(); UnknownFieldSet.Builder unknownFields = (UnknownFieldSet.Builder)null; uint fieldTag; string fieldName; while (input.ReadTag(out fieldTag, out fieldName)) { if (fieldTag == 0U && fieldName != null) { int index = Array.BinarySearch <string>(SmsContentEntry._smsContentEntryFieldNames, fieldName, (IComparer <string>)StringComparer.Ordinal); if (index >= 0) { fieldTag = SmsContentEntry._smsContentEntryFieldTags[index]; } else { if (unknownFields == null) { unknownFields = UnknownFieldSet.CreateBuilder(this.UnknownFields); } this.ParseUnknownField(input, unknownFields, extensionRegistry, fieldTag, fieldName); continue; } } switch (fieldTag) { case 0: throw InvalidProtocolBufferException.InvalidTag(); case 10: this.result.hasKey = input.ReadString(ref this.result.key_); continue; case 18: this.result.hasValue = input.ReadString(ref this.result.value_); continue; default: if (WireFormat.IsEndGroupTag(fieldTag)) { if (unknownFields != null) { this.UnknownFields = unknownFields.Build(); } return(this); } if (unknownFields == null) { unknownFields = UnknownFieldSet.CreateBuilder(this.UnknownFields); } this.ParseUnknownField(input, unknownFields, extensionRegistry, fieldTag, fieldName); continue; } } if (unknownFields != null) { this.UnknownFields = unknownFields.Build(); } return(this); }
public ProtobufDecoder(IMessageLite prototype, ExtensionRegistry extensions) { _prototype = prototype; _extensions = extensions; }
// Token: 0x06001623 RID: 5667 RVA: 0x00049EA4 File Offset: 0x000480A4 public static void RegisterAllExtensions(ExtensionRegistry registry) { }
IBuilderLite IBuilderLite.WeakMergeFrom(ByteString data, ExtensionRegistry registry) { return MergeFrom(data); }
public void SetUp() { _extensions = new ExtensionRegistry(); _extensions.Register(typeof(FooExtensions)); }
public override IMessage Receive(IBuilder builder, ExtensionRegistry extensions) { try { return streamingChannel.Receive(builder, extensions); } catch { Close(); throw; } }
/// <summary> /// Reads an embedded message field value from the stream. /// </summary> public void ReadMessage(IBuilder builder, ExtensionRegistry extensionRegistry) { int length = (int) ReadRawVarint32(); if (recursionDepth >= recursionLimit) { throw InvalidProtocolBufferException.RecursionLimitExceeded(); } int oldLimit = PushLimit(length); ++recursionDepth; builder.WeakMergeFrom(this, extensionRegistry); CheckLastTagWas(0); --recursionDepth; PopLimit(oldLimit); }
/// <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; IMessage 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: { IBuilder subBuilder; if (defaultFieldInstance != null) { subBuilder = defaultFieldInstance.WeakCreateBuilderForType(); } else { subBuilder = builder.CreateBuilderForField(field); } if (!field.IsRepeated) { subBuilder.WeakMergeFrom((IMessage)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; }
/// <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> /// 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" IBuilder 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(); IMessage originalMessage = (IMessage)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 void EvaluateAsync(SolutionMessage solution, ExtensionRegistry qualityExtensions, Action<QualityMessage> callback) { int tries = 0, maxTries = RetryParameter.Value.Value; bool success = false; while (!success) { try { tries++; CheckAndOpenChannel(); Channel.Send(solution); success = true; } catch (InvalidOperationException) { throw; } catch { if (tries >= maxTries) throw; } } System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(ReceiveAsync), new ReceiveAsyncInfo(solution, callback, qualityExtensions)); }
public ReceiveAsyncInfo(SolutionMessage solutionMessage, Action <QualityMessage> callbackDelegate, ExtensionRegistry qualityExtensions) { SolutionMessage = solutionMessage; CallbackDelegate = callbackDelegate; QualityExtensions = qualityExtensions; }
public SliceDispatcherFactory(ExtensionRegistry extensions, object target, Type type, string name, params object[] arguments) : base(extensions, target, type, name.Length == 0 ? RuntimeServices.GetDefaultMemberName(type) : name, arguments) { }
/// <summary> /// Reads a group field value from the stream. /// </summary> public void ReadGroup(int fieldNumber, IBuilder builder, ExtensionRegistry extensionRegistry) { if (recursionDepth >= recursionLimit) { throw InvalidProtocolBufferException.RecursionLimitExceeded(); } ++recursionDepth; builder.WeakMergeFrom(this, extensionRegistry); CheckLastTagWas(WireFormat.MakeTag(fieldNumber, WireFormat.WireType.EndGroup)); --recursionDepth; }
public override objectFireBarrel.Builder MergeFrom(ICodedInputStream input) { return(this.MergeFrom(input, ExtensionRegistry.get_Empty())); }
public static void Merge(TextReader reader, ExtensionRegistry registry, IBuilder builder) { Merge(reader.ReadToEnd(), registry, builder); }
public override objectFireBarrel.Builder MergeFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry) { uint num; string str; this.PrepareBuilder(); UnknownFieldSet.Builder builder = null; while (input.ReadTag(ref num, ref str)) { if ((num == 0) && (str != null)) { int index = Array.BinarySearch <string>(objectFireBarrel._objectFireBarrelFieldNames, str, StringComparer.Ordinal); if (index >= 0) { num = objectFireBarrel._objectFireBarrelFieldTags[index]; } else { if (builder == null) { builder = UnknownFieldSet.CreateBuilder(this.get_UnknownFields()); } this.ParseUnknownField(input, builder, extensionRegistry, num, str); continue; } } switch (num) { case 0: throw InvalidProtocolBufferException.InvalidTag(); case 8: break; default: { if (WireFormat.IsEndGroupTag(num)) { if (builder != null) { this.set_UnknownFields(builder.Build()); } return(this); } if (builder == null) { builder = UnknownFieldSet.CreateBuilder(this.get_UnknownFields()); } this.ParseUnknownField(input, builder, extensionRegistry, num, str); continue; } } this.result.hasOnFire = input.ReadBool(ref this.result.onFire_); } if (builder != null) { this.set_UnknownFields(builder.Build()); } return(this); }
public static void RegisterAllExtensions(ExtensionRegistry registry) { }
public static objectFireBarrel ParseFrom(byte[] data, ExtensionRegistry extensionRegistry) { return(CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed()); }