using System; using System.Collections; using System.Collections.Generic; using System.Text; using Google.ProtocolBuffers.Descriptors; using Google.ProtocolBuffers.Collections; namespace Google.ProtocolBuffers { /// /// A class which represents an arbitrary set of fields of some message type. /// This is used to implement DynamicMessage, and also to represent extensions /// in GeneratedMessage. This class is internal, since outside users should probably /// be using DynamicMessage. /// /// As in the Java implementation, this class goes against the rest of the framework /// in terms of mutability. Instead of having a mutable Builder class and an immutable /// FieldSet class, FieldSet just has a MakeImmutable() method. This is safe so long as /// all callers are careful not to let a mutable FieldSet escape into the open. This would /// be impossible to guarantee if this were a public class, of course. /// internal class FieldSet { private static readonly FieldSet defaultInstance = new FieldSet(new Dictionary()).MakeImmutable(); private IDictionary fields; private FieldSet(IDictionary fields) { this.fields = fields; } /// /// Makes this FieldSet immutable, and returns it for convenience. Any /// mutable repeated fields are made immutable, as well as the map itself. /// internal FieldSet MakeImmutable() { // First check if we have any repeated values bool hasRepeats = false; foreach (object value in fields.Values) { IList list = value as IList; if (list != null && !list.IsReadOnly) { hasRepeats = true; break; } } if (hasRepeats) { var tmp = new SortedList(); foreach (KeyValuePair entry in fields) { IList list = entry.Value as IList; tmp[entry.Key] = list == null ? entry.Value : Lists.AsReadOnly(list); } fields = tmp; } fields = Dictionaries.AsReadOnly(fields); return this; } /// /// Returns the default, immutable instance with no fields defined. /// internal static FieldSet DefaultInstance { get { return defaultInstance; } } /// /// Returns an immutable mapping of fields. Note that although the mapping itself /// is immutable, the entries may not be (i.e. any repeated values are represented by /// mutable lists). The behaviour is not specified if the contents are mutated. /// internal IDictionary AllFields { get { return Dictionaries.AsReadOnly(fields); } } /// /// See . /// public bool HasField(FieldDescriptor field) { if (field.IsRepeated) { throw new ArgumentException("HasField() can only be called on non-repeated fields."); } return fields.ContainsKey(field); } // TODO(jonskeet): Should this be in UnknownFieldSet.Builder really? internal static void MergeFrom(CodedInputStream input, UnknownFieldSet.Builder unknownFields, ExtensionRegistry extensionRegistry, IBuilder builder) { while (true) { uint tag = input.ReadTag(); if (tag == 0) { break; } if (!MergeFieldFrom(input, unknownFields, extensionRegistry, builder, tag)) { // end group tag break; } } } // TODO(jonskeet): Should this be in UnknownFieldSet.Builder really? /// /// Like /// but parses a single field. /// /// The input to read the field from /// The set of unknown fields to add the newly-read field to /// Registry to use when an extension field is encountered /// A builder (???) /// The tag, which should already have been read from the input /// true unless the tag is an end-group tag internal static bool MergeFieldFrom(CodedInputStream input, UnknownFieldSet.Builder unknownFields, ExtensionRegistry extensionRegistry, IBuilder builder, uint tag) { MessageDescriptor type = builder.DescriptorForType; if (type.Options.IsMessageSetWireFormat && tag == WireFormat.MessageSetTag.ItemStart) { MergeMessageSetExtensionFromCodedStream(input, unknownFields, extensionRegistry, builder); return true; } WireFormat.WireType wireType = WireFormat.GetTagWireType(tag); int fieldNumber = WireFormat.GetTagFieldNumber(tag); FieldDescriptor field; IMessage defaultInstance = null; if (type.IsExtensionNumber(fieldNumber)) { ExtensionInfo extension = extensionRegistry[type, fieldNumber]; if (extension == null) { field = null; } else { field = extension.Descriptor; defaultInstance = extension.DefaultInstance; } } else { field = type.FindFieldByNumber(fieldNumber); } // Unknown field or wrong wire type. Skip. if (field == null || wireType != WireFormat.FieldTypeToWireFormatMap[field.FieldType]) { return unknownFields.MergeFieldFrom(tag, input); } object value; switch (field.FieldType) { case FieldType.Group: case FieldType.Message: { IBuilder subBuilder; if (defaultInstance != null) { subBuilder = defaultInstance.CreateBuilderForType(); } else { subBuilder = builder.CreateBuilderForField(field); } if (!field.IsRepeated) { subBuilder.MergeFrom((IMessage) builder[field]); } if (field.FieldType == FieldType.Group) { input.ReadGroup(field.FieldNumber, subBuilder, extensionRegistry); } else { input.ReadMessage(subBuilder, extensionRegistry); } value = subBuilder.Build(); 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) { unknownFields.MergeVarintField(fieldNumber, (ulong) rawValue); return true; } break; } default: value = input.ReadPrimitiveField(field.FieldType); break; } if (field.IsRepeated) { builder.AddRepeatedField(field, value); } else { builder[field] = value; } return true; } // TODO(jonskeet): Move to UnknownFieldSet.Builder? /// /// Called by MergeFieldFrom to parse a MessageSet extension. /// private static void MergeMessageSetExtensionFromCodedStream(CodedInputStream input, UnknownFieldSet.Builder unknownFields, 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.CreateBuilderForType(); IMessage originalMessage = (IMessage) builder[field]; if (originalMessage != null) { subBuilder.MergeFrom(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.MergeFrom(rawBytes.CreateCodedInput()); rawBytes = null; } } else { // Unknown extension number. If we already saw data, put it // in rawBytes. if (rawBytes != null) { unknownFields.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. unknownFields.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.Build(); } } /// /// Clears all fields. /// internal void Clear() { fields.Clear(); } /// /// See /// /// /// If the field is not set, the behaviour when fetching this property varies by field type: /// /// For singular message values, null is returned. /// For singular non-message values, the default value of the field is returned. /// For repeated values, an empty immutable list is returned. /// /// 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. /// /// When setting this property, any list values are copied, and each element is checked /// to ensure it is of an appropriate type. /// /// internal object this[FieldDescriptor field] { get { object result; if (fields.TryGetValue(field, out result)) { return result; } // This will just do the right thing return field.DefaultValue; } set { if (field.IsRepeated) { List list = value as List; 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 newList = new List(list); foreach (object element in newList) { VerifyType(field, element); } value = newList; } else { VerifyType(field, value); } fields[field] = value; } } /// /// See /// internal object this[FieldDescriptor field, int index] { get { if (!field.IsRepeated) { throw new ArgumentException("Indexer specifying field and index can only be called on repeated fields."); } return ((List)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(); } ((List) list)[index] = value; } } /// /// See /// /// /// internal void AddRepeatedField(FieldDescriptor 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(); fields[field] = list; } ((List) list).Add(value); } /// /// See /// /// /// Since FieldSet itself does not have any way of knowing about /// required fields that aren't actually present in the set, it is up /// to the caller to check for genuinely required fields. This property /// merely checks that any messages present are themselves initialized. /// internal bool IsInitialized { get { foreach (KeyValuePair entry in fields) { FieldDescriptor field = entry.Key; if (field.MappedType == MappedType.Message) { if (field.IsRepeated) { foreach(IMessage message in (IEnumerable) entry.Value) { if (!message.IsInitialized) { return false; } } } else { if (!((IMessage) entry.Value).IsInitialized) { return false; } } } } return true; } } /// /// Verifies whether all the required fields in the specified message /// descriptor are present in this field set, as well as whether /// all the embedded messages are themselves initialized. /// internal bool IsInitializedWithRespectTo(MessageDescriptor type) { foreach (FieldDescriptor field in type.Fields) { if (field.IsRequired && !HasField(field)) { return false; } } return IsInitialized; } /// /// See /// public void ClearField(FieldDescriptor field) { fields.Remove(field); } /// /// See /// public int GetRepeatedFieldCount(FieldDescriptor field) { if (!field.IsRepeated) { throw new ArgumentException("GetRepeatedFieldCount() can only be called on repeated fields."); } return ((List) this[field]).Count; } /// /// Implementation of both MergeFrom methods. /// /// private void MergeFields(IEnumerable> otherFields) { // Note: We don't attempt to verify that other's fields have valid // types. Doing so would be a losing battle. We'd have to verify // all sub-messages as well, and we'd have to make copies of all of // them to insure that they don't change after verification (since // the IMessage interface itself cannot enforce immutability of // implementations). // TODO(jonskeet): Provide a function somewhere called MakeDeepCopy() // which allows people to make secure deep copies of messages. foreach (KeyValuePair entry in otherFields) { FieldDescriptor field = entry.Key; object existingValue; fields.TryGetValue(field, out existingValue); if (field.IsRepeated) { if (existingValue == null) { existingValue = new List(); fields[field] = existingValue; } List list = (List)existingValue; foreach (object otherValue in (IEnumerable)entry.Value) { list.Add(otherValue); } } else if (field.MappedType == MappedType.Message && existingValue != null) { IMessage existingMessage = (IMessage)existingValue; IMessage merged = existingMessage.CreateBuilderForType() .MergeFrom(existingMessage) .MergeFrom((IMessage)entry.Value) .Build(); this[field] = merged; } else { this[field] = entry.Value; } } } /// /// See /// public void MergeFrom(IMessage other) { MergeFields(other.AllFields); } /// /// Like , but merges from another FieldSet. /// public void MergeFrom(FieldSet other) { MergeFields(other.fields); } /// /// Verifies that the given object is of the correct type to be a valid /// value for the given field. /// /// /// For repeated fields, this checks if the object is of the right /// element type, not whether it's a list. /// /// The value is not of the right type. private static void VerifyType(FieldDescriptor field, object 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: EnumValueDescriptor enumValue = value as EnumValueDescriptor; isValid = enumValue != null && enumValue.EnumDescriptor == field.EnumType; break; case MappedType.Message: IMessage messageValue = value as IMessage; isValid = messageValue != null && messageValue.DescriptorForType == field.MessageType; 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. throw new ArgumentException("Wrong object type used with protocol message reflection. " + "Message type \"" + field.ContainingType.FullName + "\", field \"" + (field.IsExtension ? field.FullName : field.Name) + "\", value was type \"" + value.GetType().Name + "\"."); } } } }