internal bool IsInitializedWithRespectTo(IEnumerable typeFields) { IEnumerator enumerator = typeFields.GetEnumerator(); try { while (enumerator.MoveNext()) { IFieldDescriptorLite fieldDescriptorLite = (IFieldDescriptorLite)enumerator.Current; if (fieldDescriptorLite.IsRequired && !this.HasField(fieldDescriptorLite)) { return(false); } } } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } return(this.IsInitialized); }
private void MergeField(IFieldDescriptorLite field, object mergeValue) { object existingValue; fields.TryGetValue(field, out existingValue); if (field.IsRepeated) { if (existingValue == null) { existingValue = new List <object>(); fields[field] = existingValue; } IList <object> list = (IList <object>)existingValue; foreach (object otherValue in (IEnumerable)mergeValue) { list.Add(otherValue); } } else if (field.MappedType == MappedType.Message && existingValue != null) { IMessageLite existingMessage = (IMessageLite)existingValue; IMessageLite merged = existingMessage.WeakToBuilder() .WeakMergeFrom((IMessageLite)mergeValue) .WeakBuild(); this[field] = merged; } else { this[field] = mergeValue; } }
/// <summary> /// Writes a single field to a CodedOutputStream. /// </summary> public void WriteField(IFieldDescriptorLite field, Object value, ICodedOutputStream output) { if (field.IsExtension && field.MessageSetWireFormat) { output.WriteMessageSetExtension(field.FieldNumber, field.Name, (IMessageLite)value); } else { if (field.IsRepeated) { IEnumerable valueList = (IEnumerable)value; if (field.IsPacked) { output.WritePackedArray(field.FieldType, field.FieldNumber, field.Name, valueList); } else { output.WriteArray(field.FieldType, field.FieldNumber, field.Name, valueList); } } else { output.WriteField(field.FieldType, field.FieldNumber, field.Name, value); } } }
/// <summary> /// See <see cref="IMessageLite.Item(IFieldDescriptorLite,int)" /> /// </summary> internal object this[IFieldDescriptorLite field, int index] { get { if (!field.IsRepeated) { throw new ArgumentException( "Indexer specifying field and index can only be called on repeated fields."); } return(((IList <object>) this[field])[index]); } set { if (!field.IsRepeated) { throw new ArgumentException( "Indexer specifying field and index can only be called on repeated fields."); } VerifyType(field, value); object list; if (!fields.TryGetValue(field, out list)) { throw new ArgumentOutOfRangeException(); } ((IList <object>)list)[index] = value; } }
public int GetRepeatedFieldCount(IFieldDescriptorLite field) { if (!field.IsRepeated) { throw new ArgumentException("GetRepeatedFieldCount() can only be called on repeated fields."); } return(((IList <object>) this[field]).Count); }
public bool HasField(IFieldDescriptorLite field) { if (field.IsRepeated) { throw new ArgumentException("HasField() can only be called on non-repeated fields."); } return(this.fields.ContainsKey(field)); }
public void TestIndexedByDescriptorAndOrdinalOutOfRange() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); Assert.AreEqual(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor; Assert.Throws <ArgumentOutOfRangeException>(() => builder[f, 0] = 123); }
public void TestIndexedByDescriptorAndOrdinalOutOfRange() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder(); Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor; builder[f, 0] = 123; }
public TBuilder AddRepeatedField(IFieldDescriptorLite field, object value) { if (field.IsExtension) { ExtendableMessageLite <TMessage, TBuilder> extendableMessageLite = this.MessageBeingBuilt; extendableMessageLite.Extensions.AddRepeatedField(field, value); return(this.ThisBuilder); } throw new NotSupportedException("Not supported in the lite runtime."); }
public void TestClearFieldByDescriptor() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() .AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0); Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor; builder.ClearField(f); Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite)); }
public void TestAddRepeatedFieldByDescriptor() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 0); Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor; builder.AddRepeatedField(f, 123); Assert.AreEqual(2, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); Assert.AreEqual(123, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 1)); }
public void TestIndexedByDescriptorAndOrdinal() { TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder() .AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 0); Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor; builder[f, 0] = 123; Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite)); Assert.AreEqual(123, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0)); }
public TBuilder ClearField(IFieldDescriptorLite field) { if (field.IsExtension) { ExtendableMessageLite <TMessage, TBuilder> message = MessageBeingBuilt; message.Extensions.ClearField(field); return(ThisBuilder); } else { throw new NotSupportedException("Not supported in the lite runtime."); } }
public object this[IFieldDescriptorLite field, int index] { set { if (field.IsExtension) { ExtendableMessageLite <TMessage, TBuilder> extendableMessageLite = this.MessageBeingBuilt; extendableMessageLite.Extensions[field, index] = value; return; } throw new NotSupportedException("Not supported in the lite runtime."); } }
public object this[IFieldDescriptorLite field] { set { if (field.IsExtension) { ExtendableMessageLite <TMessage, TBuilder> message = MessageBeingBuilt; message.Extensions[field] = value; } else { throw new NotSupportedException("Not supported in the lite runtime."); } } }
/// <summary> /// See <see cref="IMessageLite.Item(IFieldDescriptorLite)"/> /// </summary> /// <remarks> /// If the field is not set, the behaviour when fetching this property varies by field type: /// <list> /// <item>For singular message values, null is returned.</item> /// <item>For singular non-message values, the default value of the field is returned.</item> /// <item>For repeated values, an empty immutable list is returned. This will be compatible /// with IList[object], regardless of the type of the repeated item.</item> /// </list> /// This method returns null if the field is a singular message type /// and is not set; in this case it is up to the caller to fetch the /// message's default instance. For repeated fields of message types, /// an empty collection is returned. For repeated fields of non-message /// types, null is returned. /// <para /> /// When setting this property, any list values are copied, and each element is checked /// to ensure it is of an appropriate type. /// </remarks> /// internal object this[IFieldDescriptorLite field] { get { object result; if (fields.TryGetValue(field, out result)) { return(result); } if (field.MappedType == MappedType.Message) { if (field.IsRepeated) { return(new List <object>()); } else { return(null); } } return(field.DefaultValue); } set { if (field.IsRepeated) { List <object> list = value as List <object>; if (list == null) { throw new ArgumentException("Wrong object type used with protocol message reflection."); } // Wrap the contents in a new list so that the caller cannot change // the list's contents after setting it. List <object> newList = new List <object>(list); foreach (object element in newList) { VerifyType(field, element); } value = newList; } else { VerifyType(field, value); } fields[field] = value; } }
/// <summary> /// See <see cref="IBuilder{TMessage, TBuilder}.AddRepeatedField" /> /// </summary> internal void AddRepeatedField(IFieldDescriptorLite field, object value) { if (!field.IsRepeated) { throw new ArgumentException("AddRepeatedField can only be called on repeated fields."); } VerifyType(field, value); object list; if (!fields.TryGetValue(field, out list)) { list = new List <object>(); fields[field] = list; } ((IList <object>)list).Add(value); }
internal void AddRepeatedField(IFieldDescriptorLite field, object value) { if (!field.IsRepeated) { throw new ArgumentException("AddRepeatedField can only be called on repeated fields."); } FieldSet.VerifyType(field, value); object obj; if (!this.fields.TryGetValue(field, out obj)) { obj = new List <object>(); this.fields[field] = obj; } ((IList <object>)obj).Add(value); }
internal object this[IFieldDescriptorLite field] { get { object result; if (this.fields.TryGetValue(field, out result)) { return(result); } if (field.MappedType != MappedType.Message) { return(field.DefaultValue); } if (field.IsRepeated) { return(new List <object>()); } return(null); } set { if (field.IsRepeated) { List <object> list = value as List <object>; if (list == null) { throw new ArgumentException("Wrong object type used with protocol message reflection."); } List <object> list2 = new List <object>(list); using (List <object> .Enumerator enumerator = list2.GetEnumerator()) { while (enumerator.MoveNext()) { object current = enumerator.Current; FieldSet.VerifyType(field, current); } } value = list2; } else { FieldSet.VerifyType(field, value); } this.fields[field] = value; } }
private void MergeField(IFieldDescriptorLite field, object mergeValue) { object obj; this.fields.TryGetValue(field, out obj); if (field.IsRepeated) { if (obj == null) { obj = new List <object>(); this.fields[field] = obj; } IList <object> list = (IList <object>)obj; IEnumerator enumerator = ((IEnumerable)mergeValue).GetEnumerator(); try { while (enumerator.MoveNext()) { object current = enumerator.Current; list.Add(current); } return; } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } } if (field.MappedType == MappedType.Message && obj != null) { IMessageLite messageLite = (IMessageLite)obj; IMessageLite value = messageLite.WeakToBuilder().WeakMergeFrom((IMessageLite)mergeValue).WeakBuild(); this[field] = value; return; } this[field] = mergeValue; }
/// <summary> /// Writes a single field to a CodedOutputStream. /// </summary> public void WriteField(IFieldDescriptorLite field, Object value, CodedOutputStream output) { if (field.IsExtension && field.MessageSetWireFormat) { output.WriteMessageSetExtension(field.FieldNumber, (IMessageLite)value); } else { if (field.IsRepeated) { IEnumerable valueList = (IEnumerable)value; if (field.IsPacked) { output.WriteTag(field.FieldNumber, WireFormat.WireType.LengthDelimited); // Compute the total data size so the length can be written. int dataSize = 0; foreach (object element in valueList) { dataSize += CodedOutputStream.ComputeFieldSizeNoTag(field.FieldType, element); } output.WriteRawVarint32((uint)dataSize); // Write the data itself, without any tags. foreach (object element in valueList) { output.WriteFieldNoTag(field.FieldType, element); } } else { foreach (object element in valueList) { output.WriteField(field.FieldType, field.FieldNumber, element); } } } else { output.WriteField(field.FieldType, field.FieldNumber, value); } } }
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); } }
/// <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) { 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> /// See <see cref="IBuilder{TMessage, TBuilder}.ClearField" /> /// </summary> public void ClearField(IFieldDescriptorLite field) { fields.Remove(field); }
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); }
/// <summary> /// Compares this descriptor with another one, ordering in "canonical" order /// which simply means ascending order by field number. <paramref name="other"/> /// must be a field of the same type, i.e. the <see cref="ContainingType"/> of /// both fields must be the same. /// </summary> public int CompareTo(IFieldDescriptorLite other) { return(FieldNumber - other.FieldNumber); }
/// <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); } }