/// <summary> /// Reads an enum field value from the stream. The caller is responsible /// for converting the numeric value to an actual enum. /// </summary> public bool ReadEnum(ref IEnumLite value, out object unknown, IEnumLiteMap mapping) { tokenizer.Consume(":"); if (tokenizer.LookingAtInteger()) { int rawValue = tokenizer.ConsumeInt32(); value = mapping.FindValueByNumber(rawValue); if (value != null) { unknown = null; return(true); } unknown = rawValue; } else { string rawName = tokenizer.ConsumeIdentifier(); value = mapping.FindValueByName(rawName); if (value != null) { unknown = null; return(true); } unknown = rawName; } return(false); }
public object SingularFromReflectionType(object value) { switch (Descriptor.MappedType) { case MappedType.Message: if (value is TExtensionType) { return(value); } else { // It seems the copy of the embedded message stored inside the // extended message is not of the exact type the user was // expecting. This can happen if a user defines a // GeneratedExtension manually and gives it a different type. // This should not happen in normal use. But, to be nice, we'll // copy the message to whatever type the caller was expecting. return(MessageDefaultInstance.WeakCreateBuilderForType() .WeakMergeFrom((IMessageLite)value).WeakBuild()); } case MappedType.Enum: // Just return a boxed int - that can be unboxed to the enum IEnumLite enumValue = (IEnumLite)value; return(enumValue.Number); default: return(value); } }
void ICodedInputStream.ReadEnumArray(uint fieldTag, string fieldName, ICollection <IEnumLite> list, out ICollection <object> unknown, IEnumLiteMap mapping) { unknown = null; List <object> array = new List <object>(); if (ReadEnumArray(fieldName, array)) { foreach (object rawValue in array) { IEnumLite item = null; if (rawValue is int) { item = mapping.FindValueByNumber((int)rawValue); } else if (rawValue is string) { item = mapping.FindValueByName((string)rawValue); } if (item != null) { list.Add(item); } else { if (unknown == null) { unknown = new List <object>(); } unknown.Add(rawValue); } } } }
public bool ReadEnum(ref IEnumLite value, out object unknown, IEnumLiteMap mapping) { int num = (int)this.ReadRawVarint32(); value = mapping.FindValueByNumber(num); if (value != null) { unknown = null; return(true); } unknown = num; return(false); }
public void ReadEnumArray(uint fieldTag, string fieldName, ICollection <IEnumLite> list, out ICollection <object> unknown, IEnumLiteMap mapping) { unknown = null; IEnumLite enumLite = null; WireFormat.WireType tagWireType = WireFormat.GetTagWireType(fieldTag); if (tagWireType == WireFormat.WireType.LengthDelimited) { int byteLimit = (int)(this.ReadRawVarint32() & 2147483647u); int oldLimit = this.PushLimit(byteLimit); while (!this.ReachedLimit) { object obj; if (this.ReadEnum(ref enumLite, out obj, mapping)) { list.Add(enumLite); } else { if (unknown == null) { unknown = new List <object>(); } unknown.Add(obj); } } this.PopLimit(oldLimit); return; } do { object obj; if (this.ReadEnum(ref enumLite, out obj, mapping)) { list.Add(enumLite); } else { if (unknown == null) { unknown = new List <object>(); } unknown.Add(obj); } }while (this.ContinueArray(fieldTag)); }
bool ICodedInputStream.ReadEnum(ref IEnumLite value, out object unknown, IEnumLiteMap mapping) { value = null; unknown = null; if (ReadEnum(ref unknown)) { if (unknown is int) { value = mapping.FindValueByNumber((int)unknown); } else if (unknown is string) { value = mapping.FindValueByName((string)unknown); } return(value != null); } return(false); }
public object SingularFromReflectionType(object value) { switch (this.Descriptor.MappedType) { case MappedType.Message: if (value is TExtensionType) { return(value); } return(this.MessageDefaultInstance.WeakCreateBuilderForType().WeakMergeFrom((IMessageLite)value).WeakBuild()); case MappedType.Enum: { IEnumLite enumLite = (IEnumLite)value; return(enumLite.Number); } default: return(value); } }
/// <summary> /// Verifies that the given object is of the correct type to be a valid /// value for the given field. /// </summary> /// <remarks> /// For repeated fields, this checks if the object is of the right /// element type, not whether it's a list. /// </remarks> /// <exception cref="ArgumentException">The value is not of the right type.</exception> /// <exception cref="ArgumentNullException">The value is null.</exception> private static void VerifyType(IFieldDescriptorLite field, object value) { ThrowHelper.ThrowIfNull(value, "value"); bool isValid = false; switch (field.MappedType) { case MappedType.Int32: isValid = value is int; break; case MappedType.Int64: isValid = value is long; break; case MappedType.UInt32: isValid = value is uint; break; case MappedType.UInt64: isValid = value is ulong; break; case MappedType.Single: isValid = value is float; break; case MappedType.Double: isValid = value is double; break; case MappedType.Boolean: isValid = value is bool; break; case MappedType.String: isValid = value is string; break; case MappedType.ByteString: isValid = value is ByteString; break; case MappedType.Enum: IEnumLite enumValue = value as IEnumLite; isValid = enumValue != null && field.EnumType.IsValidValue(enumValue); break; case MappedType.Message: IMessageLite messageValue = value as IMessageLite; isValid = messageValue != null; #if !LITE if (isValid && messageValue is IMessage && field is FieldDescriptor) { isValid = ((IMessage)messageValue).DescriptorForType == ((FieldDescriptor)field).MessageType; } #endif break; } if (!isValid) { // When chaining calls to SetField(), it can be hard to tell from // the stack trace which exact call failed, since the whole chain is // considered one line of code. So, let's make sure to include the // field name and other useful info in the exception. string message = "Wrong object type used with protocol message reflection."; #if !LITE Google.ProtocolBuffers.Descriptors.FieldDescriptor fieldinfo = field as Google.ProtocolBuffers.Descriptors.FieldDescriptor; if (fieldinfo != null) { message += "Message type \"" + fieldinfo.ContainingType.FullName; message += "\", field \"" + (fieldinfo.IsExtension ? fieldinfo.FullName : fieldinfo.Name); message += "\", value was type \"" + value.GetType().Name + "\"."; } #endif throw new ArgumentException(message); } }
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 bool IsValidValue(IEnumLite value) { return(items.ContainsKey(value.Number)); }
public bool IsValidValue(IEnumLite value) { TEnum val = default(TEnum); return(EnumParser <TEnum> .TryConvert(value.Number, ref val)); }
public bool IsValidValue(IEnumLite value) { return(Enum.IsDefined(typeof(TEnum), value.Number)); }
private static void VerifyType(IFieldDescriptorLite field, object value) { ThrowHelper.ThrowIfNull(value, "value"); bool flag = false; switch (field.MappedType) { case MappedType.Int32: flag = (value is int); break; case MappedType.Int64: flag = (value is long); break; case MappedType.UInt32: flag = (value is uint); break; case MappedType.UInt64: flag = (value is ulong); break; case MappedType.Single: flag = (value is float); break; case MappedType.Double: flag = (value is double); break; case MappedType.Boolean: flag = (value is bool); break; case MappedType.String: flag = (value is string); break; case MappedType.ByteString: flag = (value is ByteString); break; case MappedType.Message: { IMessageLite messageLite = value as IMessageLite; flag = (messageLite != null); break; } case MappedType.Enum: { IEnumLite enumLite = value as IEnumLite; flag = (enumLite != null && field.EnumType.IsValidValue(enumLite)); break; } } if (!flag) { string text = "Wrong object type used with protocol message reflection."; throw new ArgumentException(text); } }
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> /// Logic moved from FieldSet to continue current behavior /// </summary> public bool IsValidValue(IEnumLite value) { return(value is EnumValueDescriptor && ((EnumValueDescriptor)value).EnumDescriptor == 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); }
/// <summary> /// Verifies that the given object is of the correct type to be a valid /// value for the given field. /// </summary> /// <remarks> /// For repeated fields, this checks if the object is of the right /// element type, not whether it's a list. /// </remarks> /// <exception cref="ArgumentException">The value is not of the right type.</exception> /// <exception cref="ArgumentNullException">The value is null.</exception> private static void VerifyType(IFieldDescriptorLite field, object value) { ThrowHelper.ThrowIfNull(value, "value"); bool isValid = false; switch (field.MappedType) { case MappedType.Int32: isValid = value is int; break; case MappedType.Int64: isValid = value is long; break; case MappedType.UInt32: isValid = value is uint; break; case MappedType.UInt64: isValid = value is ulong; break; case MappedType.Single: isValid = value is float; break; case MappedType.Double: isValid = value is double; break; case MappedType.Boolean: isValid = value is bool; break; case MappedType.String: isValid = value is string; break; case MappedType.ByteString: isValid = value is ByteString; break; case MappedType.Enum: IEnumLite enumValue = value as IEnumLite; isValid = enumValue != null && field.EnumType.IsValidValue(enumValue); break; case MappedType.Message: IMessageLite messageValue = value as IMessageLite; isValid = messageValue != null; break; } if (!isValid) { // When chaining calls to SetField(), it can be hard to tell from // the stack trace which exact call failed, since the whole chain is // considered one line of code. So, let's make sure to include the // field name and other useful info in the exception. string message = "Wrong object type used with protocol message reflection."; throw new ArgumentException(message); } }