/// <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());
}
